From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 105834 invoked by alias); 30 Nov 2015 06:59:04 -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 105815 invoked by uid 89); 30 Nov 2015 06:59:03 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.5 required=5.0 tests=AWL,BAYES_50,KAM_ASCII_DIVIDERS,KAM_LAZY_DOMAIN_SECURITY,T_RP_MATCHES_RCVD autolearn=no version=3.3.2 X-HELO: nikam.ms.mff.cuni.cz Received: from nikam.ms.mff.cuni.cz (HELO nikam.ms.mff.cuni.cz) (195.113.20.16) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Mon, 30 Nov 2015 06:59:00 +0000 Received: by nikam.ms.mff.cuni.cz (Postfix, from userid 16202) id CE556541F95; Mon, 30 Nov 2015 07:58:55 +0100 (CET) Date: Mon, 30 Nov 2015 07:22:00 -0000 From: Jan Hubicka To: Jan Hubicka Cc: Richard Biener , gcc-patches@gcc.gnu.org Subject: Re: Fix verify_type ICE during Ada bootstrap Message-ID: <20151130065855.GA22602@kam.mff.cuni.cz> 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> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20151127070255.GB59662@kam.mff.cuni.cz> User-Agent: Mutt/1.5.21 (2010-09-15) X-SW-Source: 2015-11/txt/msg03442.txt.bz2 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? 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;