Re: [PATCH 1/1] PR100281 C++: Fix SImode pointer handling

[Jason Merrill via Gcc-patches]

On 4/30/21 2:32 AM, Andreas Krebbel via Gcc-patches wrote:
The problem appears to be triggered by two locations in the front-end
where non-POINTER_SIZE pointers aren't handled right now.
1. An assertion in strip_typedefs is triggered because the alignment
of the types don't match. This in turn is caused by creating the new
type with build_pointer_type instead of taking the type of the
original pointer into account.

2. An assertion in cp_convert_to_pointer is triggered which expects
the target type to always have POINTER_SIZE.

Bootstrapped and regression tested on x86_64 and s390x.

Ok for mainline?

gcc/cp/ChangeLog:

        PR c++/100281
        * cvt.c (cp_convert_to_pointer): Use the size of the target
        pointer type.
        * tree.c (cp_build_reference_type): Call
        cp_build_reference_type_for_mode with VOIDmode.
        (cp_build_reference_type_for_mode): Rename from
        cp_build_reference_type.  Add MODE argument and invoke
        build_reference_type_for_mode if MODE isn't VOIDmode.

How about putting the VOIDmode special case in the generic 
build_reference_type_for_mode instead of the C++ wrapper?

        (strip_typedefs): Use build_pointer_type_for_mode and
        cp_build_reference_type_for_mode for pointers and references.

gcc/testsuite/ChangeLog:

        PR c++/100281
        * g++.target/s390/pr100281-1.C: New test.
        * g++.target/s390/pr100281-2.C: New test.
---
  gcc/cp/cvt.c                               |  2 +-
  gcc/cp/tree.c                              | 28 +++++++++++++++++-----
  gcc/testsuite/g++.target/s390/pr100281-1.C | 10 ++++++++
  gcc/testsuite/g++.target/s390/pr100281-2.C |  9 +++++++
  4 files changed, 42 insertions(+), 7 deletions(-)
  create mode 100644 gcc/testsuite/g++.target/s390/pr100281-1.C
  create mode 100644 gcc/testsuite/g++.target/s390/pr100281-2.C

diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index f1687e804d1..7fa6e8df52b 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -232,7 +232,7 @@ cp_convert_to_pointer (tree type, tree expr, bool dofold,
      {
        if (TYPE_PRECISION (intype) == POINTER_SIZE)
        return build1 (CONVERT_EXPR, type, expr);
-      expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr,
+      expr = cp_convert (c_common_type_for_size (TYPE_PRECISION (type), 0), 
expr,
                         complain);
        /* Modes may be different but sizes should be the same.  There
         is supposed to be some integral type that is the same width
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index a8bfd5fc053..3817b499e46 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -1201,12 +1201,14 @@ vla_type_p (tree t)
    return false;
  }
  
-/* Return a reference type node referring to TO_TYPE.  If RVAL is
+
+/* Return a reference type node of MODE referring to TO_TYPE.  If MODE
+   is VOIDmode the standard pointer mode will be picked.  If RVAL is
     true, return an rvalue reference type, otherwise return an lvalue
     reference type.  If a type node exists, reuse it, otherwise create
     a new one.  */
  tree
-cp_build_reference_type (tree to_type, bool rval)
+cp_build_reference_type_for_mode (tree to_type, machine_mode mode, bool rval)
  {
    tree lvalue_ref, t;
  
@@ -1219,7 +1221,11 @@ cp_build_reference_type (tree to_type, bool rval)
        to_type = TREE_TYPE (to_type);
      }
  
-  lvalue_ref = build_reference_type (to_type);
+  if (mode == VOIDmode)
+    lvalue_ref = build_reference_type (to_type);
+  else
+    lvalue_ref = build_reference_type_for_mode (to_type, mode, false);
+
    if (!rval)
      return lvalue_ref;
  
@@ -1245,7 +1251,7 @@ cp_build_reference_type (tree to_type, bool rval)
      SET_TYPE_STRUCTURAL_EQUALITY (t);
    else if (TYPE_CANONICAL (to_type) != to_type)
      TYPE_CANONICAL (t)
-      = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
+      = cp_build_reference_type_for_mode (TYPE_CANONICAL (to_type), mode, 
rval);
    else
      TYPE_CANONICAL (t) = t;
  
@@ -1255,6 +1261,16 @@ cp_build_reference_type (tree to_type, bool rval)
  
  }
  
+/* Return a reference type node referring to TO_TYPE.  If RVAL is
+   true, return an rvalue reference type, otherwise return an lvalue
+   reference type.  If a type node exists, reuse it, otherwise create
+   a new one.  */
+tree
+cp_build_reference_type (tree to_type, bool rval)
+{
+  return cp_build_reference_type_for_mode (to_type, VOIDmode, rval);
+}
+
  /* Returns EXPR cast to rvalue reference type, like std::move.  */
  
  tree
@@ -1556,11 +1572,11 @@ strip_typedefs (tree t, bool *remove_attributes, 
unsigned int flags)
      {
      case POINTER_TYPE:
        type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
-      result = build_pointer_type (type);
+      result = build_pointer_type_for_mode (type, TYPE_MODE (t), false);
        break;
      case REFERENCE_TYPE:
        type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
-      result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
+      result = cp_build_reference_type_for_mode (type, TYPE_MODE (t), 
TYPE_REF_IS_RVALUE (t));
        break;
      case OFFSET_TYPE:
        t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t), remove_attributes, 
flags);
diff --git a/gcc/testsuite/g++.target/s390/pr100281-1.C 
b/gcc/testsuite/g++.target/s390/pr100281-1.C
new file mode 100644
index 00000000000..b82e27b64e9
--- /dev/null
+++ b/gcc/testsuite/g++.target/s390/pr100281-1.C
@@ -0,0 +1,10 @@
+// PR C++/100281
+// { dg-do compile }
+
+typedef void * __attribute__((mode (SI))) __ptr32_t;
+
+void foo () {
+  unsigned int b = 100;
+  __ptr32_t a;
+  a = b; /* { dg-error "invalid conversion from 'unsigned int' to 
'__ptr32_t'.*" } */
+}
diff --git a/gcc/testsuite/g++.target/s390/pr100281-2.C 
b/gcc/testsuite/g++.target/s390/pr100281-2.C
new file mode 100644
index 00000000000..58552becd7c
--- /dev/null
+++ b/gcc/testsuite/g++.target/s390/pr100281-2.C
@@ -0,0 +1,9 @@
+// PR C++/100281
+// { dg-do compile }
+
+typedef int & __attribute__((mode (SI))) __ref32_t;
+
+void foo () {
+  unsigned int b = 100;
+  __ref32_t a = b; /* { dg-error "cannot bind non-const lvalue reference of type 
'__ref32_t'.*" } */
+}