[clang][Interp] Only check constructors for global variables

[tbaeder]

Summary

This is a follow-up to https://reviews.llvm.org/D136694. I can also merge the two patches.

I couldn't come up with a better way of doing this than adding a new opcode which is only emitted from visitGlobalInitializer().

[tbaeder]

Ping

[tbaeder]

Ping

[shafik]

So we are only checking global constructors b/c it is valid in a constant expression context to initialize a record and not initialize all their fields as long as we don't use any of those fields.

Note, cases that stem from this has been discussed as part of https://github.com/cplusplus/papers/issues/1380 but the issue is not resolved yet.

[shafik]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.h

protected:
   /// Visits an initializer for a global.
   bool visitGlobalInitializer(const Expr *Init, unsigned I) {
     if (!this->emitGetPtrGlobal(I, Init))
       return false;
 
     if (!visitInitializer(Init))
       return false;
 
+    if (Init->getType()->isRecordType() && !this->emitCheckGlobalCtor(Init))
+      return false;
+
     return this->emitPopPtr(Init);
   }
 
   /// Visits a delegated initializer.
   bool visitThisInitializer(const Expr *I) {
     if (!this->emitThis(I))
       return false;
 

clang/lib/AST/Interp/Interp.h

 }
 
 inline bool ExpandPtr(InterpState &S, CodePtr OpPC) {
   const Pointer &Ptr = S.Stk.pop<Pointer>();
   S.Stk.push<Pointer>(Ptr.expand());
   return true;
 }
 
+inline bool CheckGlobalCtor(InterpState &S, CodePtr &PC) {
+  const Pointer &Obj = S.Stk.peek<Pointer>();
+  return CheckCtorCall(S, PC, Obj);
+}
+
 inline bool Call(InterpState &S, CodePtr &PC, const Function *Func) {
   auto NewFrame = std::make_unique<InterpFrame>(S, Func, PC);
   Pointer ThisPtr;
   if (Func->hasThisPointer()) {
     ThisPtr = NewFrame->getThis();
     if (!CheckInvoke(S, PC, ThisPtr))
       return false;
 
inline bool Call(InterpState &S, CodePtr &PC, const Function *Func) {
 
   APValue CallResult;
   // Note that we cannot assert(CallResult.hasValue()) here since
   // Ret() above only sets the APValue if the curent frame doesn't
   // have a caller set.
   if (Interpret(S, CallResult)) {
     NewFrame.release(); // Frame was delete'd already.
     assert(S.Current == FrameBefore);
-
-    // For constructors, check that all fields have been initialized.
-    if (Func->isConstructor() && !CheckCtorCall(S, PC, ThisPtr))
-      return false;
-
     return true;
   }
 
   // Interpreting the function failed somehow. Reset to
   // previous state.
   S.Current = FrameBefore;
   return false;
 }

clang/lib/AST/Interp/Interp.cpp

if (FieldType->isRecordType()) {
           cast<ConstantArrayType>(FieldType->getAsArrayTypeUnsafe());
       Result &= CheckArrayInitialized(S, OpPC, FieldPtr, CAT);
     } else if (!FieldPtr.isInitialized()) {
       DiagnoseUninitializedSubobject(S, S.Current->getSource(OpPC),
                                      F.Decl->getType(), F.Decl->getLocation());
       Result = false;
     }
   }
+
+  // Check Fields in all bases
+  for (const Record::Base &B : R->bases()) {
+    Pointer P = Pointer(BasePtr.block(), B.Offset);
+    Result &= CheckFieldsInitialized(S, OpPC, P, B.R);
+  }
+
+  // TODO: Virtual bases
+
   return Result;
 }
 
 bool CheckCtorCall(InterpState &S, CodePtr OpPC, const Pointer &This) {
   assert(!This.isZero());
   const Record *R = This.getRecord();
   return CheckFieldsInitialized(S, OpPC, This, R);
 }

clang/lib/AST/Interp/Opcodes.td

class BitFieldOpcode : Opcode {
   let HasGroup = 1;
 }
 
 // [] -> [Pointer]
 def GetLocal : AccessOpcode { let HasCustomEval = 1; }
 // [] -> [Pointer]
 def SetLocal : AccessOpcode { let HasCustomEval = 1; }
 
+def CheckGlobalCtor : Opcode {}
+
 // [] -> [Value]
 def GetGlobal : AccessOpcode;
 // [Value] -> []
 def InitGlobal : AccessOpcode;
 // [Value] -> []
 def InitGlobalTemp : AccessOpcode {
   let Args = [ArgUint32, ArgLETD];
 }

clang/test/AST/Interp/cxx20.cpp

return *a; // expected-note {{read of object outside its lifetime}} \
              // ref-note {{read of uninitialized object is not allowed in a constant expression}}
 }
 static_assert(initializedLocal2() == 20); // expected-error {{not an integral constant expression}} \
                                           // expected-note {{in call to}} \
                                           // ref-error {{not an integral constant expression}} \
                                           // ref-note {{in call to}}
 
 
-struct Int { int a; }; // expected-note {{subobject declared here}}
+struct Int { int a; };
 constexpr int initializedLocal3() {
-  Int i; // expected-note {{subobject of type 'int' is not initialized}}
-  return i.a; // ref-note {{read of uninitialized object is not allowed in a constant expression}}
+  Int i;
+  return i.a; // ref-note {{read of uninitialized object is not allowed in a constant expression}} \
+              // expected-note {{read of object outside its lifetime}}
 }
 static_assert(initializedLocal3() == 20); // expected-error {{not an integral constant expression}} \
                                           // expected-note {{in call to}} \
                                           // ref-error {{not an integral constant expression}} \
                                           // ref-note {{in call to}}
 
 
 
public:
     bool b;
     int a; // expected-note {{subobject declared here}} \
            // ref-note {{subobject declared here}}
     constexpr Base() : b(true) {}
   };
 
   class Derived : public Base {
   public:
-    constexpr Derived() : Base() {} // expected-note {{subobject of type 'int' is not initialized}}
-  };
+    constexpr Derived() : Base() {}   };
 
-constexpr Derived D; // expected-error {{must be initialized by a constant expression}} \\
-                     // expected-note {{in call to 'Derived()'}} \
+  constexpr Derived D; // expected-error {{must be initialized by a constant expression}} \
+                       // expected-note {{subobject of type 'int' is not initialized}} \
                        // ref-error {{must be initialized by a constant expression}} \
                        // ref-note {{subobject of type 'int' is not initialized}}
 
   class C2 {
   public:
     A a;
-    constexpr C2() {} // expected-note {{subobject of type 'int' is not initialized}}
-  };
+    constexpr C2() {}   };
   constexpr C2 c2; // expected-error {{must be initialized by a constant expression}} \
-                   // expected-note {{in call to 'C2()'}} \
+                   // expected-note {{subobject of type 'int' is not initialized}} \
                    // ref-error {{must be initialized by a constant expression}} \
                    // ref-note {{subobject of type 'int' is not initialized}}
 
 
   // FIXME: These two are currently disabled because the array fields
   //   cannot be initialized.
 #if 0
   class C3 {