From 6b8df3e421b56bb7853a158b889f5e45611fd31f Mon Sep 17 00:00:00 2001
From: Richard Biener <rguenther@suse.de>
Date: Tue, 14 Jan 2020 08:43:32 +0100
Subject: [PATCH] PR middle-end/93246 - missing alias subsets

Starting with the introduction of TYPE_TYPELESS_STORAGE the situation
of having a alias-set zero aggregate field became more common which
prevents recording alias-sets of fields of said aggregate as subset
of the outer aggregate.  component_uses_parent_alias_set_from in the
past fended off some of the issues with that but the alias oracles
use of the alias set of the base of an access path never appropriately
handled it.

The following makes it so that alias-sets of fields of alias-set zero
aggregate fields are still recorded as subset of the container.

2020-01-14  Richard Biener  <rguenther@suse.de>

	PR middle-end/93246
	* alias.c (record_component_aliases): Take superset to record
	into, recurse for alias-set zero fields.
	(record_component_aliases): New oveerload wrapping around the above.

	* g++.dg/torture/pr93246.C: New testcase.
---
 gcc/alias.c                            | 34 +++++++++++++++++++++++---
 gcc/testsuite/g++.dg/torture/pr93246.C | 31 +++++++++++++++++++++++
 2 files changed, 61 insertions(+), 4 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/torture/pr93246.C

diff --git a/gcc/alias.c b/gcc/alias.c
index 336af4e52a7..9629b5a9f48 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -1191,15 +1191,14 @@ record_alias_subset (alias_set_type superset, alias_set_type subset)
     }
 }
 
-/* Record that component types of TYPE, if any, are part of that type for
+/* Record that component types of TYPE, if any, are part of SUPERSET for
    aliasing purposes.  For record types, we only record component types
    for fields that are not marked non-addressable.  For array types, we
    only record the component type if it is not marked non-aliased.  */
 
 void
-record_component_aliases (tree type)
+record_component_aliases (tree type, alias_set_type superset)
 {
-  alias_set_type superset = get_alias_set (type);
   tree field;
 
   if (superset == 0)
@@ -1253,7 +1252,21 @@ record_component_aliases (tree type)
 					 == get_alias_set (TREE_TYPE (field)));
 		}
 
-	      record_alias_subset (superset, get_alias_set (t));
+	      alias_set_type set = get_alias_set (t);
+	      record_alias_subset (superset, set);
+	      /* If the field has alias-set zero make sure to still record
+		 any componets of it.  This makes sure that for
+		   struct A {
+		     struct B {
+		       int i;
+		       char c[4];
+		     } b;
+		   };
+		 in C++ even though 'B' has alias-set zero because
+		 TYPE_TYPELESS_STORAGE is set, 'A' has the alias-set of
+		 'int' as subset.  */
+	      if (set == 0)
+		record_component_aliases (t, superset);
 	    }
       }
       break;
@@ -1270,6 +1283,19 @@ record_component_aliases (tree type)
     }
 }
 
+/* Record that component types of TYPE, if any, are part of that type for
+   aliasing purposes.  For record types, we only record component types
+   for fields that are not marked non-addressable.  For array types, we
+   only record the component type if it is not marked non-aliased.  */
+
+void
+record_component_aliases (tree type)
+{
+  alias_set_type superset = get_alias_set (type);
+  record_component_aliases (type, superset);
+}
+
+
 /* Allocate an alias set for use in storing and reading from the varargs
    spill area.  */
 
diff --git a/gcc/testsuite/g++.dg/torture/pr93246.C b/gcc/testsuite/g++.dg/torture/pr93246.C
new file mode 100644
index 00000000000..4c523443175
--- /dev/null
+++ b/gcc/testsuite/g++.dg/torture/pr93246.C
@@ -0,0 +1,31 @@
+// { dg-do run }
+// { dg-additional-options "-fstrict-aliasing" }
+
+template <typename = void> struct Optional {
+  auto is_present() const { const bool &p = inner.present; return p; }
+  auto set_present() { if (not is_present()) inner.present = true; }
+  struct InnerType {
+    bool present = false;
+    char padding[1] = {0};
+  };
+  using inner_t = InnerType;
+  inner_t inner = {};
+};
+
+template <typename WrappedType> struct Wrapper {
+  auto operator-> () { return value; }
+  WrappedType *value;
+};
+
+void __attribute__((noipa)) foo(Optional<>& x) {}
+
+int main()
+{
+  Optional<> buf{};
+  foo(buf);
+  Wrapper<Optional<>> wo = {&buf};
+  wo->set_present();
+  auto x = wo->is_present();
+  if (!x)
+    __builtin_abort ();
+}
-- 
2.30.2