Re: Fix verify_type ICE during Ada bootstrap

[Jan Hubicka <hubicka at ucw dot cz>]

> 
> 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).

Ok, the assert was there mostly to double check that all zero alias
sets rematerialize correctly in LTO which I tested so it can go.
> 
> 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 ;)

OK, there is symmetric condition in ipa-inline-analysis, will comment on it.
It indeed can go in separately.
> 
> > +      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.

I don't know - even for Firefox that heavily mix -fstrict-aliasing
and -fno-strict-aliasing units this seems quite rare occasion and it
is hard to judge when dopping the flag_strict_aliasing.
> 
> The two above should be enough to fix the correctness issue.

We also need to prevent ipa-icf and fold_const from optimizing functions
early in a way that is not compatible with inlining -fno-strict-aliasing comdat
to -fstrict-aliasing function.

Honza
> 
> The parse_optimize_options hack looks indeed interesting, but we solved
> the issue differently by
> 
> 2014-11-27  Richard Biener  <rguenther@suse.de>
> 
>         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 <rguenther@suse.de>
> SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nuernberg)