https://gcc.gnu.org/g:8f1560e8f96a3f4c20a82d420a24dfea13ce5e8a
commit 8f1560e8f96a3f4c20a82d420a24dfea13ce5e8a Author: Michael Matz <[email protected]> Date: Mon Feb 26 03:19:19 2018 +0100 no-update-stmt: Remove more update_stmt_for_real This implements updating when setting non-trivial trees via SET_USE in debug statements and properly using gimple setters in some more files. Diff: --- gcc/gimple.c | 3 ++- gcc/ipa-param-manipulation.c | 9 ++++++--- gcc/ipa-param-manipulation.h | 2 +- gcc/tree-cfg.c | 7 +++++-- gcc/tree-inline.c | 6 ++++++ gcc/tree-parloops.c | 9 ++++++--- gcc/tree-sra.c | 43 +++++++++++++++++++---------------------- gcc/tree-ssa-dse.c | 40 ++++++++++++++++++++------------------ gcc/tree-ssa-loop-im.c | 14 ++++++++------ gcc/tree-ssa-loop-ivopts.c | 46 +++++++++++++++++++++++++++++++++++--------- gcc/tree-ssa-operands.c | 42 ++++++++++++++++++++++++++++++++++------ gcc/tree-ssa.c | 6 ++---- 12 files changed, 150 insertions(+), 77 deletions(-) diff --git a/gcc/gimple.c b/gcc/gimple.c index 11fa0a8af866..e8811a58ddc8 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -1593,8 +1593,9 @@ gimple_assign_unary_nop_p (gimple *gs) void gimple_set_bb (gimple *stmt, basic_block bb) { + basic_block oldbb = stmt->bb; stmt->bb = bb; - if (flag_try_patch && bb) + if (flag_try_patch && !oldbb && bb) update_stmt_for_real (stmt); if (gimple_code (stmt) != GIMPLE_LABEL) diff --git a/gcc/ipa-param-manipulation.c b/gcc/ipa-param-manipulation.c index 1ab1fcccdaec..5a2ee5e63691 100644 --- a/gcc/ipa-param-manipulation.c +++ b/gcc/ipa-param-manipulation.c @@ -618,6 +618,8 @@ ipa_get_adjustment_candidate (tree **expr, bool *convert, ipa_parm_adjustment_vec adjustments, bool ignore_default_def) { + if (TREE_CODE (**expr) == TREE_LIST) + *expr = &TREE_VALUE (**expr); if (TREE_CODE (**expr) == BIT_FIELD_REF || TREE_CODE (**expr) == IMAGPART_EXPR || TREE_CODE (**expr) == REALPART_EXPR) @@ -671,9 +673,10 @@ ipa_get_adjustment_candidate (tree **expr, bool *convert, was modified. */ bool -ipa_modify_expr (tree *expr, bool convert, +ipa_modify_expr (gimple *stmt, tree *expr, bool convert, ipa_parm_adjustment_vec adjustments) { + tree *op_ptr = expr; struct ipa_parm_adjustment *cand = ipa_get_adjustment_candidate (&expr, &convert, adjustments, false); if (!cand) @@ -700,10 +703,10 @@ ipa_modify_expr (tree *expr, bool convert, if (convert && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type)) { tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr), src); - *expr = vce; + gimple_change_in_op (stmt, op_ptr, expr, vce); } else - *expr = src; + gimple_change_in_op (stmt, op_ptr, expr, src); return true; } diff --git a/gcc/ipa-param-manipulation.h b/gcc/ipa-param-manipulation.h index 84bc42d51968..4f877eca0998 100644 --- a/gcc/ipa-param-manipulation.h +++ b/gcc/ipa-param-manipulation.h @@ -112,7 +112,7 @@ ipa_parm_adjustment_vec ipa_combine_adjustments (ipa_parm_adjustment_vec, ipa_parm_adjustment_vec); void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree); -bool ipa_modify_expr (tree *, bool, ipa_parm_adjustment_vec); +bool ipa_modify_expr (gimple *, tree *, bool, ipa_parm_adjustment_vec); ipa_parm_adjustment *ipa_get_adjustment_candidate (tree **, bool *, ipa_parm_adjustment_vec, bool); diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 5fe405506424..7fe7966489ac 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -2033,7 +2033,7 @@ replace_uses_by (tree name, tree val) if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt)) gimple_purge_dead_eh_edges (gimple_bb (stmt)); - /* SET_USE (within replace_exp) update all operand caches + /* SET_USE (within replace_exp) updates all operand caches and VOPs, except when we change the call target from e.g. unknown to pure/const. */ if ((call = dyn_cast <gcall *> (stmt)) @@ -9382,6 +9382,9 @@ execute_fixup_cfg (void) if (gimple_in_ssa_p (cfun) && gimple_vuse (stmt)) { todo |= TODO_update_ssa | TODO_cleanup_cfg; + /* XXX Maybe find nicer way to recheck VOPs when + only call targets might have changed, instead + of rechecking the whole stmt. */ update_stmt_for_real (stmt); } } @@ -9389,7 +9392,7 @@ execute_fixup_cfg (void) if (flags & ECF_NORETURN && fixup_noreturn_call (stmt)) todo |= TODO_cleanup_cfg; - } + } /* Remove stores to variables we marked write-only. Keep access when store has side effect, i.e. in case when source diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 1696ba9d3598..0aa7bd13ae35 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -2919,6 +2919,12 @@ copy_debug_stmt (gdebug *stmt, copy_body_data *id) processing_debug_stmt = 0; + /* remap_gimple_op_r doesn't use normal operand setters but direct + access for remapping, which is okay at stmt-copy time because + then the copy doesn't yet belong to a BB. But here the debug + stmts are already part of a function and hence have operand caches, + so that direct modification clobbers the operands. Hence recheck + the whole stmt. */ update_stmt_for_real (stmt); } diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c index a3276e7d40ee..64908af67b33 100644 --- a/gcc/tree-parloops.c +++ b/gcc/tree-parloops.c @@ -649,7 +649,8 @@ eliminate_local_variables_1 (tree *tp, int *walk_subtrees, void *data) return NULL_TREE; } - *tp = build_simple_mem_ref (addr); + gimple_change_in_op (dta->info.stmt, dta->info.op_ptr, tp, + build_simple_mem_ref (addr)); dta->changed = true; return NULL_TREE; @@ -685,7 +686,7 @@ eliminate_local_variables_1 (tree *tp, int *walk_subtrees, void *data) dta->reset = true; return NULL_TREE; } - *tp = addr; + gimple_change_in_op (dta->info.stmt, dta->info.op_ptr, tp, addr); dta->changed = true; return NULL_TREE; @@ -718,6 +719,8 @@ eliminate_local_variables_stmt (edge entry, gimple_stmt_iterator *gsi, if (gimple_debug_bind_p (stmt)) { dta.gsi = NULL; + dta.info.stmt = stmt; + dta.info.op_ptr = gimple_debug_bind_get_value_ptr (stmt); walk_tree (gimple_debug_bind_get_value_ptr (stmt), eliminate_local_variables_1, &dta.info, NULL); if (dta.reset) @@ -742,7 +745,7 @@ eliminate_local_variables_stmt (edge entry, gimple_stmt_iterator *gsi, /* XXX If we weren't changing the gimple ops via direct pointer access we wouldn't need to do this: */ if (dta.changed) - update_stmt_for_real (stmt); + update_stmt (stmt); } /* Eliminates the references to local variables from the single entry diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 3be6d2ca09a6..5225dec97689 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -3128,12 +3128,16 @@ sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write) location_t loc; struct access *access; tree type, bfr, orig_expr; + tree *op_ptr = expr; + gimple *stmt = gsi_stmt (*gsi); if (TREE_CODE (*expr) == BIT_FIELD_REF) { bfr = *expr; expr = &TREE_OPERAND (*expr, 0); } + else if (TREE_CODE (*expr) == TREE_LIST) + expr = &TREE_VALUE (*expr), bfr = NULL_TREE; else bfr = NULL_TREE; @@ -3196,7 +3200,7 @@ sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write) } } else - *expr = repl; + gimple_change_in_op (stmt, op_ptr, expr, repl); sra_stats.exprs++; } else if (write && access->grp_to_be_debug_replaced) @@ -3831,12 +3835,12 @@ sra_modify_function_body (void) gasm *asm_stmt = as_a <gasm *> (stmt); for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++) { - t = &TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); + t = gimple_asm_input_op_ptr (asm_stmt, i); modified |= sra_modify_expr (t, &gsi, false); } for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++) { - t = &TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); + t = gimple_asm_output_op_ptr (asm_stmt, i); modified |= sra_modify_expr (t, &gsi, true); } } @@ -3848,10 +3852,7 @@ sra_modify_function_body (void) if (modified) { - /* XXX Use proper gimple operand setter to update - operands instead of in-place modifications, so no - update_stmt is necessary. */ - update_stmt_for_real (stmt); + update_stmt (stmt); if (maybe_clean_eh_stmt (stmt) && gimple_purge_dead_eh_edges (gimple_bb (stmt))) cfg_changed = true; @@ -4976,8 +4977,8 @@ sra_ipa_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi, rhs_p = gimple_assign_rhs1_ptr (stmt); lhs_p = gimple_assign_lhs_ptr (stmt); - any = ipa_modify_expr (rhs_p, false, adjustments); - any |= ipa_modify_expr (lhs_p, false, adjustments); + any = ipa_modify_expr (stmt, rhs_p, false, adjustments); + any |= ipa_modify_expr (stmt, lhs_p, false, adjustments); if (any) { tree new_rhs = NULL_TREE; @@ -4988,10 +4989,9 @@ sra_ipa_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi, { /* V_C_Es of constructors can cause trouble (PR 42714). */ if (is_gimple_reg_type (TREE_TYPE (*lhs_p))) - *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p)); + new_rhs = build_zero_cst (TREE_TYPE (*lhs_p)); else - *rhs_p = build_constructor (TREE_TYPE (*lhs_p), - NULL); + new_rhs = build_constructor (TREE_TYPE (*lhs_p), NULL); } else new_rhs = fold_build1_loc (gimple_location (stmt), @@ -5058,7 +5058,7 @@ ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments) case GIMPLE_RETURN: t = gimple_return_retval_ptr (as_a <greturn *> (stmt)); if (*t != NULL_TREE) - modified |= ipa_modify_expr (t, true, adjustments); + modified |= ipa_modify_expr (stmt, t, true, adjustments); break; case GIMPLE_ASSIGN: @@ -5070,13 +5070,13 @@ ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments) for (i = 0; i < gimple_call_num_args (stmt); i++) { t = gimple_call_arg_ptr (stmt, i); - modified |= ipa_modify_expr (t, true, adjustments); + modified |= ipa_modify_expr (stmt, t, true, adjustments); } if (gimple_call_lhs (stmt)) { t = gimple_call_lhs_ptr (stmt); - modified |= ipa_modify_expr (t, false, adjustments); + modified |= ipa_modify_expr (stmt, t, false, adjustments); } break; @@ -5085,13 +5085,13 @@ ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments) gasm *asm_stmt = as_a <gasm *> (stmt); for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++) { - t = &TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); - modified |= ipa_modify_expr (t, true, adjustments); + t = gimple_asm_input_op_ptr (asm_stmt, i); + modified |= ipa_modify_expr (stmt, t, true, adjustments); } for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++) { - t = &TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); - modified |= ipa_modify_expr (t, false, adjustments); + t = gimple_asm_output_op_ptr (asm_stmt, i); + modified |= ipa_modify_expr (stmt, t, false, adjustments); } } break; @@ -5116,10 +5116,7 @@ ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments) if (modified) { - /* XXX Use proper gimple operand setter to update - operands instead of in-place modifications, so no - update_stmt is necessary. */ - update_stmt_for_real (stmt); + update_stmt (stmt); if (maybe_clean_eh_stmt (stmt) && gimple_purge_dead_eh_edges (gimple_bb (stmt))) cfg_changed = true; diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c index bcaed1675cd8..68ce140dedc0 100644 --- a/gcc/tree-ssa-dse.c +++ b/gcc/tree-ssa-dse.c @@ -376,27 +376,24 @@ decrement_count (gimple *stmt, int decrement) } -static void -increment_start_addr (gimple *stmt, tree *where, int increment) +static tree +increment_start_addr (gimple *stmt, tree where, int increment) { - if (TREE_CODE (*where) == SSA_NAME) + if (TREE_CODE (where) == SSA_NAME) { - tree tem = make_ssa_name (TREE_TYPE (*where)); + tree tem = make_ssa_name (TREE_TYPE (where)); gassign *newop - = gimple_build_assign (tem, POINTER_PLUS_EXPR, *where, + = gimple_build_assign (tem, POINTER_PLUS_EXPR, where, build_int_cst (sizetype, increment)); gimple_stmt_iterator gsi = gsi_for_stmt (stmt); gsi_insert_before (&gsi, newop, GSI_SAME_STMT); - *where = tem; - /* XXX don't use direct operand change via pointer. */ - update_stmt_for_real (gsi_stmt (gsi)); - return; + return tem; } - *where = build_fold_addr_expr (fold_build2 (MEM_REF, char_type_node, - *where, - build_int_cst (ptr_type_node, - increment))); + return build_fold_addr_expr (fold_build2 (MEM_REF, char_type_node, + where, + build_int_cst (ptr_type_node, + increment))); } /* STMT is builtin call that writes bytes in bitmap ORIG, some bytes are dead @@ -425,11 +422,14 @@ maybe_trim_memstar_call (ao_ref *ref, sbitmap live, gimple *stmt) /* Head trimming requires adjusting all the arguments. */ if (head_trim) { - tree *dst = gimple_call_arg_ptr (stmt, 0); - increment_start_addr (stmt, dst, head_trim); - tree *src = gimple_call_arg_ptr (stmt, 1); - increment_start_addr (stmt, src, head_trim); + tree dst = gimple_call_arg(stmt, 0); + gimple_call_set_arg (stmt, 0, + increment_start_addr (stmt, dst, head_trim)); + tree src = gimple_call_arg(stmt, 1); + gimple_call_set_arg (stmt, 1, + increment_start_addr (stmt, src, head_trim)); decrement_count (stmt, head_trim); + update_stmt (stmt); } break; } @@ -446,9 +446,11 @@ maybe_trim_memstar_call (ao_ref *ref, sbitmap live, gimple *stmt) /* Head trimming requires adjusting all the arguments. */ if (head_trim) { - tree *dst = gimple_call_arg_ptr (stmt, 0); - increment_start_addr (stmt, dst, head_trim); + tree dst = gimple_call_arg (stmt, 0); + gimple_call_set_arg (stmt, 0, + increment_start_addr (stmt, dst, head_trim)); decrement_count (stmt, head_trim); + update_stmt (stmt); } break; } diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index 4dddd3056bc5..2b7aa6580218 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -1666,12 +1666,14 @@ struct rewrite_mem_ref_loc bool rewrite_mem_ref_loc::operator () (mem_ref_loc *loc) { - /* XXX should use proper gimple operand setters so that - update_stmt isn't needed. (At this point we replace a real - memref (in top-level operand) with a tmp VAR_DECL which is - going to become an SSA name) */ - *loc->ref = tmp_var; - update_stmt_for_real (loc->stmt); + if (loc->ref == gimple_assign_lhs_ptr (loc->stmt)) + gimple_assign_set_lhs (loc->stmt, tmp_var); + else + { + gcc_assert (loc->ref == gimple_assign_rhs1_ptr (loc->stmt)); + gimple_assign_set_rhs1 (loc->stmt, tmp_var); + } + update_stmt (loc->stmt); return false; } diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 4cd8298226f4..cb7e13e87b3e 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -7145,7 +7145,18 @@ rewrite_use_address (struct ivopts_data *data, else copy_ref_info (ref, *use->op_p); - *use->op_p = ref; + if (gcall *call = dyn_cast <gcall *> (use->stmt)) + { + gcc_assert (use->op_p == gimple_call_arg_ptr (call, 0)); + gimple_call_set_arg (call, 0, ref); + } + else if (use->op_p == gimple_assign_lhs_ptr (use->stmt)) + gimple_assign_set_lhs (use->stmt, ref); + else + { + gcc_assert (use->op_p == gimple_assign_rhs1_ptr (use->stmt)); + gimple_assign_set_rhs1 (use->stmt, ref); + } } /* Rewrites USE (the condition such that one of the arguments is an iv) using @@ -7193,9 +7204,27 @@ rewrite_use_compare (struct ivopts_data *data, comp = get_computation_at (data->current_loop, use->stmt, use, cand); gcc_assert (comp != NULL_TREE); gcc_assert (use->op_p != NULL); - *use->op_p = force_gimple_operand_gsi (&bsi, comp, true, - SSA_NAME_VAR (*use->op_p), - true, GSI_SAME_STMT); + comp = force_gimple_operand_gsi (&bsi, comp, true, + SSA_NAME_VAR (*use->op_p), + true, GSI_SAME_STMT); + if (gimple_code (use->stmt) == GIMPLE_COND) + { + gcond *cond_stmt = as_a <gcond *> (use->stmt); + if (use->op_p == gimple_cond_lhs_ptr (cond_stmt)) + gimple_cond_set_lhs (cond_stmt, comp); + else + { + gcc_assert (use->op_p == gimple_cond_rhs_ptr (cond_stmt)); + gimple_cond_set_rhs (cond_stmt, comp); + } + } + else if (use->op_p == gimple_assign_rhs1_ptr (use->stmt)) + gimple_assign_set_rhs1 (use->stmt, comp); + else + { + gcc_assert (use->op_p == gimple_assign_rhs2_ptr (use->stmt)); + gimple_assign_set_rhs2 (use->stmt, comp); + } } /* Rewrite the groups using the selected induction variables. */ @@ -7217,7 +7246,7 @@ rewrite_groups (struct ivopts_data *data) for (j = 0; j < group->vuses.length (); j++) { rewrite_use_nonlinear_expr (data, group->vuses[j], cand); - update_stmt_for_real (group->vuses[j]->stmt); + update_stmt (group->vuses[j]->stmt); } } else if (address_p (group->type)) @@ -7225,7 +7254,7 @@ rewrite_groups (struct ivopts_data *data) for (j = 0; j < group->vuses.length (); j++) { rewrite_use_address (data, group->vuses[j], cand); - update_stmt_for_real (group->vuses[j]->stmt); + update_stmt (group->vuses[j]->stmt); } } else @@ -7235,7 +7264,7 @@ rewrite_groups (struct ivopts_data *data) for (j = 0; j < group->vuses.length (); j++) { rewrite_use_compare (data, group->vuses[j], cand); - update_stmt_for_real (group->vuses[j]->stmt); + update_stmt (group->vuses[j]->stmt); } } } @@ -7365,8 +7394,7 @@ remove_unused_ivs (struct ivopts_data *data) FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) SET_USE (use_p, comp); - /* XXX blaeh, debug statement operands are complicated. */ - update_stmt_for_real (stmt); + update_stmt (stmt); } } } diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index 3d5cfd02966c..ced9ccd89d40 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -1169,9 +1169,10 @@ update_stmt_use (use_operand_p use) gcc_assert (gimple_code (stmt) == GIMPLE_PHI); return; } + tree *pnewval = use->use; gcc_assert (is_gimple_debug (stmt) - || !USE_FROM_PTR (use) - || is_gimple_min_invariant (USE_FROM_PTR (use))); + || !*pnewval + || is_gimple_min_invariant (*pnewval)); use_optype_p *puse, stmtuse; for (puse = &ops_stmt->use_ops; USE_OP_PTR (*puse) != use; puse = &((*puse)->next)) @@ -1180,6 +1181,35 @@ update_stmt_use (use_operand_p use) *puse = (*puse)->next; stmtuse->next = gimple_ssa_operands (cfun)->free_uses; gimple_ssa_operands (cfun)->free_uses = stmtuse; + + if (gimple_debug_bind_p (stmt) + && pnewval == gimple_debug_bind_get_value_ptr (stmt) + && *pnewval + && !is_gimple_min_invariant (*pnewval)) + { + start_ssa_stmt_operands (); + get_expr_operands (cfun, stmt, pnewval, opf_no_vops | opf_use); + for (unsigned i = 0; i < build_uses.length (); i++) + { + tree *op = build_uses[i]; + use_optype_p *insert_point; + use_optype_p new_use; + + new_use = alloc_use (cfun); + USE_OP_PTR (new_use)->use = op; + link_imm_use_stmt (USE_OP_PTR (new_use), *op, stmt); + /* Ensure vop use is in front. */ + insert_point = &ops_stmt->use_ops; + if (*insert_point) + insert_point = &((*insert_point)->next); + new_use->next = *insert_point; + *insert_point = new_use; + } + + if (build_flags & BF_RENAME) + cfun->gimple_df->ssa_renaming_needed = 1; + cleanup_build_arrays (); + } } /* Check if it's easy to determine if STMT needs a vuse @@ -1617,12 +1647,12 @@ gimple_set_op_update (gimple *gs, unsigned i, tree val) { *pop = val; do_full_update: - fprintf (stderr, " XXX replace "); + /*fprintf (stderr, " XXX replace "); print_generic_expr (stderr, old, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, " with "); print_generic_expr (stderr, val, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, " in "); - print_gimple_stmt (stderr, gs, 0, 0); + print_gimple_stmt (stderr, gs, 0, 0);*/ update_stmt_for_real (gs); } } @@ -1659,12 +1689,12 @@ gimple_change_in_op (gimple *gs, tree *op_ptr, tree *pop, tree val) { *pop = val; do_full_update: - fprintf (stderr, " YYY replace "); + /*fprintf (stderr, " YYY replace "); print_generic_expr (stderr, old, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, " with "); print_generic_expr (stderr, val, TDF_VOPS|TDF_MEMSYMS); fprintf (stderr, " in "); - print_gimple_stmt (stderr, gs, 0, 0); + print_gimple_stmt (stderr, gs, 0, 0);*/ update_stmt_for_real (gs); } } diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index b9f4c2ddacb7..bfd2c11f579e 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -474,9 +474,6 @@ insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var) { gimple_stmt_iterator gsi = gsi_for_stmt (stmt); fold_stmt_inplace (&gsi); - /* XXX if SET_USE would also handle nested trees, this - wouldn't be necessary: */ - update_stmt_for_real (stmt); } } else @@ -2037,7 +2034,8 @@ execute_update_addresses_taken (void) if (gimple_references_memory_p (stmt) || is_gimple_debug (stmt)) /* XXX maybe find better way of removing vops for statements - which now no longer refer to memory due to non-address-taken */ + which now no longer refer to memory due to non-address-taken + maybe_rewrite_mem_ref_base also does direct pointer access*/ update_stmt_for_real (stmt); gsi_next (&gsi);
