osprey-gcc-4.2.0/gcc/tree-stdarg.c

Go to the documentation of this file.

/* Pass computing data for optimizing stdarg functions.
   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   Contributed by Jakub Jelinek <jakub@redhat.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING.  If not, write to
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "function.h"
#include "langhooks.h"
#include "diagnostic.h"
#include "target.h"
#include "tree-flow.h"
#include "tree-pass.h"
#include "tree-stdarg.h"

/* A simple pass that attempts to optimize stdarg functions on architectures
   that need to save register arguments to stack on entry to stdarg functions.
   If the function doesn't use any va_start macros, no registers need to
   be saved.  If va_start macros are used, the va_list variables don't escape
   the function, it is only necessary to save registers that will be used
   in va_arg macros.  E.g. if va_arg is only used with integral types
   in the function, floating point registers don't need to be saved, etc.  */


/* Return true if basic block VA_ARG_BB is dominated by VA_START_BB and
   is executed at most as many times as VA_START_BB.  */

static bool
reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
{
  edge *stack, e;
  edge_iterator ei;
  int sp;
  sbitmap visited;
  bool ret;

  if (va_arg_bb == va_start_bb)
    return true;

  if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
    return false;

  stack = XNEWVEC (edge, n_basic_blocks + 1);
  sp = 0;

  visited = sbitmap_alloc (last_basic_block);
  sbitmap_zero (visited);
  ret = true;

  FOR_EACH_EDGE (e, ei, va_arg_bb->preds)
    stack[sp++] = e;

  while (sp)
    {
      basic_block src;

      --sp;
      e = stack[sp];
      src = e->src;

      if (e->flags & EDGE_COMPLEX)
  {
    ret = false;
    break;
  }

      if (src == va_start_bb)
  continue;

      /* va_arg_bb can be executed more times than va_start_bb.  */
      if (src == va_arg_bb)
  {
    ret = false;
    break;
  }

      gcc_assert (src != ENTRY_BLOCK_PTR);

      if (! TEST_BIT (visited, src->index))
  {
    SET_BIT (visited, src->index);
    FOR_EACH_EDGE (e, ei, src->preds)
      stack[sp++] = e;
  }
    }

  free (stack);
  sbitmap_free (visited);
  return ret;
}


/* For statement COUNTER = RHS, if RHS is COUNTER + constant,
   return constant, otherwise return (unsigned HOST_WIDE_INT) -1.
   GPR_P is true if this is GPR counter.  */

static unsigned HOST_WIDE_INT
va_list_counter_bump (struct stdarg_info *si, tree counter, tree rhs,
          bool gpr_p)
{
  tree stmt, lhs, orig_lhs;
  unsigned HOST_WIDE_INT ret = 0, val, counter_val;
  unsigned int max_size;

  if (si->offsets == NULL)
    {
      unsigned int i;

      si->offsets = XNEWVEC (int, num_ssa_names);
      for (i = 0; i < num_ssa_names; ++i)
  si->offsets[i] = -1;
    }

  counter_val = gpr_p ? cfun->va_list_gpr_size : cfun->va_list_fpr_size;
  max_size = gpr_p ? VA_LIST_MAX_GPR_SIZE : VA_LIST_MAX_FPR_SIZE;
  orig_lhs = lhs = rhs;
  while (lhs)
    {
      if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
  {
    if (counter_val >= max_size)
      {
        ret = max_size;
        break;
      }

    ret -= counter_val - si->offsets[SSA_NAME_VERSION (lhs)];
    break;
  }

      stmt = SSA_NAME_DEF_STMT (lhs);

      if (TREE_CODE (stmt) != MODIFY_EXPR
    || TREE_OPERAND (stmt, 0) != lhs)
  return (unsigned HOST_WIDE_INT) -1;

      rhs = TREE_OPERAND (stmt, 1);
      if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
  rhs = TREE_OPERAND (rhs, 0);

      if (TREE_CODE (rhs) == SSA_NAME)
  {
    lhs = rhs;
    continue;
  }

      if ((TREE_CODE (rhs) == NOP_EXPR
     || TREE_CODE (rhs) == CONVERT_EXPR)
    && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
  {
    lhs = TREE_OPERAND (rhs, 0);
    continue;
  }

      if (TREE_CODE (rhs) == PLUS_EXPR
    && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
    && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST
    && host_integerp (TREE_OPERAND (rhs, 1), 1))
  {
    ret += tree_low_cst (TREE_OPERAND (rhs, 1), 1);
    lhs = TREE_OPERAND (rhs, 0);
    continue;
  }

      if (TREE_CODE (counter) != TREE_CODE (rhs))
  return (unsigned HOST_WIDE_INT) -1;

      if (TREE_CODE (counter) == COMPONENT_REF)
  {
    if (get_base_address (counter) != get_base_address (rhs)
        || TREE_CODE (TREE_OPERAND (rhs, 1)) != FIELD_DECL
        || TREE_OPERAND (counter, 1) != TREE_OPERAND (rhs, 1))
      return (unsigned HOST_WIDE_INT) -1;
  }
      else if (counter != rhs)
  return (unsigned HOST_WIDE_INT) -1;

      lhs = NULL;
    }

  lhs = orig_lhs;
  val = ret + counter_val;
  while (lhs)
    {
      if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
  break;

      if (val >= max_size)
  si->offsets[SSA_NAME_VERSION (lhs)] = max_size;
      else
  si->offsets[SSA_NAME_VERSION (lhs)] = val;

      stmt = SSA_NAME_DEF_STMT (lhs);

      rhs = TREE_OPERAND (stmt, 1);
      if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
  rhs = TREE_OPERAND (rhs, 0);

      if (TREE_CODE (rhs) == SSA_NAME)
  {
    lhs = rhs;
    continue;
  }

      if ((TREE_CODE (rhs) == NOP_EXPR
     || TREE_CODE (rhs) == CONVERT_EXPR)
    && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
  {
    lhs = TREE_OPERAND (rhs, 0);
    continue;
  }

      if (TREE_CODE (rhs) == PLUS_EXPR
    && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
    && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST
    && host_integerp (TREE_OPERAND (rhs, 1), 1))
  {
    val -= tree_low_cst (TREE_OPERAND (rhs, 1), 1);
    lhs = TREE_OPERAND (rhs, 0);
    continue;
  }

      lhs = NULL;
    }

  return ret;
}


/* Called by walk_tree to look for references to va_list variables.  */

static tree
find_va_list_reference (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
      void *data)
{
  bitmap va_list_vars = (bitmap) data;
  tree var = *tp;

  if (TREE_CODE (var) == SSA_NAME)
    var = SSA_NAME_VAR (var);

  if (TREE_CODE (var) == VAR_DECL
      && bitmap_bit_p (va_list_vars, DECL_UID (var)))
    return var;

  return NULL_TREE;
}


/* Helper function of va_list_counter_struct_op.  Compute
   cfun->va_list_{g,f}pr_size.  AP is a va_list GPR/FPR counter,
   if WRITE_P is true, seen in AP = VAR, otherwise seen in VAR = AP
   statement.  GPR_P is true if AP is a GPR counter, false if it is
   a FPR counter.  */

static void
va_list_counter_op (struct stdarg_info *si, tree ap, tree var, bool gpr_p,
        bool write_p)
{
  unsigned HOST_WIDE_INT increment;

  if (si->compute_sizes < 0)
    {
      si->compute_sizes = 0;
      if (si->va_start_count == 1
    && reachable_at_most_once (si->bb, si->va_start_bb))
  si->compute_sizes = 1;

      if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file,
     "bb%d will %sbe executed at most once for each va_start "
     "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
     si->va_start_bb->index);
    }

  if (write_p
      && si->compute_sizes
      && (increment = va_list_counter_bump (si, ap, var, gpr_p)) + 1 > 1)
    {
      if (gpr_p && cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
  {
    cfun->va_list_gpr_size += increment;
    return;
  }

      if (!gpr_p && cfun->va_list_fpr_size + increment < VA_LIST_MAX_FPR_SIZE)
  {
    cfun->va_list_fpr_size += increment;
    return;
  }
    }

  if (write_p || !si->compute_sizes)
    {
      if (gpr_p)
  cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
      else
  cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
    }
}


/* If AP is a va_list GPR/FPR counter, compute cfun->va_list_{g,f}pr_size.
   If WRITE_P is true, AP has been seen in AP = VAR assignment, if WRITE_P
   is false, AP has been seen in VAR = AP assignment.
   Return true if the AP = VAR (resp. VAR = AP) statement is a recognized
   va_arg operation that doesn't cause the va_list variable to escape
   current function.  */

static bool
va_list_counter_struct_op (struct stdarg_info *si, tree ap, tree var,
         bool write_p)
{
  tree base;

  if (TREE_CODE (ap) != COMPONENT_REF
      || TREE_CODE (TREE_OPERAND (ap, 1)) != FIELD_DECL)
    return false;

  if (TREE_CODE (var) != SSA_NAME
      || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (var))))
    return false;

  base = get_base_address (ap);
  if (TREE_CODE (base) != VAR_DECL
      || !bitmap_bit_p (si->va_list_vars, DECL_UID (base)))
    return false;

  if (TREE_OPERAND (ap, 1) == va_list_gpr_counter_field)
    va_list_counter_op (si, ap, var, true, write_p);
  else if (TREE_OPERAND (ap, 1) == va_list_fpr_counter_field)
    va_list_counter_op (si, ap, var, false, write_p);

  return true;
}


/* Check for TEM = AP.  Return true if found and the caller shouldn't
   search for va_list references in the statement.  */

static bool
va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem)
{
  if (TREE_CODE (ap) != VAR_DECL
      || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
    return false;

  if (TREE_CODE (tem) != SSA_NAME
      || bitmap_bit_p (si->va_list_vars,
           DECL_UID (SSA_NAME_VAR (tem)))
      || is_global_var (SSA_NAME_VAR (tem)))
    return false;

  if (si->compute_sizes < 0)
    {
      si->compute_sizes = 0;
      if (si->va_start_count == 1
    && reachable_at_most_once (si->bb, si->va_start_bb))
  si->compute_sizes = 1;

      if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file,
     "bb%d will %sbe executed at most once for each va_start "
     "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
     si->va_start_bb->index);
    }

  /* For void * or char * va_list types, there is just one counter.
     If va_arg is used in a loop, we don't know how many registers need
     saving.  */
  if (! si->compute_sizes)
    return false;

  if (va_list_counter_bump (si, ap, tem, true) == (unsigned HOST_WIDE_INT) -1)
    return false;

  /* Note the temporary, as we need to track whether it doesn't escape
     the current function.  */
  bitmap_set_bit (si->va_list_escape_vars,
      DECL_UID (SSA_NAME_VAR (tem)));
  return true;
}


/* Check for:
     tem1 = AP;
     TEM2 = tem1 + CST;
     AP = TEM2;
   sequence and update cfun->va_list_gpr_size.  Return true if found.  */

static bool
va_list_ptr_write (struct stdarg_info *si, tree ap, tree tem2)
{
  unsigned HOST_WIDE_INT increment;

  if (TREE_CODE (ap) != VAR_DECL
      || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
    return false;

  if (TREE_CODE (tem2) != SSA_NAME
      || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (tem2))))
    return false;

  if (si->compute_sizes <= 0)
    return false;

  increment = va_list_counter_bump (si, ap, tem2, true);
  if (increment + 1 <= 1)
    return false;

  if (cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
    cfun->va_list_gpr_size += increment;
  else
    cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;

  return true;
}


/* If RHS is X, (some type *) X or X + CST for X a temporary variable
   containing value of some va_list variable plus optionally some constant,
   either set si->va_list_escapes or add LHS to si->va_list_escape_vars,
   depending whether LHS is a function local temporary.  */

static void
check_va_list_escapes (struct stdarg_info *si, tree lhs, tree rhs)
{
  if (! POINTER_TYPE_P (TREE_TYPE (rhs)))
    return;

  if ((TREE_CODE (rhs) == PLUS_EXPR
       && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
      || TREE_CODE (rhs) == NOP_EXPR
      || TREE_CODE (rhs) == CONVERT_EXPR)
    rhs = TREE_OPERAND (rhs, 0);

  if (TREE_CODE (rhs) != SSA_NAME
      || ! bitmap_bit_p (si->va_list_escape_vars,
       DECL_UID (SSA_NAME_VAR (rhs))))
    return;

  if (TREE_CODE (lhs) != SSA_NAME || is_global_var (SSA_NAME_VAR (lhs)))
    {
      si->va_list_escapes = true;
      return;
    }

  if (si->compute_sizes < 0)
    {
      si->compute_sizes = 0;
      if (si->va_start_count == 1
    && reachable_at_most_once (si->bb, si->va_start_bb))
  si->compute_sizes = 1;

      if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file,
     "bb%d will %sbe executed at most once for each va_start "
     "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
     si->va_start_bb->index);
    }

  /* For void * or char * va_list types, there is just one counter.
     If va_arg is used in a loop, we don't know how many registers need
     saving.  */
  if (! si->compute_sizes)
    {
      si->va_list_escapes = true;
      return;
    }

  if (va_list_counter_bump (si, si->va_start_ap, lhs, true)
      == (unsigned HOST_WIDE_INT) -1)
    {
      si->va_list_escapes = true;
      return;
    }

  bitmap_set_bit (si->va_list_escape_vars,
      DECL_UID (SSA_NAME_VAR (lhs)));
}


/* Check all uses of temporaries from si->va_list_escape_vars bitmap.
   Return true if va_list might be escaping.  */

static bool
check_all_va_list_escapes (struct stdarg_info *si)
{
  basic_block bb;

  FOR_EACH_BB (bb)
    {
      block_stmt_iterator i;

      for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
  {
    tree stmt = bsi_stmt (i), use;
    ssa_op_iter iter;

    FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
      {
        if (! bitmap_bit_p (si->va_list_escape_vars,
          DECL_UID (SSA_NAME_VAR (use))))
    continue;

        if (TREE_CODE (stmt) == MODIFY_EXPR)
    {
      tree lhs = TREE_OPERAND (stmt, 0);
      tree rhs = TREE_OPERAND (stmt, 1);

      if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
        rhs = TREE_OPERAND (rhs, 0);

      /* x = *ap_temp;  */
      if (TREE_CODE (rhs) == INDIRECT_REF
          && TREE_OPERAND (rhs, 0) == use
          && TYPE_SIZE_UNIT (TREE_TYPE (rhs))
          && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (rhs)), 1)
          && si->offsets[SSA_NAME_VERSION (use)] != -1)
        {
          unsigned HOST_WIDE_INT gpr_size;
          tree access_size = TYPE_SIZE_UNIT (TREE_TYPE (rhs));

          gpr_size = si->offsets[SSA_NAME_VERSION (use)]
         + tree_low_cst (access_size, 1);
          if (gpr_size >= VA_LIST_MAX_GPR_SIZE)
      cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
          else if (gpr_size > cfun->va_list_gpr_size)
      cfun->va_list_gpr_size = gpr_size;
          continue;
        }

      /* va_arg sequences may contain
         other_ap_temp = ap_temp;
         other_ap_temp = ap_temp + constant;
         other_ap_temp = (some_type *) ap_temp;
         ap = ap_temp;
         statements.  */
      if ((TREE_CODE (rhs) == PLUS_EXPR
           && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
          || TREE_CODE (rhs) == NOP_EXPR
          || TREE_CODE (rhs) == CONVERT_EXPR)
        rhs = TREE_OPERAND (rhs, 0);

      if (rhs == use)
        {
          if (TREE_CODE (lhs) == SSA_NAME
        && bitmap_bit_p (si->va_list_escape_vars,
             DECL_UID (SSA_NAME_VAR (lhs))))
      continue;

          if (TREE_CODE (lhs) == VAR_DECL
        && bitmap_bit_p (si->va_list_vars,
             DECL_UID (lhs)))
      continue;
        }
    }

        if (dump_file && (dump_flags & TDF_DETAILS))
    {
      fputs ("va_list escapes in ", dump_file);
      print_generic_expr (dump_file, stmt, dump_flags);
      fputc ('\n', dump_file);
    }
        return true;
      }
  }
    }

  return false;
}


/* Return true if this optimization pass should be done.
   It makes only sense for stdarg functions.  */

static bool
gate_optimize_stdarg (void)
{
  /* This optimization is only for stdarg functions.  */
  return current_function_stdarg != 0;
}


/* Entry point to the stdarg optimization pass.  */

static unsigned int
execute_optimize_stdarg (void)
{
  basic_block bb;
  bool va_list_escapes = false;
  bool va_list_simple_ptr;
  struct stdarg_info si;
  const char *funcname = NULL;

  cfun->va_list_gpr_size = 0;
  cfun->va_list_fpr_size = 0;
  memset (&si, 0, sizeof (si));
  si.va_list_vars = BITMAP_ALLOC (NULL);
  si.va_list_escape_vars = BITMAP_ALLOC (NULL);

  if (dump_file)
    funcname = lang_hooks.decl_printable_name (current_function_decl, 2);

  va_list_simple_ptr = POINTER_TYPE_P (va_list_type_node)
           && (TREE_TYPE (va_list_type_node) == void_type_node
         || TREE_TYPE (va_list_type_node) == char_type_node);
  gcc_assert (is_gimple_reg_type (va_list_type_node) == va_list_simple_ptr);

  FOR_EACH_BB (bb)
    {
      block_stmt_iterator i;

      for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
  {
    tree stmt = bsi_stmt (i);
    tree call = get_call_expr_in (stmt), callee;
    tree ap;

    if (!call)
      continue;

    callee = get_callee_fndecl (call);
    if (!callee
        || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
      continue;

    switch (DECL_FUNCTION_CODE (callee))
      {
      case BUILT_IN_VA_START:
        break;
        /* If old style builtins are used, don't optimize anything.  */
      case BUILT_IN_SAVEREGS:
      case BUILT_IN_STDARG_START:
      case BUILT_IN_ARGS_INFO:
      case BUILT_IN_NEXT_ARG:
        va_list_escapes = true;
        continue;
      default:
        continue;
      }

    si.va_start_count++;
    ap = TREE_VALUE (TREE_OPERAND (call, 1));

    if (TREE_CODE (ap) != ADDR_EXPR)
      {
        va_list_escapes = true;
        break;
      }
    ap = TREE_OPERAND (ap, 0);
    if (TREE_CODE (ap) == ARRAY_REF)
      {
        if (! integer_zerop (TREE_OPERAND (ap, 1)))
          {
            va_list_escapes = true;
            break;
    }
        ap = TREE_OPERAND (ap, 0);
      }
    if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
        != TYPE_MAIN_VARIANT (va_list_type_node)
        || TREE_CODE (ap) != VAR_DECL)
      {
        va_list_escapes = true;
        break;
      }

    if (is_global_var (ap))
      {
        va_list_escapes = true;
        break;
      }

    bitmap_set_bit (si.va_list_vars, DECL_UID (ap));

    /* VA_START_BB and VA_START_AP will be only used if there is just
       one va_start in the function.  */
    si.va_start_bb = bb;
    si.va_start_ap = ap;
  }

      if (va_list_escapes)
  break;
    }

  /* If there were no va_start uses in the function, there is no need to
     save anything.  */
  if (si.va_start_count == 0)
    goto finish;

  /* If some va_list arguments weren't local, we can't optimize.  */
  if (va_list_escapes)
    goto finish;

  /* For void * or char * va_list, something useful can be done only
     if there is just one va_start.  */
  if (va_list_simple_ptr && si.va_start_count > 1)
    {
      va_list_escapes = true;
      goto finish;
    }

  /* For struct * va_list, if the backend didn't tell us what the counter fields
     are, there is nothing more we can do.  */
  if (!va_list_simple_ptr
      && va_list_gpr_counter_field == NULL_TREE
      && va_list_fpr_counter_field == NULL_TREE)
    {
      va_list_escapes = true;
      goto finish;
    }

  /* For void * or char * va_list there is just one counter
     (va_list itself).  Use VA_LIST_GPR_SIZE for it.  */
  if (va_list_simple_ptr)
    cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;

  calculate_dominance_info (CDI_DOMINATORS);

  FOR_EACH_BB (bb)
    {
      block_stmt_iterator i;

      si.compute_sizes = -1;
      si.bb = bb;

      /* For va_list_simple_ptr, we have to check PHI nodes too.  We treat
   them as assignments for the purpose of escape analysis.  This is
   not needed for non-simple va_list because virtual phis don't perform
   any real data movement.  */
      if (va_list_simple_ptr)
  {
    tree phi, lhs, rhs;
    use_operand_p uop;
    ssa_op_iter soi;

    for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
      {
        lhs = PHI_RESULT (phi);

        if (!is_gimple_reg (lhs))
    continue;

        FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE)
    {
      rhs = USE_FROM_PTR (uop);
      if (va_list_ptr_read (&si, rhs, lhs))
        continue;
      else if (va_list_ptr_write (&si, lhs, rhs))
        continue;
      else
        check_va_list_escapes (&si, lhs, rhs);

      if (si.va_list_escapes
          || walk_tree (&phi, find_va_list_reference,
            si.va_list_vars, NULL))
        {
          if (dump_file && (dump_flags & TDF_DETAILS))
      {
        fputs ("va_list escapes in ", dump_file);
        print_generic_expr (dump_file, phi, dump_flags);
        fputc ('\n', dump_file);
      }
          va_list_escapes = true;
        }
    }
      }
  }

      for (i = bsi_start (bb);
     !bsi_end_p (i) && !va_list_escapes;
     bsi_next (&i))
  {
    tree stmt = bsi_stmt (i);
    tree call;

    /* Don't look at __builtin_va_{start,end}, they are ok.  */
    call = get_call_expr_in (stmt);
    if (call)
      {
        tree callee = get_callee_fndecl (call);

        if (callee
      && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
      && (DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_START
          || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END))
    continue;
      }

    if (TREE_CODE (stmt) == MODIFY_EXPR)
      {
        tree lhs = TREE_OPERAND (stmt, 0);
        tree rhs = TREE_OPERAND (stmt, 1);

        if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
    rhs = TREE_OPERAND (rhs, 0);

        if (va_list_simple_ptr)
    {
      /* Check for tem = ap.  */
      if (va_list_ptr_read (&si, rhs, lhs))
        continue;

      /* Check for the last insn in:
         tem1 = ap;
         tem2 = tem1 + CST;
         ap = tem2;
         sequence.  */
      else if (va_list_ptr_write (&si, lhs, rhs))
        continue;

      else
        check_va_list_escapes (&si, lhs, rhs);
    }
        else
    {
      /* Check for ap[0].field = temp.  */
      if (va_list_counter_struct_op (&si, lhs, rhs, true))
        continue;

      /* Check for temp = ap[0].field.  */
      else if (va_list_counter_struct_op (&si, rhs, lhs, false))
        continue;

      /* Do any architecture specific checking.  */
      else if (targetm.stdarg_optimize_hook
         && targetm.stdarg_optimize_hook (&si, lhs, rhs))
        continue;
    }
      }

    /* All other uses of va_list are either va_copy (that is not handled
       in this optimization), taking address of va_list variable or
       passing va_list to other functions (in that case va_list might
       escape the function and therefore va_start needs to set it up
       fully), or some unexpected use of va_list.  None of these should
       happen in a gimplified VA_ARG_EXPR.  */
    if (si.va_list_escapes
        || walk_tree (&stmt, find_va_list_reference,
          si.va_list_vars, NULL))
      {
        if (dump_file && (dump_flags & TDF_DETAILS))
    {
      fputs ("va_list escapes in ", dump_file);
      print_generic_expr (dump_file, stmt, dump_flags);
      fputc ('\n', dump_file);
    }
        va_list_escapes = true;
      }
  }

      if (va_list_escapes)
  break;
    }

  if (! va_list_escapes
      && va_list_simple_ptr
      && ! bitmap_empty_p (si.va_list_escape_vars)
      && check_all_va_list_escapes (&si))
    va_list_escapes = true;

finish:
  if (va_list_escapes)
    {
      cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
      cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
    }
  BITMAP_FREE (si.va_list_vars);
  BITMAP_FREE (si.va_list_escape_vars);
  free (si.offsets);
  if (dump_file)
    {
      fprintf (dump_file, "%s: va_list escapes %d, needs to save ",
         funcname, (int) va_list_escapes);
      if (cfun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
  fputs ("all", dump_file);
      else
  fprintf (dump_file, "%d", cfun->va_list_gpr_size);
      fputs (" GPR units and ", dump_file);
      if (cfun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
  fputs ("all", dump_file);
      else
  fprintf (dump_file, "%d", cfun->va_list_fpr_size);
      fputs (" FPR units.\n", dump_file);
    }
  return 0;
}


struct tree_opt_pass pass_stdarg =
{
  "stdarg",       /* name */
  gate_optimize_stdarg,     /* gate */
  execute_optimize_stdarg,    /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  TODO_dump_func,     /* todo_flags_finish */
  0         /* letter */
};

---