From: Jakub Jelinek <jakub@redhat.com>
Date: Fri, 22 Jan 2021 18:03:23 +0000 (+0100)
Subject: c++: Fix up ubsan false positives on references [PR95693]
X-Git-Tag: releases/gcc-10.3.0~346
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e5750f847158e7f9bdab770fd9c5fff58c5074d3;p=thirdparty%2Fgcc.git

c++: Fix up ubsan false positives on references [PR95693]

Alex' 2 years old change to build_zero_init_1 to return NULL pointer with
reference type for references breaks the sanitizers, the assignment of NULL
to a reference typed member is then instrumented before it is overwritten
with a non-NULL address later on.
That change has been done to fix error recovery ICE during
process_init_constructor_record, where we:
          if (TYPE_REF_P (fldtype))
            {
              if (complain & tf_error)
                error ("member %qD is uninitialized reference", field);
              else
                return PICFLAG_ERRONEOUS;
            }
a few lines earlier, but then continue and ICE when build_zero_init returns
NULL.

The following patch reverts the build_zero_init_1 change and instead creates
the NULL with reference type constants during the error recovery.

The pr84593.C testcase Alex' change was fixing still works as before.

2021-01-22  Jakub Jelinek  <jakub@redhat.com>

	PR sanitizer/95693
	* init.c (build_zero_init_1): Revert the 2018-03-06 change to
	return build_zero_cst for reference types.
	* typeck2.c (process_init_constructor_record): Instead call
	build_zero_cst here during error recovery instead of build_zero_init.

	* g++.dg/ubsan/pr95693.C: New test.
---

diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 4ad6c3db99ff..8cdce2782488 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -287,10 +287,7 @@ build_zero_init_1 (tree type, tree nelts, bool static_storage_p,
   else if (VECTOR_TYPE_P (type))
     init = build_zero_cst (type);
   else
-    {
-      gcc_assert (TYPE_REF_P (type));
-      init = build_zero_cst (type);
-    }
+    gcc_assert (TYPE_REF_P (type));
 
   /* In all cases, the initializer is a constant.  */
   if (init)
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 2fc6081557f2..96421caf22ec 100644
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -1756,10 +1756,14 @@ process_init_constructor_record (tree type, tree init, int nested, int flags,
 	    warning (OPT_Wmissing_field_initializers,
 		     "missing initializer for member %qD", field);
 
-	  if (!zero_init_p (fldtype)
-	      || skipped < 0)
-	    next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
-				    /*static_storage_p=*/false);
+	  if (!zero_init_p (fldtype) || skipped < 0)
+	    {
+	      if (TYPE_REF_P (fldtype))
+		next = build_zero_cst (TREE_TYPE (field));
+	      else
+		next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
+					/*static_storage_p=*/false);
+	    }
 	  else
 	    {
 	      /* The default zero-initialization is fine for us; don't
diff --git a/gcc/testsuite/g++.dg/ubsan/pr95693.C b/gcc/testsuite/g++.dg/ubsan/pr95693.C
new file mode 100644
index 000000000000..13f688e8ec0c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ubsan/pr95693.C
@@ -0,0 +1,26 @@
+// PR sanitizer/95693
+// { dg-do run }
+// { dg-options "-O2 -fsanitize=undefined -fno-sanitize-recover=undefined" }
+
+int g = 9;
+
+struct A {
+  A () : a(g) {}
+private:
+  int &a;
+};
+
+struct B {
+  A payload;
+};
+
+struct C : public B {
+  C () : B () {}
+  A p;
+};
+
+int
+main ()
+{
+  C t;
+}