[clang][Interp] Fix initializing base class members

[tbaeder]

Summary

For the given test case, we were trying to initialize a member of C,
which doesn't have any. Get the proper base pointer instead and
initialize the members there.

[tbaeder]

Ping

[aaron.ballman]

clang/test/AST/Interp/records.cpp

258

We should test that the initialization actually happened.

260

Another test would be for invalid base initialization, like:

struct Base {
  int a;
};

struct Intermediate : Base {
  int b;
};

struct Final : Intermediate {
  int c;

  constexpr Final(int a, int b, int c) : c(c) {}
};

static_assert(Final{1, 2, 3}.c == 3, ""); // OK
static_assert(Final{1, 2, 3}.a == 0, ""); // Error, reads uninitialized member

or with multiple bases:

struct Base {
  int a;
};

struct Mixin  {
  int b;

  constexpr Mixin() = default;
  constexpr Mixin(int b) : b(b) {}
};

struct Final : Base, Mixin {
  int c;

  constexpr Final(int a, int b, int c) : Mixin(b), c(c) {}
  constexpr Final(int a, int b, int c, bool) : c(c) {}
};

static_assert(Final{1, 2, 3}.c == 3, ""); // OK
static_assert(Final{1, 2, 3}.b == 2, ""); // OK
static_assert(Final{1, 2, 3}.a == 0, ""); // Error, reads uninitialized member

or in a different form:

struct Base {
  int a;
};

struct Mixin  {
  int b;
};

struct Final : Base, Mixin {
  int c;

  constexpr Final(int a, int b, int c) : c(c) { this->b = b; }
  constexpr Final(int a, int b, int c, bool) : c(c) {}
};

static_assert(Final{1, 2, 3}.c == 3, ""); // OK
static_assert(Final{1, 2, 3}.b == 2, ""); // OK
static_assert(Final{1, 2, 3}.a == 0, ""); // Error, reads uninitialized member

[tbaeder]

The tests you proposed need https://reviews.llvm.org/D143480 first so we can cast up more than one level.

[aaron.ballman]

In D143466#4181191, @tbaeder wrote:

The tests you proposed need https://reviews.llvm.org/D143480 first so we can cast up more than one level.

Okay, how about we land that one first then come back to this one? I left some comments on the other review.

[tbaeder]

clang/test/AST/Interp/records.cpp

271

These lines are added by https://reviews.llvm.org/D143480 now, but the tests are left commented since they require this patch as well.

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (const auto CtorExpr = dyn_cast<CXXConstructExpr>(Initializer)) {
     }
 
     return this->emitCall(Func, Initializer);
   } else if (const auto *InitList = dyn_cast<InitListExpr>(Initializer)) {
     const Record *R = getRecord(InitList->getType());
 
     unsigned InitIndex = 0;
     for (const Expr *Init : InitList->inits()) {
-      const Record::Field *FieldToInit = R->getField(InitIndex);
 
       if (!this->emitDupPtr(Initializer))
         return false;
 
       if (std::optional<PrimType> T = classify(Init)) {
+        const Record::Field *FieldToInit = R->getField(InitIndex);
         if (!this->visit(Init))
           return false;
 
         if (!this->emitInitField(*T, FieldToInit->Offset, Initializer))
           return false;
 
         if (!this->emitPopPtr(Initializer))
           return false;
       } else {
+        // Initializer for a direct base class.
+        if (const Record::Base *B = R->getBase(Init->getType())) {
+          if (!this->emitGetPtrBasePop(B->Offset, Init))
+            return false;
+
+          if (!this->visitInitializer(Init))
+            return false;
+
+          if (!this->emitPopPtr(Initializer))
+            return false;
+        } else {
+          const Record::Field *FieldToInit = R->getField(InitIndex);
           // Non-primitive case. Get a pointer to the field-to-initialize
           // on the stack and recurse into visitInitializer().
           if (!this->emitGetPtrField(FieldToInit->Offset, Init))
             return false;
 
           if (!this->visitInitializer(Init))
             return false;
 
           if (!this->emitPopPtr(Initializer))
             return false;
         }
+      }
       ++InitIndex;
     }
 
     return true;
   } else if (const CallExpr *CE = dyn_cast<CallExpr>(Initializer)) {
     // RVO functions expect a pointer to initialize on the stack.
     // Dup our existing pointer so it has its own copy to use.
     if (!this->emitDupPtr(Initializer))

clang/lib/AST/Interp/Interp.cpp

if (FieldType->isRecordType()) {
       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);
+    Pointer P = BasePtr.atField(B.Offset);
     Result &= CheckFieldsInitialized(S, OpPC, P, B.R);
   }
 
   // TODO: Virtual bases
 
   return Result;
 }
 

clang/lib/AST/Interp/Record.h

public:
   /// Returns the size of the record.
   unsigned getSize() const { return BaseSize; }
   /// Returns the full size of the record, including records.
   unsigned getFullSize() const { return BaseSize + VirtualSize; }
   /// Returns a field.
   const Field *getField(const FieldDecl *FD) const;
   /// Returns a base descriptor.
   const Base *getBase(const RecordDecl *FD) const;
+  /// Returns a base descriptor.
+  const Base *getBase(QualType T) const;
   /// Returns a virtual base descriptor.
   const Base *getVirtualBase(const RecordDecl *RD) const;
   // Returns the destructor of the record, if any.
   const CXXDestructorDecl *getDestructor() const {
     if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(Decl))
       return CXXDecl->getDestructor();
     return nullptr;
   }

clang/lib/AST/Interp/Record.cpp

 }
 
 const Record::Base *Record::getBase(const RecordDecl *FD) const {
   auto It = BaseMap.find(FD);
   assert(It != BaseMap.end() && "Missing base");
   return It->second;
 }
 
+const Record::Base *Record::getBase(QualType T) const {
+  if (!T->isRecordType())
+    return nullptr;
+
+  const RecordDecl *RD = T->getAs<RecordType>()->getDecl();
+  if (auto It = BaseMap.find(RD); It != BaseMap.end())
+    return It->second;
+  return nullptr;
+}
+
 const Record::Base *Record::getVirtualBase(const RecordDecl *FD) const {
   auto It = VirtualBaseMap.find(FD);
   assert(It != VirtualBaseMap.end() && "Missing virtual base");
   return It->second;
 }

clang/test/AST/Interp/cxx20.cpp

constexpr ctor_test<false> bad_ctor; // expected-error {{must be initialized by a constant expression}} \
                                        // ref-error {{must be initialized by a constant expression}} \
                                        // ref-note {{in call to}}
   constexpr dtor_test<false> bad_dtor; // expected-error {{must have constant destruction}} \
                                        // expected-note {{in call to}} \
                                        // ref-error {{must have constant destruction}} \
                                        // ref-note {{in call to}}
 };
 
+namespace BaseInit {
+  struct Base {
+    int a;
+  };
+
+  struct Intermediate : Base {
+    int b;
+  };
+
+  struct Final : Intermediate {
+    int c;
+
+    constexpr Final(int a, int b, int c) : c(c) {}
+  };
+
+  static_assert(Final{1, 2, 3}.c == 3, ""); // OK
+  static_assert(Final{1, 2, 3}.a == 0, ""); // expected-error {{not an integral constant expression}} \
+                                            // expected-note {{read of object outside its lifetime}} \
+                                            // ref-error {{not an integral constant expression}} \
+                                            // ref-note {{read of uninitialized object}}
+
+
+  struct Mixin  {
+    int b;
+
+    constexpr Mixin() = default;
+    constexpr Mixin(int b) : b(b) {}
+  };
+
+  struct Final2 : Base, Mixin {
+    int c;
+
+    constexpr Final2(int a, int b, int c) : Mixin(b), c(c) {}
+    constexpr Final2(int a, int b, int c, bool) : c(c) {}
+  };
+
+  static_assert(Final2{1, 2, 3}.c == 3, ""); // OK
+  static_assert(Final2{1, 2, 3}.b == 2, ""); // OK
+  static_assert(Final2{1, 2, 3}.a == 0, ""); // expected-error {{not an integral constant expression}} \
+                                             // expected-note {{read of object outside its lifetime}} \
+                                             // ref-error {{not an integral constant expression}} \
+                                             // ref-note {{read of uninitialized object}}
+
+
+  struct Mixin3  {
+    int b;
+  };
+
+  struct Final3 : Base, Mixin3 {
+    int c;
+
+    constexpr Final3(int a, int b, int c) : c(c) { this->b = b; }
+    constexpr Final3(int a, int b, int c, bool) : c(c) {}
+  };
+
+  static_assert(Final3{1, 2, 3}.c == 3, ""); // OK
+  static_assert(Final3{1, 2, 3}.b == 2, ""); // OK
+  static_assert(Final3{1, 2, 3}.a == 0, ""); // expected-error {{not an integral constant expression}} \
+                                             // expected-note {{read of object outside its lifetime}} \
+                                             // ref-error {{not an integral constant expression}} \
+                                             // ref-note {{read of uninitialized object}}
+};
+
 namespace Destructors {
 
   class Inc final {
   public:
     int &I;
     constexpr Inc(int &I) : I(I) {}
     constexpr ~Inc() {
       I++;

clang/test/AST/Interp/records.cpp

constexpr int m() const {
     return 1;
   }
 };
 constexpr S s;
 static_assert(s.m() == 1, "");
 
 #if __cplusplus >= 201703L
 namespace BaseInit {
+  class _A {public: int a;};
+  class _B : public _A {};
+  class _C : public _B {};
+
+  constexpr _C c{12};
+  constexpr const _B &b = c;
+  static_assert(b.a == 12);
+
   class A {public: int a;};
   class B : public A {};
   class C : public A {};
   class D : public B, public C {};
 
-  // FIXME: Enable this once we support the initialization.
   // This initializes D::B::A::a and not D::C::A::a.
-  //constexpr D d{12};
-  //static_assert(d.B::a == 12);
-  //static_assert(d.C::a == 0);
+  constexpr D d{12};
+  static_assert(d.B::a == 12);
+  static_assert(d.C::a == 0);
 };
 #endif
 
 namespace MI {
   class A {
   public:
     int a;
     constexpr A(int a) : a(a) {}