From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 89220 invoked by alias); 30 Nov 2015 13:46:36 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 89206 invoked by uid 89); 30 Nov 2015 13:46:35 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.6 required=5.0 tests=AWL,BAYES_50,KAM_ASCII_DIVIDERS,RCVD_IN_DNSWL_LOW,SPF_PASS,T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mx2.suse.de Received: from mx2.suse.de (HELO mx2.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (CAMELLIA256-SHA encrypted) ESMTPS; Mon, 30 Nov 2015 13:46:32 +0000 Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id DD9B1AD66; Mon, 30 Nov 2015 13:46:28 +0000 (UTC) Date: Mon, 30 Nov 2015 14:12:00 -0000 From: Richard Biener To: Jan Hubicka cc: gcc-patches@gcc.gnu.org Subject: Re: Fix verify_type ICE during Ada bootstrap In-Reply-To: <20151130065855.GA22602@kam.mff.cuni.cz> Message-ID: References: <20151124082008.GA90197@kam.mff.cuni.cz> <20151124185104.GD90197@kam.mff.cuni.cz> <20151124193342.GF90197@kam.mff.cuni.cz> <20151127070255.GB59662@kam.mff.cuni.cz> <20151130065855.GA22602@kam.mff.cuni.cz> User-Agent: Alpine 2.11 (LSU 23 2013-08-11) MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII X-SW-Source: 2015-11/txt/msg03481.txt.bz2 On Mon, 30 Nov 2015, Jan Hubicka wrote: > Hi, > here is updated patch which bootstraps®testes, lto-bootstraps x86_64-linux and > also works for Firefox. The basic pain is to identify which calls to get_alias_set > are used to build alias sets themselves and thus must be made -fstrict-aliasing > independent and which are used to drive queries to oracle and thus should follow > -fstrict-aliasing. Fortunately the sanity checking I added seems pretty effective > to check bugs in this area: either we get ice in tree-streamer-out.c because alias > set is 0 when it is not expected to be or we get an ice in record_component_aliases > because alias set of component gets 0. > > OK? I think you are doing too many things in one patch. I'm fine with dropping the zero-alias-set streaming (but I'd rather not assert as FE get_alias_set langhook may assign zero to random tree nodes). I'm also fine with handling flag_strict_aliasing conservatively during inlining - but the condition you placed on this handling needs a comment. I couldn't decipher it ;) > + if (dump_file) > + fprintf (dump_file, "Dropping flag_strict_aliasing on %s:%i\n", > + to->name (), to->order); So I wonder if it makes sense to pessimize such inlining as well. The two above should be enough to fix the correctness issue. The parse_optimize_options hack looks indeed interesting, but we solved the issue differently by 2014-11-27 Richard Biener PR middle-end/63704 * alias.c (mems_in_disjoint_alias_sets_p): Remove assert and instead return false when !fstrict-aliasing. So the hack can be removed as a separate commit after the first one above. This should make optimize("fno-strict-aliasing") work. I don't really see why we need all the other changes and IMHO the get_alias_set interface change is ugly and fragile. And this doesn't look like sth for stage3. Thus please split the patch up. Thanks, Richard. > Honza > > * tree.c (free_lang_data): Pass true to get_alias_set. > * tree-streamer-in.c (unpack_ts_type_common_value_fields): Do not stream > alias set. > * tree-ssa-alias.c (ao_ref_base_alias_set, ao_ref_alias_set): Pass true > to get_alias_set; comment. > (same_type_for_tbaa): Likewise. > * alias.c (alias_set_subset_of, alias_sets_conflict_p): When strict > aliasing is disabled, return true. > (get_alias_set): New parameter strict. > (new_alias_set): Always produce new alias set. > (record_component_aliases): Pass true to get_alias_set. > * alias.h (get_alias_set): New optional parameter STRICT. > * lto-streamer-out.c (hash_tree): Do not hash alias set. > * ipa-inline-transform.c (inline_call): Drop strict aliasing of > caller if needed. > * ipa-icf-gimple.c (func_checker::compatible_types_p): Pass true > to get_alias_set. > * tree-streamer-out.c (pack_ts_type_common_value_fields): Do not > stream TYPE_ALIAS_SET; sanity check that alias set 0 at LTO time will > match what frontneds does. > * fold-const.c (operand_equal_p): Be cureful about TBAA info before > inlining even with -fno-strict-aliasing. > * gimple.c (gimple_get_alias_set): Pass true to get_alias_set. > > * misc.c (gnat_get_alias_set): Pass true to get_alias_set. > * utils.c (relate_alias_sets): Likewise. > * trans.c (validate_unchecked_conversion): Likewise. > > * lto-symtab.c (warn_type_compatibility_p): Pass true to get_alias_set. > * lto.c (compare_tree_sccs_1): Do not ocmpare TYPE_ALIAS_SET. > > * gcc.c-torture/execute/alias-1.c: New testcase. > * gcc.dg/lto/alias-1_0.c: New testcase. > * gcc.dg/lto/alias-1_1.c: New testcase. > > * c-common.c (parse_optimize_options): Remove hack about > flag_strict_aliasing. > (convert_vector_to_pointer_for_subscript): Pass true to get_alias_set. > > * cp-objcp-common.c (cxx_get_alias_set): Pass true to get_alias_set. > > * rtti.c (typeid_ok_p): Pass true to get_alias_set. > Index: tree.c > =================================================================== > --- tree.c (revision 231020) > +++ tree.c (working copy) > @@ -5971,7 +5971,8 @@ free_lang_data (void) > while the slots are still in the way the frontends generated them. */ > for (i = 0; i < itk_none; ++i) > if (integer_types[i]) > - TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]); > + TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i], > + true); > > /* Traverse the IL resetting language specific information for > operands, expressions, etc. */ > Index: cp/rtti.c > =================================================================== > --- cp/rtti.c (revision 231020) > +++ cp/rtti.c (working copy) > @@ -300,10 +300,10 @@ typeid_ok_p (void) > /* Make sure abi::__type_info_pseudo has the same alias set > as std::type_info. */ > if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info)) > - TYPE_ALIAS_SET (pseudo_type_info) = get_alias_set (type_info_type); > + TYPE_ALIAS_SET (pseudo_type_info) = get_alias_set (type_info_type, true); > else > gcc_assert (TYPE_ALIAS_SET (pseudo_type_info) > - == get_alias_set (type_info_type)); > + == get_alias_set (type_info_type, true)); > > return true; > } > Index: cp/cp-objcp-common.c > =================================================================== > --- cp/cp-objcp-common.c (revision 231020) > +++ cp/cp-objcp-common.c (working copy) > @@ -32,7 +32,7 @@ cxx_get_alias_set (tree t) > if (IS_FAKE_BASE_TYPE (t)) > /* The base variant of a type must be in the same alias set as the > complete type. */ > - return get_alias_set (TYPE_CONTEXT (t)); > + return get_alias_set (TYPE_CONTEXT (t), true); > > /* Punt on PMFs until we canonicalize functions properly. */ > if (TYPE_PTRMEMFUNC_P (t) > Index: tree-streamer-in.c > =================================================================== > --- tree-streamer-in.c (revision 231020) > +++ tree-streamer-in.c (working copy) > @@ -366,7 +366,6 @@ unpack_ts_type_common_value_fields (stru > TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1); > TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1); > TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1); > - TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, 1) ? 0 : -1; > if (RECORD_OR_UNION_TYPE_P (expr)) > { > TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1); > Index: tree-ssa-alias.c > =================================================================== > --- tree-ssa-alias.c (revision 231020) > +++ tree-ssa-alias.c (working copy) > @@ -563,7 +563,10 @@ ao_ref_base_alias_set (ao_ref *ref) > base_ref = ref->ref; > while (handled_component_p (base_ref)) > base_ref = TREE_OPERAND (base_ref, 0); > - ref->base_alias_set = get_alias_set (base_ref); > + /* Do not return 0 in case of strict aliasing; this function is used at > + IPA level by ipa-icf-gimple.c. It is job of caller to give up on > + using TBAA oracle when asked to not do so. */ > + ref->base_alias_set = get_alias_set (base_ref, true); > return ref->base_alias_set; > } > > @@ -574,7 +577,10 @@ ao_ref_alias_set (ao_ref *ref) > { > if (ref->ref_alias_set != -1) > return ref->ref_alias_set; > - ref->ref_alias_set = get_alias_set (ref->ref); > + /* Do not return 0 in case of strict aliasing; this function is used at > + IPA level by ipa-icf-gimple.c. It is job of caller to give up on > + using TBAA oracle when asked to not do so. */ > + ref->ref_alias_set = get_alias_set (ref->ref, true); > return ref->ref_alias_set; > } > > @@ -668,7 +674,7 @@ same_type_for_tbaa (tree type1, tree typ > would mean that conversions between them are useless, whereas they are > not (e.g. type and subtypes can have different modes). So, in the end, > they are only guaranteed to have the same alias set. */ > - if (get_alias_set (type1) == get_alias_set (type2)) > + if (get_alias_set (type1, true) == get_alias_set (type2, true)) > return -1; > > /* The types are known to be not equal. */ > Index: alias.c > =================================================================== > --- alias.c (revision 231020) > +++ alias.c (working copy) > @@ -406,7 +406,7 @@ alias_set_subset_of (alias_set_type set1 > alias_set_entry *ase2; > > /* Everything is a subset of the "aliases everything" set. */ > - if (set2 == 0) > + if (set2 == 0 || !flag_strict_aliasing) > return true; > > /* Check if set1 is a subset of set2. */ > @@ -467,7 +467,7 @@ alias_sets_conflict_p (alias_set_type se > alias_set_entry *ase2; > > /* The easy case. */ > - if (alias_sets_must_conflict_p (set1, set2)) > + if (!flag_strict_aliasing || alias_sets_must_conflict_p (set1, set2)) > return 1; > > /* See if the first alias set is a subset of the second. */ > @@ -809,17 +809,21 @@ init_alias_set_entry (alias_set_type set > } > > /* Return the alias set for T, which may be either a type or an > - expression. Call language-specific routine for help, if needed. */ > + expression. Call language-specific routine for help, if needed. > + If STRICT is true, ignore value of flag_strict_aliasing. This is needed > + in cases we are in -fno-strict-aliasing region but still need to compute > + alias sets for some reason (this is used, for example, by rtti code to copy > + alias set from type to type). */ > > alias_set_type > -get_alias_set (tree t) > +get_alias_set (tree t, bool strict) > { > alias_set_type set; > > /* If we're not doing any alias analysis, just assume everything > aliases everything else. Also return 0 if this or its type is > an error. */ > - if (! flag_strict_aliasing || t == error_mark_node > + if ((! flag_strict_aliasing && !strict)|| t == error_mark_node > || (! TYPE_P (t) > && (TREE_TYPE (t) == 0 || TREE_TYPE (t) == error_mark_node))) > return 0; > @@ -898,7 +902,7 @@ get_alias_set (tree t) > /* For arrays with unknown size the conservative answer is the > alias set of the element type. */ > if (TREE_CODE (t) == ARRAY_TYPE) > - return get_alias_set (TREE_TYPE (t)); > + return get_alias_set (TREE_TYPE (t), true); > > /* But return zero as a conservative answer for incomplete types. */ > return 0; > @@ -920,7 +924,7 @@ get_alias_set (tree t) > normal usage. And indeed lets vectors be treated more like an > array slice. */ > else if (TREE_CODE (t) == VECTOR_TYPE) > - set = get_alias_set (TREE_TYPE (t)); > + set = get_alias_set (TREE_TYPE (t), true); > > /* Unless the language specifies otherwise, treat array types the > same as their components. This avoids the asymmetry we get > @@ -933,7 +937,7 @@ get_alias_set (tree t) > else if (TREE_CODE (t) == ARRAY_TYPE > && (!TYPE_NONALIASED_COMPONENT (t) > || TYPE_STRUCTURAL_EQUALITY_P (t))) > - set = get_alias_set (TREE_TYPE (t)); > + set = get_alias_set (TREE_TYPE (t), true); > > /* From the former common C and C++ langhook implementation: > > @@ -997,7 +1001,7 @@ get_alias_set (tree t) > (see record_component_aliases) and thus it is safe it to use it for > pointers to types with TYPE_STRUCTURAL_EQUALITY_P. */ > if (TREE_CODE (p) == VOID_TYPE || TYPE_STRUCTURAL_EQUALITY_P (p)) > - set = get_alias_set (ptr_type_node); > + set = get_alias_set (ptr_type_node, true); > else > { > /* Rebuild pointer type starting from canonical types using > @@ -1085,15 +1089,10 @@ get_alias_set (tree t) > alias_set_type > new_alias_set (void) > { > - if (flag_strict_aliasing) > - { > - if (alias_sets == 0) > - vec_safe_push (alias_sets, (alias_set_entry *) NULL); > - vec_safe_push (alias_sets, (alias_set_entry *) NULL); > - return alias_sets->length () - 1; > - } > - else > - return 0; > + if (alias_sets == 0) > + vec_safe_push (alias_sets, (alias_set_entry *) NULL); > + vec_safe_push (alias_sets, (alias_set_entry *) NULL); > + return alias_sets->length () - 1; > } > > /* Indicate that things in SUBSET can alias things in SUPERSET, but that > @@ -1169,7 +1168,7 @@ record_alias_subset (alias_set_type supe > void > record_component_aliases (tree type) > { > - alias_set_type superset = get_alias_set (type); > + alias_set_type superset = get_alias_set (type, true); > tree field; > > if (superset == 0) > @@ -1215,16 +1214,17 @@ record_component_aliases (tree type) > if (POINTER_TYPE_P (t)) > t = ptr_type_node; > else if (flag_checking) > - gcc_checking_assert (get_alias_set (t) > - == get_alias_set (TREE_TYPE (field))); > + gcc_checking_assert (get_alias_set (t, true) > + == get_alias_set (TREE_TYPE (field), > + true)); > } > > - record_alias_subset (superset, get_alias_set (t)); > + record_alias_subset (superset, get_alias_set (t, true)); > } > break; > > case COMPLEX_TYPE: > - record_alias_subset (superset, get_alias_set (TREE_TYPE (type))); > + record_alias_subset (superset, get_alias_set (TREE_TYPE (type), true)); > break; > > /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their > Index: alias.h > =================================================================== > --- alias.h (revision 231020) > +++ alias.h (working copy) > @@ -21,7 +21,7 @@ along with GCC; see the file COPYING3. > #define GCC_ALIAS_H > > extern alias_set_type new_alias_set (void); > -extern alias_set_type get_alias_set (tree); > +extern alias_set_type get_alias_set (tree, bool strict = false); > extern alias_set_type get_deref_alias_set (tree); > extern alias_set_type get_varargs_alias_set (void); > extern alias_set_type get_frame_alias_set (void); > Index: lto/lto-symtab.c > =================================================================== > --- lto/lto-symtab.c (revision 231020) > +++ lto/lto-symtab.c (working copy) > @@ -276,8 +276,8 @@ warn_type_compatibility_p (tree prevaili > we make ptr_type_node to TBAA compatible with every other type. */ > if (type_with_alias_set_p (type) && type_with_alias_set_p (prevailing_type)) > { > - alias_set_type set1 = get_alias_set (type); > - alias_set_type set2 = get_alias_set (prevailing_type); > + alias_set_type set1 = get_alias_set (type, true); > + alias_set_type set2 = get_alias_set (prevailing_type, true); > > if (set1 && set2 && set1 != set2 > && (!POINTER_TYPE_P (type) || !POINTER_TYPE_P (prevailing_type) > Index: lto/lto.c > =================================================================== > --- lto/lto.c (revision 231020) > +++ lto/lto.c (working copy) > @@ -1166,7 +1166,9 @@ compare_tree_sccs_1 (tree t1, tree t2, t > compare_values (TYPE_READONLY); > compare_values (TYPE_PRECISION); > compare_values (TYPE_ALIGN); > - compare_values (TYPE_ALIAS_SET); > + /* Do not compare TYPE_ALIAS_SET. Doing so introduce ordering issues > + with calls to get_alias_set which may initialize it for streamed > + in types. */ > } > > /* We don't want to compare locations, so there is nothing do compare > Index: testsuite/gcc.c-torture/execute/alias-1.c > =================================================================== > --- testsuite/gcc.c-torture/execute/alias-1.c (revision 0) > +++ testsuite/gcc.c-torture/execute/alias-1.c (revision 0) > @@ -0,0 +1,19 @@ > +int val; > + > +int *ptr = &val; > +float *ptr2 = &val; > + > +__attribute__((optimize ("-fno-strict-aliasing"))) > +typepun () > +{ > + *ptr2=0; > +} > + > +main() > +{ > + *ptr=1; > + typepun (); > + if (*ptr) > + __builtin_abort (); > +} > + > Index: testsuite/gcc.dg/lto/alias-1_0.c > =================================================================== > --- testsuite/gcc.dg/lto/alias-1_0.c (revision 0) > +++ testsuite/gcc.dg/lto/alias-1_0.c (revision 0) > @@ -0,0 +1,22 @@ > +/* { dg-lto-do run } */ > +/* { dg-lto-options { { -O2 -flto } } } */ > +int val; > + > +int *ptr = &val; > +float *ptr2 = &val; > + > +extern void typefun(void); > + > +void link_error (void); > + > +int > +main() > +{ > + *ptr=1; > + typefun (); > + if (*ptr) > + /*link_error ();*/ > + __builtin_abort (); > + return 0; > +} > + > Index: testsuite/gcc.dg/lto/alias-1_1.c > =================================================================== > --- testsuite/gcc.dg/lto/alias-1_1.c (revision 0) > +++ testsuite/gcc.dg/lto/alias-1_1.c (revision 0) > @@ -0,0 +1,8 @@ > +/* { dg-options "-fno-strict-aliasing" } */ > +extern float *ptr2; > +void > +__attribute__((optimize ("-fno-strict-aliasing"))) > +typefun () > +{ > + *ptr2=0; > +} > Index: c-family/c-common.c > =================================================================== > --- c-family/c-common.c (revision 231048) > +++ c-family/c-common.c (working copy) > @@ -9988,7 +9988,6 @@ parse_optimize_options (tree args, bool > bool ret = true; > unsigned opt_argc; > unsigned i; > - int saved_flag_strict_aliasing; > const char **opt_argv; > struct cl_decoded_option *decoded_options; > unsigned int decoded_options_count; > @@ -10081,8 +10080,6 @@ parse_optimize_options (tree args, bool > for (i = 1; i < opt_argc; i++) > opt_argv[i] = (*optimize_args)[i]; > > - saved_flag_strict_aliasing = flag_strict_aliasing; > - > /* Now parse the options. */ > decode_cmdline_options_to_array_default_mask (opt_argc, opt_argv, > &decoded_options, > @@ -10093,9 +10090,6 @@ parse_optimize_options (tree args, bool > > targetm.override_options_after_change(); > > - /* Don't allow changing -fstrict-aliasing. */ > - flag_strict_aliasing = saved_flag_strict_aliasing; > - > optimize_args->truncate (0); > return ret; > } > @@ -12930,8 +12924,8 @@ convert_vector_to_pointer_for_subscript > /* If the original vector isn't declared may_alias and it > isn't a bare vector look if the subscripting would > alias the vector we subscript, and if not, force ref-all. */ > - alias_set_type vecset = get_alias_set (*vecp); > - alias_set_type sset = get_alias_set (type); > + alias_set_type vecset = get_alias_set (*vecp, true); > + alias_set_type sset = get_alias_set (type, true); > if (!alias_sets_must_conflict_p (sset, vecset) > && !alias_set_subset_of (sset, vecset)) > ref_all = true; > Index: lto-streamer-out.c > =================================================================== > --- lto-streamer-out.c (revision 231020) > +++ lto-streamer-out.c (working copy) > @@ -1109,10 +1109,6 @@ hash_tree (struct streamer_tree_cache_d > hstate.commit_flag (); > hstate.add_int (TYPE_PRECISION (t)); > hstate.add_int (TYPE_ALIGN (t)); > - hstate.add_int ((TYPE_ALIAS_SET (t) == 0 > - || (!in_lto_p > - && get_alias_set (t) == 0)) > - ? 0 : -1); > } > > if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL)) > Index: ipa-inline-transform.c > =================================================================== > --- ipa-inline-transform.c (revision 231020) > +++ ipa-inline-transform.c (working copy) > @@ -322,6 +322,23 @@ inline_call (struct cgraph_edge *e, bool > if (DECL_FUNCTION_PERSONALITY (callee->decl)) > DECL_FUNCTION_PERSONALITY (to->decl) > = DECL_FUNCTION_PERSONALITY (callee->decl); > + if (!opt_for_fn (callee->decl, flag_strict_aliasing) > + && opt_for_fn (to->decl, flag_strict_aliasing) > + && (!callee->merged > + || lookup_attribute ("optimization", DECL_ATTRIBUTES (e->caller->decl)) > + || lookup_attribute ("optimization", DECL_ATTRIBUTES (callee->decl)))) > + { > + struct gcc_options opts = global_options; > + cl_optimization_restore (&opts, > + TREE_OPTIMIZATION (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (to->decl))); > + opts.x_flag_strict_aliasing = false; > + if (dump_file) > + fprintf (dump_file, "Dropping flag_strict_aliasing on %s:%i\n", > + to->name (), to->order); > + build_optimization_node (&opts); > + DECL_FUNCTION_SPECIFIC_OPTIMIZATION (to->decl) > + = build_optimization_node (&opts); > + } > > /* If aliases are involved, redirect edge to the actual destination and > possibly remove the aliases. */ > Index: ipa-icf-gimple.c > =================================================================== > --- ipa-icf-gimple.c (revision 231020) > +++ ipa-icf-gimple.c (working copy) > @@ -241,7 +241,7 @@ func_checker::compatible_types_p (tree t > For time being just avoid calling get_alias_set on types that are not > having alias sets defined at all. */ > if (type_with_alias_set_p (t1) && type_with_alias_set_p (t2) > - && get_alias_set (t1) != get_alias_set (t2)) > + && get_alias_set (t1, true) != get_alias_set (t2, true)) > return return_false_with_msg ("alias sets are different"); > > return true; > Index: tree-streamer-out.c > =================================================================== > --- tree-streamer-out.c (revision 231020) > +++ tree-streamer-out.c (working copy) > @@ -317,13 +321,18 @@ pack_ts_type_common_value_fields (struct > bp_pack_value (bp, TYPE_RESTRICT (expr), 1); > bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1); > bp_pack_value (bp, TYPE_READONLY (expr), 1); > - /* Make sure to preserve the fact whether the frontend would assign > - alias-set zero to this type. Do that only for main variants, because > - type variants alias sets are never computed. > - FIXME: This does not work for pre-streamed builtin types. */ > - bp_pack_value (bp, (TYPE_ALIAS_SET (expr) == 0 > - || (!in_lto_p && TYPE_MAIN_VARIANT (expr) == expr > - && get_alias_set (expr) == 0)), 1); > + /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark > + types that are opaque for TBAA. This however did not work as intended, > + becuase TYPE_ALIAS_SET == 0 was regularly lost in type merging. > + > + Instead now double check that all aliaset set 0 types will be alias set > + 0 in LTO world, too. */ > + gcc_checking_assert (!type_with_alias_set_p (expr) > + || !canonical_type_used_p (expr) > + || TYPE_ALIAS_SET (expr) != 0 > + || expr == char_type_node > + || expr == signed_char_type_node > + || expr == unsigned_char_type_node); > if (RECORD_OR_UNION_TYPE_P (expr)) > { > bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1); > Index: fold-const.c > =================================================================== > --- fold-const.c (revision 231020) > +++ fold-const.c (working copy) > @@ -2987,7 +2987,7 @@ operand_equal_p (const_tree arg0, const_ > flags))) > return 0; > /* Verify that accesses are TBAA compatible. */ > - if (flag_strict_aliasing > + if ((flag_strict_aliasing || !cfun->after_inlining) > && (!alias_ptr_types_compatible_p > (TREE_TYPE (TREE_OPERAND (arg0, 1)), > TREE_TYPE (TREE_OPERAND (arg1, 1))) > Index: ada/gcc-interface/misc.c > =================================================================== > --- ada/gcc-interface/misc.c (revision 231020) > +++ ada/gcc-interface/misc.c (working copy) > @@ -592,13 +592,14 @@ gnat_get_alias_set (tree type) > { > /* If this is a padding type, use the type of the first field. */ > if (TYPE_IS_PADDING_P (type)) > - return get_alias_set (TREE_TYPE (TYPE_FIELDS (type))); > + return get_alias_set (TREE_TYPE (TYPE_FIELDS (type)), true); > > /* If the type is an unconstrained array, use the type of the > self-referential array we make. */ > else if (TREE_CODE (type) == UNCONSTRAINED_ARRAY_TYPE) > return > - get_alias_set (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (type))))); > + get_alias_set (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (type)))), > + true); > > /* If the type can alias any other types, return the alias set 0. */ > else if (TYPE_P (type) && TYPE_UNIVERSAL_ALIASING_P (type)) > Index: ada/gcc-interface/utils.c > =================================================================== > --- ada/gcc-interface/utils.c (revision 231020) > +++ ada/gcc-interface/utils.c (working copy) > @@ -1520,14 +1520,14 @@ relate_alias_sets (tree gnu_new_type, tr > && TYPE_NONALIASED_COMPONENT (gnu_new_type) > != TYPE_NONALIASED_COMPONENT (gnu_old_type))); > > - TYPE_ALIAS_SET (gnu_new_type) = get_alias_set (gnu_old_type); > + TYPE_ALIAS_SET (gnu_new_type) = get_alias_set (gnu_old_type, true); > break; > > case ALIAS_SET_SUBSET: > case ALIAS_SET_SUPERSET: > { > - alias_set_type old_set = get_alias_set (gnu_old_type); > - alias_set_type new_set = get_alias_set (gnu_new_type); > + alias_set_type old_set = get_alias_set (gnu_old_type, true); > + alias_set_type new_set = get_alias_set (gnu_new_type, true); > > /* Do nothing if the alias sets conflict. This ensures that we > never call record_alias_subset several times for the same pair > Index: ada/gcc-interface/trans.c > =================================================================== > --- ada/gcc-interface/trans.c (revision 231020) > +++ ada/gcc-interface/trans.c (working copy) > @@ -9702,11 +9702,13 @@ validate_unchecked_conversion (Node_Id g > ? TREE_TYPE (gnu_source_type) > : NULL_TREE; > tree gnu_target_desig_type = TREE_TYPE (gnu_target_type); > - alias_set_type target_alias_set = get_alias_set (gnu_target_desig_type); > + alias_set_type target_alias_set = get_alias_set (gnu_target_desig_type, > + true); > > if (target_alias_set != 0 > && (!POINTER_TYPE_P (gnu_source_type) > - || !alias_sets_conflict_p (get_alias_set (gnu_source_desig_type), > + || !alias_sets_conflict_p (get_alias_set (gnu_source_desig_type, > + true), > target_alias_set))) > { > post_error_ne ("?possible aliasing problem for type&", > @@ -9728,11 +9730,13 @@ validate_unchecked_conversion (Node_Id g > : NULL_TREE; > tree gnu_target_desig_type > = TREE_TYPE (TREE_TYPE (TYPE_FIELDS (gnu_target_type))); > - alias_set_type target_alias_set = get_alias_set (gnu_target_desig_type); > + alias_set_type target_alias_set = get_alias_set (gnu_target_desig_type, > + true); > > if (target_alias_set != 0 > && (!TYPE_IS_FAT_POINTER_P (gnu_source_type) > - || !alias_sets_conflict_p (get_alias_set (gnu_source_desig_type), > + || !alias_sets_conflict_p (get_alias_set (gnu_source_desig_type, > + true), > target_alias_set))) > { > post_error_ne ("?possible aliasing problem for type&", > Index: gimple.c > =================================================================== > --- gimple.c (revision 231020) > +++ gimple.c (working copy) > @@ -2408,7 +2408,7 @@ gimple_get_alias_set (tree t) > > /* t1 == t can happen for boolean nodes which are always unsigned. */ > if (t1 != t) > - return get_alias_set (t1); > + return get_alias_set (t1, true); > } > > return -1; > > -- Richard Biener SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nuernberg)