sra: Avoid verification failure (PR 93516)

get_ref_base_and_extent can return different sizes for COMPONENT_REFs
and DECLs of the same type, with the latter including (more?)  padding.
When in the IL there is an assignment between such a COMPONENT_REF and a
DECL, SRA will try to propagate the access from the former as a child of
the latter, creating an artificial reference that does not match the
access's declared size, which triggers a verifier assert.

Fixed by teaching the propagation functions about this special situation
so that they don't do it.  The condition is the same that
build_user_friendly_ref_for_offset uses so the artificial reference
causing the verifier is guaranteed not to be created.

2020-02-14  Martin Jambor  <mjambor@suse.cz>

	PR tree-optimization/93516
	* tree-sra.c (propagate_subaccesses_from_rhs): Do not create
	access of the same type as the parent.
	(propagate_subaccesses_from_lhs): Likewise.

	gcc/testsuite/
	* g++.dg/tree-ssa/pr93516.C: New test.

gcc/ChangeLog

+2020-02-14  Martin Jambor  <mjambor@suse.cz>
+
+	PR tree-optimization/93516
+	* tree-sra.c (propagate_subaccesses_from_rhs): Do not create
+	access of the same type as the parent.
+	(propagate_subaccesses_from_lhs): Likewise.
+
 2020-02-14 Hongtao Liu  <hongtao.liu@intel.com>
 
 	PR target/93724

gcc/testsuite/ChangeLog

+2020-02-14  Martin Jambor  <mjambor@suse.cz>
+
+	PR tree-optimization/93516
+	* g++.dg/tree-ssa/pr93516.C: New test.
+
 2020-02-14 Hongtao Liu  <hongtao.liu@intel.com>
 
 	* gcc.target/i386/avx512vbmi2-vpshld-1.c: New test.

gcc/testsuite/g++.dg/tree-ssa/pr93516.C

+// { dg-do compile }
+// { dg-options "-O2" } */
+
+struct b;
+struct c {
+  b *operator->();
+};
+class e {
+  void *f;
+  int d;
+
+public:
+  template <typename a> a g() { return *static_cast<a *>(this); }
+};
+struct h : e {};
+struct b {
+  void i(e);
+  e j();
+};
+void m() {
+  c k;
+  h l = k->j().g<h>();
+  k->i(l);
+}

gcc/tree-sra.c

@@ -2785,9 +2785,17 @@ propagate_subaccesses_from_rhs (struct access *lacc, struct access *racc)
 	}
 
       rchild->grp_hint = 1;
-      new_acc = create_artificial_child_access (lacc, rchild, norm_offset,
-						false, (lacc->grp_write
-							|| rchild->grp_write));
+      /* Because get_ref_base_and_extent always includes padding in size for
+	 accesses to DECLs but not necessarily for COMPONENT_REFs of the same
+	 type, we might be actually attempting to here to create a child of the
+	 same type as the parent.  */
+      if (!types_compatible_p (lacc->type, rchild->type))
+	new_acc = create_artificial_child_access (lacc, rchild, norm_offset,
+						  false,
+						  (lacc->grp_write
+						   || rchild->grp_write));
+      else
+	new_acc = lacc;
       gcc_checking_assert (new_acc);
       if (racc->first_child)
 	propagate_subaccesses_from_rhs (new_acc, rchild);
@@ -2834,10 +2842,19 @@ propagate_subaccesses_from_lhs (struct access *lacc, struct access *racc)
 	  continue;
 	}
 
-      struct access *new_acc
-	=  create_artificial_child_access (racc, lchild, norm_offset,
-					   true, false);
-      propagate_subaccesses_from_lhs (lchild, new_acc);
+      /* Because get_ref_base_and_extent always includes padding in size for
+	 accesses to DECLs but not necessarily for COMPONENT_REFs of the same
+	 type, we might be actually attempting to here to create a child of the
+	 same type as the parent.  */
+      if (!types_compatible_p (racc->type, lchild->type))
+	{
+	  struct access *new_acc
+	    = create_artificial_child_access (racc, lchild, norm_offset,
+					      true, false);
+	  propagate_subaccesses_from_lhs (lchild, new_acc);
+	}
+      else
+	propagate_subaccesses_from_lhs (lchild, racc);
       ret = true;
     }
   return ret;