From patchwork Sun Jul 10 15:32:33 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bernd Edlinger X-Patchwork-Id: 646777 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3rnXL561ZBz9sXx for ; Mon, 11 Jul 2016 01:33:00 +1000 (AEST) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=xFiWr3bE; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:references:in-reply-to :content-type:mime-version; q=dns; s=default; b=puDSsBJJnmd3fABj 5dbRG4qdnqy+gN/EiYpm1UlGGPp0CENnhXPzf9h3H6wPzgkzLHpd56tw/IBmoD7U vO+fdrkU7twxDNIDIHxbPXbXrMuMccOa9cFF0hlAiDaWKfEwrSmoStxEJSixGUDc 5dMjiJkrSyRUGdE1yOgpaNj9J1Q= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:references:in-reply-to :content-type:mime-version; s=default; bh=Ozu2zsXkJYCrrO0PBR8uPt 1LtCM=; b=xFiWr3bEims1oSskjrsQlkSFkDIluWjO/SPkyIv1mCr0W4aOgtm7pb zX90s6YEkViubbiu545G1BAkDSOdb8gxAmqkHW6fyFf1g3yfT8FsJIrKMOC5+w3I 3W7YzaQ9XyLr4O+mTyqe4MdxRmLofyW6v2SZxu/uQZ7EuGdunTLuU= Received: (qmail 109539 invoked by alias); 10 Jul 2016 15:32:52 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 109527 invoked by uid 89); 10 Jul 2016 15:32:51 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.3 required=5.0 tests=AWL, BAYES_50, FREEMAIL_FROM, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=no version=3.3.2 spammy=cod, HX-HELO:sk:COL004-, !mem_p, !MEM_P X-HELO: COL004-OMC3S2.hotmail.com Received: from col004-omc3s2.hotmail.com (HELO COL004-OMC3S2.hotmail.com) (65.55.34.140) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA256 encrypted) ESMTPS; Sun, 10 Jul 2016 15:32:41 +0000 Received: from EUR01-HE1-obe.outbound.protection.outlook.com ([65.55.34.136]) by COL004-OMC3S2.hotmail.com over TLS secured channel with Microsoft SMTPSVC(7.5.7601.23008); Sun, 10 Jul 2016 08:32:39 -0700 Received: from HE1EUR01FT004.eop-EUR01.prod.protection.outlook.com (10.152.0.52) by HE1EUR01HT137.eop-EUR01.prod.protection.outlook.com (10.152.1.14) with Microsoft SMTP Server (TLS) id 15.1.523.9; Sun, 10 Jul 2016 15:32:34 +0000 Received: from AM4PR0701MB2162.eurprd07.prod.outlook.com (10.152.0.52) by HE1EUR01FT004.mail.protection.outlook.com (10.152.1.233) with Microsoft SMTP Server (TLS) id 15.1.534.7 via Frontend Transport; Sun, 10 Jul 2016 15:32:34 +0000 Received: from AM4PR0701MB2162.eurprd07.prod.outlook.com ([10.167.132.147]) by AM4PR0701MB2162.eurprd07.prod.outlook.com ([10.167.132.147]) with mapi id 15.01.0523.028; Sun, 10 Jul 2016 15:32:33 +0000 From: Bernd Edlinger To: Eric Botcazou , Richard Biener CC: "gcc-patches@gcc.gnu.org" , Jeff Law , Jakub Jelinek Subject: Re: [RFC] Convert TYPE_ALIGN_OK into an TYPE_LANG_FLAG Date: Sun, 10 Jul 2016 15:32:33 +0000 Message-ID: References: <6118860.M61PVKhIUh@polaris> <8488520.4vm5BbQENR@polaris> In-Reply-To: <8488520.4vm5BbQENR@polaris> authentication-results: spf=softfail (sender IP is 10.152.0.52) smtp.mailfrom=hotmail.de; adacore.com; dkim=none (message not signed) header.d=none; adacore.com; dmarc=none action=none header.from=hotmail.de; received-spf: SoftFail (protection.outlook.com: domain of transitioning hotmail.de discourages use of 10.152.0.52 as permitted sender) x-ms-exchange-messagesentrepresentingtype: 1 x-eopattributedmessage: 0 x-forefront-antispam-report: CIP:10.152.0.52; IPV:NLI; CTRY:; EFV:NLI; SFV:NSPM; SFS:(10019020)(98900003); DIR:OUT; SFP:1102; SCL:1; SRVR:HE1EUR01HT137; H:AM4PR0701MB2162.eurprd07.prod.outlook.com; FPR:; SPF:None; CAT:NONE; LANG:en; CAT:NONE; x-ms-office365-filtering-correlation-id: c1bbba6c-ff87-4e15-9e43-08d3a8d76918 x-microsoft-antispam: UriScan:; BCL:0; PCL:0; RULEID:(1601124038)(5061506196)(5061507196)(1603103041)(1601125047); SRVR:HE1EUR01HT137; x-exchange-antispam-report-cfa-test: BCL:0; PCL:0; RULEID:(432015012)(102415321)(82015046); SRVR:HE1EUR01HT137; BCL:0; PCL:0; RULEID:; SRVR:HE1EUR01HT137; x-forefront-prvs: 0999136621 MIME-Version: 1.0 X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-originalarrivaltime: 10 Jul 2016 15:32:33.4706 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Internet X-MS-Exchange-CrossTenant-id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1EUR01HT137 On 07/10/16 10:23, Eric Botcazou wrote: >> I expect it still has an effect due to the same reason as the >> DECL_OFFSET_ALIGN thing - memory reference expansion doesn't gather >> information from the full reference but tries to re-cover it from >> the pieces returned from get_inner_reference. So I guess we need >> to fix that first. > > The situation is a bit different though, because the main (and single?) case > for which TYPE_ALIGN_OK had been necessary in the middle-end was made obsolete > by a gigi change at some point. And indeed extensive testing of Bernd's patch > on a strict-alignment platform didn't reveal any issue. > > So no objection to the patch on principle by me. > Thank you, Eric. So following Jeff's suggestion, here is an updated patch that allocates a new lang_flag_7 out of the spare bits in tree_type_common. The only difference to the previous version is in tree-core.h where tree_type_common is declared, and print-tree.c where the new flag is printed. Boot-strapped and reg-tested on armv7-linux-gneabihf. OK for trunk? Thanks Bernd. 2016-07-08 Bernd Edlinger Convert TYPE_ALIGN_OK to a TYPE_LANG_FLAG. * tree-core.h (tree_base::nothrow_flag): Adjust comment. (tree_type_common::lang_flag_7): New. (tree_type_common::spare): Reduce size. * tree.h (TYPE_ALIGN_OK): Remove. (TYPE_LANG_FLAG_7): New. (get_inner_reference): Adjust header. * print-tree.c (print_node): Adjust. * expr.c (get_inner_reference): Remove parameter keep_aligning. (get_bit_range, expand_assignment, expand_expr_addr_expr_1): Adjust calls to get_inner_reference. (expand_expr_real_1): Adjust call to get_inner_reference. Remove handling of TYPE_ALIGN_OK. * builtins.c (get_object_alignment_2): Adjust call to get_inner_reference. Remove handling of VIEW_CONVERT_EXPR. * emit-rtl.c (set_mem_attributes_minus_bitpos): Remove handling of TYPE_ALIGN_OK. * asan.c (instrument_derefs): Adjust calls to get_inner_reference. * cfgexpand.c (expand_debug_expr): Likewise. * dbxout.c (dbxout_expand_expr): Likewise. * dwarf2out.c (loc_list_for_address_of_addr_expr_of_indirect_ref, loc_list_from_tree, fortran_common): Likewise. * fold-const.c (optimize_bit_field_compare, decode_field_reference, fold_unary_loc, fold_comparison, split_address_to_core_and_offset): Likewise. * gimple-laddress.c (execute): Likewise. * gimple-ssa-strength-reduction.c (slsr_process_ref): Likewise. * gimplify.c (gimplify_scan_omp_clauses): Likewise. * hsa-gen.c (gen_hsa_addr): Likewise. * simplifx-rtx.c (delegitimize_mem_from_attrs): Likewise. * tsan.c (instrument_expr): Likewise. * ubsan.c (instrument_bool_enum_load, instrument_object_size): Likewise. * tree.c (verify_type_variant): Remove handling of TYPE_ALIGN_OK. * tree-affine.c (tree_to_aff_combination, get_inner_reference_aff): Adjust calls to get_inner_reference. * tree-data-ref.c (split_constant_offset_1, dr_analyze_innermost): Likewise. * tree-scalar-evolution.c (interpret_rhs_expr): Likewise. * tree-sra.c (ipa_sra_check_caller): Likewise. * tree-ssa-loop-ivopts.c (split_address_cost): Likewise. * tree-ssa-math-opts.c (find_bswap_or_nop_load, bswap_replace): Likewise. * tree-vect-data-refs.c (vect_check_gather, vect_analyze_data_refs): Likewise. * config/mips/mips.c (r10k_safe_mem_expr_p): Likewise. * config/pa/pa.c (pa_emit_move_sequence): Remove handling of TYPE_ALIGN_OK. ada: 2016-07-08 Bernd Edlinger Convert TYPE_ALIGN_OK to a TYPE_LANG_FLAG. * gcc-interface/ada-tree.h (TYPE_ALIGN_OK): Define. * gcc-interface/trans.c (Attribute_to_gnu): Adjust call to get_inner_reference. * gcc-interface/utils2.c (build_unary_op): Likewise. Index: gcc/ada/gcc-interface/ada-tree.h =================================================================== --- gcc/ada/gcc-interface/ada-tree.h (revision 238117) +++ gcc/ada/gcc-interface/ada-tree.h (working copy) @@ -199,6 +199,9 @@ do { \ alignment value the type ought to have. */ #define TYPE_MAX_ALIGN(NODE) (TYPE_PRECISION (RECORD_OR_UNION_CHECK (NODE))) +/* True if objects of tagged types are guaranteed to be properly aligned. */ +#define TYPE_ALIGN_OK(NODE) TYPE_LANG_FLAG_7 (NODE) + /* For an UNCONSTRAINED_ARRAY_TYPE, this is the record containing both the template and the object. Index: gcc/ada/gcc-interface/trans.c =================================================================== --- gcc/ada/gcc-interface/trans.c (revision 238117) +++ gcc/ada/gcc-interface/trans.c (working copy) @@ -2181,7 +2181,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_res && TREE_CODE (gnu_prefix) == FIELD_DECL)); get_inner_reference (gnu_prefix, &bitsize, &bitpos, &gnu_offset, - &mode, &unsignedp, &reversep, &volatilep, false); + &mode, &unsignedp, &reversep, &volatilep); if (TREE_CODE (gnu_prefix) == COMPONENT_REF) { Index: gcc/ada/gcc-interface/utils2.c =================================================================== --- gcc/ada/gcc-interface/utils2.c (revision 238117) +++ gcc/ada/gcc-interface/utils2.c (working copy) @@ -1419,7 +1419,7 @@ build_unary_op (enum tree_code op_code, tree resul inner = get_inner_reference (operand, &bitsize, &bitpos, &offset, &mode, &unsignedp, &reversep, - &volatilep, false); + &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 Index: gcc/asan.c =================================================================== --- gcc/asan.c (revision 238117) +++ gcc/asan.c (working copy) @@ -1793,7 +1793,7 @@ instrument_derefs (gimple_stmt_iterator *iter, tre machine_mode mode; int unsignedp, reversep, volatilep = 0; tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (TREE_CODE (t) == COMPONENT_REF && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t, 1)) != NULL_TREE) Index: gcc/builtins.c =================================================================== --- gcc/builtins.c (revision 238117) +++ gcc/builtins.c (working copy) @@ -259,7 +259,7 @@ get_object_alignment_2 (tree exp, unsigned int *al /* 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, &reversep, &volatilep, true); + &unsignedp, &reversep, &volatilep); /* Extract alignment information from the innermost object and possibly adjust bitpos and offset. */ @@ -289,10 +289,6 @@ get_object_alignment_2 (tree exp, unsigned int *al 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) Index: gcc/cfgexpand.c =================================================================== --- gcc/cfgexpand.c (revision 238117) +++ gcc/cfgexpand.c (working copy) @@ -4444,7 +4444,7 @@ expand_debug_expr (tree exp) int reversep, volatilep = 0; tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); rtx orig_op0; if (bitsize == 0) Index: gcc/config/mips/mips.c =================================================================== --- gcc/config/mips/mips.c (revision 238117) +++ gcc/config/mips/mips.c (working copy) @@ -17470,7 +17470,7 @@ r10k_safe_mem_expr_p (tree expr, unsigned HOST_WID int unsigned_p, reverse_p, volatile_p; inner = get_inner_reference (expr, &bitsize, &bitoffset, &var_offset, &mode, - &unsigned_p, &reverse_p, &volatile_p, false); + &unsigned_p, &reverse_p, &volatile_p); if (!DECL_P (inner) || !DECL_SIZE_UNIT (inner) || var_offset) return false; Index: gcc/config/pa/pa.c =================================================================== --- gcc/config/pa/pa.c (revision 238117) +++ gcc/config/pa/pa.c (working copy) @@ -1929,16 +1929,7 @@ pa_emit_move_sequence (rtx *operands, machine_mode type = strip_array_types (type); if (POINTER_TYPE_P (type)) - { - int align; - - type = TREE_TYPE (type); - /* Using TYPE_ALIGN_OK is rather conservative as - only the ada frontend actually sets it. */ - align = (TYPE_ALIGN_OK (type) ? TYPE_ALIGN (type) - : BITS_PER_UNIT); - mark_reg_pointer (operand0, align); - } + mark_reg_pointer (operand0, BITS_PER_UNIT); } } Index: gcc/dbxout.c =================================================================== --- gcc/dbxout.c (revision 238117) +++ gcc/dbxout.c (working copy) @@ -2485,7 +2485,7 @@ dbxout_expand_expr (tree expr) rtx x; tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, true); + &unsignedp, &reversep, &volatilep); x = dbxout_expand_expr (tem); if (x == NULL || !MEM_P (x)) Index: gcc/dwarf2out.c =================================================================== --- gcc/dwarf2out.c (revision 238117) +++ gcc/dwarf2out.c (working copy) @@ -15136,7 +15136,7 @@ loc_list_for_address_of_addr_expr_of_indirect_ref obj = get_inner_reference (TREE_OPERAND (loc, 0), &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); STRIP_NOPS (obj); if (bitpos % BITS_PER_UNIT) { @@ -16073,7 +16073,7 @@ loc_list_from_tree_1 (tree loc, int want_address, int unsignedp, reversep, volatilep = 0; obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); gcc_assert (obj != loc); @@ -17548,7 +17548,7 @@ fortran_common (tree decl, HOST_WIDE_INT *value) return NULL_TREE; cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, true); + &unsignedp, &reversep, &volatilep); if (cvar == NULL_TREE || TREE_CODE (cvar) != VAR_DECL Index: gcc/emit-rtl.c =================================================================== --- gcc/emit-rtl.c (revision 238117) +++ gcc/emit-rtl.c (working copy) @@ -1813,9 +1813,9 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, able to simply always use TYPE_ALIGN? */ } - /* We can set the alignment from the type if we are making an object, - this is an INDIRECT_REF, or if TYPE_ALIGN_OK. */ - if (objectp || TREE_CODE (t) == INDIRECT_REF || TYPE_ALIGN_OK (type)) + /* We can set the alignment from the type if we are making an object or if + this is an INDIRECT_REF. */ + if (objectp || TREE_CODE (t) == INDIRECT_REF) attrs.align = MAX (attrs.align, TYPE_ALIGN (type)); /* If the size is known, we can set that. */ Index: gcc/expr.c =================================================================== --- gcc/expr.c (revision 238117) +++ gcc/expr.c (working copy) @@ -4828,7 +4828,7 @@ get_bit_range (unsigned HOST_WIDE_INT *bitstart, int unsignedp, reversep, volatilep = 0; get_inner_reference (TREE_OPERAND (exp, 0), &rbitsize, &rbitpos, &roffset, &rmode, &unsignedp, &reversep, - &volatilep, false); + &volatilep); if ((rbitpos % BITS_PER_UNIT) != 0) { *bitstart = *bitend = 0; @@ -4984,7 +4984,7 @@ expand_assignment (tree to, tree from, bool nontem push_temp_slots (); tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1, - &unsignedp, &reversep, &volatilep, true); + &unsignedp, &reversep, &volatilep); /* Make sure bitpos is not negative, it can wreak havoc later. */ if (bitpos < 0) @@ -6971,27 +6971,13 @@ store_field (rtx target, HOST_WIDE_INT bitsize, HO 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. + 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. */ - tree get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize, HOST_WIDE_INT *pbitpos, tree *poffset, machine_mode *pmode, int *punsignedp, - int *preversep, int *pvolatilep, bool keep_aligning) + int *preversep, int *pvolatilep) { tree size_tree = 0; machine_mode mode = VOIDmode; @@ -7113,14 +7099,6 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbit 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: @@ -7839,7 +7817,7 @@ expand_expr_addr_expr_1 (tree exp, rtx target, mac 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, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); break; } @@ -10369,7 +10347,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_ int reversep, volatilep = 0, must_force_mem; tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1, - &unsignedp, &reversep, &volatilep, true); + &unsignedp, &reversep, &volatilep); rtx orig_op0, memloc; bool clear_mem_expr = false; @@ -10767,7 +10745,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_ int unsignedp, reversep, volatilep = 0; tree tem = get_inner_reference (treeop0, &bitsize, &bitpos, &offset, &mode1, - &unsignedp, &reversep, &volatilep, true); + &unsignedp, &reversep, &volatilep); rtx orig_op0; /* ??? We should work harder and deal with non-zero offsets. */ @@ -10878,21 +10856,12 @@ expand_expr_real_1 (tree exp, rtx target, machine_ { enum insn_code icode; - if (TYPE_ALIGN_OK (type)) + if (modifier != EXPAND_WRITE + && modifier != EXPAND_MEMORY + && !inner_reference_p + && mode != BLKmode + && MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (mode)) { - /* ??? Copying the MEM without substantially changing it might - run afoul of the code handling volatile memory references in - store_expr, which assumes that TARGET is returned unmodified - if it has been used. */ - op0 = copy_rtx (op0); - set_mem_align (op0, MAX (MEM_ALIGN (op0), TYPE_ALIGN (type))); - } - else if (modifier != EXPAND_WRITE - && modifier != EXPAND_MEMORY - && !inner_reference_p - && mode != BLKmode - && MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (mode)) - { /* If the target does have special handling for unaligned loads of mode then use them. */ if ((icode = optab_handler (movmisalign_optab, mode)) Index: gcc/fold-const.c =================================================================== --- gcc/fold-const.c (revision 238117) +++ gcc/fold-const.c (working copy) @@ -3881,7 +3881,7 @@ optimize_bit_field_compare (location_t loc, enum t 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, &lreversep, &lvolatilep, false); + &lunsignedp, &lreversep, &lvolatilep); if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0 || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR || lvolatilep) return 0; @@ -3894,7 +3894,7 @@ optimize_bit_field_compare (location_t loc, enum t sizes, signedness and storage order are the same. */ rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode, - &runsignedp, &rreversep, &rvolatilep, false); + &runsignedp, &rreversep, &rvolatilep); if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize || lunsignedp != runsignedp || lreversep != rreversep || offset != 0 @@ -4076,7 +4076,7 @@ decode_field_reference (location_t loc, tree *exp_ } inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode, - punsignedp, preversep, pvolatilep, false); + punsignedp, preversep, pvolatilep); if ((inner == exp && and_mask == 0) || *pbitsize < 0 || offset != 0 || TREE_CODE (inner) == PLACEHOLDER_EXPR) @@ -7731,7 +7731,7 @@ fold_unary_loc (location_t loc, enum tree_code cod tree base = get_inner_reference (TREE_OPERAND (op0, 0), &bitsize, &bitpos, &offset, &mode, &unsignedp, &reversep, - &volatilep, false); + &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. */ @@ -8335,7 +8335,7 @@ fold_comparison (location_t loc, enum tree_code co base0 = get_inner_reference (TREE_OPERAND (arg0, 0), &bitsize, &bitpos0, &offset0, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (TREE_CODE (base0) == INDIRECT_REF) base0 = TREE_OPERAND (base0, 0); else @@ -8350,8 +8350,7 @@ fold_comparison (location_t loc, enum tree_code co base0 = get_inner_reference (TREE_OPERAND (base0, 0), &bitsize, &bitpos0, &offset0, &mode, - &unsignedp, &reversep, &volatilep, - false); + &unsignedp, &reversep, &volatilep); if (TREE_CODE (base0) == INDIRECT_REF) base0 = TREE_OPERAND (base0, 0); else @@ -8382,7 +8381,7 @@ fold_comparison (location_t loc, enum tree_code co base1 = get_inner_reference (TREE_OPERAND (arg1, 0), &bitsize, &bitpos1, &offset1, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (TREE_CODE (base1) == INDIRECT_REF) base1 = TREE_OPERAND (base1, 0); else @@ -8397,8 +8396,7 @@ fold_comparison (location_t loc, enum tree_code co base1 = get_inner_reference (TREE_OPERAND (base1, 0), &bitsize, &bitpos1, &offset1, &mode, - &unsignedp, &reversep, &volatilep, - false); + &unsignedp, &reversep, &volatilep); if (TREE_CODE (base1) == INDIRECT_REF) base1 = TREE_OPERAND (base1, 0); else @@ -14296,7 +14294,7 @@ split_address_to_core_and_offset (tree exp, { core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos, poffset, &mode, &unsignedp, &reversep, - &volatilep, false); + &volatilep); core = build_fold_addr_expr_loc (loc, core); } else Index: gcc/gimple-laddress.c =================================================================== --- gcc/gimple-laddress.c (revision 238117) +++ gcc/gimple-laddress.c (working copy) @@ -105,7 +105,7 @@ pass_laddress::execute (function *fun) int volatilep = 0, reversep, unsignedp = 0; base = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos, &offset, &mode, &unsignedp, - &reversep, &volatilep, false); + &reversep, &volatilep); gcc_assert (base != NULL_TREE && (bitpos % BITS_PER_UNIT) == 0); if (offset != NULL_TREE) { Index: gcc/gimple-ssa-strength-reduction.c =================================================================== --- gcc/gimple-ssa-strength-reduction.c (revision 238117) +++ gcc/gimple-ssa-strength-reduction.c (working copy) @@ -987,7 +987,7 @@ slsr_process_ref (gimple *gs) return; base = get_inner_reference (ref_expr, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (reversep) return; widest_int index = bitpos; Index: gcc/gimplify.c =================================================================== --- gcc/gimplify.c (revision 238117) +++ gcc/gimplify.c (working copy) @@ -7046,7 +7046,7 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_se base = TREE_OPERAND (base, 0); base = get_inner_reference (base, &bitsize, &bitpos, &offset, &mode, &unsignedp, &reversep, - &volatilep, false); + &volatilep); tree orig_base = base; if ((TREE_CODE (base) == INDIRECT_REF || (TREE_CODE (base) == MEM_REF @@ -7182,8 +7182,7 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_se base = get_inner_reference (base, &bitsize2, &bitpos2, &offset2, &mode, &unsignedp, - &reversep, &volatilep, - false); + &reversep, &volatilep); if ((TREE_CODE (base) == INDIRECT_REF || (TREE_CODE (base) == MEM_REF && integer_zerop (TREE_OPERAND (base, Index: gcc/hsa-gen.c =================================================================== --- gcc/hsa-gen.c (revision 238117) +++ gcc/hsa-gen.c (working copy) @@ -2045,7 +2045,7 @@ gen_hsa_addr (tree ref, hsa_bb *hbb, HOST_WIDE_INT int unsignedp, volatilep, preversep; ref = get_inner_reference (ref, &bitsize, &bitpos, &varoffset, &mode, - &unsignedp, &preversep, &volatilep, false); + &unsignedp, &preversep, &volatilep); offset = bitpos; offset = wi::rshift (offset, LOG2_BITS_PER_UNIT, SIGNED); Index: gcc/print-tree.c =================================================================== --- gcc/print-tree.c (revision 238117) +++ gcc/print-tree.c (working copy) @@ -316,7 +316,7 @@ print_node (FILE *file, const char *prefix, tree n if (TREE_USED (node)) fputs (" used", file); if (TREE_NOTHROW (node)) - fputs (TYPE_P (node) ? " align-ok" : " nothrow", file); + fputs (" nothrow", file); if (TREE_PUBLIC (node)) fputs (" public", file); if (TREE_PRIVATE (node)) @@ -601,6 +601,8 @@ print_node (FILE *file, const char *prefix, tree n fputs (" type_5", file); if (TYPE_LANG_FLAG_6 (node)) fputs (" type_6", file); + if (TYPE_LANG_FLAG_7 (node)) + fputs (" type_7", file); mode = TYPE_MODE (node); fprintf (file, " %s", GET_MODE_NAME (mode)); Index: gcc/simplify-rtx.c =================================================================== --- gcc/simplify-rtx.c (revision 238117) +++ gcc/simplify-rtx.c (working copy) @@ -305,7 +305,7 @@ delegitimize_mem_from_attrs (rtx x) decl = get_inner_reference (decl, &bitsize, &bitpos, &toffset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (bitsize != GET_MODE_BITSIZE (mode) || (bitpos % BITS_PER_UNIT) || (toffset && !tree_fits_shwi_p (toffset))) Index: gcc/tree-affine.c =================================================================== --- gcc/tree-affine.c (revision 238117) +++ gcc/tree-affine.c (working copy) @@ -318,7 +318,7 @@ tree_to_aff_combination (tree expr, tree type, aff } core = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos, &toffset, &mode, &unsignedp, &reversep, - &volatilep, false); + &volatilep); if (bitpos % BITS_PER_UNIT != 0) break; aff_combination_const (comb, type, bitpos / BITS_PER_UNIT); @@ -888,7 +888,7 @@ get_inner_reference_aff (tree ref, aff_tree *addr, int uns, rev, vol; aff_tree tmp; tree base = get_inner_reference (ref, &bitsize, &bitpos, &toff, &mode, - &uns, &rev, &vol, false); + &uns, &rev, &vol); tree base_addr = build_fold_addr_expr (base); /* ADDR = &BASE + TOFF + BITPOS / BITS_PER_UNIT. */ Index: gcc/tree-core.h =================================================================== --- gcc/tree-core.h (revision 238117) +++ gcc/tree-core.h (working copy) @@ -1154,9 +1154,6 @@ struct GTY(()) tree_base { CALL_EXPR FUNCTION_DECL - TYPE_ALIGN_OK in - all types - TREE_THIS_NOTRAP in INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF @@ -1447,6 +1444,7 @@ struct GTY(()) tree_type_common { unsigned lang_flag_4 : 1; unsigned lang_flag_5 : 1; unsigned lang_flag_6 : 1; + unsigned lang_flag_7 : 1; /* TYPE_ALIGN in log2; this has to be large enough to hold values of the maximum of BIGGEST_ALIGNMENT and MAX_OFILE_ALIGNMENT, @@ -1454,7 +1452,7 @@ struct GTY(()) tree_type_common { so we need to store the value 32 (not 31, as we need the zero as well), hence six bits. */ unsigned align : 6; - unsigned spare : 26; + unsigned spare : 25; alias_set_type alias_set; tree pointer_to; tree reference_to; Index: gcc/tree-data-ref.c =================================================================== --- gcc/tree-data-ref.c (revision 238117) +++ gcc/tree-data-ref.c (working copy) @@ -618,7 +618,7 @@ split_constant_offset_1 (tree type, tree op0, enum op0 = TREE_OPERAND (op0, 0); base = get_inner_reference (op0, &pbitsize, &pbitpos, &poffset, &pmode, - &punsignedp, &preversep, &pvolatilep, false); + &punsignedp, &preversep, &pvolatilep); if (pbitpos % BITS_PER_UNIT != 0) return false; @@ -771,7 +771,7 @@ dr_analyze_innermost (struct data_reference *dr, s fprintf (dump_file, "analyze_innermost: "); base = get_inner_reference (ref, &pbitsize, &pbitpos, &poffset, &pmode, - &punsignedp, &preversep, &pvolatilep, false); + &punsignedp, &preversep, &pvolatilep); gcc_assert (base != NULL_TREE); if (pbitpos % BITS_PER_UNIT != 0) Index: gcc/tree-scalar-evolution.c =================================================================== --- gcc/tree-scalar-evolution.c (revision 238117) +++ gcc/tree-scalar-evolution.c (working copy) @@ -1744,8 +1744,7 @@ interpret_rhs_expr (struct loop *loop, gimple *at_ base = get_inner_reference (TREE_OPERAND (rhs1, 0), &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, - false); + &unsignedp, &reversep, &volatilep); if (TREE_CODE (base) == MEM_REF) { Index: gcc/tree-sra.c =================================================================== --- gcc/tree-sra.c (revision 238117) +++ gcc/tree-sra.c (working copy) @@ -5230,7 +5230,7 @@ ipa_sra_check_caller (struct cgraph_node *node, vo machine_mode mode; int unsignedp, reversep, volatilep = 0; get_inner_reference (arg, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (bitpos % BITS_PER_UNIT) { iscc->bad_arg_alignment = true; Index: gcc/tree-ssa-loop-ivopts.c =================================================================== --- gcc/tree-ssa-loop-ivopts.c (revision 238117) +++ gcc/tree-ssa-loop-ivopts.c (working copy) @@ -4526,7 +4526,7 @@ split_address_cost (struct ivopts_data *data, int unsignedp, reversep, volatilep; core = get_inner_reference (addr, &bitsize, &bitpos, &toffset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (toffset != 0 || bitpos % BITS_PER_UNIT != 0 Index: gcc/tree-ssa-math-opts.c =================================================================== --- gcc/tree-ssa-math-opts.c (revision 238117) +++ gcc/tree-ssa-math-opts.c (working copy) @@ -2097,7 +2097,7 @@ find_bswap_or_nop_load (gimple *stmt, tree ref, st return false; base_addr = get_inner_reference (ref, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (TREE_CODE (base_addr) == MEM_REF) { @@ -2640,7 +2640,7 @@ bswap_replace (gimple *cur_stmt, gimple *src_stmt, tree offset; get_inner_reference (src, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (n->range < (unsigned HOST_WIDE_INT) bitsize) { load_offset = (bitsize - n->range) / BITS_PER_UNIT; Index: gcc/tree-vect-data-refs.c =================================================================== --- gcc/tree-vect-data-refs.c (revision 238117) +++ gcc/tree-vect-data-refs.c (working copy) @@ -3239,7 +3239,7 @@ vect_check_gather_scatter (gimple *stmt, loop_vec_ 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, &reversep, &pvolatilep, false); + &punsignedp, &reversep, &pvolatilep); gcc_assert (base && (pbitpos % BITS_PER_UNIT) == 0 && !reversep); if (TREE_CODE (base) == MEM_REF) @@ -3709,7 +3709,7 @@ again: outer_base = get_inner_reference (inner_base, &pbitsize, &pbitpos, &poffset, &pmode, &punsignedp, - &preversep, &pvolatilep, false); + &preversep, &pvolatilep); gcc_assert (outer_base != NULL_TREE); if (pbitpos % BITS_PER_UNIT != 0) Index: gcc/tree.c =================================================================== --- gcc/tree.c (revision 238117) +++ gcc/tree.c (working copy) @@ -13204,7 +13204,6 @@ verify_type_variant (const_tree t, tree tv) verify_variant_match (TYPE_REF_CAN_ALIAS_ALL); /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build. */ verify_variant_match (TYPE_UNSIGNED); - verify_variant_match (TYPE_ALIGN_OK); verify_variant_match (TYPE_PACKED); if (TREE_CODE (t) == REFERENCE_TYPE) verify_variant_match (TYPE_REF_IS_RVALUE); Index: gcc/tree.h =================================================================== --- gcc/tree.h (revision 238117) +++ gcc/tree.h (working copy) @@ -916,14 +916,6 @@ extern void omp_clause_range_check_failed (const_t /* In a CALL_EXPR, means call was instrumented by Pointer Bounds Checker. */ #define CALL_WITH_BOUNDS_P(NODE) (CALL_EXPR_CHECK (NODE)->base.deprecated_flag) -/* In a type, nonzero means that all objects of the type are guaranteed by the - language or front-end to be properly aligned, so we can indicate that a MEM - of this type is aligned at least to the alignment of the type, even if it - doesn't appear that it is. We see this, for example, in object-oriented - languages where a tag field may show this is an object of a more-aligned - variant of the more generic type. */ -#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->base.nothrow_flag) - /* Used in classes in C++. */ #define TREE_PRIVATE(NODE) ((NODE)->base.private_flag) /* Used in classes in C++. */ @@ -1960,6 +1952,7 @@ extern machine_mode element_mode (const_tree t); #define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_4) #define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_5) #define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_6) +#define TYPE_LANG_FLAG_7(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_7) /* Used to keep track of visited nodes in tree traversals. This is set to 0 by copy_node and make_node. */ @@ -5387,8 +5380,7 @@ extern bool complete_ctor_at_level_p (const_tree, 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 *, machine_mode *, int *, int *, - int *, bool); + tree *, machine_mode *, int *, int *, int *); extern tree build_personality_function (const char *); Index: gcc/tsan.c =================================================================== --- gcc/tsan.c (revision 238117) +++ gcc/tsan.c (working copy) @@ -110,7 +110,7 @@ instrument_expr (gimple_stmt_iterator gsi, tree ex machine_mode mode; int unsignedp, reversep, volatilep = 0; base = get_inner_reference (expr, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); /* No need to instrument accesses to decls that don't escape, they can't escape to other threads then. */ Index: gcc/ubsan.c =================================================================== --- gcc/ubsan.c (revision 238117) +++ gcc/ubsan.c (working copy) @@ -1360,7 +1360,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *g machine_mode mode; int volatilep = 0, reversep, unsignedp = 0; tree base = get_inner_reference (rhs, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); tree utype = build_nonstandard_integer_type (modebitsize, 1); if ((TREE_CODE (base) == VAR_DECL && DECL_HARD_REGISTER (base)) @@ -1781,7 +1781,7 @@ instrument_object_size (gimple_stmt_iterator *gsi, machine_mode mode; int volatilep = 0, reversep, unsignedp = 0; tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset, &mode, - &unsignedp, &reversep, &volatilep, false); + &unsignedp, &reversep, &volatilep); if (bitpos % BITS_PER_UNIT != 0 || bitsize != size_in_bytes * BITS_PER_UNIT)