Track GNU vector elements and apply Core issue 616 in C++11 modes [GH #90]

Constant evaluation now marks each element of a GNU vector as initialized
when a whole vector value is stored (at the end of process_expr_work), and
constexpr_copy_object_init_bits copies the state of each element.  This
fixes spurious "access to uninitialized object" errors when subscripting a
vector member initialized from a vector value (e.g., Y(a).v[3]).

To keep that sound, reading a whole vector (do_glvalue_to_prvalue) or
copying an object that contains one now requires each element to be
initialized, not only the first.

When emulating GCC 9+ or Clang 4+, selecting a member of a class prvalue
now produces an xvalue in C++11 mode too, as those compilers do.

is_address_of_auto_object now also looks for temporaries on the
addressing path, so returning a pointer into a member of a trivially
destructible class prvalue (e.g., &make().arr[1]) is diagnosed.

The re-recorded imported clang tests improve: cwg6xx loses three bogus
cwg616 errors and expr.const/p2-0x gains its expected volatile error.  In
C++11 GNU mode, gnu cpp0x/decltype72 now passes, and gnu
cpp26/name-independent-decl6 and clang C11/n1285 lose a few warnings, as
in C++14 mode.

Author: Momen-G-Ar

src/cmd_line.c

@@ -4301,6 +4301,13 @@ default mode (e.g., exception handling).
   std_override_modifiers_enabled = value;
   constexpr_implies_const = value;
   register_is_deprecated = TRUE;
+  if (value && rvalue_references_enabled &&
+      (cpp14_mode || gpp_mode || clang_mode) &&
+      !gpp_version_is(<90000) && !clangcpp_version_is(<40000)) {
+    /* A field selection on a class prvalue is an xvalue (CWG 616).  GCC 9+
+       and Clang 4+ also do that in C++11 mode. */
+    selection_from_prvalue_is_xvalue = TRUE;
+  }  /* if */
   if (cpp14_mode) {
     /* Features enabled in C++14 mode. */
     if (auto_type_specifier_enabled) {
@@ -4317,11 +4324,6 @@ default mode (e.g., exception handling).
     if (!option_kind_used[(int)optk_digit_separators]) {
       digit_separators_enabled = TRUE;
     }  /* if */
-    if (rvalue_references_enabled &&
-        !gpp_version_is(<90000) && !clangcpp_version_is(<40000)) {
-      /* A field selection on a class prvalue is an xvalue (CWG 616). */
-      selection_from_prvalue_is_xvalue = TRUE;
-    }  /* if */
     relaxed_constexpr_enabled = TRUE;
     sized_deallocation_enabled = RUNTIME_SUPPORTS_SIZED_DEALLOCATION;
     if (gpp_mode && !clang_mode && gnu_version < 50000) {

src/cmd_line.h

@@ -1742,7 +1742,8 @@ EXTERN_THREAD a_boolean
 EXTERN_THREAD a_boolean
 		selection_from_prvalue_is_xvalue;
 			/* TRUE if a field selection on a prvalue class object
-			   produces an xvalue (C++14 / CWG 616).  When FALSE,
+			   produces an xvalue (C++14 / CWG 616; GCC 9 and
+			   Clang 4 also apply it in C++11 mode).  When FALSE,
 			   the selection is a prvalue. */
 
 EXTERN_THREAD a_boolean

src/exprutil.c

@@ -25482,9 +25482,12 @@ underlying entity is a temporary, return *is_temp set to TRUE.
     tblock.process_expr = examine_expr_for_auto_object;
     tblock.follow_addressing_path = TRUE;
     /* A pointer into a prvalue.field xvalue (CWG 616) addresses a
-       subobject of the class prvalue. */
+       subobject of the class prvalue, which is a temporary even when it
+       is not represented by an explicit temporary (e.g., for a trivially
+       destructible class). */
     tblock.follow_class_rvalue_addressing_path =
                                          selection_from_prvalue_is_xvalue;
+    tblock.look_for_temporaries = selection_from_prvalue_is_xvalue;
     traverse_expr(expr, &tblock);
     is_addr_of_auto = tblock.result;
     *is_temp = tblock.is_temp;  

src/il_walk.h

@@ -387,7 +387,8 @@ typedef struct an_expr_or_stmt_traversal_block {
 			/* TRUE if expr_complete_object_type was called
 			   to determine the object type for a virtual function
 			   call. */
-  /* Fields used by is_glvalue_for_auto_object: */
+  /* Fields used by is_glvalue_for_auto_object and
+     is_address_of_auto_object: */
   a_boolean	is_temp;
 			/* TRUE if the underlying object is a temporary. */
   a_boolean	look_for_temporaries;

src/interpret.c

@@ -4887,6 +4887,36 @@ object) is initialized.
 }  /* subobject_is_initialized */
 
 
+#if GNU_VECTOR_TYPES_ALLOWED
+static a_boolean vector_elements_are_initialized(
+                                          an_interpreter_state  *ips,
+                                          a_type_ptr            tp,
+                                          a_constexpr_address   *cap)
+/*
+Return TRUE if each element of the vector of type tp at the address described
+by *cap is initialized (or if the enclosing complete object is fully
+initialized).  The elements of a vector are tracked individually, so a whole
+vector value can only be read if none of them is uninitialized.
+*/
+{
+  a_boolean  result = TRUE;
+
+  if (!complete_object_is_initialized(cap->complete_object)) {
+    a_type_ptr     etp = skip_typerefs(tp->variant.vector.element_type);
+    a_targ_size_t  k, n_elems = num_vector_elements(tp);
+    a_byte_count   elem_size = value_bytes_for_type(ips, etp, &result);
+    for (k = 0; result && k<n_elems; k += 1) {
+      if (!subobject_is_initialized(cap->address+k*elem_size,
+                                    cap->complete_object)) {
+        result = FALSE;
+      }  /* if */
+    }  /* for */
+  }  /* if */
+  return result;
+}  /* vector_elements_are_initialized */
+#endif /* GNU_VECTOR_TYPES_ALLOWED */
+
+
 static a_boolean mark_mutable_members_not_initialized(
                                           an_interpreter_state  *ips,
                                           a_byte                *subobj,
@@ -7488,15 +7518,8 @@ END_DISABLE_GCC_WARNING_STR_OVERFLOW
                   /* A vector element can be accessed by itself (e.g., by
                      subscripting the member), so mark each element
                      initialized. */
-                  a_type_ptr     etp = skip_typerefs(
-                                           ftp->variant.vector.element_type);
-                  a_targ_size_t  k, n_elems = num_vector_elements(ftp);
-                  a_byte_count   elem_size = value_bytes_for_type(ips, etp,
-                                                                  &result);
-                  for (k = 0; result && k<n_elems; k += 1) {
-                    mark_subobject_initialized(dst_addr.address+k*elem_size,
-                                               complete_object);
-                  }  /* for */
+                  mark_whole_subobject_initialized(ips, dst_addr.address, ftp,
+                                                   complete_object);
                 }  /* if */
 #endif /* GNU_VECTOR_TYPES_ALLOWED */
                 elem_con = elem_con->next;
@@ -7834,6 +7857,25 @@ any subobject that is not initialized (the diagnostic is associated with pos).
         }  /* if */
       }
       break;
+#if GNU_VECTOR_TYPES_ALLOWED
+    case tk_vector:
+      { /* The elements of a vector are tracked individually: Handle each
+           element after the first (which shares the address of the vector
+           and was handled above). */
+        a_type_ptr      etp = skip_typerefs(tp->variant.vector.element_type);
+        a_targ_size_t   k, n_elems = num_vector_elements(tp);
+        a_byte_count    elem_size = value_bytes_for_type(ips, etp, &result);
+        for (k = 1; result && k<n_elems; ++k) {
+          if (subobject_is_initialized(src_bytes+k*elem_size, complete_src)) {
+            mark_subobject_initialized(dst_bytes+k*elem_size, complete_dst);
+          } else {
+            do_constexpr_fail(result);
+            info_with_pos(ec_object_not_initialized, pos, ips);
+          }  /* if */
+        }  /* for */
+      }
+      break;
+#endif /* GNU_VECTOR_TYPES_ALLOWED */
     default:
       /* Nothing more to do. */
       break;
@@ -25492,6 +25534,14 @@ conversion to an rvalue is forced externally.
   } else if (!is_initialized(cap) && !is_immediate_class_type(tp)) {
     do_constexpr_fail(result);
     info_with_pos(ec_object_not_initialized, &expr->position, ips);
+#if GNU_VECTOR_TYPES_ALLOWED
+  } else if (type_is(tp, tk_vector) &&
+             !vector_elements_are_initialized(ips, tp, cap)) {
+    /* A whole vector is read, but some of its elements are not
+       initialized. */
+    do_constexpr_fail(result);
+    info_with_pos(ec_object_not_initialized, &expr->position, ips);
+#endif /* GNU_VECTOR_TYPES_ALLOWED */
   } else if (is_variant_path(cap) &&
              !check_variant_path(ips, cap, &expr->position)) {
     /* An attempt to dereference an inactive variant path. */
@@ -33158,6 +33208,16 @@ the value representation of the integer value.
                     &expr->position, ips);
   }  /* switch */
 done:
+#if GNU_VECTOR_TYPES_ALLOWED
+  if (pop_when_done && result && type_is(tp, tk_vector) &&
+      !is_glvalue_node(expr)) {
+    /* The whole vector value has been stored, and its elements can be
+       accessed individually (e.g., by subscripting an lvalue for it), so
+       mark each of them initialized. */
+    mark_whole_subobject_initialized(ips, result_storage, tp,
+                                     complete_object);
+  }  /* if */
+#endif /* GNU_VECTOR_TYPES_ALLOWED */
   end_work_visit(ips, result, pop_when_done);
 #undef SET_result_val_from_operand_address
 #undef CHECK_int_range

src/pending_changes/gh-90-lifetime-extension-member-of-temporary.txt

@@ -1,15 +1,22 @@
 [GH #90]
 GNU and Clang C++ modes: lifetime extension through a member of a temporary
 
-When emulating GCC 9 or later or Clang 4 or later, selecting a member of a
-class prvalue now produces an xvalue (Core issue 616), as it already did in
-standard C++14 and later modes.  Binding a reference to the member now
-extends the lifetime of the whole temporary.  For example, with
---g++ --gnu_version=150000:
+When emulating GCC 9 or later or Clang 4 or later (in C++11 and later
+modes), selecting a member of a class prvalue now produces an xvalue (Core
+issue 616), as it already did in standard C++14 and later modes.  Binding a
+reference to the member now extends the lifetime of the whole temporary.
+For example, with --g++ --gnu_version=150000:
 
   struct A { int b; ~A(); };
   const int &r = A().b;  // A() was previously destroyed here.
 
+Returning a pointer into a member of a class prvalue is now diagnosed also
+when the class is trivially destructible.  For example, with --c++20:
+
+  struct T { int b; int arr[2]; };
+  T make();
+  const int *f() { return &make().arr[1]; }  // Warning.
+
 Constant evaluation also no longer treats every member of a class prvalue
 as initialized when one is selected with "." or ".*".  Since C++20, a
 constexpr constructor can leave members uninitialized, and reading such a
@@ -18,3 +25,16 @@ example, with --c++20:
 
   struct W { int n; constexpr W() {} };
   static_assert(W().n == 0);  // Error: n is uninitialized.
+
+Constant evaluation now also marks each element of a GNU vector as
+initialized when a whole vector value is stored (e.g., by a mem-initializer),
+and copies the state of each element when an object containing a vector is
+copied.  Subscripting such a vector could previously give a spurious "access
+to uninitialized object" error.  Conversely, reading or copying a whole
+vector subobject now requires each of its elements to be initialized.  For
+example, with --g++ --c++20:
+
+  typedef int V4 __attribute__((vector_size(16)));
+  struct Y { V4 v; constexpr Y(V4 a) : v(a) {} };
+  constexpr int f() { V4 a = {1, 2, 3, 4}; Y y(a); return y.v[3]; }
+  static_assert(f() == 4, "");  // Previously rejected.

tests/expectations/edg_x86_64/imported.log

@@ -6600,7 +6600,6 @@ gnu/cpp/cpp0x/constexpr-typeid/test.mft.cpp:fn:-DTEST_NUMBER=1 --c++11:FAIL:
 gnu/cpp/cpp0x/conv-tmpl1.sft.cpp:fp:-DTEST_NUMBER=1 --c++11:FAIL:
 gnu/cpp/cpp0x/conv-tmpl6.sft.cpp:fp:-DTEST_NUMBER=1 --c++11:FAIL:
 gnu/cpp/cpp0x/decltype41/test.mft.cpp:fp:-DTEST_NUMBER=1 --c++11:FAIL:
-gnu/cpp/cpp0x/decltype72.sft.cpp:fp:-DTEST_NUMBER=1 --c++11:FAIL:
 gnu/cpp/cpp0x/decltype80.sft.cpp:fn:-DTEST_NUMBER=1 --c++11:FAIL:
 gnu/cpp/cpp0x/decltype83.sft.cpp:fp:-DTEST_NUMBER=1 --c++11:ABORT:
 gnu/cpp/cpp0x/decltype83a.sft.cpp:fp:-DTEST_NUMBER=1 --c++11:ABORT:

tests/tests/cwg/.cwg616.rto/default.4.1.txt

@@ -0,0 +1 @@
+fe_only -DTEST_NUMBER=4 --c++11 --g++ --gnu_version=90000 Test_name.c

tests/tests/cwg/.cwg616.rto/default.5.1.txt

@@ -0,0 +1 @@
+fe_only -DTEST_NUMBER=5 --c++11 --clang --clang_version=40000 Test_name.c

tests/tests/cwg/cwg616.sft.cpp

@@ -1,6 +1,5 @@
 //type:fp
-//options_all:--c++14
-//options::--g++ --gnu_version=150000:--clang --clang_version=190100
+//options:--c++14:--c++14 --g++ --gnu_version=150000:--c++14 --clang --clang_version=190100:--c++11 --g++ --gnu_version=90000:--c++11 --clang --clang_version=40000
 template <class T> struct is_xvalue { static const bool value = false; };
 template <class T> struct is_xvalue<T &&> { static const bool value = true; };
 struct A { int b; };