From 08af82b017a63c7a91937af2d6c72232a53de47d Mon Sep 17 00:00:00 2001 From: Bernd Edlinger Date: Tue, 26 Nov 2013 16:58:40 +0000 Subject: [PATCH] Remove parameter keep_aligning from get_inner_reference. 2013-11-26 Bernd Edlinger Remove parameter keep_aligning from get_inner_reference. * tree.h (get_inner_reference): Adjust header. * expr.c (get_inner_reference): Remove parameter keep_aligning. (get_bit_range, expand_assignment, expand_expr_addr_expr_1, expand_expr_real_1): Adjust. * asan.c (instrument_derefs): Adjust. * builtins.c (get_object_alignment_2): Adjust. Remove handling of VIEW_CONVERT_EXPR. * cfgexpand.c (expand_debug_expr): Adjust. * dbxout.c (dbxout_expand_expr): Adjust. * dwarf2out.c (loc_list_for_address_of_addr_expr_of_indirect_ref, loc_list_from_tree, fortran_common): Adjust. * fold-const.c (optimize_bit_field_compare, decode_field_reference, fold_unary_loc, fold_comparison, split_address_to_core_and_offset): Adjust. * gimple-ssa-strength-reduction.c (slsr_process_ref): Adjust. * simplifx-rtx.c (delegitimize_mem_from_attrs): Adjust. * tree-affine.c (tree_to_aff_combination, get_inner_reference_aff): Adjust. * tree-data-ref.c (split_constant_offset_1, dr_analyze_innermost): Adjust. * tree-vect-data-refs.c (vect_check_gather, vect_analyze_data_refs): Adjust. * tree-scalar-evolution.c (interpret_rhs_expr): Adjust. * tree-ssa-loop-ivopts.c (may_be_unaligned_p, split_address_cost): Adjust. * tsan.c (instrument_expr): Adjust. * ada/gcc-interface/decl.c (elaborate_expression_1): Adjust. * ada/gcc-interface/trans.c (Attribute_to_gnu): Adjust. * ada/gcc-interface/utils2.c (build_unary_op): Adjust. * config/mips/mips.c (r10k_safe_mem_expr_p): Adjust. From-SVN: r205398 --- gcc/ChangeLog | 34 ++++++++++++++++++++++++++ gcc/ada/gcc-interface/decl.c | 2 +- gcc/ada/gcc-interface/trans.c | 2 +- gcc/ada/gcc-interface/utils2.c | 3 +-- gcc/asan.c | 2 +- gcc/builtins.c | 6 +---- gcc/cfgexpand.c | 2 +- gcc/config/mips/mips.c | 2 +- gcc/dbxout.c | 2 +- gcc/dwarf2out.c | 6 ++--- gcc/expr.c | 37 ++++++----------------------- gcc/fold-const.c | 15 ++++++------ gcc/gimple-ssa-strength-reduction.c | 2 +- gcc/simplify-rtx.c | 2 +- gcc/tree-affine.c | 5 ++-- gcc/tree-data-ref.c | 4 ++-- gcc/tree-scalar-evolution.c | 2 +- gcc/tree-ssa-loop-ivopts.c | 4 ++-- gcc/tree-vect-data-refs.c | 4 ++-- gcc/tree.h | 3 +-- gcc/tsan.c | 2 +- 21 files changed, 72 insertions(+), 69 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 62dc6e0bca5..11994746d9f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,37 @@ +2013-11-26 Bernd Edlinger + + Remove parameter keep_aligning from get_inner_reference. + * tree.h (get_inner_reference): Adjust header. + * expr.c (get_inner_reference): Remove parameter keep_aligning. + (get_bit_range, expand_assignment, + expand_expr_addr_expr_1, expand_expr_real_1): Adjust. + * asan.c (instrument_derefs): Adjust. + * builtins.c (get_object_alignment_2): Adjust. Remove handling of + VIEW_CONVERT_EXPR. + * cfgexpand.c (expand_debug_expr): Adjust. + * dbxout.c (dbxout_expand_expr): Adjust. + * dwarf2out.c (loc_list_for_address_of_addr_expr_of_indirect_ref, + loc_list_from_tree, fortran_common): Adjust. + * fold-const.c (optimize_bit_field_compare, + decode_field_reference, fold_unary_loc, fold_comparison, + split_address_to_core_and_offset): Adjust. + * gimple-ssa-strength-reduction.c (slsr_process_ref): Adjust. + * simplifx-rtx.c (delegitimize_mem_from_attrs): Adjust. + * tree-affine.c (tree_to_aff_combination, + get_inner_reference_aff): Adjust. + * tree-data-ref.c (split_constant_offset_1, + dr_analyze_innermost): Adjust. + * tree-vect-data-refs.c (vect_check_gather, + vect_analyze_data_refs): Adjust. + * tree-scalar-evolution.c (interpret_rhs_expr): Adjust. + * tree-ssa-loop-ivopts.c (may_be_unaligned_p, + split_address_cost): Adjust. + * tsan.c (instrument_expr): Adjust. + * ada/gcc-interface/decl.c (elaborate_expression_1): Adjust. + * ada/gcc-interface/trans.c (Attribute_to_gnu): Adjust. + * ada/gcc-interface/utils2.c (build_unary_op): Adjust. + * config/mips/mips.c (r10k_safe_mem_expr_p): Adjust. + 2013-11-26 Yufeng Zhang * config/arm/arm.c (arm_legitimize_address): Check xop1 is not diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index ee76a9d160f..51adf18e0a3 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -6269,7 +6269,7 @@ elaborate_expression_1 (tree gnu_expr, Entity_Id gnat_entity, tree gnu_name, int unsignedp, volatilep; inner = get_inner_reference (inner, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + &mode, &unsignedp, &volatilep); /* If the offset is variable, err on the side of caution. */ if (offset) inner = NULL_TREE; diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c index e533de6dcbf..6c7a418662f 100644 --- a/gcc/ada/gcc-interface/trans.c +++ b/gcc/ada/gcc-interface/trans.c @@ -2060,7 +2060,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute) && TREE_CODE (gnu_prefix) == FIELD_DECL)); get_inner_reference (gnu_prefix, &bitsize, &bitpos, &gnu_offset, - &mode, &unsignedp, &volatilep, false); + &mode, &unsignedp, &volatilep); if (TREE_CODE (gnu_prefix) == COMPONENT_REF) { diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c index 224a87d8777..b6299cbeefa 100644 --- a/gcc/ada/gcc-interface/utils2.c +++ b/gcc/ada/gcc-interface/utils2.c @@ -1312,8 +1312,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) int unsignedp, volatilep; inner = get_inner_reference (operand, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, - false); + &mode, &unsignedp, &volatilep); /* If INNER is a padding type whose field has a self-referential size, convert to that inner type. We know the offset is zero diff --git a/gcc/asan.c b/gcc/asan.c index 677435e05ae..c901e1da380 100644 --- a/gcc/asan.c +++ b/gcc/asan.c @@ -1488,7 +1488,7 @@ instrument_derefs (gimple_stmt_iterator *iter, tree t, enum machine_mode mode; int volatilep = 0, unsignedp = 0; tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + &mode, &unsignedp, &volatilep); if (bitpos % (size_in_bytes * BITS_PER_UNIT) || bitsize != size_in_bytes * BITS_PER_UNIT) { diff --git a/gcc/builtins.c b/gcc/builtins.c index 5f657aed1d4..912c14c1174 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -329,7 +329,7 @@ get_object_alignment_2 (tree exp, unsigned int *alignp, /* Get the innermost object and the constant (bitpos) and possibly variable (offset) offset of the access. */ exp = get_inner_reference (exp, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, true); + &mode, &unsignedp, &volatilep); /* Extract alignment information from the innermost object and possibly adjust bitpos and offset. */ @@ -360,10 +360,6 @@ get_object_alignment_2 (tree exp, unsigned int *alignp, align = DECL_ALIGN (exp); known_alignment = true; } - else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR) - { - align = TYPE_ALIGN (TREE_TYPE (exp)); - } else if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == MEM_REF || TREE_CODE (exp) == TARGET_MEM_REF) diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index 207f8767573..98983f40b3b 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -3941,7 +3941,7 @@ expand_debug_expr (tree exp) tree offset; int volatilep = 0; tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset, - &mode1, &unsignedp, &volatilep, false); + &mode1, &unsignedp, &volatilep); rtx orig_op0; if (bitsize == 0) diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index 36ba6df7a4c..69e67be4973 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -14948,7 +14948,7 @@ r10k_safe_mem_expr_p (tree expr, unsigned HOST_WIDE_INT offset) int unsigned_p, volatile_p; inner = get_inner_reference (expr, &bitsize, &bitoffset, &var_offset, &mode, - &unsigned_p, &volatile_p, false); + &unsigned_p, &volatile_p); if (!DECL_P (inner) || !DECL_SIZE_UNIT (inner) || var_offset) return false; diff --git a/gcc/dbxout.c b/gcc/dbxout.c index bc6a3af0f96..5988c7e1bd4 100644 --- a/gcc/dbxout.c +++ b/gcc/dbxout.c @@ -2515,7 +2515,7 @@ dbxout_expand_expr (tree expr) rtx x; tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, true); + &mode, &unsignedp, &volatilep); x = dbxout_expand_expr (tem); if (x == NULL || !MEM_P (x)) diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 3448ec4a98c..6376306802a 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -13934,7 +13934,7 @@ loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev) obj = get_inner_reference (TREE_OPERAND (loc, 0), &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &volatilep); STRIP_NOPS (obj); if (bitpos % BITS_PER_UNIT) { @@ -14211,7 +14211,7 @@ loc_list_from_tree (tree loc, int want_address) int unsignedp, volatilep = 0; obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &volatilep); gcc_assert (obj != loc); @@ -15521,7 +15521,7 @@ fortran_common (tree decl, HOST_WIDE_INT *value) return NULL_TREE; cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, true); + &mode, &unsignedp, &volatilep); if (cvar == NULL_TREE || TREE_CODE (cvar) != VAR_DECL diff --git a/gcc/expr.c b/gcc/expr.c index df1c1e88f6f..dc379dc1094 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -4648,7 +4648,7 @@ get_bit_range (unsigned HOST_WIDE_INT *bitstart, int unsignedp; int volatilep = 0; get_inner_reference (TREE_OPERAND (exp, 0), &rbitsize, &rbitpos, - &roffset, &rmode, &unsignedp, &volatilep, false); + &roffset, &rmode, &unsignedp, &volatilep); if ((rbitpos % BITS_PER_UNIT) != 0) { *bitstart = *bitend = 0; @@ -4802,7 +4802,7 @@ expand_assignment (tree to, tree from, bool nontemporal) push_temp_slots (); tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1, - &unsignedp, &volatilep, true); + &unsignedp, &volatilep); /* Make sure bitpos is not negative, it can wreak havoc later. */ if (bitpos < 0) @@ -6644,27 +6644,13 @@ store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, If the field describes a variable-sized object, *PMODE is set to BLKmode and *PBITSIZE is set to -1. An access cannot be made in - this case, but the address of the object can be found. - - If KEEP_ALIGNING is true and the target is STRICT_ALIGNMENT, we don't - look through nodes that serve as markers of a greater alignment than - the one that can be deduced from the expression. These nodes make it - possible for front-ends to prevent temporaries from being created by - the middle-end on alignment considerations. For that purpose, the - normal operating mode at high-level is to always pass FALSE so that - the ultimate containing object is really returned; moreover, the - associated predicate handled_component_p will always return TRUE - on these nodes, thus indicating that they are essentially handled - by get_inner_reference. TRUE should only be passed when the caller - is scanning the expression in order to build another representation - and specifically knows how to handle these nodes; as such, this is - the normal operating mode in the RTL expanders. */ + this case, but the address of the object can be found. */ tree get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize, HOST_WIDE_INT *pbitpos, tree *poffset, enum machine_mode *pmode, int *punsignedp, - int *pvolatilep, bool keep_aligning) + int *pvolatilep) { tree size_tree = 0; enum machine_mode mode = VOIDmode; @@ -6784,14 +6770,6 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize, break; case VIEW_CONVERT_EXPR: - if (keep_aligning && STRICT_ALIGNMENT - && (TYPE_ALIGN (TREE_TYPE (exp)) - > TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))) - && (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0))) - < BIGGEST_ALIGNMENT) - && (TYPE_ALIGN_OK (TREE_TYPE (exp)) - || TYPE_ALIGN_OK (TREE_TYPE (TREE_OPERAND (exp, 0))))) - goto done; break; case MEM_REF: @@ -7656,7 +7634,7 @@ expand_expr_addr_expr_1 (tree exp, rtx target, enum machine_mode tmode, they won't change the final object whose address will be returned (they actually exist only for that purpose). */ inner = get_inner_reference (exp, &bitsize, &bitpos, &offset, - &mode1, &unsignedp, &volatilep, false); + &mode1, &unsignedp, &volatilep); break; } @@ -9933,7 +9911,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, tree offset; int volatilep = 0, must_force_mem; tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset, - &mode1, &unsignedp, &volatilep, true); + &mode1, &unsignedp, &volatilep); rtx orig_op0, memloc; bool mem_attrs_from_type = false; @@ -10294,8 +10272,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, int volatilep = 0; tree tem = get_inner_reference (treeop0, &bitsize, &bitpos, - &offset, &mode1, &unsignedp, &volatilep, - true); + &offset, &mode1, &unsignedp, &volatilep); rtx orig_op0; /* ??? We should work harder and deal with non-zero offsets. */ diff --git a/gcc/fold-const.c b/gcc/fold-const.c index d99cd93c5ea..2289ba41c4f 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -3488,7 +3488,7 @@ optimize_bit_field_compare (location_t loc, enum tree_code code, do anything if the inner expression is a PLACEHOLDER_EXPR since we then will no longer be able to replace it. */ linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode, - &lunsignedp, &lvolatilep, false); + &lunsignedp, &lvolatilep); if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0 || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR || lvolatilep) return 0; @@ -3498,7 +3498,7 @@ optimize_bit_field_compare (location_t loc, enum tree_code code, /* If this is not a constant, we can only do something if bit positions, sizes, and signedness are the same. */ rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode, - &runsignedp, &rvolatilep, false); + &runsignedp, &rvolatilep); if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize || lunsignedp != runsignedp || offset != 0 @@ -3672,7 +3672,7 @@ decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize, } inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode, - punsignedp, pvolatilep, false); + punsignedp, pvolatilep); if ((inner == exp && and_mask == 0) || *pbitsize < 0 || offset != 0 || TREE_CODE (inner) == PLACEHOLDER_EXPR) @@ -8056,7 +8056,7 @@ fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0) int unsignedp, volatilep; tree base = TREE_OPERAND (op0, 0); base = get_inner_reference (base, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + &mode, &unsignedp, &volatilep); /* If the reference was to a (constant) zero offset, we can use the address of the base if it has the same base type as the result type and the pointer type is unqualified. */ @@ -9081,7 +9081,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type, { base0 = get_inner_reference (TREE_OPERAND (arg0, 0), &bitsize, &bitpos0, &offset0, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &volatilep); if (TREE_CODE (base0) == INDIRECT_REF) base0 = TREE_OPERAND (base0, 0); else @@ -9115,7 +9115,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type, { base1 = get_inner_reference (TREE_OPERAND (arg1, 0), &bitsize, &bitpos1, &offset1, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &volatilep); if (TREE_CODE (base1) == INDIRECT_REF) base1 = TREE_OPERAND (base1, 0); else @@ -16982,8 +16982,7 @@ split_address_to_core_and_offset (tree exp, if (TREE_CODE (exp) == ADDR_EXPR) { core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos, - poffset, &mode, &unsignedp, &volatilep, - false); + poffset, &mode, &unsignedp, &volatilep); core = build_fold_addr_expr_loc (loc, core); } else diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c index bc2484b5b13..1f881350021 100644 --- a/gcc/gimple-ssa-strength-reduction.c +++ b/gcc/gimple-ssa-strength-reduction.c @@ -940,7 +940,7 @@ slsr_process_ref (gimple gs) return; base = get_inner_reference (ref_expr, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &volatilep); index = double_int::from_uhwi (bitpos); if (!restructure_reference (&base, &offset, &index, &type)) diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index ec138584c38..f680e1773a7 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -296,7 +296,7 @@ delegitimize_mem_from_attrs (rtx x) int unsignedp, volatilep = 0; decl = get_inner_reference (decl, &bitsize, &bitpos, &toffset, - &mode, &unsignedp, &volatilep, false); + &mode, &unsignedp, &volatilep); if (bitsize != GET_MODE_BITSIZE (mode) || (bitpos % BITS_PER_UNIT) || (toffset && !tree_fits_shwi_p (toffset))) diff --git a/gcc/tree-affine.c b/gcc/tree-affine.c index f93f186a761..ea80e7593e6 100644 --- a/gcc/tree-affine.c +++ b/gcc/tree-affine.c @@ -325,8 +325,7 @@ tree_to_aff_combination (tree expr, tree type, aff_tree *comb) return; } core = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos, - &toffset, &mode, &unsignedp, &volatilep, - false); + &toffset, &mode, &unsignedp, &volatilep); if (bitpos % BITS_PER_UNIT != 0) break; aff_combination_const (comb, type, @@ -895,7 +894,7 @@ get_inner_reference_aff (tree ref, aff_tree *addr, double_int *size) int uns, vol; aff_tree tmp; tree base = get_inner_reference (ref, &bitsize, &bitpos, &toff, &mode, - &uns, &vol, false); + &uns, &vol); tree base_addr = build_fold_addr_expr (base); /* ADDR = &BASE + TOFF + BITPOS / BITS_PER_UNIT. */ diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c index fef6a716b7a..559a546d29f 100644 --- a/gcc/tree-data-ref.c +++ b/gcc/tree-data-ref.c @@ -619,7 +619,7 @@ split_constant_offset_1 (tree type, tree op0, enum tree_code code, tree op1, op0 = TREE_OPERAND (op0, 0); base = get_inner_reference (op0, &pbitsize, &pbitpos, &poffset, - &pmode, &punsignedp, &pvolatilep, false); + &pmode, &punsignedp, &pvolatilep); if (pbitpos % BITS_PER_UNIT != 0) return false; @@ -769,7 +769,7 @@ dr_analyze_innermost (struct data_reference *dr, struct loop *nest) fprintf (dump_file, "analyze_innermost: "); base = get_inner_reference (ref, &pbitsize, &pbitpos, &poffset, - &pmode, &punsignedp, &pvolatilep, false); + &pmode, &punsignedp, &pvolatilep); gcc_assert (base != NULL_TREE); if (pbitpos % BITS_PER_UNIT != 0) diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c index ada942df389..ddea81b3b8e 100644 --- a/gcc/tree-scalar-evolution.c +++ b/gcc/tree-scalar-evolution.c @@ -1658,7 +1658,7 @@ interpret_rhs_expr (struct loop *loop, gimple at_stmt, base = get_inner_reference (TREE_OPERAND (rhs1, 0), &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + &mode, &unsignedp, &volatilep); if (TREE_CODE (base) == MEM_REF) { diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 1f5590a7ac2..f790bb180cd 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -1684,7 +1684,7 @@ may_be_unaligned_p (tree ref, tree step) does to check whether the object must be loaded by parts when STRICT_ALIGNMENT is true. */ base = get_inner_reference (ref, &bitsize, &bitpos, &toffset, &mode, - &unsignedp, &volatilep, true); + &unsignedp, &volatilep); base_type = TREE_TYPE (base); base_align = get_object_alignment (base); base_align = MAX (base_align, TYPE_ALIGN (base_type)); @@ -3781,7 +3781,7 @@ split_address_cost (struct ivopts_data *data, int unsignedp, volatilep; core = get_inner_reference (addr, &bitsize, &bitpos, &toffset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &volatilep); if (toffset != 0 || bitpos % BITS_PER_UNIT != 0 diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index 5e3b5209e68..82616450e1e 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -2970,7 +2970,7 @@ vect_check_gather (gimple stmt, loop_vec_info loop_vinfo, tree *basep, SSA_NAME OFF and put the loop invariants into a tree BASE that can be gimplified before the loop. */ base = get_inner_reference (DR_REF (dr), &pbitsize, &pbitpos, &off, - &pmode, &punsignedp, &pvolatilep, false); + &pmode, &punsignedp, &pvolatilep); gcc_assert (base != NULL_TREE && (pbitpos % BITS_PER_UNIT) == 0); if (TREE_CODE (base) == MEM_REF) @@ -3466,7 +3466,7 @@ again: } outer_base = get_inner_reference (inner_base, &pbitsize, &pbitpos, - &poffset, &pmode, &punsignedp, &pvolatilep, false); + &poffset, &pmode, &punsignedp, &pvolatilep); gcc_assert (outer_base != NULL_TREE); if (pbitpos % BITS_PER_UNIT != 0) diff --git a/gcc/tree.h b/gcc/tree.h index 68f98261b56..be57f651fd6 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4511,8 +4511,7 @@ extern tree build_personality_function (const char *); look for the ultimate containing object, which is returned and specify the access position and size. */ extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *, - tree *, enum machine_mode *, int *, int *, - bool); + tree *, enum machine_mode *, int *, int *); /* Return a tree representing the lower bound of the array mentioned in EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */ diff --git a/gcc/tsan.c b/gcc/tsan.c index 4efcfe565aa..10b74fd96ee 100644 --- a/gcc/tsan.c +++ b/gcc/tsan.c @@ -121,7 +121,7 @@ instrument_expr (gimple_stmt_iterator gsi, tree expr, bool is_write) enum machine_mode mode; int volatilep = 0, unsignedp = 0; base = get_inner_reference (expr, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + &mode, &unsignedp, &volatilep); /* No need to instrument accesses to decls that don't escape, they can't escape to other threads then. */