Index: gcc/ipa-polymorphic-call.c =================================================================== --- gcc/ipa-polymorphic-call.c (.../trunk) (revision 224461) +++ gcc/ipa-polymorphic-call.c (.../branches/scalar-storage-order) (revision 224467) @@ -774,6 +774,7 @@ ipa_polymorphic_call_context::set_by_inv HOST_WIDE_INT off) { HOST_WIDE_INT offset2, size, max_size; + bool reverse; tree base; invalid = false; @@ -784,7 +785,7 @@ ipa_polymorphic_call_context::set_by_inv return false; cst = TREE_OPERAND (cst, 0); - base = get_ref_base_and_extent (cst, &offset2, &size, &max_size); + base = get_ref_base_and_extent (cst, &offset2, &size, &max_size, &reverse); if (!DECL_P (base) || max_size == -1 || max_size != size) return false; @@ -914,8 +915,10 @@ ipa_polymorphic_call_context::ipa_polymo { HOST_WIDE_INT size, max_size; HOST_WIDE_INT offset2; - tree base = get_ref_base_and_extent (TREE_OPERAND (base_pointer, 0), - &offset2, &size, &max_size); + bool reverse; + tree base + = get_ref_base_and_extent (TREE_OPERAND (base_pointer, 0), + &offset2, &size, &max_size, &reverse); if (max_size != -1 && max_size == size) combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base)), @@ -1183,6 +1186,7 @@ extr_type_from_vtbl_ptr_store (gimple st { HOST_WIDE_INT offset, size, max_size; tree lhs, rhs, base; + bool reverse; if (!gimple_assign_single_p (stmt)) return NULL_TREE; @@ -1201,7 +1205,7 @@ extr_type_from_vtbl_ptr_store (gimple st ; else { - base = get_ref_base_and_extent (lhs, &offset, &size, &max_size); + base = get_ref_base_and_extent (lhs, &offset, &size, &max_size, &reverse); if (DECL_P (tci->instance)) { if (base != tci->instance) @@ -1390,6 +1394,7 @@ check_stmt_for_type_change (ao_ref *ao A tree op = walk_ssa_copies (gimple_call_arg (stmt, 0)); tree type = TYPE_METHOD_BASETYPE (TREE_TYPE (fn)); HOST_WIDE_INT offset = 0, size, max_size; + bool reverse; if (dump_file) { @@ -1400,8 +1405,8 @@ check_stmt_for_type_change (ao_ref *ao A /* See if THIS parameter seems like instance pointer. */ if (TREE_CODE (op) == ADDR_EXPR) { - op = get_ref_base_and_extent (TREE_OPERAND (op, 0), - &offset, &size, &max_size); + op = get_ref_base_and_extent (TREE_OPERAND (op, 0), &offset, + &size, &max_size, &reverse); if (size != max_size || max_size == -1) { tci->speculative = true; @@ -1544,6 +1549,7 @@ ipa_polymorphic_call_context::get_dynami { tree ref = gimple_call_fn (call); HOST_WIDE_INT offset2, size, max_size; + bool reverse; if (TREE_CODE (ref) == OBJ_TYPE_REF) { @@ -1573,8 +1579,9 @@ ipa_polymorphic_call_context::get_dynami && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref))) { tree ref_exp = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (ref)); - tree base_ref = get_ref_base_and_extent - (ref_exp, &offset2, &size, &max_size); + tree base_ref + = get_ref_base_and_extent (ref_exp, &offset2, &size, + &max_size, &reverse); /* Finally verify that what we found looks like read from OTR_OBJECT or from INSTANCE with offset OFFSET. */ Index: gcc/ipa-cp.c =================================================================== --- gcc/ipa-cp.c (.../trunk) (revision 224461) +++ gcc/ipa-cp.c (.../branches/scalar-storage-order) (revision 224467) @@ -948,7 +948,7 @@ ipa_get_jf_ancestor_result (struct ipa_j { tree t = TREE_OPERAND (input, 0); t = build_ref_for_offset (EXPR_LOCATION (t), t, - ipa_get_jf_ancestor_offset (jfunc), + ipa_get_jf_ancestor_offset (jfunc), false, ptr_type_node, NULL, false); return build_fold_addr_expr (t); } Index: gcc/tree-scalar-evolution.c =================================================================== --- gcc/tree-scalar-evolution.c (.../trunk) (revision 224461) +++ gcc/tree-scalar-evolution.c (.../branches/scalar-storage-order) (revision 224467) @@ -1742,15 +1742,16 @@ interpret_rhs_expr (struct loop *loop, g { machine_mode mode; HOST_WIDE_INT bitsize, bitpos; - int unsignedp; + int unsignedp, reversep; int volatilep = 0; tree base, offset; tree chrec3; tree unitpos; base = get_inner_reference (TREE_OPERAND (rhs1, 0), - &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + &bitsize, &bitpos, &offset, &mode, + &unsignedp, &reversep, &volatilep, + false); if (TREE_CODE (base) == MEM_REF) { Index: gcc/builtins.c =================================================================== --- gcc/builtins.c (.../trunk) (revision 224461) +++ gcc/builtins.c (.../branches/scalar-storage-order) (revision 224467) @@ -299,14 +299,14 @@ get_object_alignment_2 (tree exp, unsign HOST_WIDE_INT bitsize, bitpos; tree offset; machine_mode mode; - int unsignedp, volatilep; + int unsignedp, reversep, volatilep; unsigned int align = BITS_PER_UNIT; bool known_alignment = false; /* 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); + exp = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode, + &unsignedp, &reversep, &volatilep, true); /* Extract alignment information from the innermost object and possibly adjust bitpos and offset. */ Index: gcc/tree-ssa-sccvn.c =================================================================== --- gcc/tree-ssa-sccvn.c (.../trunk) (revision 224461) +++ gcc/tree-ssa-sccvn.c (.../branches/scalar-storage-order) (revision 224467) @@ -732,6 +732,9 @@ vn_reference_eq (const_vn_reference_t co { if (vro1->opcode == MEM_REF) deref1 = true; + /* Do not look through a storage order barrier. */ + else if (vro1->opcode == VIEW_CONVERT_EXPR && vro1->reverse) + return false; if (vro1->off == -1) break; off1 += vro1->off; @@ -740,6 +743,9 @@ vn_reference_eq (const_vn_reference_t co { if (vro2->opcode == MEM_REF) deref2 = true; + /* Do not look through a storage order barrier. */ + else if (vro2->opcode == VIEW_CONVERT_EXPR && vro2->reverse) + return false; if (vro2->off == -1) break; off2 += vro2->off; @@ -839,11 +845,13 @@ copy_reference_ops_from_ref (tree ref, v temp.op0 = TREE_OPERAND (ref, 1); if (tree_fits_shwi_p (TREE_OPERAND (ref, 1))) temp.off = tree_to_shwi (TREE_OPERAND (ref, 1)); + temp.reverse = REF_REVERSE_STORAGE_ORDER (ref); break; case BIT_FIELD_REF: - /* Record bits and position. */ + /* Record bits, position and storage order. */ temp.op0 = TREE_OPERAND (ref, 1); temp.op1 = TREE_OPERAND (ref, 2); + temp.reverse = REF_REVERSE_STORAGE_ORDER (ref); break; case COMPONENT_REF: /* The field decl is enough to unambiguously specify the field, @@ -940,8 +948,11 @@ copy_reference_ops_from_ref (tree ref, v operand), so we don't have to put anything for op* as it will be handled by the iteration */ case REALPART_EXPR: + temp.off = 0; + break; case VIEW_CONVERT_EXPR: temp.off = 0; + temp.reverse = storage_order_barrier_p (ref); break; case IMAGPART_EXPR: /* This is only interesting for its constant offset. */ @@ -1426,6 +1437,21 @@ fully_constant_vn_reference_p (vn_refere return NULL_TREE; } +/* Return true if OPS contain a storage order barrier. */ + +static bool +contains_storage_order_barrier_p (vec ops) +{ + vn_reference_op_t op; + unsigned i; + + FOR_EACH_VEC_ELT (ops, i, op) + if (op->opcode == VIEW_CONVERT_EXPR && op->reverse) + return true; + + return false; +} + /* Transform any SSA_NAME's in a vector of vn_reference_op_s structures into their value numbers. This is done in-place, and the vector passed in is returned. *VALUEIZED_ANYTHING will specify @@ -1738,7 +1764,9 @@ vn_reference_lookup_3 (ao_ref *ref, tree tree ref2 = TREE_OPERAND (gimple_call_arg (def_stmt, 0), 0); tree base2; HOST_WIDE_INT offset2, size2, maxsize2; - base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2); + bool reverse; + base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2, + &reverse); size2 = tree_to_uhwi (gimple_call_arg (def_stmt, 2)) * 8; if ((unsigned HOST_WIDE_INT)size2 / 8 == tree_to_uhwi (gimple_call_arg (def_stmt, 2)) @@ -1761,8 +1789,9 @@ vn_reference_lookup_3 (ao_ref *ref, tree { tree base2; HOST_WIDE_INT offset2, size2, maxsize2; + bool reverse; base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt), - &offset2, &size2, &maxsize2); + &offset2, &size2, &maxsize2, &reverse); if (maxsize2 != -1 && operand_equal_p (base, base2, 0) && offset2 <= offset @@ -1782,13 +1811,15 @@ vn_reference_lookup_3 (ao_ref *ref, tree && maxsize % BITS_PER_UNIT == 0 && offset % BITS_PER_UNIT == 0 && is_gimple_reg_type (vr->type) + && !contains_storage_order_barrier_p (vr->operands) && gimple_assign_single_p (def_stmt) && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt))) { tree base2; HOST_WIDE_INT offset2, size2, maxsize2; + bool reverse; base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt), - &offset2, &size2, &maxsize2); + &offset2, &size2, &maxsize2, &reverse); if (maxsize2 != -1 && maxsize2 == size2 && size2 % BITS_PER_UNIT == 0 @@ -1821,6 +1852,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree to access pieces from. */ else if (ref->size == maxsize && is_gimple_reg_type (vr->type) + && !contains_storage_order_barrier_p (vr->operands) && gimple_assign_single_p (def_stmt) && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME) { @@ -1833,8 +1865,10 @@ vn_reference_lookup_3 (ao_ref *ref, tree { tree base2; HOST_WIDE_INT offset2, size2, maxsize2, off; + bool reverse; base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt), - &offset2, &size2, &maxsize2); + &offset2, &size2, &maxsize2, + &reverse); off = offset - offset2; if (maxsize2 != -1 && maxsize2 == size2 @@ -1885,7 +1919,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree { tree base2; HOST_WIDE_INT offset2, size2, maxsize2; - int i, j; + int i, j, k; auto_vec rhs; vn_reference_op_t vro; ao_ref r; @@ -1948,6 +1982,14 @@ vn_reference_lookup_3 (ao_ref *ref, tree if (j != -1) return (void *)-1; + /* Punt if the additional ops contain a storage order barrier. */ + for (k = i; k >= 0; k--) + { + vro = &vr->operands[k]; + if (vro->opcode == VIEW_CONVERT_EXPR && vro->reverse) + return (void *)-1; + } + /* Now re-write REF to be based on the rhs of the assignment. */ copy_reference_ops_from_ref (gimple_assign_rhs1 (def_stmt), &rhs); @@ -2022,7 +2064,6 @@ vn_reference_lookup_3 (ao_ref *ref, tree vn_reference_op_s op; HOST_WIDE_INT at; - /* Only handle non-variable, addressable refs. */ if (ref->size != maxsize || offset % BITS_PER_UNIT != 0 Index: gcc/tree-ssa-sccvn.h =================================================================== --- gcc/tree-ssa-sccvn.h (.../trunk) (revision 224461) +++ gcc/tree-ssa-sccvn.h (.../branches/scalar-storage-order) (revision 224467) @@ -89,6 +89,7 @@ typedef struct vn_reference_op_struct tree op0; tree op1; tree op2; + bool reverse; } vn_reference_op_s; typedef vn_reference_op_s *vn_reference_op_t; typedef const vn_reference_op_s *const_vn_reference_op_t; Index: gcc/dbxout.c =================================================================== --- gcc/dbxout.c (.../trunk) (revision 224461) +++ gcc/dbxout.c (.../branches/scalar-storage-order) (revision 224467) @@ -2495,11 +2495,11 @@ dbxout_expand_expr (tree expr) machine_mode mode; HOST_WIDE_INT bitsize, bitpos; tree offset, tem; - int volatilep = 0, unsignedp = 0; + int unsignedp, reversep, volatilep = 0; rtx x; - tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, true); + tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, &mode, + &unsignedp, &reversep, &volatilep, true); x = dbxout_expand_expr (tem); if (x == NULL || !MEM_P (x)) Index: gcc/tree-ssa-loop-ivopts.c =================================================================== --- gcc/tree-ssa-loop-ivopts.c (.../trunk) (revision 224461) +++ gcc/tree-ssa-loop-ivopts.c (.../branches/scalar-storage-order) (revision 224467) @@ -1858,10 +1858,27 @@ may_be_nonaddressable_p (tree expr) target, thus they are always addressable. */ return false; + case MEM_REF: + /* Likewise for MEM_REFs, modulo the storage order. */ + return REF_REVERSE_STORAGE_ORDER (expr); + + case BIT_FIELD_REF: + if (REF_REVERSE_STORAGE_ORDER (expr)) + return true; + return may_be_nonaddressable_p (TREE_OPERAND (expr, 0)); + case COMPONENT_REF: + if (TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (expr, 0)))) + return true; return DECL_NONADDRESSABLE_P (TREE_OPERAND (expr, 1)) || may_be_nonaddressable_p (TREE_OPERAND (expr, 0)); + case ARRAY_REF: + case ARRAY_RANGE_REF: + if (TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (expr, 0)))) + return true; + return may_be_nonaddressable_p (TREE_OPERAND (expr, 0)); + case VIEW_CONVERT_EXPR: /* This kind of view-conversions may wrap non-addressable objects and make them look addressable. After some processing the @@ -1870,11 +1887,6 @@ may_be_nonaddressable_p (tree expr) if (is_gimple_reg (TREE_OPERAND (expr, 0)) || !is_gimple_addressable (TREE_OPERAND (expr, 0))) return true; - - /* ... fall through ... */ - - case ARRAY_REF: - case ARRAY_RANGE_REF: return may_be_nonaddressable_p (TREE_OPERAND (expr, 0)); CASE_CONVERT: @@ -4136,13 +4148,14 @@ split_address_cost (struct ivopts_data * HOST_WIDE_INT bitpos; tree toffset; machine_mode mode; - int unsignedp, volatilep; + int unsignedp, reversep, volatilep; core = get_inner_reference (addr, &bitsize, &bitpos, &toffset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); if (toffset != 0 || bitpos % BITS_PER_UNIT != 0 + || reversep || TREE_CODE (core) != VAR_DECL) { *symbol_present = false; Index: gcc/lto-streamer-out.c =================================================================== --- gcc/lto-streamer-out.c (.../trunk) (revision 224461) +++ gcc/lto-streamer-out.c (.../branches/scalar-storage-order) (revision 224467) @@ -986,7 +986,8 @@ hash_tree (struct streamer_tree_cache_d hstate.add_flag (TREE_PRIVATE (t)); if (TYPE_P (t)) { - hstate.add_flag (TYPE_SATURATING (t)); + hstate.add_flag (AGGREGATE_TYPE_P (t) + ? TYPE_REVERSE_STORAGE_ORDER (t) : TYPE_SATURATING (t)); hstate.add_flag (TYPE_ADDR_SPACE (t)); } else if (code == SSA_NAME) Index: gcc/tree-ssa-math-opts.c =================================================================== --- gcc/tree-ssa-math-opts.c (.../trunk) (revision 224461) +++ gcc/tree-ssa-math-opts.c (.../branches/scalar-storage-order) (revision 224467) @@ -2058,7 +2058,7 @@ find_bswap_or_nop_load (gimple stmt, tre offset from base to compare to other such leaf node. */ HOST_WIDE_INT bitsize, bitpos; machine_mode mode; - int unsignedp, volatilep; + int unsignedp, reversep, volatilep; tree offset, base_addr; /* Not prepared to handle PDP endian. */ @@ -2069,7 +2069,7 @@ find_bswap_or_nop_load (gimple stmt, tre return false; base_addr = get_inner_reference (ref, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); if (TREE_CODE (base_addr) == MEM_REF) { @@ -2108,6 +2108,8 @@ find_bswap_or_nop_load (gimple stmt, tre return false; if (bitsize % BITS_PER_UNIT) return false; + if (reversep) + return false; if (!init_symbolic_number (n, ref)) return false; @@ -2555,11 +2557,11 @@ bswap_replace (gimple cur_stmt, gimple s { HOST_WIDE_INT bitsize, bitpos; machine_mode mode; - int unsignedp, volatilep; + int unsignedp, reversep, volatilep; tree offset; get_inner_reference (src, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); if (n->range < (unsigned HOST_WIDE_INT) bitsize) { load_offset = (bitsize - n->range) / BITS_PER_UNIT; Index: gcc/tree-ssa-alias.c =================================================================== --- gcc/tree-ssa-alias.c (.../trunk) (revision 224461) +++ gcc/tree-ssa-alias.c (.../branches/scalar-storage-order) (revision 224467) @@ -571,10 +571,12 @@ ao_ref_init (ao_ref *r, tree ref) tree ao_ref_base (ao_ref *ref) { + bool reverse; + if (ref->base) return ref->base; ref->base = get_ref_base_and_extent (ref->ref, &ref->offset, &ref->size, - &ref->max_size); + &ref->max_size, &reverse); return ref->base; } @@ -755,9 +757,10 @@ aliasing_component_refs_p (tree ref1, else if (same_p == 1) { HOST_WIDE_INT offadj, sztmp, msztmp; - get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp); + bool reverse; + get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp, &reverse); offset2 -= offadj; - get_ref_base_and_extent (base1, &offadj, &sztmp, &msztmp); + get_ref_base_and_extent (base1, &offadj, &sztmp, &msztmp, &reverse); offset1 -= offadj; return ranges_overlap_p (offset1, max_size1, offset2, max_size2); } @@ -773,9 +776,10 @@ aliasing_component_refs_p (tree ref1, else if (same_p == 1) { HOST_WIDE_INT offadj, sztmp, msztmp; - get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp); + bool reverse; + get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp, &reverse); offset1 -= offadj; - get_ref_base_and_extent (base2, &offadj, &sztmp, &msztmp); + get_ref_base_and_extent (base2, &offadj, &sztmp, &msztmp, &reverse); offset2 -= offadj; return ranges_overlap_p (offset1, max_size1, offset2, max_size2); } @@ -2320,7 +2324,9 @@ stmt_kills_ref_p (gimple stmt, ao_ref *r if (ref->max_size == -1) return false; HOST_WIDE_INT size, offset, max_size, ref_offset = ref->offset; - tree base = get_ref_base_and_extent (lhs, &offset, &size, &max_size); + bool reverse; + tree base + = get_ref_base_and_extent (lhs, &offset, &size, &max_size, &reverse); /* We can get MEM[symbol: sZ, index: D.8862_1] here, so base == ref->base does not always hold. */ if (base != ref->base) Index: gcc/ifcvt.c =================================================================== --- gcc/ifcvt.c (.../trunk) (revision 224461) +++ gcc/ifcvt.c (.../branches/scalar-storage-order) (revision 224467) @@ -961,7 +961,7 @@ noce_emit_move_insn (rtx x, rtx y) } gcc_assert (start < (MEM_P (op) ? BITS_PER_UNIT : BITS_PER_WORD)); - store_bit_field (op, size, start, 0, 0, GET_MODE (x), y); + store_bit_field (op, size, start, 0, 0, GET_MODE (x), y, false); return; } @@ -1016,7 +1016,7 @@ noce_emit_move_insn (rtx x, rtx y) outmode = GET_MODE (outer); bitpos = SUBREG_BYTE (outer) * BITS_PER_UNIT; store_bit_field (inner, GET_MODE_BITSIZE (outmode), bitpos, - 0, 0, outmode, y); + 0, 0, outmode, y, false); } /* Return the CC reg if it is used in COND. */ Index: gcc/dwarf2out.c =================================================================== --- gcc/dwarf2out.c (.../trunk) (revision 224461) +++ gcc/dwarf2out.c (.../branches/scalar-storage-order) (revision 224467) @@ -5249,9 +5249,10 @@ add_var_loc_to_decl (tree decl, rtx loc_ && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR)) { HOST_WIDE_INT maxsize; - tree innerdecl; - innerdecl - = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize); + bool reverse; + tree innerdecl + = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize, + &reverse); if (!DECL_P (innerdecl) || DECL_IGNORED_P (innerdecl) || TREE_STATIC (innerdecl) @@ -14431,12 +14432,12 @@ loc_list_for_address_of_addr_expr_of_ind tree obj, offset; HOST_WIDE_INT bitsize, bitpos, bytepos; machine_mode mode; - int unsignedp, volatilep = 0; + int unsignedp, reversep, volatilep = 0; dw_loc_list_ref list_ret = NULL, list_ret1 = NULL; obj = get_inner_reference (TREE_OPERAND (loc, 0), &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); STRIP_NOPS (obj); if (bitpos % BITS_PER_UNIT) { @@ -14765,10 +14766,10 @@ loc_list_from_tree (tree loc, int want_a tree obj, offset; HOST_WIDE_INT bitsize, bitpos, bytepos; machine_mode mode; - int unsignedp, volatilep = 0; + int unsignedp, reversep, volatilep = 0; obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); gcc_assert (obj != loc); @@ -16068,7 +16069,7 @@ fortran_common (tree decl, HOST_WIDE_INT machine_mode mode; HOST_WIDE_INT bitsize, bitpos; tree offset; - int unsignedp, volatilep = 0; + int unsignedp, reversep, volatilep = 0; /* If the decl isn't a VAR_DECL, or if it isn't static, or if it does not have a value (the offset into the common area), or if it @@ -16084,8 +16085,8 @@ fortran_common (tree decl, HOST_WIDE_INT if (TREE_CODE (val_expr) != COMPONENT_REF) return NULL_TREE; - cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, true); + cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset, &mode, + &unsignedp, &reversep, &volatilep, true); if (cvar == NULL_TREE || TREE_CODE (cvar) != VAR_DECL Index: gcc/tsan.c =================================================================== --- gcc/tsan.c (.../trunk) (revision 224461) +++ gcc/tsan.c (.../branches/scalar-storage-order) (revision 224467) @@ -141,9 +141,9 @@ instrument_expr (gimple_stmt_iterator gs HOST_WIDE_INT bitsize, bitpos; tree offset; machine_mode mode; - int volatilep = 0, unsignedp = 0; - base = get_inner_reference (expr, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + int unsignedp, reversep, volatilep = 0; + base = get_inner_reference (expr, &bitsize, &bitpos, &offset, &mode, + &unsignedp, &reversep, &volatilep, false); /* No need to instrument accesses to decls that don't escape, they can't escape to other threads then. */ Index: gcc/asan.c =================================================================== --- gcc/asan.c (.../trunk) (revision 224461) +++ gcc/asan.c (.../branches/scalar-storage-order) (revision 224467) @@ -1814,9 +1814,9 @@ instrument_derefs (gimple_stmt_iterator HOST_WIDE_INT bitsize, bitpos; tree offset; machine_mode mode; - int volatilep = 0, unsignedp = 0; - tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset, - &mode, &unsignedp, &volatilep, false); + int unsignedp, reversep, volatilep = 0; + tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset, &mode, + &unsignedp, &reversep, &volatilep, false); if (TREE_CODE (t) == COMPONENT_REF && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t, 1)) != NULL_TREE) Index: gcc/gimple-ssa-strength-reduction.c =================================================================== --- gcc/gimple-ssa-strength-reduction.c (.../trunk) (revision 224461) +++ gcc/gimple-ssa-strength-reduction.c (.../branches/scalar-storage-order) (revision 224467) @@ -1001,7 +1001,7 @@ slsr_process_ref (gimple gs) tree ref_expr, base, offset, type; HOST_WIDE_INT bitsize, bitpos; machine_mode mode; - int unsignedp, volatilep; + int unsignedp, reversep, volatilep; slsr_cand_t c; if (gimple_vdef (gs)) @@ -1016,7 +1016,9 @@ slsr_process_ref (gimple gs) return; base = get_inner_reference (ref_expr, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); + if (reversep) + return; widest_int index = bitpos; if (!restructure_reference (&base, &offset, &index, &type)) Index: gcc/tree-data-ref.c =================================================================== --- gcc/tree-data-ref.c (.../trunk) (revision 224461) +++ gcc/tree-data-ref.c (.../branches/scalar-storage-order) (revision 224467) @@ -636,11 +636,12 @@ split_constant_offset_1 (tree type, tree tree base, poffset; HOST_WIDE_INT pbitsize, pbitpos; machine_mode pmode; - int punsignedp, pvolatilep; + int punsignedp, preversep, pvolatilep; op0 = TREE_OPERAND (op0, 0); - base = get_inner_reference (op0, &pbitsize, &pbitpos, &poffset, - &pmode, &punsignedp, &pvolatilep, false); + base + = get_inner_reference (op0, &pbitsize, &pbitpos, &poffset, &pmode, + &punsignedp, &preversep, &pvolatilep, false); if (pbitpos % BITS_PER_UNIT != 0) return false; @@ -784,7 +785,7 @@ dr_analyze_innermost (struct data_refere HOST_WIDE_INT pbitsize, pbitpos; tree base, poffset; machine_mode pmode; - int punsignedp, pvolatilep; + int punsignedp, preversep, pvolatilep; affine_iv base_iv, offset_iv; tree init, dinit, step; bool in_loop = (loop && loop->num); @@ -792,8 +793,8 @@ dr_analyze_innermost (struct data_refere if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "analyze_innermost: "); - base = get_inner_reference (ref, &pbitsize, &pbitpos, &poffset, - &pmode, &punsignedp, &pvolatilep, false); + base = get_inner_reference (ref, &pbitsize, &pbitpos, &poffset, &pmode, + &punsignedp, &preversep, &pvolatilep, false); gcc_assert (base != NULL_TREE); if (pbitpos % BITS_PER_UNIT != 0) @@ -803,6 +804,13 @@ dr_analyze_innermost (struct data_refere return false; } + if (preversep) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "failed: reverse storage order.\n"); + return false; + } + if (TREE_CODE (base) == MEM_REF) { if (!integer_zerop (TREE_OPERAND (base, 1))) Index: gcc/tree-affine.c =================================================================== --- gcc/tree-affine.c (.../trunk) (revision 224461) +++ gcc/tree-affine.c (.../branches/scalar-storage-order) (revision 224467) @@ -283,7 +283,7 @@ tree_to_aff_combination (tree expr, tree tree cst, core, toffset; HOST_WIDE_INT bitpos, bitsize; machine_mode mode; - int unsignedp, volatilep; + int unsignedp, reversep, volatilep; STRIP_NOPS (expr); @@ -340,8 +340,8 @@ tree_to_aff_combination (tree expr, tree return; } core = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos, - &toffset, &mode, &unsignedp, &volatilep, - false); + &toffset, &mode, &unsignedp, &reversep, + &volatilep, false); if (bitpos % BITS_PER_UNIT != 0) break; aff_combination_const (comb, type, bitpos / BITS_PER_UNIT); @@ -908,10 +908,10 @@ get_inner_reference_aff (tree ref, aff_t HOST_WIDE_INT bitsize, bitpos; tree toff; machine_mode mode; - int uns, vol; + int uns, rev, vol; aff_tree tmp; tree base = get_inner_reference (ref, &bitsize, &bitpos, &toff, &mode, - &uns, &vol, false); + &uns, &rev, &vol, false); tree base_addr = build_fold_addr_expr (base); /* ADDR = &BASE + TOFF + BITPOS / BITS_PER_UNIT. */ Index: gcc/tree-vect-data-refs.c =================================================================== --- gcc/tree-vect-data-refs.c (.../trunk) (revision 224461) +++ gcc/tree-vect-data-refs.c (.../branches/scalar-storage-order) (revision 224467) @@ -2974,7 +2974,7 @@ vect_check_gather (gimple stmt, loop_vec tree offtype = NULL_TREE; tree decl, base, off; machine_mode pmode; - int punsignedp, pvolatilep; + int punsignedp, reversep, pvolatilep = 0; base = DR_REF (dr); /* For masked loads/stores, DR_REF (dr) is an artificial MEM_REF, @@ -3006,9 +3006,9 @@ vect_check_gather (gimple stmt, loop_vec vectorized. The following code attempts to find such a preexistng SSA_NAME OFF and put the loop invariants into a tree BASE that can be gimplified before the loop. */ - base = get_inner_reference (base, &pbitsize, &pbitpos, &off, - &pmode, &punsignedp, &pvolatilep, false); - gcc_assert (base != NULL_TREE && (pbitpos % BITS_PER_UNIT) == 0); + base = get_inner_reference (base, &pbitsize, &pbitpos, &off, &pmode, + &punsignedp, &reversep, &pvolatilep, false); + gcc_assert (base && (pbitpos % BITS_PER_UNIT) == 0 && !reversep); if (TREE_CODE (base) == MEM_REF) { @@ -3547,7 +3547,7 @@ again: HOST_WIDE_INT pbitsize, pbitpos; tree poffset; machine_mode pmode; - int punsignedp, pvolatilep; + int punsignedp, preversep, pvolatilep; affine_iv base_iv, offset_iv; tree dinit; @@ -3566,7 +3566,8 @@ again: } outer_base = get_inner_reference (inner_base, &pbitsize, &pbitpos, - &poffset, &pmode, &punsignedp, &pvolatilep, false); + &poffset, &pmode, &punsignedp, + &preversep, &pvolatilep, false); gcc_assert (outer_base != NULL_TREE); if (pbitpos % BITS_PER_UNIT != 0) @@ -3577,6 +3578,14 @@ again: return false; } + if (preversep) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "failed: reverse storage order.\n"); + return false; + } + outer_base = build_fold_addr_expr (outer_base); if (!simple_iv (loop, loop_containing_stmt (stmt), outer_base, &base_iv, false)) Index: gcc/gimple-fold.c =================================================================== --- gcc/gimple-fold.c (.../trunk) (revision 224461) +++ gcc/gimple-fold.c (.../branches/scalar-storage-order) (revision 224467) @@ -926,13 +926,14 @@ gimple_fold_builtin_memory_op (gimple_st HOST_WIDE_INT src_offset = 0, dest_offset = 0; HOST_WIDE_INT size = -1; HOST_WIDE_INT maxsize = -1; + bool reverse; srcvar = TREE_OPERAND (src, 0); src_base = get_ref_base_and_extent (srcvar, &src_offset, - &size, &maxsize); + &size, &maxsize, &reverse); destvar = TREE_OPERAND (dest, 0); dest_base = get_ref_base_and_extent (destvar, &dest_offset, - &size, &maxsize); + &size, &maxsize, &reverse); if (tree_fits_uhwi_p (len)) maxsize = tree_to_uhwi (len); else @@ -5219,6 +5220,8 @@ get_base_constructor (tree base, HOST_WI tree (*valueize)(tree)) { HOST_WIDE_INT bit_offset2, size, max_size; + bool reverse; + if (TREE_CODE (base) == MEM_REF) { if (!integer_zerop (TREE_OPERAND (base, 1))) @@ -5259,7 +5262,8 @@ get_base_constructor (tree base, HOST_WI case ARRAY_REF: case COMPONENT_REF: - base = get_ref_base_and_extent (base, &bit_offset2, &size, &max_size); + base = get_ref_base_and_extent (base, &bit_offset2, &size, &max_size, + &reverse); if (max_size == -1 || size != max_size) return NULL_TREE; *bit_offset += bit_offset2; @@ -5503,6 +5507,7 @@ fold_const_aggregate_ref_1 (tree t, tree tree ctor, idx, base; HOST_WIDE_INT offset, size, max_size; tree tem; + bool reverse; if (TREE_THIS_VOLATILE (t)) return NULL_TREE; @@ -5573,7 +5578,7 @@ fold_const_aggregate_ref_1 (tree t, tree case BIT_FIELD_REF: case TARGET_MEM_REF: case MEM_REF: - base = get_ref_base_and_extent (t, &offset, &size, &max_size); + base = get_ref_base_and_extent (t, &offset, &size, &max_size, &reverse); ctor = get_base_constructor (base, &offset, valueize); /* Empty constructor. Always fold to 0. */ Index: gcc/cfgexpand.c =================================================================== --- gcc/cfgexpand.c (.../trunk) (revision 224461) +++ gcc/cfgexpand.c (.../branches/scalar-storage-order) (revision 224467) @@ -4121,9 +4121,10 @@ expand_debug_expr (tree exp) machine_mode mode1; HOST_WIDE_INT bitsize, bitpos; tree offset; - int volatilep = 0; - tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset, - &mode1, &unsignedp, &volatilep, false); + int reversep, volatilep = 0; + tree tem + = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1, + &unsignedp, &reversep, &volatilep, false); rtx orig_op0; if (bitsize == 0) @@ -4548,9 +4549,10 @@ expand_debug_expr (tree exp) if (handled_component_p (TREE_OPERAND (exp, 0))) { HOST_WIDE_INT bitoffset, bitsize, maxsize; + bool reverse; tree decl - = get_ref_base_and_extent (TREE_OPERAND (exp, 0), - &bitoffset, &bitsize, &maxsize); + = get_ref_base_and_extent (TREE_OPERAND (exp, 0), &bitoffset, + &bitsize, &maxsize, &reverse); if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL) Index: gcc/simplify-rtx.c =================================================================== --- gcc/simplify-rtx.c (.../trunk) (revision 224461) +++ gcc/simplify-rtx.c (.../branches/scalar-storage-order) (revision 224467) @@ -322,10 +322,11 @@ delegitimize_mem_from_attrs (rtx x) { HOST_WIDE_INT bitsize, bitpos; tree toffset; - int unsignedp, volatilep = 0; + int unsignedp, reversep, volatilep = 0; - decl = get_inner_reference (decl, &bitsize, &bitpos, &toffset, - &mode, &unsignedp, &volatilep, false); + decl + = get_inner_reference (decl, &bitsize, &bitpos, &toffset, &mode, + &unsignedp, &reversep, &volatilep, false); if (bitsize != GET_MODE_BITSIZE (mode) || (bitpos % BITS_PER_UNIT) || (toffset && !tree_fits_shwi_p (toffset))) Index: gcc/tree-ssa-pre.c =================================================================== --- gcc/tree-ssa-pre.c (.../trunk) (revision 224461) +++ gcc/tree-ssa-pre.c (.../branches/scalar-storage-order) (revision 224467) @@ -2552,7 +2552,9 @@ create_component_ref_by_pieces_1 (basic_ off)); baseop = build_fold_addr_expr (base); } - return fold_build2 (MEM_REF, currop->type, baseop, offset); + tree t = fold_build2 (MEM_REF, currop->type, baseop, offset); + REF_REVERSE_STORAGE_ORDER (t) = currop->reverse; + return t; } case TARGET_MEM_REF: @@ -2617,7 +2619,9 @@ create_component_ref_by_pieces_1 (basic_ return NULL_TREE; tree op1 = currop->op0; tree op2 = currop->op1; - return fold_build3 (BIT_FIELD_REF, currop->type, genop0, op1, op2); + tree t = build3 (BIT_FIELD_REF, currop->type, genop0, op1, op2); + REF_REVERSE_STORAGE_ORDER (t) = currop->reverse; + return fold (t); } /* For array ref vn_reference_op's, operand 1 of the array ref Index: gcc/tree-sra.c =================================================================== --- gcc/tree-sra.c (.../trunk) (revision 224461) +++ gcc/tree-sra.c (.../branches/scalar-storage-order) (revision 224467) @@ -207,12 +207,15 @@ struct access when grp_to_be_replaced flag is set. */ tree replacement_decl; - /* Is this particular access write access? */ - unsigned write : 1; - /* Is this access an access to a non-addressable field? */ unsigned non_addressable : 1; + /* Is this access made in reverse storage order? */ + unsigned reverse : 1; + + /* Is this particular access write access? */ + unsigned write : 1; + /* Is this access currently in the work queue? */ unsigned grp_queued : 1; @@ -483,6 +486,8 @@ dump_access (FILE *f, struct access *acc print_generic_expr (f, access->expr, 0); fprintf (f, ", type = "); print_generic_expr (f, access->type, 0); + fprintf (f, ", non_addressable = %d, reverse = %d", + access->non_addressable, access->reverse); if (grp) fprintf (f, ", grp_read = %d, grp_write = %d, grp_assignment_read = %d, " "grp_assignment_write = %d, grp_scalar_read = %d, " @@ -899,9 +904,9 @@ create_access (tree expr, gimple stmt, b struct access *access; HOST_WIDE_INT offset, size, max_size; tree base = expr; - bool ptr, unscalarizable_region = false; + bool reverse, ptr, unscalarizable_region = false; - base = get_ref_base_and_extent (expr, &offset, &size, &max_size); + base = get_ref_base_and_extent (expr, &offset, &size, &max_size, &reverse); if (sra_mode == SRA_MODE_EARLY_IPA && TREE_CODE (base) == MEM_REF) @@ -955,6 +960,7 @@ create_access (tree expr, gimple stmt, b access->write = write; access->grp_unscalarizable_region = unscalarizable_region; access->stmt = stmt; + access->reverse = reverse; if (TREE_CODE (expr) == COMPONENT_REF && DECL_NONADDRESSABLE_P (TREE_OPERAND (expr, 1))) @@ -1022,6 +1028,7 @@ completely_scalarize_record (tree base, access->expr = nref; access->type = ft; access->grp_total_scalarization = 1; + access->reverse = TYPE_REVERSE_STORAGE_ORDER (decl_type); /* Accesses for intraprocedural SRA can have their stmt NULL. */ } else @@ -1101,7 +1108,7 @@ build_access_from_expr_1 (tree expr, gim and not the result type. Ada produces such statements. We are also capable of handling the topmost V_C_E but not any of those buried in other handled components. */ - if (TREE_CODE (expr) == VIEW_CONVERT_EXPR) + if (TREE_CODE (expr) == VIEW_CONVERT_EXPR && !storage_order_barrier_p (expr)) expr = TREE_OPERAND (expr, 0); if (contains_view_convert_expr_p (expr)) @@ -1234,7 +1241,11 @@ build_accesses_from_assign (gimple stmt) lacc = build_access_from_expr_1 (lhs, stmt, true); if (lacc) - lacc->grp_assignment_write = 1; + { + lacc->grp_assignment_write = 1; + if (storage_order_barrier_p (rhs)) + lacc->grp_unscalarizable_region = 1; + } if (racc) { @@ -1242,6 +1253,8 @@ build_accesses_from_assign (gimple stmt) if (should_scalarize_away_bitmap && !gimple_has_volatile_ops (stmt) && !is_gimple_reg_type (racc->type)) bitmap_set_bit (should_scalarize_away_bitmap, DECL_UID (racc->base)); + if (storage_order_barrier_p (lhs)) + racc->grp_unscalarizable_region = 1; } if (lacc && racc @@ -1549,17 +1562,15 @@ make_fancy_name (tree expr) } /* Construct a MEM_REF that would reference a part of aggregate BASE of type - EXP_TYPE at the given OFFSET. If BASE is something for which - get_addr_base_and_unit_offset returns NULL, gsi must be non-NULL and is used - to insert new statements either before or below the current one as specified - by INSERT_AFTER. This function is not capable of handling bitfields. - - BASE must be either a declaration or a memory reference that has correct - alignment ifformation embeded in it (e.g. a pre-existing one in SRA). */ + EXP_TYPE at the given OFFSET and with storage order REVERSE. If BASE is + something for which get_addr_base_and_unit_offset returns NULL, gsi must + be non-NULL and is used to insert new statements either before or below + the current one as specified by INSERT_AFTER. This function is not capable + of handling bitfields. */ tree build_ref_for_offset (location_t loc, tree base, HOST_WIDE_INT offset, - tree exp_type, gimple_stmt_iterator *gsi, + bool reverse, tree exp_type, gimple_stmt_iterator *gsi, bool insert_after) { tree prev_base = base; @@ -1616,6 +1627,7 @@ build_ref_for_offset (location_t loc, tr exp_type = build_aligned_type (exp_type, align); mem_ref = fold_build2_loc (loc, MEM_REF, exp_type, base, off); + REF_REVERSE_STORAGE_ORDER (mem_ref) = reverse; if (TREE_THIS_VOLATILE (prev_base)) TREE_THIS_VOLATILE (mem_ref) = 1; if (TREE_SIDE_EFFECTS (prev_base)) @@ -1642,13 +1654,17 @@ build_ref_for_model (location_t loc, tre offset -= int_bit_position (fld); exp_type = TREE_TYPE (TREE_OPERAND (model->expr, 0)); - t = build_ref_for_offset (loc, base, offset, exp_type, gsi, insert_after); + t = build_ref_for_offset (loc, base, offset, model->reverse, exp_type, + gsi, insert_after); + /* The flag will be set on the record type. */ + REF_REVERSE_STORAGE_ORDER (t) = 0; return fold_build3_loc (loc, COMPONENT_REF, TREE_TYPE (fld), t, fld, NULL_TREE); } else - return build_ref_for_offset (loc, base, offset, model->type, - gsi, insert_after); + return + build_ref_for_offset (loc, base, offset, model->reverse, model->type, + gsi, insert_after); } /* Attempt to build a memory reference that we could but into a gimple @@ -2305,8 +2321,8 @@ analyze_access_subtree (struct access *r && (root->size % BITS_PER_UNIT) == 0); root->type = build_nonstandard_integer_type (root->size, TYPE_UNSIGNED (rt)); - root->expr = build_ref_for_offset (UNKNOWN_LOCATION, - root->base, root->offset, + root->expr = build_ref_for_offset (UNKNOWN_LOCATION, root->base, + root->offset, root->reverse, root->type, NULL, false); if (dump_file && (dump_flags & TDF_DETAILS)) @@ -2804,6 +2820,7 @@ get_access_for_expr (tree expr) { HOST_WIDE_INT offset, size, max_size; tree base; + bool reverse; /* FIXME: This should not be necessary but Ada produces V_C_Es with a type of a different size than the size of its argument and we need the latter @@ -2811,7 +2828,7 @@ get_access_for_expr (tree expr) if (TREE_CODE (expr) == VIEW_CONVERT_EXPR) expr = TREE_OPERAND (expr, 0); - base = get_ref_base_and_extent (expr, &offset, &size, &max_size); + base = get_ref_base_and_extent (expr, &offset, &size, &max_size, &reverse); if (max_size == -1 || !DECL_P (base)) return NULL; @@ -4444,6 +4461,7 @@ turn_representatives_into_adjustments (v adj.type = repr->type; adj.alias_ptr_type = reference_alias_ptr_type (repr->expr); adj.offset = repr->offset; + adj.reverse = repr->reverse; adj.by_ref = (POINTER_TYPE_P (TREE_TYPE (repr->base)) && (repr->grp_maybe_modified || repr->grp_not_necessarilly_dereferenced)); @@ -5070,9 +5088,9 @@ ipa_sra_check_caller (struct cgraph_node tree offset; HOST_WIDE_INT bitsize, bitpos; machine_mode mode; - int unsignedp, volatilep = 0; + int unsignedp, reversep, volatilep = 0; get_inner_reference (arg, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); if (bitpos % BITS_PER_UNIT) { iscc->bad_arg_alignment = true; Index: gcc/ubsan.c =================================================================== --- gcc/ubsan.c (.../trunk) (revision 224461) +++ gcc/ubsan.c (.../branches/scalar-storage-order) (revision 224467) @@ -1398,9 +1398,9 @@ instrument_bool_enum_load (gimple_stmt_i HOST_WIDE_INT bitsize, bitpos; tree offset; machine_mode mode; - int volatilep = 0, unsignedp = 0; + int volatilep = 0, unsignedp = 0, reversep; tree base = get_inner_reference (rhs, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); tree utype = build_nonstandard_integer_type (modebitsize, 1); if ((TREE_CODE (base) == VAR_DECL && DECL_HARD_REGISTER (base)) @@ -1783,9 +1783,9 @@ instrument_object_size (gimple_stmt_iter HOST_WIDE_INT bitsize, bitpos; tree offset; machine_mode mode; - int volatilep = 0, unsignedp = 0; + int volatilep = 0, unsignedp = 0, reversep; tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &volatilep, false); + &unsignedp, &reversep, &volatilep, false); if (bitpos % BITS_PER_UNIT != 0 || bitsize != size_in_bytes * BITS_PER_UNIT) Index: gcc/lto/lto.c =================================================================== --- gcc/lto/lto.c (.../trunk) (revision 224461) +++ gcc/lto/lto.c (.../branches/scalar-storage-order) (revision 224467) @@ -1031,7 +1031,10 @@ compare_tree_sccs_1 (tree t1, tree t2, t compare_values (TREE_DEPRECATED); if (TYPE_P (t1)) { - compare_values (TYPE_SATURATING); + if (AGGREGATE_TYPE_P (t1)) + compare_values (TYPE_REVERSE_STORAGE_ORDER); + else + compare_values (TYPE_SATURATING); compare_values (TYPE_ADDR_SPACE); } else if (code == SSA_NAME) Index: gcc/tree-streamer-out.c =================================================================== --- gcc/tree-streamer-out.c (.../trunk) (revision 224461) +++ gcc/tree-streamer-out.c (.../branches/scalar-storage-order) (revision 224467) @@ -126,9 +126,14 @@ pack_ts_base_value_fields (struct bitpac bp_pack_value (bp, TREE_DEPRECATED (expr), 1); if (TYPE_P (expr)) { - bp_pack_value (bp, TYPE_SATURATING (expr), 1); + if (AGGREGATE_TYPE_P (expr)) + bp_pack_value (bp, TYPE_REVERSE_STORAGE_ORDER (expr), 1); + else + bp_pack_value (bp, TYPE_SATURATING (expr), 1); bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8); } + else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF) + bp_pack_value (bp, REF_REVERSE_STORAGE_ORDER (expr), 1); else if (TREE_CODE (expr) == SSA_NAME) { bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1); Index: gcc/ipa-prop.c =================================================================== --- gcc/ipa-prop.c (.../trunk) (revision 224461) +++ gcc/ipa-prop.c (.../branches/scalar-storage-order) (revision 224467) @@ -1037,7 +1037,9 @@ ipa_load_from_parm_agg_1 (struct func_bo { int index; HOST_WIDE_INT size, max_size; - tree base = get_ref_base_and_extent (op, offset_p, &size, &max_size); + bool reverse; + tree base + = get_ref_base_and_extent (op, offset_p, &size, &max_size, &reverse); if (max_size == -1 || max_size != size || *offset_p < 0) return false; @@ -1174,6 +1176,7 @@ compute_complex_assign_jump_func (struct { HOST_WIDE_INT offset, size, max_size; tree op1, tc_ssa, base, ssa; + bool reverse; int index; op1 = gimple_assign_rhs1 (stmt); @@ -1221,7 +1224,7 @@ compute_complex_assign_jump_func (struct op1 = TREE_OPERAND (op1, 0); if (TREE_CODE (TREE_TYPE (op1)) != RECORD_TYPE) return; - base = get_ref_base_and_extent (op1, &offset, &size, &max_size); + base = get_ref_base_and_extent (op1, &offset, &size, &max_size, &reverse); if (TREE_CODE (base) != MEM_REF /* If this is a varying address, punt. */ || max_size == -1 @@ -1257,6 +1260,7 @@ get_ancestor_addr_info (gimple assign, t { HOST_WIDE_INT size, max_size; tree expr, parm, obj; + bool reverse; if (!gimple_assign_single_p (assign)) return NULL_TREE; @@ -1266,7 +1270,7 @@ get_ancestor_addr_info (gimple assign, t return NULL_TREE; expr = TREE_OPERAND (expr, 0); obj = expr; - expr = get_ref_base_and_extent (expr, offset, &size, &max_size); + expr = get_ref_base_and_extent (expr, offset, &size, &max_size, &reverse); if (TREE_CODE (expr) != MEM_REF /* If this is a varying address, punt. */ @@ -1532,10 +1536,11 @@ determine_locally_known_aggregate_parts else if (TREE_CODE (arg) == ADDR_EXPR) { HOST_WIDE_INT arg_max_size; + bool reverse; arg = TREE_OPERAND (arg, 0); arg_base = get_ref_base_and_extent (arg, &arg_offset, &arg_size, - &arg_max_size); + &arg_max_size, &reverse); if (arg_max_size == -1 || arg_max_size != arg_size || arg_offset < 0) @@ -1554,13 +1559,14 @@ determine_locally_known_aggregate_parts else { HOST_WIDE_INT arg_max_size; + bool reverse; gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg))); by_ref = false; check_ref = false; arg_base = get_ref_base_and_extent (arg, &arg_offset, &arg_size, - &arg_max_size); + &arg_max_size, &reverse); if (arg_max_size == -1 || arg_max_size != arg_size || arg_offset < 0) @@ -1581,6 +1587,7 @@ determine_locally_known_aggregate_parts gimple stmt = gsi_stmt (gsi); HOST_WIDE_INT lhs_offset, lhs_size, lhs_max_size; tree lhs, rhs, lhs_base; + bool reverse; if (!stmt_may_clobber_ref_p_1 (stmt, &r)) continue; @@ -1595,7 +1602,7 @@ determine_locally_known_aggregate_parts break; lhs_base = get_ref_base_and_extent (lhs, &lhs_offset, &lhs_size, - &lhs_max_size); + &lhs_max_size, &reverse); if (lhs_max_size == -1 || lhs_max_size != lhs_size) break; @@ -4060,6 +4067,7 @@ ipa_modify_call_arguments (struct cgraph base = force_gimple_operand_gsi (&gsi, base, true, NULL, true, GSI_SAME_STMT); expr = fold_build2_loc (loc, MEM_REF, type, base, off); + REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse; /* If expr is not a valid gimple call argument emit a load into a temporary. */ if (is_gimple_reg_type (TREE_TYPE (expr))) @@ -4079,6 +4087,7 @@ ipa_modify_call_arguments (struct cgraph else { expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off); + REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse; expr = build_fold_addr_expr (expr); expr = force_gimple_operand_gsi (&gsi, expr, true, NULL, true, GSI_SAME_STMT); @@ -4250,7 +4259,9 @@ ipa_get_adjustment_candidate (tree **exp } HOST_WIDE_INT offset, size, max_size; - tree base = get_ref_base_and_extent (**expr, &offset, &size, &max_size); + bool reverse; + tree base + = get_ref_base_and_extent (**expr, &offset, &size, &max_size, &reverse); if (!base || size == -1 || max_size == -1) return NULL; Index: gcc/ipa-prop.h =================================================================== --- gcc/ipa-prop.h (.../trunk) (revision 224461) +++ gcc/ipa-prop.h (.../branches/scalar-storage-order) (revision 224467) @@ -683,6 +683,10 @@ struct ipa_parm_adjustment or one about to be removed. */ enum ipa_parm_op op; + /* Storage order of the original parameter (for the cases when the new + parameter is a component of an original one). */ + unsigned reverse : 1; + /* The parameter is to be passed by reference. */ unsigned by_ref : 1; }; @@ -720,7 +724,7 @@ ipa_parm_adjustment *ipa_get_adjustment_ /* From tree-sra.c: */ -tree build_ref_for_offset (location_t, tree, HOST_WIDE_INT, tree, +tree build_ref_for_offset (location_t, tree, HOST_WIDE_INT, bool, tree, gimple_stmt_iterator *, bool); /* In ipa-cp.c */ Index: gcc/tree-ssa-dce.c =================================================================== --- gcc/tree-ssa-dce.c (.../trunk) (revision 224461) +++ gcc/tree-ssa-dce.c (.../branches/scalar-storage-order) (revision 224467) @@ -499,8 +499,10 @@ mark_aliased_reaching_defs_necessary_1 ( { tree base, lhs = gimple_get_lhs (def_stmt); HOST_WIDE_INT size, offset, max_size; + bool reverse; ao_ref_base (ref); - base = get_ref_base_and_extent (lhs, &offset, &size, &max_size); + base + = get_ref_base_and_extent (lhs, &offset, &size, &max_size, &reverse); /* We can get MEM[symbol: sZ, index: D.8862_1] here, so base == refd->base does not always hold. */ if (base == ref->base) Index: gcc/tree-streamer-in.c =================================================================== --- gcc/tree-streamer-in.c (.../trunk) (revision 224461) +++ gcc/tree-streamer-in.c (.../branches/scalar-storage-order) (revision 224467) @@ -155,9 +155,14 @@ unpack_ts_base_value_fields (struct bitp TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1); if (TYPE_P (expr)) { - TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1); + if (AGGREGATE_TYPE_P (expr)) + TYPE_REVERSE_STORAGE_ORDER (expr) = (unsigned) bp_unpack_value (bp, 1); + else + TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1); TYPE_ADDR_SPACE (expr) = (unsigned) bp_unpack_value (bp, 8); } + else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF) + REF_REVERSE_STORAGE_ORDER (expr) = (unsigned) bp_unpack_value (bp, 1); else if (TREE_CODE (expr) == SSA_NAME) { SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1); Index: gcc/var-tracking.c =================================================================== --- gcc/var-tracking.c (.../trunk) (revision 224461) +++ gcc/var-tracking.c (.../branches/scalar-storage-order) (revision 224467) @@ -5165,9 +5165,10 @@ track_expr_p (tree expr, bool need_rtl) && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR)) { HOST_WIDE_INT bitsize, bitpos, maxsize; + bool reverse; tree innerdecl = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, - &maxsize); + &maxsize, &reverse); if (!DECL_P (innerdecl) || DECL_IGNORED_P (innerdecl) /* Do not track declarations for parts of tracked parameters Index: gcc/tree-ssa-structalias.c =================================================================== --- gcc/tree-ssa-structalias.c (.../trunk) (revision 224461) +++ gcc/tree-ssa-structalias.c (.../branches/scalar-storage-order) (revision 224467) @@ -3192,6 +3192,7 @@ get_constraint_for_component_ref (tree t HOST_WIDE_INT bitsize = -1; HOST_WIDE_INT bitmaxsize = -1; HOST_WIDE_INT bitpos; + bool reverse; tree forzero; /* Some people like to do cute things like take the address of @@ -3213,7 +3214,7 @@ get_constraint_for_component_ref (tree t return; } - t = get_ref_base_and_extent (t, &bitpos, &bitsize, &bitmaxsize); + t = get_ref_base_and_extent (t, &bitpos, &bitsize, &bitmaxsize, &reverse); /* Pretend to take the address of the base, we'll take care of adding the required subset of sub-fields below. */ @@ -3639,9 +3640,12 @@ do_structure_copy (tree lhsop, tree rhso { HOST_WIDE_INT lhssize, lhsmaxsize, lhsoffset; HOST_WIDE_INT rhssize, rhsmaxsize, rhsoffset; + bool reverse; unsigned k = 0; - get_ref_base_and_extent (lhsop, &lhsoffset, &lhssize, &lhsmaxsize); - get_ref_base_and_extent (rhsop, &rhsoffset, &rhssize, &rhsmaxsize); + get_ref_base_and_extent (lhsop, &lhsoffset, &lhssize, &lhsmaxsize, + &reverse); + get_ref_base_and_extent (rhsop, &rhsoffset, &rhssize, &rhsmaxsize, + &reverse); for (j = 0; lhsc.iterate (j, &lhsp);) { varinfo_t lhsv, rhsv; Index: gcc/config/s390/s390.c =================================================================== --- gcc/config/s390/s390.c (.../trunk) (revision 224461) +++ gcc/config/s390/s390.c (.../branches/scalar-storage-order) (revision 224467) @@ -8587,7 +8587,7 @@ s390_output_pool_entry (rtx exp, machine gcc_assert (GET_CODE (exp) == CONST_DOUBLE); REAL_VALUE_FROM_CONST_DOUBLE (r, exp); - assemble_real (r, mode, align); + assemble_real (r, mode, align, false); break; case MODE_INT: Index: gcc/config/sh/sh.md =================================================================== --- gcc/config/sh/sh.md (.../trunk) (revision 224461) +++ gcc/config/sh/sh.md (.../branches/scalar-storage-order) (revision 224467) @@ -12382,7 +12382,7 @@ (define_insn "consttable_sf" { REAL_VALUE_TYPE d; REAL_VALUE_FROM_CONST_DOUBLE (d, operands[0]); - assemble_real (d, SFmode, GET_MODE_ALIGNMENT (SFmode)); + assemble_real (d, SFmode, GET_MODE_ALIGNMENT (SFmode), false); } return ""; } @@ -12400,7 +12400,7 @@ (define_insn "consttable_df" { REAL_VALUE_TYPE d; REAL_VALUE_FROM_CONST_DOUBLE (d, operands[0]); - assemble_real (d, DFmode, GET_MODE_ALIGNMENT (DFmode)); + assemble_real (d, DFmode, GET_MODE_ALIGNMENT (DFmode), false); } return ""; } Index: gcc/config/arm/arm.c =================================================================== --- gcc/config/arm/arm.c (.../trunk) (revision 224461) +++ gcc/config/arm/arm.c (.../branches/scalar-storage-order) (revision 224467) @@ -22325,7 +22325,7 @@ arm_assemble_integer (rtx x, unsigned in assemble_real (rval, GET_MODE_INNER (mode), - i == 0 ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT); + i == 0 ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT, false); } return true; Index: gcc/config/arm/arm.md =================================================================== --- gcc/config/arm/arm.md (.../trunk) (revision 224461) +++ gcc/config/arm/arm.md (.../branches/scalar-storage-order) (revision 224467) @@ -10743,7 +10743,7 @@ (define_insn "consttable_4" { REAL_VALUE_TYPE r; REAL_VALUE_FROM_CONST_DOUBLE (r, x); - assemble_real (r, GET_MODE (x), BITS_PER_WORD); + assemble_real (r, GET_MODE (x), BITS_PER_WORD, false); break; } default: @@ -10776,7 +10776,7 @@ (define_insn "consttable_8" { REAL_VALUE_TYPE r; REAL_VALUE_FROM_CONST_DOUBLE (r, operands[0]); - assemble_real (r, GET_MODE (operands[0]), BITS_PER_WORD); + assemble_real (r, GET_MODE (operands[0]), BITS_PER_WORD, false); break; } default: @@ -10801,7 +10801,7 @@ (define_insn "consttable_16" { REAL_VALUE_TYPE r; REAL_VALUE_FROM_CONST_DOUBLE (r, operands[0]); - assemble_real (r, GET_MODE (operands[0]), BITS_PER_WORD); + assemble_real (r, GET_MODE (operands[0]), BITS_PER_WORD, false); break; } default: Index: gcc/config/mips/mips.md =================================================================== --- gcc/config/mips/mips.md (.../trunk) (revision 224461) +++ gcc/config/mips/mips.md (.../branches/scalar-storage-order) (revision 224467) @@ -7214,7 +7214,7 @@ (define_insn "consttable_float" gcc_assert (GET_CODE (operands[0]) == CONST_DOUBLE); REAL_VALUE_FROM_CONST_DOUBLE (d, operands[0]); assemble_real (d, GET_MODE (operands[0]), - GET_MODE_BITSIZE (GET_MODE (operands[0]))); + GET_MODE_BITSIZE (GET_MODE (operands[0])), false); return ""; } [(set (attr "length")