OSDN Git Service

2010-05-04 Martin Jambor <mjambor@suse.cz>
authorjamborm <jamborm@138bc75d-0d04-0410-961f-82ee72b054a4>
Tue, 4 May 2010 17:34:01 +0000 (17:34 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 04:58:46 +0000 (13:58 +0900)
* tree-sra.c (build_access_from_expr_1): The first parameter type
changed to simple tree.
(build_access_from_expr): Likewise, gsi parameter was eliminated.
(scan_assign_result): Renamed to assignment_mod_result, enum elements
renamed as well.
(build_accesses_from_assign): Removed all parameters except for a
simple gimple statement.  Now returns a simple bool.
(scan_function): All non-analysis parts moved to separate functions
sra_modify_function_body and ipa_sra_modify_function_body.  Removed all
parameters and updated both callers.
(sra_modify_expr): Removed parameter data.
(sra_modify_function_body): New function.
(perform_intra_sra): Call sra_modify_function_body to modify the
function body.
(replace_removed_params_ssa_names): Parameter data changed into
adjustments vector.
(sra_ipa_modify_expr): Likewise.  Also removed unused parameter gsi and
changed the parameter dont_convert to convert with the opposite
meaning.
(sra_ipa_modify_assign): Parameter data changed into adjustments
vector, return value changed to bool.
(ipa_sra_modify_function_body): New function.
(sra_ipa_reset_debug_stmts): Updated a comment.
(modify_function): Use ipa_sra_modify_function_body to modify function
body.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@159038 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/tree-sra.c

index a93e111..41139cb 100644 (file)
@@ -1,3 +1,31 @@
+2010-05-04  Martin Jambor  <mjambor@suse.cz>
+
+       * tree-sra.c (build_access_from_expr_1): The first parameter type
+       changed to simple tree.
+       (build_access_from_expr): Likewise, gsi parameter was eliminated.
+       (scan_assign_result): Renamed to assignment_mod_result, enum elements
+       renamed as well.
+       (build_accesses_from_assign): Removed all parameters except for a
+       simple gimple statement.  Now returns a simple bool.
+       (scan_function): All non-analysis parts moved to separate functions
+       sra_modify_function_body and ipa_sra_modify_function_body.  Removed all
+       parameters and updated both callers.
+       (sra_modify_expr): Removed parameter data.
+       (sra_modify_function_body): New function.
+       (perform_intra_sra): Call sra_modify_function_body to modify the
+       function body.
+       (replace_removed_params_ssa_names): Parameter data changed into
+       adjustments vector.
+       (sra_ipa_modify_expr): Likewise.  Also removed unused parameter gsi and
+       changed the parameter dont_convert to convert with the opposite
+       meaning.
+       (sra_ipa_modify_assign): Parameter data changed into adjustments
+       vector, return value changed to bool.
+       (ipa_sra_modify_function_body): New function.
+       (sra_ipa_reset_debug_stmts): Updated a comment.
+       (modify_function): Use ipa_sra_modify_function_body to modify function
+       body.
+
 2010-05-04  H.J. Lu  <hongjiu.lu@intel.com>
 
        PR middle-end/43671
index 1bfb5c2..166338f 100644 (file)
@@ -903,10 +903,9 @@ disqualify_base_of_expr (tree t, const char *reason)
    created.  */
 
 static struct access *
-build_access_from_expr_1 (tree *expr_ptr, gimple stmt, bool write)
+build_access_from_expr_1 (tree expr, gimple stmt, bool write)
 {
   struct access *ret = NULL;
-  tree expr = *expr_ptr;
   bool partial_ref;
 
   if (TREE_CODE (expr) == BIT_FIELD_REF
@@ -958,18 +957,17 @@ build_access_from_expr_1 (tree *expr_ptr, gimple stmt, bool write)
   return ret;
 }
 
-/* Callback of scan_function.  Scan expression EXPR and create access
-   structures for all accesses to candidates for scalarization.  Return true if
-   any access has been inserted.  */
+/* Scan expression EXPR and create access structures for all accesses to
+   candidates for scalarization.  Return true if any access has been inserted.
+   STMT must be the statement from which the expression is taken, WRITE must be
+   true if the expression is a store and false otherwise. */
 
 static bool
-build_access_from_expr (tree *expr_ptr,
-                       gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED, bool write,
-                       void *data ATTRIBUTE_UNUSED)
+build_access_from_expr (tree expr, gimple stmt, bool write)
 {
   struct access *access;
 
-  access = build_access_from_expr_1 (expr_ptr, gsi_stmt (*gsi), write);
+  access = build_access_from_expr_1 (expr, stmt, write);
   if (access)
     {
       /* This means the aggregate is accesses as a whole in a way other than an
@@ -1001,39 +999,28 @@ disqualify_ops_if_throwing_stmt (gimple stmt, tree lhs, tree rhs)
   return false;
 }
 
-
-/* Result code for scan_assign callback for scan_function.  */
-enum scan_assign_result { SRA_SA_NONE,       /* nothing done for the stmt */
-                         SRA_SA_PROCESSED,  /* stmt analyzed/changed */
-                         SRA_SA_REMOVED };  /* stmt redundant and eliminated */
-
-
-/* Callback of scan_function.  Scan expressions occuring in the statement
-   pointed to by STMT_EXPR, create access structures for all accesses to
-   candidates for scalarization and remove those candidates which occur in
+/* Scan expressions occuring in STMT, create access structures for all accesses
+   to candidates for scalarization and remove those candidates which occur in
    statements or expressions that prevent them from being split apart.  Return
    true if any access has been inserted.  */
 
-static enum scan_assign_result
-build_accesses_from_assign (gimple *stmt_ptr,
-                           gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
-                           void *data ATTRIBUTE_UNUSED)
+static bool
+build_accesses_from_assign (gimple stmt)
 {
-  gimple stmt = *stmt_ptr;
-  tree *lhs_ptr, *rhs_ptr;
+  tree lhs, rhs;
   struct access *lacc, *racc;
 
   if (!gimple_assign_single_p (stmt))
-    return SRA_SA_NONE;
+    return false;
 
-  lhs_ptr = gimple_assign_lhs_ptr (stmt);
-  rhs_ptr = gimple_assign_rhs1_ptr (stmt);
+  lhs = gimple_assign_lhs (stmt);
+  rhs = gimple_assign_rhs1 (stmt);
 
-  if (disqualify_ops_if_throwing_stmt (stmt, *lhs_ptr, *rhs_ptr))
-    return SRA_SA_NONE;
+  if (disqualify_ops_if_throwing_stmt (stmt, lhs, rhs))
+    return false;
 
-  racc = build_access_from_expr_1 (rhs_ptr, stmt, false);
-  lacc = build_access_from_expr_1 (lhs_ptr, stmt, true);
+  racc = build_access_from_expr_1 (rhs, stmt, false);
+  lacc = build_access_from_expr_1 (lhs, stmt, true);
 
   if (racc)
     {
@@ -1047,7 +1034,7 @@ build_accesses_from_assign (gimple *stmt_ptr,
       && (sra_mode == SRA_MODE_EARLY_INTRA || sra_mode == SRA_MODE_INTRA)
       && !lacc->grp_unscalarizable_region
       && !racc->grp_unscalarizable_region
-      && AGGREGATE_TYPE_P (TREE_TYPE (*lhs_ptr))
+      && AGGREGATE_TYPE_P (TREE_TYPE (lhs))
       /* FIXME: Turn the following line into an assert after PR 40058 is
         fixed.  */
       && lacc->size == racc->size
@@ -1064,7 +1051,7 @@ build_accesses_from_assign (gimple *stmt_ptr,
       add_link_to_rhs (racc, link);
     }
 
-  return (lacc || racc) ? SRA_SA_PROCESSED : SRA_SA_NONE;
+  return lacc || racc;
 }
 
 /* Callback of walk_stmt_load_store_addr_ops visit_addr used to determine
@@ -1091,76 +1078,46 @@ callsite_has_enough_arguments_p (gimple call)
   return gimple_call_num_args (call) >= (unsigned) func_param_count;
 }
 
-/* Scan function and look for interesting statements. Return true if any has
-   been found or processed, as indicated by callbacks.  SCAN_EXPR is a callback
-   called on all expressions within statements except assign statements and
-   those deemed entirely unsuitable for some reason (all operands in such
-   statements and expression are removed from candidate_bitmap).  SCAN_ASSIGN
-   is a callback called on all assign statements, HANDLE_SSA_DEFS is a callback
-   called on assign statements and those call statements which have a lhs, it
-   can be NULL.  ANALYSIS_STAGE is true when running in the analysis stage of a
-   pass and thus no statement is being modified.  DATA is a pointer passed to
-   all callbacks.  If any single callback returns true, this function also
-   returns true, otherwise it returns false.  */
+/* Scan function and look for interesting expressions and create access
+   structures for them.  Return true iff any access is created.  */
 
 static bool
-scan_function (bool (*scan_expr) (tree *, gimple_stmt_iterator *, bool, void *),
-              enum scan_assign_result (*scan_assign) (gimple *,
-                                                      gimple_stmt_iterator *,
-                                                      void *),
-              bool (*handle_ssa_defs)(gimple, void *),
-              bool analysis_stage, void *data)
+scan_function (void)
 {
-  gimple_stmt_iterator gsi;
   basic_block bb;
-  unsigned i;
-  tree *t;
   bool ret = false;
 
   FOR_EACH_BB (bb)
     {
-      bool bb_changed = false;
-
-      if (handle_ssa_defs)
-       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-         ret |= handle_ssa_defs (gsi_stmt (gsi), data);
-
-      gsi = gsi_start_bb (bb);
-      while (!gsi_end_p (gsi))
+      gimple_stmt_iterator gsi;
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
        {
          gimple stmt = gsi_stmt (gsi);
-         enum scan_assign_result assign_result;
-         bool any = false, deleted = false;
+         tree t;
+         unsigned i;
 
-         if (analysis_stage && final_bbs && stmt_can_throw_external (stmt))
+         if (final_bbs && stmt_can_throw_external (stmt))
            bitmap_set_bit (final_bbs, bb->index);
          switch (gimple_code (stmt))
            {
            case GIMPLE_RETURN:
-             t = gimple_return_retval_ptr (stmt);
-             if (*t != NULL_TREE)
-               any |= scan_expr (t, &gsi, false, data);
-             if (analysis_stage && final_bbs)
+             t = gimple_return_retval (stmt);
+             if (t != NULL_TREE)
+               ret |= build_access_from_expr (t, stmt, false);
+             if (final_bbs)
                bitmap_set_bit (final_bbs, bb->index);
              break;
 
            case GIMPLE_ASSIGN:
-             assign_result = scan_assign (&stmt, &gsi, data);
-             any |= assign_result == SRA_SA_PROCESSED;
-             deleted = assign_result == SRA_SA_REMOVED;
-             if (handle_ssa_defs && assign_result != SRA_SA_REMOVED)
-               any |= handle_ssa_defs (stmt, data);
+             ret |= build_accesses_from_assign (stmt);
              break;
 
            case GIMPLE_CALL:
-             /* Operands must be processed before the lhs.  */
              for (i = 0; i < gimple_call_num_args (stmt); i++)
-               {
-                 tree *argp = gimple_call_arg_ptr (stmt, i);
-                 any |= scan_expr (argp, &gsi, false, data);
-               }
+               ret |= build_access_from_expr (gimple_call_arg (stmt, i),
+                                              stmt, false);
 
-             if (analysis_stage && sra_mode == SRA_MODE_EARLY_IPA)
+             if (sra_mode == SRA_MODE_EARLY_IPA)
                {
                  tree dest = gimple_call_fndecl (stmt);
                  int flags = gimple_call_flags (stmt);
@@ -1184,65 +1141,33 @@ scan_function (bool (*scan_expr) (tree *, gimple_stmt_iterator *, bool, void *),
                    bitmap_set_bit (final_bbs, bb->index);
                }
 
-             if (gimple_call_lhs (stmt))
-               {
-                 tree *lhs_ptr = gimple_call_lhs_ptr (stmt);
-                 if (!analysis_stage
-                     || !disqualify_ops_if_throwing_stmt (stmt,
-                                                          *lhs_ptr, NULL))
-                   {
-                     any |= scan_expr (lhs_ptr, &gsi, true, data);
-                     if (handle_ssa_defs)
-                       any |= handle_ssa_defs (stmt, data);
-                   }
-               }
+             t = gimple_call_lhs (stmt);
+             if (t && !disqualify_ops_if_throwing_stmt (stmt, t, NULL))
+               ret |= build_access_from_expr (t, stmt, true);
              break;
 
            case GIMPLE_ASM:
-             if (analysis_stage)
-               {
-                 walk_stmt_load_store_addr_ops (stmt, NULL, NULL, NULL,
-                                                asm_visit_addr);
-                 if (final_bbs)
-                   bitmap_set_bit (final_bbs, bb->index);
-               }
+             walk_stmt_load_store_addr_ops (stmt, NULL, NULL, NULL,
+                                            asm_visit_addr);
+             if (final_bbs)
+               bitmap_set_bit (final_bbs, bb->index);
+
              for (i = 0; i < gimple_asm_ninputs (stmt); i++)
                {
-                 tree *op = &TREE_VALUE (gimple_asm_input_op (stmt, i));
-                 any |= scan_expr (op, &gsi, false, data);
+                 t = TREE_VALUE (gimple_asm_input_op (stmt, i));
+                 ret |= build_access_from_expr (t, stmt, false);
                }
              for (i = 0; i < gimple_asm_noutputs (stmt); i++)
                {
-                 tree *op = &TREE_VALUE (gimple_asm_output_op (stmt, i));
-                 any |= scan_expr (op, &gsi, true, data);
+                 t = TREE_VALUE (gimple_asm_output_op (stmt, i));
+                 ret |= build_access_from_expr (t, stmt, true);
                }
              break;
 
            default:
              break;
            }
-
-         if (any)
-           {
-             ret = true;
-
-             if (!analysis_stage)
-               {
-                 bb_changed = true;
-                 update_stmt (stmt);
-                 maybe_clean_eh_stmt (stmt);
-               }
-           }
-         if (deleted)
-           bb_changed = true;
-         else
-           {
-             gsi_next (&gsi);
-             ret = true;
-           }
        }
-      if (!analysis_stage && bb_changed && sra_mode == SRA_MODE_EARLY_IPA)
-       gimple_purge_dead_eh_edges (bb);
     }
 
   return ret;
@@ -2300,15 +2225,14 @@ get_access_for_expr (tree expr)
   return get_var_base_offset_size_access (base, offset, max_size);
 }
 
-/* Callback for scan_function.  Replace the expression EXPR with a scalar
-   replacement if there is one and generate other statements to do type
-   conversion or subtree copying if necessary.  GSI is used to place newly
-   created statements, WRITE is true if the expression is being written to (it
-   is on a LHS of a statement or output in an assembly statement).  */
+/* Replace the expression EXPR with a scalar replacement if there is one and
+   generate other statements to do type conversion or subtree copying if
+   necessary.  GSI is used to place newly created statements, WRITE is true if
+   the expression is being written to (it is on a LHS of a statement or output
+   in an assembly statement).  */
 
 static bool
-sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write,
-                void *data ATTRIBUTE_UNUSED)
+sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write)
 {
   struct access *access;
   tree type, bfr;
@@ -2510,11 +2434,17 @@ load_assign_lhs_subreplacements (struct access *lacc, struct access *top_racc,
   while (lacc);
 }
 
+/* Result code for SRA assignment modification.  */
+enum assignment_mod_result { SRA_AM_NONE,       /* nothing done for the stmt */
+                            SRA_AM_MODIFIED,  /* stmt changed but not
+                                                 removed */
+                            SRA_AM_REMOVED };  /* stmt eliminated */
+
 /* Modify assignments with a CONSTRUCTOR on their RHS.  STMT contains a pointer
    to the assignment and GSI is the statement iterator pointing at it.  Returns
    the same values as sra_modify_assign.  */
 
-static enum scan_assign_result
+static enum assignment_mod_result
 sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
 {
   tree lhs = gimple_assign_lhs (*stmt);
@@ -2522,7 +2452,7 @@ sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
 
   acc = get_access_for_expr (lhs);
   if (!acc)
-    return SRA_SA_NONE;
+    return SRA_AM_NONE;
 
   if (VEC_length (constructor_elt,
                  CONSTRUCTOR_ELTS (gimple_assign_rhs1 (*stmt))) > 0)
@@ -2532,7 +2462,7 @@ sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
       if (access_has_children_p (acc))
        generate_subtree_copies (acc->first_child, acc->base, 0, 0, 0, gsi,
                                 true, true);
-      return SRA_SA_PROCESSED;
+      return SRA_AM_MODIFIED;
     }
 
   if (acc->grp_covered)
@@ -2540,12 +2470,12 @@ sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
       init_subtree_with_zero (acc, gsi, false);
       unlink_stmt_vdef (*stmt);
       gsi_remove (gsi, true);
-      return SRA_SA_REMOVED;
+      return SRA_AM_REMOVED;
     }
   else
     {
       init_subtree_with_zero (acc, gsi, true);
-      return SRA_SA_PROCESSED;
+      return SRA_AM_MODIFIED;
     }
 }
 
@@ -2578,16 +2508,14 @@ replace_uses_with_default_def_ssa_name (tree ssa)
   replace_uses_by (ssa, repl);
 }
 
-/* Callback of scan_function to process assign statements.  It examines both
-   sides of the statement, replaces them with a scalare replacement if there is
-   one and generating copying of replacements if scalarized aggregates have been
-   used in the assignment.  STMT is a pointer to the assign statement, GSI is
-   used to hold generated statements for type conversions and subtree
+/* Examine both sides of the assignment statement pointed to by STMT, replace
+   them with a scalare replacement if there is one and generate copying of
+   replacements if scalarized aggregates have been used in the assignment.  GSI
+   is used to hold generated statements for type conversions and subtree
    copying.  */
 
-static enum scan_assign_result
-sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi,
-                  void *data ATTRIBUTE_UNUSED)
+static enum assignment_mod_result
+sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi)
 {
   struct access *lacc, *racc;
   tree lhs, rhs;
@@ -2597,7 +2525,7 @@ sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi,
   gimple_stmt_iterator orig_gsi = *gsi;
 
   if (!gimple_assign_single_p (*stmt))
-    return SRA_SA_NONE;
+    return SRA_AM_NONE;
   lhs = gimple_assign_lhs (*stmt);
   rhs = gimple_assign_rhs1 (*stmt);
 
@@ -2609,16 +2537,16 @@ sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi,
       || TREE_CODE (rhs) == BIT_FIELD_REF || TREE_CODE (lhs) == BIT_FIELD_REF)
     {
       modify_this_stmt = sra_modify_expr (gimple_assign_rhs1_ptr (*stmt),
-                                         gsi, false, data);
+                                         gsi, false);
       modify_this_stmt |= sra_modify_expr (gimple_assign_lhs_ptr (*stmt),
-                                          gsi, true, data);
-      return modify_this_stmt ? SRA_SA_PROCESSED : SRA_SA_NONE;
+                                          gsi, true);
+      return modify_this_stmt ? SRA_AM_MODIFIED : SRA_AM_NONE;
     }
 
   lacc = get_access_for_expr (lhs);
   racc = get_access_for_expr (rhs);
   if (!lacc && !racc)
-    return SRA_SA_NONE;
+    return SRA_AM_NONE;
 
   if (lacc && lacc->grp_to_be_replaced)
     {
@@ -2747,7 +2675,7 @@ sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi,
              unlink_stmt_vdef (*stmt);
              gsi_remove (&orig_gsi, true);
              sra_stats.deleted++;
-             return SRA_SA_REMOVED;
+             return SRA_AM_REMOVED;
            }
        }
       else
@@ -2767,7 +2695,7 @@ sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi,
                  unlink_stmt_vdef (*stmt);
                  gsi_remove (gsi, true);
                  sra_stats.deleted++;
-                 return SRA_SA_REMOVED;
+                 return SRA_AM_REMOVED;
                }
              else if (racc->first_child)
                generate_subtree_copies (racc->first_child, lhs,
@@ -2790,7 +2718,83 @@ sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi,
       gcc_assert (*stmt == gsi_stmt (orig_gsi));
     }
 
-  return modify_this_stmt ? SRA_SA_PROCESSED : SRA_SA_NONE;
+  return modify_this_stmt ? SRA_AM_MODIFIED : SRA_AM_NONE;
+}
+
+/* Traverse the function body and all modifications as decided in
+   analyze_all_variable_accesses.  */
+
+static void
+sra_modify_function_body (void)
+{
+  basic_block bb;
+
+  FOR_EACH_BB (bb)
+    {
+      gimple_stmt_iterator gsi = gsi_start_bb (bb);
+      while (!gsi_end_p (gsi))
+       {
+         gimple stmt = gsi_stmt (gsi);
+         enum assignment_mod_result assign_result;
+         bool modified = false, deleted = false;
+         tree *t;
+         unsigned i;
+
+         switch (gimple_code (stmt))
+           {
+           case GIMPLE_RETURN:
+             t = gimple_return_retval_ptr (stmt);
+             if (*t != NULL_TREE)
+               modified |= sra_modify_expr (t, &gsi, false);
+             break;
+
+           case GIMPLE_ASSIGN:
+             assign_result = sra_modify_assign (&stmt, &gsi);
+             modified |= assign_result == SRA_AM_MODIFIED;
+             deleted = assign_result == SRA_AM_REMOVED;
+             break;
+
+           case GIMPLE_CALL:
+             /* Operands must be processed before the lhs.  */
+             for (i = 0; i < gimple_call_num_args (stmt); i++)
+               {
+                 t = gimple_call_arg_ptr (stmt, i);
+                 modified |= sra_modify_expr (t, &gsi, false);
+               }
+
+             if (gimple_call_lhs (stmt))
+               {
+                 t = gimple_call_lhs_ptr (stmt);
+                 modified |= sra_modify_expr (t, &gsi, true);
+               }
+             break;
+
+           case GIMPLE_ASM:
+             for (i = 0; i < gimple_asm_ninputs (stmt); i++)
+               {
+                 t = &TREE_VALUE (gimple_asm_input_op (stmt, i));
+                 modified |= sra_modify_expr (t, &gsi, false);
+               }
+             for (i = 0; i < gimple_asm_noutputs (stmt); i++)
+               {
+                 t = &TREE_VALUE (gimple_asm_output_op (stmt, i));
+                 modified |= sra_modify_expr (t, &gsi, true);
+               }
+             break;
+
+           default:
+             break;
+           }
+
+         if (modified)
+           {
+             update_stmt (stmt);
+             maybe_clean_eh_stmt (stmt);
+           }
+         if (!deleted)
+           gsi_next (&gsi);
+       }
+    }
 }
 
 /* Generate statements initializing scalar replacements of parts of function
@@ -2844,14 +2848,13 @@ perform_intra_sra (void)
   if (!find_var_candidates ())
     goto out;
 
-  if (!scan_function (build_access_from_expr, build_accesses_from_assign, NULL,
-                     true, NULL))
+  if (!scan_function ())
     goto out;
 
   if (!analyze_all_variable_accesses ())
     goto out;
 
-  scan_function (sra_modify_expr, sra_modify_assign, NULL, false, NULL);
+  sra_modify_function_body ();
   initialize_parameter_reductions ();
 
   statistics_counter_event (cfun, "Scalar replacements created",
@@ -3786,20 +3789,18 @@ get_adjustment_for_base (ipa_parm_adjustment_vec adjustments, tree base)
   return NULL;
 }
 
-/* Callback for scan_function.  If the statement STMT defines an SSA_NAME of a
-   parameter which is to be removed because its value is not used, replace the
-   SSA_NAME with a one relating to a created VAR_DECL and replace all of its
-   uses too and return true (update_stmt is then issued for the statement by
-   the caller).  DATA is a pointer to an adjustments vector.  */
+/* If the statement STMT defines an SSA_NAME of a parameter which is to be
+   removed because its value is not used, replace the SSA_NAME with a one
+   relating to a created VAR_DECL together all of its uses and return true.
+   ADJUSTMENTS is a pointer to an adjustments vector.  */
 
 static bool
-replace_removed_params_ssa_names (gimple stmt, void *data)
+replace_removed_params_ssa_names (gimple stmt,
+                                 ipa_parm_adjustment_vec adjustments)
 {
-  VEC (ipa_parm_adjustment_t, heap) *adjustments;
   struct ipa_parm_adjustment *adj;
   tree lhs, decl, repl, name;
 
-  adjustments = (VEC (ipa_parm_adjustment_t, heap) *) data;
   if (gimple_code (stmt) == GIMPLE_PHI)
     lhs = gimple_phi_result (stmt);
   else if (is_gimple_assign (stmt))
@@ -3842,27 +3843,22 @@ replace_removed_params_ssa_names (gimple stmt, void *data)
   return true;
 }
 
-/* Callback for scan_function and helper to sra_ipa_modify_assign.  If the
-   expression *EXPR should be replaced by a reduction of a parameter, do so.
-   DATA is a pointer to a vector of adjustments.  DONT_CONVERT specifies
-   whether the function should care about type incompatibility the current and
-   new expressions.  If it is true, the function will leave incompatibility
-   issues to the caller.
-
-   When called directly by scan_function, DONT_CONVERT is true when the EXPR is
-   a write (LHS) expression.  */
+/* If the expression *EXPR should be replaced by a reduction of a parameter, do
+   so.  ADJUSTMENTS is a pointer to a vector of adjustments.  CONVERT
+   specifies whether the function should care about type incompatibility the
+   current and new expressions.  If it is false, the function will leave
+   incompatibility issues to the caller.  Return true iff the expression
+   was modified. */
 
 static bool
-sra_ipa_modify_expr (tree *expr, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
-                    bool dont_convert, void *data)
+sra_ipa_modify_expr (tree *expr, bool convert,
+                    ipa_parm_adjustment_vec adjustments)
 {
-  ipa_parm_adjustment_vec adjustments;
   int i, len;
   struct ipa_parm_adjustment *adj, *cand = NULL;
   HOST_WIDE_INT offset, size, max_size;
   tree base, src;
 
-  adjustments = (VEC (ipa_parm_adjustment_t, heap) *) data;
   len = VEC_length (ipa_parm_adjustment_t, adjustments);
 
   if (TREE_CODE (*expr) == BIT_FIELD_REF
@@ -3870,7 +3866,7 @@ sra_ipa_modify_expr (tree *expr, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
       || TREE_CODE (*expr) == REALPART_EXPR)
     {
       expr = &TREE_OPERAND (*expr, 0);
-      dont_convert = false;
+      convert = true;
     }
 
   base = get_ref_base_and_extent (*expr, &offset, &size, &max_size);
@@ -3919,8 +3915,7 @@ sra_ipa_modify_expr (tree *expr, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
       fprintf (dump_file, "\n");
     }
 
-  if (!dont_convert
-      && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type))
+  if (convert && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type))
     {
       tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr), src);
       *expr = vce;
@@ -3930,24 +3925,28 @@ sra_ipa_modify_expr (tree *expr, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
   return true;
 }
 
-/* Callback for scan_function to process assign statements.  Performs
-   essentially the same function like sra_ipa_modify_expr.  */
+/* If the statement pointed to by STMT_PTR contains any expressions that need
+   to replaced with a different one as noted by ADJUSTMENTS, do so.  Handle any
+   potential type incompatibilities (GSI is used to accommodate conversion
+   statements and must point to the statement).  Return true iff the statement
+   was modified.  */
 
-static enum scan_assign_result
-sra_ipa_modify_assign (gimple *stmt_ptr, gimple_stmt_iterator *gsi, void *data)
+static bool
+sra_ipa_modify_assign (gimple *stmt_ptr, gimple_stmt_iterator *gsi,
+                      ipa_parm_adjustment_vec adjustments)
 {
   gimple stmt = *stmt_ptr;
   tree *lhs_p, *rhs_p;
   bool any;
 
   if (!gimple_assign_single_p (stmt))
-    return SRA_SA_NONE;
+    return false;
 
   rhs_p = gimple_assign_rhs1_ptr (stmt);
   lhs_p = gimple_assign_lhs_ptr (stmt);
 
-  any = sra_ipa_modify_expr (rhs_p, gsi, true, data);
-  any |= sra_ipa_modify_expr (lhs_p, gsi, true, data);
+  any = sra_ipa_modify_expr (rhs_p, false, adjustments);
+  any |= sra_ipa_modify_expr (lhs_p, false, adjustments);
   if (any)
     {
       tree new_rhs = NULL_TREE;
@@ -3983,10 +3982,94 @@ sra_ipa_modify_assign (gimple *stmt_ptr, gimple_stmt_iterator *gsi, void *data)
          gimple_assign_set_rhs_from_tree (gsi, tmp);
        }
 
-      return SRA_SA_PROCESSED;
+      return true;
     }
 
-  return SRA_SA_NONE;
+  return false;
+}
+
+/* Traverse the function body and all modifications as described in
+   ADJUSTMENTS.  */
+
+static void
+ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments)
+{
+  basic_block bb;
+
+  FOR_EACH_BB (bb)
+    {
+      gimple_stmt_iterator gsi;
+      bool bb_changed = false;
+
+      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+       replace_removed_params_ssa_names (gsi_stmt (gsi), adjustments);
+
+      gsi = gsi_start_bb (bb);
+      while (!gsi_end_p (gsi))
+       {
+         gimple stmt = gsi_stmt (gsi);
+         bool modified = false;
+         tree *t;
+         unsigned i;
+
+         switch (gimple_code (stmt))
+           {
+           case GIMPLE_RETURN:
+             t = gimple_return_retval_ptr (stmt);
+             if (*t != NULL_TREE)
+               modified |= sra_ipa_modify_expr (t, true, adjustments);
+             break;
+
+           case GIMPLE_ASSIGN:
+             modified |= sra_ipa_modify_assign (&stmt, &gsi, adjustments);
+             modified |= replace_removed_params_ssa_names (stmt, adjustments);
+             break;
+
+           case GIMPLE_CALL:
+             /* Operands must be processed before the lhs.  */
+             for (i = 0; i < gimple_call_num_args (stmt); i++)
+               {
+                 t = gimple_call_arg_ptr (stmt, i);
+                 modified |= sra_ipa_modify_expr (t, true, adjustments);
+               }
+
+             if (gimple_call_lhs (stmt))
+               {
+                 t = gimple_call_lhs_ptr (stmt);
+                 modified |= sra_ipa_modify_expr (t, false, adjustments);
+                 modified |= replace_removed_params_ssa_names (stmt,
+                                                               adjustments);
+               }
+             break;
+
+           case GIMPLE_ASM:
+             for (i = 0; i < gimple_asm_ninputs (stmt); i++)
+               {
+                 t = &TREE_VALUE (gimple_asm_input_op (stmt, i));
+                 modified |= sra_ipa_modify_expr (t, true, adjustments);
+               }
+             for (i = 0; i < gimple_asm_noutputs (stmt); i++)
+               {
+                 t = &TREE_VALUE (gimple_asm_output_op (stmt, i));
+                 modified |= sra_ipa_modify_expr (t, false, adjustments);
+               }
+             break;
+
+           default:
+             break;
+           }
+
+         if (modified)
+           {
+             bb_changed = true;
+             update_stmt (stmt);
+             maybe_clean_eh_stmt (stmt);
+           }
+         gsi_next (&gsi);
+       }
+      if (bb_changed)
+       gimple_purge_dead_eh_edges (bb);
+    }
 }
 
 /* Call gimple_debug_bind_reset_value on all debug statements describing
@@ -4013,7 +4096,8 @@ sra_ipa_reset_debug_stmts (ipa_parm_adjustment_vec adjustments)
        continue;
       FOR_EACH_IMM_USE_STMT (stmt, ui, name)
        {
-         /* All other users must have been removed by scan_function.  */
+         /* All other users must have been removed by
+            ipa_sra_modify_function_body.  */
          gcc_assert (is_gimple_debug (stmt));
          gimple_debug_bind_reset_value (stmt);
          update_stmt (stmt);
@@ -4131,8 +4215,7 @@ modify_function (struct cgraph_node *node, ipa_parm_adjustment_vec adjustments)
      as following functions will use what it computed.  */
   create_abstract_origin (current_function_decl);
   ipa_modify_formal_parameters (current_function_decl, adjustments, "ISRA");
-  scan_function (sra_ipa_modify_expr, sra_ipa_modify_assign,
-                replace_removed_params_ssa_names, false, adjustments);
+  ipa_sra_modify_function_body (adjustments);
   sra_ipa_reset_debug_stmts (adjustments);
   convert_callers (node, adjustments);
   cgraph_make_node_local (node);
@@ -4224,8 +4307,7 @@ ipa_early_sra (void)
                                 * last_basic_block_for_function (cfun));
   final_bbs = BITMAP_ALLOC (NULL);
 
-  scan_function (build_access_from_expr, build_accesses_from_assign,
-                NULL, true, NULL);
+  scan_function ();
   if (encountered_apply_args)
     {
       if (dump_file)