c++: Fix initializing empty base from prvalue [PR97597]

unsafe_return_slot_p wasn't recognizing an empty base as
potentially-overlapping, which it definitely is.

The change to build_base_path is to make the virtual conversion also
recognized by is_empty_base_ref; unsafe_return_slot_p doesn't to handle
virtual conversions, but hypothetical future callers might.

gcc/cp/ChangeLog:

	PR c++/97597
	* class.c (is_empty_base_ref): New.
	(build_base_path): Add NOP_EXPR after offset.
	* cp-tree.h (is_empty_base_ref): Declare it.
	* call.c (unsafe_return_slot_p): Call it.

gcc/testsuite/ChangeLog:

	PR c++/97597
	* g++.dg/init/empty3.C: New test.

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index c2d62e582bf9e4b930e58af4dfdc4732e348367b..65a4d73a7e04e2d64a6ec2a847197e3ecfced0ea 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -8426,6 +8426,10 @@ call_copy_ctor (tree a, tsubst_flags_t complain)
 bool
 unsafe_return_slot_p (tree t)
 {
+  /* Check empty bases separately, they don't have fields.  */
+  if (is_empty_base_ref (t))
+    return true;
+
   STRIP_NOPS (t);
   if (TREE_CODE (t) == ADDR_EXPR)
     t = TREE_OPERAND (t, 0);

diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index bc0d3d6bf8624654b02e0b71e7c1edf69a931452..fc5502aad980b9b1524b220ac3efa07b3e174560 100644 (file)
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -494,8 +494,6 @@ build_base_path (enum tree_code code,
   if (want_pointer)
     target_type = ptr_target_type;
 
-  expr = build1 (NOP_EXPR, ptr_target_type, expr);
-
   if (!integer_zerop (offset))
     {
       offset = fold_convert (sizetype, offset);
@@ -506,6 +504,8 @@ build_base_path (enum tree_code code,
   else
     null_test = NULL;
 
+  expr = build1 (NOP_EXPR, ptr_target_type, expr);
+
  indout:
   if (!want_pointer)
     {
@@ -659,6 +659,33 @@ convert_to_base_statically (tree expr, tree base)
   return expr;
 }
 
+/* True IFF EXPR is a reference to an empty base class "subobject", as built in
+   convert_to_base_statically.  We look for the result of the fold_convert
+   call, a NOP_EXPR from one pointer type to another, where the target is an
+   empty base of the original type.  */
+
+bool
+is_empty_base_ref (tree expr)
+{
+  if (TREE_CODE (expr) == INDIRECT_REF)
+    expr = TREE_OPERAND (expr, 0);
+  if (TREE_CODE (expr) != NOP_EXPR)
+    return false;
+  tree type = TREE_TYPE (expr);
+  if (!POINTER_TYPE_P (type))
+    return false;
+  type = TREE_TYPE (type);
+  if (!is_empty_class (type))
+    return false;
+  STRIP_NOPS (expr);
+  tree fromtype = TREE_TYPE (expr);
+  if (!POINTER_TYPE_P (fromtype))
+    return false;
+  fromtype = TREE_TYPE (fromtype);
+  return (CLASS_TYPE_P (fromtype)
+         && !same_type_ignoring_top_level_qualifiers_p (fromtype, type)
+         && DERIVED_FROM_P (type, fromtype));
+}
 \f
 tree
 build_vfield_ref (tree datum, tree type)

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 6cce9e2b4077337d08130e000ca28f963227989a..fc6a7898475d4fcdaa7fd12b7f4a895ad638f9a9 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6484,6 +6484,7 @@ extern tree build_base_path                       (enum tree_code, tree,
 extern tree convert_to_base                    (tree, tree, bool, bool,
                                                 tsubst_flags_t);
 extern tree convert_to_base_statically         (tree, tree);
+extern bool is_empty_base_ref                  (tree);
 extern tree build_vtbl_ref                     (tree, tree);
 extern tree build_vfn_ref                      (tree, tree);
 extern tree get_vtable_decl                    (tree, int);

diff --git a/gcc/testsuite/g++.dg/init/empty3.C b/gcc/testsuite/g++.dg/init/empty3.C
new file mode 100644 (file)
index 0000000..510338b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/init/empty3.C
@@ -0,0 +1,18 @@
+// PR c++/97597
+
+struct pq {
+  pq (const pq &);
+};
+
+struct a9 {
+  operator pq () const;
+};
+
+struct zp : pq {
+  zp (const a9 &k3) : pq (k3) { }
+};
+
+int main()
+{
+  zp z = a9();
+}