* Emit diagnostics when validation fails: null pointer, one-past-the-end,

out-of-bounds access.
* Enhance test suite to cover more scenarios
* Return true when Size is zero.

Author: chaitanyav

clang/lib/AST/ByteCode/InterpBuiltin.cpp

@@ -2222,12 +2222,22 @@ static bool interp__builtin_assume_dereferenceable(InterpState &S, CodePtr OpPC,
   assert(Call->getNumArgs() == 2);
 
   APSInt ReqSize = popToAPSInt(S.Stk, *S.Ctx.classify(Call->getArg(1)));
-  if (ReqSize.getZExtValue() < 1)
-    return false;
-
   const Pointer &Ptr = S.Stk.pop<Pointer>();
-  if (Ptr.isZero() || !Ptr.isLive() || !Ptr.isBlockPointer() || Ptr.isPastEnd())
+
+  if (ReqSize.isZero())
+    return true;
+  if (Ptr.isZero()) {
+    S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_null)
+        << AK_Read << S.Current->getRange(OpPC);
     return false;
+  }
+  if (!Ptr.isLive() || !Ptr.isBlockPointer())
+    return false;
+  if (Ptr.isPastEnd()) {
+    S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_past_end)
+        << AK_Read << S.Current->getRange(OpPC);
+    return false;
+  }
 
   const ASTContext &ASTCtx = S.getASTContext();
   const Descriptor *DeclDesc = Ptr.getDeclDesc();
@@ -2239,9 +2249,12 @@ static bool interp__builtin_assume_dereferenceable(InterpState &S, CodePtr OpPC,
   if (ByteOffset > *FullSize)
     return false;
 
-  unsigned RemainingSpace = *FullSize - ByteOffset;
-  if (RemainingSpace < ReqSize.getZExtValue())
+  unsigned AvailSize = *FullSize - ByteOffset;
+  if (AvailSize < ReqSize.getZExtValue()) {
+    S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_past_end)
+        << AK_Read << S.Current->getRange(OpPC);
     return false;
+  }
 
   return true;
 }

clang/lib/AST/ExprConstant.cpp

@@ -19697,24 +19697,32 @@ class VoidExprEvaluator
       APSInt ReqSizeVal;
       if (!::EvaluateInteger(E->getArg(1), ReqSizeVal, Info))
         return false;
+      if (ReqSizeVal.isZero())
+        return true;
+
       LValue Pointer;
       if (!EvaluatePointer(E->getArg(0), Pointer, Info))
         return false;
       if (Pointer.Designator.Invalid)
         return false;
-      if (Pointer.isNullPointer())
+      if (Pointer.isNullPointer()) {
+        Info.FFDiag(E, diag::note_constexpr_access_null) << AK_Read;
+        return false;
+      }
+      if (Pointer.Designator.isOnePastTheEnd()) {
+        Info.FFDiag(E, diag::note_constexpr_access_past_end) << AK_Read;
         return false;
+      }
 
       uint64_t ReqSize = ReqSizeVal.getZExtValue();
-      if (ReqSize < 1)
-        return false;
       CharUnits EndOffset;
       if (!determineEndOffset(Info, E->getExprLoc(), 0, Pointer, EndOffset))
         return false;
 
-      uint64_t TotalSize =
+      uint64_t AvailSize =
           (EndOffset - Pointer.getLValueOffset()).getQuantity();
-      if (TotalSize < ReqSize) {
+      if (AvailSize < ReqSize) {
+        Info.FFDiag(E, diag::note_constexpr_access_past_end) << AK_Read;
         return false;
       }
       return true;

clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp

@@ -1,64 +1,92 @@
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -triple x86_64-unknown-unknown %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -triple x86_64-unknown-unknown %s -fexperimental-new-constant-interpreter
 
-constexpr int arr[10] = {};
-
 constexpr bool test_constexpr_valid() {
+  constexpr int arr[10] = {};
   __builtin_assume_dereferenceable(arr, 40);
   return true;
 }
 static_assert(test_constexpr_valid(), "");
 
 constexpr bool test_constexpr_partial() {
+  constexpr int arr[10] = {};
   __builtin_assume_dereferenceable(&arr[5], 20);
   return true;
 }
 static_assert(test_constexpr_partial(), "");
 
-constexpr bool test_constexpr_nullptr() {
-  __builtin_assume_dereferenceable(nullptr, 4);
+constexpr bool test_constexpr_nullptr() { // expected-error {{constexpr function never produces a constant expression}}
+  __builtin_assume_dereferenceable(nullptr, 4); // expected-note 2{{read of dereferenced null pointer is not allowed in a constant expression}}
   return true;
 }
-static_assert(test_constexpr_nullptr(), ""); // expected-error {{not an integral constant expression}}
+static_assert(test_constexpr_nullptr(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}}
 
-constexpr bool test_constexpr_too_large() {
-  __builtin_assume_dereferenceable(arr, 100);
+constexpr bool test_constexpr_too_large() { // expected-error {{constexpr function never produces a constant expression}}
+  constexpr int arr[10] = {};
+  __builtin_assume_dereferenceable(arr, 100); // expected-note 2{{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}}
   return true;
 }
-static_assert(test_constexpr_too_large(), ""); // expected-error {{not an integral constant expression}}
+static_assert(test_constexpr_too_large(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}}
 
-constexpr int single_var = 42;
 constexpr bool test_single_var() {
+  constexpr int single_var = 42;
   __builtin_assume_dereferenceable(&single_var, 4);
   return true;
 }
 static_assert(test_single_var(), "");
 
 constexpr bool test_exact_boundary() {
+  constexpr int arr[10] = {};
   __builtin_assume_dereferenceable(&arr[9], 4);
   return true;
 }
 static_assert(test_exact_boundary(), "");
 
-constexpr bool test_one_over() {
-  __builtin_assume_dereferenceable(&arr[9], 5);
+constexpr bool test_one_over() { // expected-error {{constexpr function never produces a constant expression}}
+  constexpr int arr[10] = {};
+  __builtin_assume_dereferenceable(&arr[9], 5); // expected-note 2{{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}}
   return true;
 }
-static_assert(test_one_over(), ""); // expected-error {{not an integral constant expression}}
+static_assert(test_one_over(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}}
 
 constexpr bool test_zero_size() {
+  constexpr int arr[10] = {};
   __builtin_assume_dereferenceable(arr, 0);
   return true;
 }
-static_assert(test_zero_size(), ""); // expected-error {{not an integral constant expression}}
+static_assert(test_zero_size(), "");
 
-struct S {
-  int x;
-  int y;
-};
-constexpr S s = {1, 2};
 constexpr bool test_struct_member() {
+  struct S {
+    int x;
+    int y;
+  };
+  constexpr S s = {1, 2};
   __builtin_assume_dereferenceable(&s.x, 4);
   return true;
 }
 static_assert(test_struct_member(), "");
+
+constexpr bool test_range_valid() {
+  constexpr int range_data[5] = {1, 2, 3, 4, 5};
+  __builtin_assume_dereferenceable(range_data, 5 * sizeof(int));
+  return range_data[0] == 1;
+}
+static_assert(test_range_valid(), "");
+
+constexpr bool test_range_invalid() { // expected-error {{constexpr function never produces a constant expression}}
+  constexpr int range_data[5] = {1, 2, 3, 4, 5};
+  __builtin_assume_dereferenceable(range_data, 6 * sizeof(int)); // expected-note 2{{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}}
+  return true;
+}
+static_assert(test_range_invalid(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}}
+
+constexpr int arr1[10] = {};
+constexpr int valid = (__builtin_assume_dereferenceable(arr1, 40), 12);
+
+constexpr int invalid = (__builtin_assume_dereferenceable((int*)123, 4), 12); // expected-error {{constexpr variable 'invalid' must be initialized by a constant expression}} expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
+
+constexpr int arr2[5] = {1, 2, 3, 4, 5};
+constexpr int too_large = (__builtin_assume_dereferenceable(arr2, 6 * sizeof(int)), 12); // expected-error {{constexpr variable 'too_large' must be initialized by a constant expression}} expected-note {{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}}
+
+constexpr int null = (__builtin_assume_dereferenceable(nullptr, 4), 12); // expected-error {{constexpr variable 'null' must be initialized by a constant expression}} expected-note {{read of dereferenced null pointer is not allowed in a constant expression}}