https://gcc.gnu.org/g:a2112bb3959098711d0091511937a6a7854e4455
commit a2112bb3959098711d0091511937a6a7854e4455 Author: Michael Matz <[email protected]> Date: Tue Feb 27 03:24:51 2018 +0100 update-stmt: get rid of addressable marking the operand scanner shouldn't simply set TREE_ADDRESSABLE when it sees address-taken operands. That's the duty of whomever created the ADDR_EXPR and put it into gimple operand statements. So, operand scanner now asserts this. We need to add some address-taken markings at several places, for which tree-nested's build_addr proves convenient, so move it to fold-const.[ch] in parallel to build_fold_addr_expr and friends. Diff: --- gcc/asan.c | 7 ++++++- gcc/fold-const.c | 10 ++++++++++ gcc/fold-const.h | 1 + gcc/omp-simd-clone.c | 3 ++- gcc/sancov.c | 1 + gcc/trans-mem.c | 9 +++++---- gcc/tree-chkp.c | 2 +- gcc/tree-loop-distribution.c | 6 ++++++ gcc/tree-nested.c | 10 ---------- gcc/tree-nested.h | 1 - gcc/tree-parloops.c | 11 ++++++++--- gcc/tree-profile.c | 2 ++ gcc/tree-sra.c | 6 +++--- gcc/tree-ssa-address.c | 3 +++ gcc/tree-ssa-ccp.c | 2 +- gcc/tree-ssa-operands.c | 33 ++++++++++++++++++++------------- gcc/tree-ssa.c | 2 +- gcc/tree-vect-data-refs.c | 10 ++++++---- gcc/tsan.c | 4 ++-- gcc/ubsan.c | 6 +++--- 20 files changed, 81 insertions(+), 48 deletions(-) diff --git a/gcc/asan.c b/gcc/asan.c index e71ab2cc710f..5aa0bee71b16 100644 --- a/gcc/asan.c +++ b/gcc/asan.c @@ -1925,6 +1925,8 @@ maybe_create_ssa_name (location_t loc, tree base, gimple_stmt_iterator *iter, { if (TREE_CODE (base) == SSA_NAME) return base; + if (TREE_CODE (base) == ADDR_EXPR) + mark_addressable (TREE_OPERAND (base, 0)); gimple *g = gimple_build_assign (make_ssa_name (TREE_TYPE (base)), TREE_CODE (base), base); gimple_set_location (g, loc); @@ -2623,7 +2625,7 @@ asan_add_global (tree decl, tree type, vec<constructor_elt, va_gc> *v) ASM_GENERATE_INTERNAL_LABEL (buf, "LASAN", vec_safe_length (v) + 1); refdecl = build_decl (DECL_SOURCE_LOCATION (decl), VAR_DECL, get_identifier (buf), TREE_TYPE (decl)); - TREE_ADDRESSABLE (refdecl) = TREE_ADDRESSABLE (decl); + TREE_ADDRESSABLE (refdecl) = 1; TREE_READONLY (refdecl) = TREE_READONLY (decl); TREE_THIS_VOLATILE (refdecl) = TREE_THIS_VOLATILE (decl); DECL_GIMPLE_REG_P (refdecl) = DECL_GIMPLE_REG_P (decl); @@ -2669,6 +2671,7 @@ asan_add_global (tree decl, tree type, vec<constructor_elt, va_gc> *v) ubsan_get_source_location_type ()); TREE_STATIC (var) = 1; TREE_PUBLIC (var) = 0; + TREE_ADDRESSABLE (var) = 1; DECL_ARTIFICIAL (var) = 1; DECL_IGNORED_P (var) = 1; pretty_printer filename_pp; @@ -2946,6 +2949,7 @@ asan_finish_file (void) type); TREE_STATIC (var) = 1; TREE_PUBLIC (var) = 0; + TREE_ADDRESSABLE (var) = 1; DECL_ARTIFICIAL (var) = 1; DECL_IGNORED_P (var) = 1; vec_alloc (v, gcount); @@ -3347,6 +3351,7 @@ create_asan_shadow_var (tree var_decl, id.src_fn = id.dst_fn = current_function_decl; copy_decl_for_dup_finish (&id, var_decl, shadow_var); + TREE_ADDRESSABLE (shadow_var) = 1; DECL_ARTIFICIAL (shadow_var) = 1; DECL_IGNORED_P (shadow_var) = 1; DECL_SEEN_IN_BIND_EXPR_P (shadow_var) = 0; diff --git a/gcc/fold-const.c b/gcc/fold-const.c index faa184a2bbdd..e79775beaeb8 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -7686,6 +7686,16 @@ build_fold_addr_expr_loc (location_t loc, tree t) return build_fold_addr_expr_with_type_loc (loc, t, ptrtype); } +/* Take the address of EXP to be used within function CONTEXT. + Mark it for addressability as necessary. */ + +tree +build_addr (tree exp) +{ + mark_addressable (exp); + return build_fold_addr_expr (exp); +} + /* Fold a unary expression of code CODE and type TYPE with operand OP0. Return the folded expression if folding is successful. Otherwise, return NULL_TREE. */ diff --git a/gcc/fold-const.h b/gcc/fold-const.h index 8e3ad512a0b2..f50dc510bfe1 100644 --- a/gcc/fold-const.h +++ b/gcc/fold-const.h @@ -98,6 +98,7 @@ extern tree fold_unary_to_constant (enum tree_code, tree, tree); extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree); extern tree fold_read_from_constant_string (tree); extern tree int_const_binop (enum tree_code, const_tree, const_tree); +extern tree build_addr (tree); #define build_fold_addr_expr(T)\ build_fold_addr_expr_loc (UNKNOWN_LOCATION, (T)) extern tree build_fold_addr_expr_loc (location_t, tree); diff --git a/gcc/omp-simd-clone.c b/gcc/omp-simd-clone.c index 64cd91e3b391..24fc081b46db 100644 --- a/gcc/omp-simd-clone.c +++ b/gcc/omp-simd-clone.c @@ -773,6 +773,7 @@ simd_clone_init_simd_arrays (struct cgraph_node *node, } continue; } + TREE_ADDRESSABLE (array) = 1; if (simd_clone_subparts (TREE_TYPE (arg)) == node->simdclone->simdlen) { tree ptype = build_pointer_type (TREE_TYPE (TREE_TYPE (array))); @@ -864,7 +865,7 @@ ipa_simd_modify_stmt_ops (tree *tp, int *walk_subtrees, void *data) if (tp != orig_tp) { - repl = build_fold_addr_expr (repl); + repl = build_addr (repl); gimple *stmt; if (is_gimple_debug (info->stmt)) { diff --git a/gcc/sancov.c b/gcc/sancov.c index 684a885f44d6..b0e5df07f2b7 100644 --- a/gcc/sancov.c +++ b/gcc/sancov.c @@ -177,6 +177,7 @@ instrument_switch (gimple_stmt_iterator *gsi, gimple *stmt, function *fun) TREE_PUBLIC (case_array_var) = 0; TREE_CONSTANT (case_array_var) = 1; TREE_READONLY (case_array_var) = 1; + TREE_ADDRESSABLE (case_array_var) = 1; DECL_EXTERNAL (case_array_var) = 0; DECL_ARTIFICIAL (case_array_var) = 1; DECL_IGNORED_P (case_array_var) = 1; diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index ca14915ef0d3..5361f9da1713 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -1181,8 +1181,9 @@ gimplify_addr (gimple_stmt_iterator *gsi, tree x) if (TREE_CODE (x) == TARGET_MEM_REF) x = tree_mem_ref_addr (build_pointer_type (TREE_TYPE (x)), x); else - x = build_fold_addr_expr (x); - return force_gimple_operand_gsi (gsi, x, true, NULL, true, GSI_SAME_STMT); + x = build_addr (x); + x = force_gimple_operand_gsi (gsi, x, true, NULL, true, GSI_SAME_STMT); + return x; } /* Instrument one address with the logging functions. @@ -2431,14 +2432,14 @@ expand_assign_tm (struct tm_region *region, gimple_stmt_iterator *gsi) if (is_gimple_reg (lhs)) { ltmp = create_tmp_var (TREE_TYPE (lhs)); - lhs_addr = build_fold_addr_expr (ltmp); + lhs_addr = build_addr (ltmp); } else lhs_addr = gimplify_addr (gsi, lhs); if (is_gimple_reg (rhs)) { tree rtmp = create_tmp_var (TREE_TYPE (rhs)); - rhs_addr = build_fold_addr_expr (rtmp); + rhs_addr = build_addr (rtmp); gcall = gimple_build_assign (rtmp, rhs); gsi_insert_before (gsi, gcall, GSI_SAME_STMT); } diff --git a/gcc/tree-chkp.c b/gcc/tree-chkp.c index d10e6c404236..dda2cea225c8 100644 --- a/gcc/tree-chkp.c +++ b/gcc/tree-chkp.c @@ -1098,7 +1098,7 @@ chkp_build_addr_expr (tree obj) /* If not - return regular ADDR_EXPR. */ return TREE_CODE (obj) == TARGET_MEM_REF ? tree_mem_ref_addr (ptr_type_node, obj) - : build_fold_addr_expr (obj); + : build_addr (obj); } /* Helper function for chkp_finish_file. diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c index 5e327f4bfd8e..f63cee5cd783 100644 --- a/gcc/tree-loop-distribution.c +++ b/gcc/tree-loop-distribution.c @@ -1003,6 +1003,8 @@ generate_memset_builtin (struct loop *loop, partition *partition) mem = builtin->dst_base; mem = force_gimple_operand_gsi (&gsi, mem, true, NULL_TREE, false, GSI_CONTINUE_LINKING); + if (TREE_CODE (mem) == ADDR_EXPR) + mark_addressable (TREE_OPERAND (mem, 0)); /* This exactly matches the pattern recognition in classify_partition. */ val = gimple_assign_rhs1 (DR_STMT (builtin->dst_dr)); @@ -1062,8 +1064,12 @@ generate_memcpy_builtin (struct loop *loop, partition *partition) dest = force_gimple_operand_gsi (&gsi, dest, true, NULL_TREE, false, GSI_CONTINUE_LINKING); + if (TREE_CODE (dest) == ADDR_EXPR) + mark_addressable (TREE_OPERAND (dest, 0)); src = force_gimple_operand_gsi (&gsi, src, true, NULL_TREE, false, GSI_CONTINUE_LINKING); + if (TREE_CODE (src) == ADDR_EXPR) + mark_addressable (TREE_OPERAND (src, 0)); fn = build_fold_addr_expr (builtin_decl_implicit (kind)); fn_call = gimple_build_call (fn, 3, dest, src, nb_bytes); gsi_insert_after (&gsi, fn_call, GSI_CONTINUE_LINKING); diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c index f1557c986b7f..d8998af66673 100644 --- a/gcc/tree-nested.c +++ b/gcc/tree-nested.c @@ -167,16 +167,6 @@ create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix) return tmp_var; } -/* Take the address of EXP to be used within function CONTEXT. - Mark it for addressability as necessary. */ - -tree -build_addr (tree exp) -{ - mark_addressable (exp); - return build_fold_addr_expr (exp); -} - /* Insert FIELD into TYPE, sorted by alignment requirements. */ void diff --git a/gcc/tree-nested.h b/gcc/tree-nested.h index 6c9b963f89b2..f104abfcb426 100644 --- a/gcc/tree-nested.h +++ b/gcc/tree-nested.h @@ -20,7 +20,6 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_TREE_NESTED_H #define GCC_TREE_NESTED_H -extern tree build_addr (tree); extern void insert_field_into_struct (tree, tree); extern void lower_nested_functions (tree); diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c index 64908af67b33..e0deecf32948 100644 --- a/gcc/tree-parloops.c +++ b/gcc/tree-parloops.c @@ -509,7 +509,12 @@ take_address_of (tree obj, tree type, edge entry, /* Canonicalize the access to base on a MEM_REF. */ if (DECL_P (*var_p)) - *var_p = build_simple_mem_ref (build_fold_addr_expr (*var_p)); + { + if (gsi) + *var_p = build_simple_mem_ref (build_addr (*var_p)); + else + *var_p = build_simple_mem_ref (build_fold_addr_expr (*var_p)); + } /* Assign a canonical SSA name to the address of the base decl used in the address and share it for all accesses and addresses based @@ -1223,7 +1228,7 @@ create_final_loads_for_reduction (reduction_info_table_type *reduction_list, gimple *stmt; gsi = gsi_after_labels (ld_st_data->load_bb); - t = build_fold_addr_expr (ld_st_data->store); + t = build_addr (ld_st_data->store); stmt = gimple_build_assign (ld_st_data->load, t); gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); @@ -2082,7 +2087,7 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data, gsi = gsi_after_labels (bb); param = make_ssa_name (DECL_ARGUMENTS (loop_fn)); - assign_stmt = gimple_build_assign (param, build_fold_addr_expr (data)); + assign_stmt = gimple_build_assign (param, build_addr (data)); gsi_insert_before (&gsi, assign_stmt, GSI_SAME_STMT); assign_stmt = gimple_build_assign (new_data, diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c index d5f58f50ee12..b02a60a51b18 100644 --- a/gcc/tree-profile.c +++ b/gcc/tree-profile.c @@ -206,6 +206,8 @@ gimple_init_gcov_profiler (void) TREE_PUBLIC (tree_time_profiler_counter) = 1; DECL_EXTERNAL (tree_time_profiler_counter) = 1; TREE_STATIC (tree_time_profiler_counter) = 1; + if (flag_profile_update == PROFILE_UPDATE_ATOMIC) + TREE_ADDRESSABLE (tree_time_profiler_counter) = 1; DECL_ARTIFICIAL (tree_time_profiler_counter) = 1; DECL_INITIAL (tree_time_profiler_counter) = NULL; diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 5225dec97689..52481c9e6915 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -1737,7 +1737,7 @@ build_ref_for_offset (location_t loc, tree base, poly_int64 offset, gcc_checking_assert (gsi); tmp = make_ssa_name (build_pointer_type (TREE_TYPE (prev_base))); - addr = build_fold_addr_expr (unshare_expr (prev_base)); + addr = build_addr (unshare_expr (prev_base)); STRIP_USELESS_TYPE_CONVERSION (addr); stmt = gimple_build_assign (tmp, addr); gimple_set_location (stmt, loc); @@ -1760,7 +1760,7 @@ build_ref_for_offset (location_t loc, tree base, poly_int64 offset, { off = build_int_cst (reference_alias_ptr_type (prev_base), base_offset + byte_offset); - base = build_fold_addr_expr (unshare_expr (base)); + base = build_addr (unshare_expr (base)); } unsigned int align_bound = known_alignment (misalign + offset); @@ -1841,7 +1841,7 @@ build_debug_ref_for_model (location_t loc, tree base, HOST_WIDE_INT offset, { off = build_int_cst (reference_alias_ptr_type (base), base_offset + offset / BITS_PER_UNIT); - base = build_fold_addr_expr (unshare_expr (base)); + base = build_addr (unshare_expr (base)); } return fold_build2_loc (loc, MEM_REF, model->type, base, off); diff --git a/gcc/tree-ssa-address.c b/gcc/tree-ssa-address.c index c8ff8514529c..cb8bf4f83c23 100644 --- a/gcc/tree-ssa-address.c +++ b/gcc/tree-ssa-address.c @@ -1049,6 +1049,9 @@ copy_ref_info (tree new_ref, tree old_ref) pt_solution_set_var (&pi->pt, base); } } + + if (new_ptr_base && TREE_CODE (new_ptr_base) == ADDR_EXPR) + mark_addressable (TREE_OPERAND (new_ptr_base, 0)); } /* Move constants in target_mem_ref REF to offset. Returns the new target diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index 5591097d0183..d43186798c01 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -2192,7 +2192,7 @@ fold_builtin_alloca_with_align (gimple *stmt) } /* Fold alloca to the address of the array. */ - return fold_convert (TREE_TYPE (lhs), build_fold_addr_expr (var)); + return fold_convert (TREE_TYPE (lhs), build_addr (var)); } /* Fold the stmt at *GSI with CCP specific information that propagating diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index ced9ccd89d40..47bc20809050 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -452,6 +452,7 @@ finalize_ssa_stmt_operands (struct function *fn, gimple *stmt) fn->gimple_df->ssa_renaming_needed = 1; if (build_flags & BF_RENAME_VOP) fn->gimple_df->rename_vops = 1; + if (0) for (i = 0; i < build_addressable.length (); i++) { tree var = build_addressable[i]; @@ -580,15 +581,20 @@ mark_address_taken (tree ref) taking the address of a field means that the whole structure may be referenced using pointer arithmetic. See PR 21407 and the ensuing mailing list discussion. */ - var = get_base_address (ref); - if (var) + if (flag_checking) { - if (DECL_P (var)) - build_addressable.safe_push (var); - else if (TREE_CODE (var) == MEM_REF - && TREE_CODE (TREE_OPERAND (var, 0)) == ADDR_EXPR - && DECL_P (TREE_OPERAND (TREE_OPERAND (var, 0), 0))) - build_addressable.safe_push (TREE_OPERAND (TREE_OPERAND (var, 0), 0)) ; + var = get_base_address (ref); + if (var) + { + if (TREE_CODE (var) == MEM_REF + && TREE_CODE (TREE_OPERAND (var, 0)) == ADDR_EXPR + && DECL_P (TREE_OPERAND (TREE_OPERAND (var, 0), 0))) + var = TREE_OPERAND (TREE_OPERAND (var, 0), 0); + if (VAR_P (var) + || TREE_CODE (var) == PARM_DECL + || TREE_CODE (var) == RESULT_DECL) + gcc_assert (TREE_ADDRESSABLE (var)); + } } } @@ -1338,9 +1344,10 @@ add_ssa_op (gimple *stmt, tree *pop, tree val, unsigned nop, int flags) but we can't currently, because the list might contain stale entries (from setting to constants or such via SET_USE). We must reuse that entry in case it's there (or remove it and generate a new one). */ - for (puse = &ops_stmt->use_ops; *puse; puse = &((*puse)->next)) - if ((*puse)->use_ptr.use == pop) - break; + if (*pop && SSA_VAR_P (*pop)) + for (puse = &ops_stmt->use_ops; *puse; puse = &((*puse)->next)) + if ((*puse)->use_ptr.use == pop) + break; if (puse && *puse) { delink_imm_use (&((*puse)->use_ptr)); @@ -1426,7 +1433,7 @@ add_ssa_op (gimple *stmt, tree *pop, tree val, unsigned nop, int flags) if (was_vop && diddle_vops (stmt, was_vop, newvop, nop) < 0) return 1; /* And check for addresses in val. */ - if (val && TREE_CODE (val) == ADDR_EXPR && !is_gimple_debug (stmt)) + if (0 && val && TREE_CODE (val) == ADDR_EXPR && !is_gimple_debug (stmt)) { mark_address_taken (TREE_OPERAND (val, 0)); if (build_addressable.length ()) @@ -1570,6 +1577,7 @@ exchange_complex_op (gimple *stmt, tree *pop, tree val, unsigned nop, int flags) cfun->gimple_df->ssa_renaming_needed = 1; if (build_flags & BF_RENAME_VOP) cfun->gimple_df->rename_vops = 1; + if (0) for (i = 0; i < build_addressable.length (); i++) { tree var = build_addressable[i]; @@ -1961,4 +1969,3 @@ single_imm_use_1 (const ssa_use_operand_t *head, return single_use; } - diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index bfd2c11f579e..9632869ba81c 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -979,7 +979,7 @@ verify_phi_args (gphi *phi, basic_block bb, basic_block *definition_block) tree base = TREE_OPERAND (op, 0); while (handled_component_p (base)) base = TREE_OPERAND (base, 0); - if ((VAR_P (base) + if (1 && (VAR_P (base) || TREE_CODE (base) == PARM_DECL || TREE_CODE (base) == RESULT_DECL) && !TREE_ADDRESSABLE (base)) diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index 9608b769cf2a..875da995f39a 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -4606,12 +4606,14 @@ vect_create_addr_base_for_vector_ref (gimple *stmt, /* base + base_offset */ if (loop_vinfo) - addr_base = fold_build_pointer_plus (data_ref_base, base_offset); + { + if (TREE_CODE (data_ref_base) == ADDR_EXPR) + mark_addressable (TREE_OPERAND (data_ref_base, 0)); + addr_base = fold_build_pointer_plus (data_ref_base, base_offset); + } else { - addr_base = build1 (ADDR_EXPR, - build_pointer_type (TREE_TYPE (DR_REF (dr))), - unshare_expr (DR_REF (dr))); + addr_base = build_addr (unshare_expr (DR_REF (dr))); } vect_ptr_type = build_pointer_type (STMT_VINFO_VECTYPE (stmt_info)); diff --git a/gcc/tsan.c b/gcc/tsan.c index 67b111dfc39e..00f998e00b3d 100644 --- a/gcc/tsan.c +++ b/gcc/tsan.c @@ -183,7 +183,7 @@ instrument_expr (gimple_stmt_iterator gsi, tree expr, bool is_write) expr = build_fold_addr_expr (unshare_expr (base)); expr = build2 (MEM_REF, char_type_node, expr, build_int_cst (TREE_TYPE (expr), bitpos / BITS_PER_UNIT)); - expr_ptr = build_fold_addr_expr (expr); + expr_ptr = build_addr (expr); } else { @@ -192,7 +192,7 @@ instrument_expr (gimple_stmt_iterator gsi, tree expr, bool is_write) align = get_object_alignment (expr); if (align < BITS_PER_UNIT) return false; - expr_ptr = build_fold_addr_expr (unshare_expr (expr)); + expr_ptr = build_addr (unshare_expr (expr)); } expr_ptr = force_gimple_operand (expr_ptr, &seq, true, NULL_TREE); if ((size & (size - 1)) != 0 || size > 16 diff --git a/gcc/ubsan.c b/gcc/ubsan.c index 722f57026128..68ecf90ec220 100644 --- a/gcc/ubsan.c +++ b/gcc/ubsan.c @@ -602,6 +602,7 @@ ubsan_create_data (const char *name, int loccnt, const location_t *ploc, ...) ret); TREE_STATIC (var) = 1; TREE_PUBLIC (var) = 0; + TREE_ADDRESSABLE (var) = 1; DECL_ARTIFICIAL (var) = 1; DECL_IGNORED_P (var) = 1; DECL_EXTERNAL (var) = 0; @@ -1477,8 +1478,7 @@ maybe_instrument_pointer_overflow (gimple_stmt_iterator *gsi, tree t) tree base_addr = base; if (decl_p) - base_addr = build1 (ADDR_EXPR, - build_pointer_type (TREE_TYPE (base)), base); + base_addr = build_addr (base); t = offset; if (maybe_ne (bytepos, 0)) { @@ -1685,7 +1685,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi) tree ptype = build_pointer_type (TREE_TYPE (rhs)); tree atype = reference_alias_ptr_type (rhs); gimple *g = gimple_build_assign (make_ssa_name (ptype), - build_fold_addr_expr (rhs)); + build_addr (rhs)); gimple_set_location (g, loc); gsi_insert_before (gsi, g, GSI_SAME_STMT); tree mem = build2 (MEM_REF, utype, gimple_assign_lhs (g),
