[clang][Interp] Check declarations for constexpr-ness in Load() instructions

[tbaeder]

Summary

Refering to non-constexpr variables in a constant expression is (apparently) just fine, and only problematic once we load a value.

[tbaeder]

This is wrong if the (constant) initializer is for a legitimate non-constexpr variable declaration. We do a load in visitDecl().

[shafik]

clang/lib/AST/Interp/Interp.cpp

101

Is CheckConstexpr descriptive enough? Would something like CheckLoadIsValid be better?

110

Is this sufficient? How about something like this:

int *p;

int constexpr f(int &x) {
    *p=1;
    return 10;
}

Maybe I am not understanding. I think more test case would be useful.

clang/lib/AST/Interp/Interp.cpp

 
 static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) {
   if (!S.Stk.pop<bool>()) {
     PC += Offset;
   }
   return true;
 }
 
+static bool CheckConstexpr(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
+  if (!S.inConstantContext())
+    return true;
+
+  auto *VD = Ptr.getDeclDesc()->asValueDecl();
+  if (!VD)
+    return true;
+
+  if (auto *VarD = dyn_cast<VarDecl>(VD)) {
+    if (VarD->hasLocalStorage() || VarD->isConstexpr())
+      return true;
+  }
+
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
+  S.Note(VD->getLocation(), diag::note_declared_at);
+
+  return false;
+}
+
 static bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
                              AccessKinds AK) {
   if (Ptr.isInitialized())
     return true;
   if (!S.checkingPotentialConstantExpression()) {
     const SourceInfo &Loc = S.Current->getSource(OpPC);
     S.FFDiag(Loc, diag::note_constexpr_access_uninit) << AK << false;
   }
bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
   return false;
 }
 
 bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
   if (!CheckLive(S, OpPC, Ptr, AK_Read))
     return false;
   if (!CheckExtern(S, OpPC, Ptr))
     return false;
+  if (!CheckConstexpr(S, OpPC, Ptr))
+    return false;
   if (!CheckRange(S, OpPC, Ptr, AK_Read))
     return false;
   if (!CheckInitialized(S, OpPC, Ptr, AK_Read))
     return false;
   if (!CheckActive(S, OpPC, Ptr, AK_Read))
     return false;
   if (!CheckTemporary(S, OpPC, Ptr, AK_Read))
     return false;

clang/test/AST/Interp/records.cpp

struct Ints {
 
   constexpr int getTen() const {
     return 10;
   }
 };
 
 static_assert(Ints::getFive() == 5, "");
 
+// Read of a non-constexpr variable in a constant expression.
+BoolPair nonConstBP; // ref-note {{declared here}} \
+                     // expected-note {{declared here}}
+constexpr BoolPair *constBP = &nonConstBP;
+static_assert(constBP->first, ""); // ref-error {{not an integral constant expression}} \
+                                   // ref-note {{read of non-constexpr variable}} \
+                                   // expected-error {{not an integral constant expression}} \
+                                   // expected-note {{read of non-constexpr variable}}
+
 constexpr Ints ints;
 static_assert(ints.a == 20, "");
 static_assert(ints.b == 30, "");
 static_assert(ints.c, "");
 static_assert(ints.getTen() == 10, "");
 static_assert(ints.numbers[0] == 1, "");
 static_assert(ints.numbers[1] == 2, "");
 static_assert(ints.numbers[2] == 3, "");