[clang][Interp] Start supporting virtual base classes

[tbaeder]

Summary

As discussed on IRC. This is just the bare minimum to support virtual base classes.

[shafik]

clang/lib/AST/Interp/Descriptor.cpp

126

To recurse or not seems to be a property of whether the base is virtual or not.

Maybe a enum w/ Base and Virtual base would be better and then the logic of whether to recurse can be kept local to the lambda,

147

clang/lib/AST/Interp/ByteCodeExprGen.cpp

case CK_DerivedToBase: {
     if (!this->visit(SubExpr))
       return false;
 
     const CXXRecordDecl *FromDecl = getRecordDecl(SubExpr);
     assert(FromDecl);
     const CXXRecordDecl *ToDecl = getRecordDecl(CE);
     assert(ToDecl);
     const Record *R = getRecord(FromDecl);
-    const Record::Base *ToBase = R->getBase(ToDecl);
-    assert(ToBase);
+    const Record::Base *ToBase;
+    if (FromDecl->isVirtuallyDerivedFrom(ToDecl))
+      ToBase = R->getVirtualBase(ToDecl);
+    else
+      ToBase = R->getBase(ToDecl);
 
+    assert(ToBase);
     return this->emitGetPtrBase(ToBase->Offset, CE);
   }
 
   case CK_FloatingCast: {
     if (!this->visit(SubExpr))
       return false;
     const auto *TargetSemantics =
         &Ctx.getASTContext().getFloatTypeSemantics(CE->getType());
bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *E) {
   if (!this->visit(Base))
     return false;
 
   // Base above gives us a pointer on the stack.
   // TODO: Implement non-FieldDecl members.
   if (const auto *FD = dyn_cast<FieldDecl>(Member)) {
     const RecordDecl *RD = FD->getParent();
     const Record *R = getRecord(RD);
+    assert(R);
     const Record::Field *F = R->getField(FD);
+    assert(F);
     // Leave a pointer to the field on the stack.
     if (F->Decl->getType()->isReferenceType())
       return this->emitGetFieldPop(PT_Ptr, F->Offset, E);
     return this->emitGetPtrField(F->Offset, E);
   }
 
   return false;
 }

clang/lib/AST/Interp/Descriptor.cpp

for (unsigned I = 0; I < NumElems; ++I, ElemOffset += ElemSize) {
     if (auto Fn = D->ElemDesc->MoveFn)
       Fn(B, SrcElemLoc, DstElemLoc, D->ElemDesc);
   }
 }
 
 static void ctorRecord(Block *B, char *Ptr, bool IsConst, bool IsMutable,
                        bool IsActive, Descriptor *D) {
   const bool IsUnion = D->ElemRecord->isUnion();
-  auto CtorSub = [=](unsigned SubOff, Descriptor *F, bool IsBase) {
+  auto CtorSub = [=](unsigned SubOff, Descriptor *F, bool IsBase,
+                     bool Recurse = true) {
     auto *Desc = reinterpret_cast<InlineDescriptor *>(Ptr + SubOff) - 1;
     Desc->Offset = SubOff;
     Desc->Desc = F;
     Desc->IsInitialized = F->IsArray && !IsBase;
     Desc->IsBase = IsBase;
     Desc->IsActive = IsActive && !IsUnion;
     Desc->IsConst = IsConst || F->IsConst;
     Desc->IsMutable = IsMutable || F->IsMutable;
+
+    if (!Recurse)
+      return;
+
     if (auto Fn = F->CtorFn)
       Fn(B, Ptr + SubOff, Desc->IsConst, Desc->IsMutable, Desc->IsActive, F);
   };
   for (const auto &B : D->ElemRecord->bases())
     CtorSub(B.Offset, B.Desc, /*isBase=*/true);
   for (const auto &F : D->ElemRecord->fields())
     CtorSub(F.Offset, F.Desc, /*isBase=*/false);
   for (const auto &V : D->ElemRecord->virtual_bases())
-    CtorSub(V.Offset, V.Desc, /*isBase=*/true);
+    CtorSub(V.Offset, V.Desc, /*isBase=*/true, false);
 }
 
 static void dtorRecord(Block *B, char *Ptr, Descriptor *D) {
   auto DtorSub = [=](unsigned SubOff, Descriptor *F) {
     if (auto Fn = F->DtorFn)
       Fn(B, Ptr + SubOff, F);
   };
   for (const auto &F : D->ElemRecord->bases())

clang/test/AST/Interp/records.cpp

struct YetAnotherDerived : YetAnotherBase {
     constexpr bool doit() const { return Val == OtherVal; }
   };
 
   constexpr YetAnotherDerived Oops(0); // ref-error {{must be initialized by a constant expression}} \
                                        // ref-note {{constructor inherited from base class 'YetAnotherBase' cannot be used in a constant expression}} \
                                        // expected-error {{must be initialized by a constant expression}}
                                        // FIXME: Missing reason for rejection.
 };
+
+namespace VirtBases {
+  struct VB {
+    int a;
+  };
+
+  struct S : virtual VB {}; // ref-note {{struct with virtual base class is not a literal type}} \
+                            // expected-note {{struct with virtual base class is not a literal type}} \
+                            // ref-note {{virtual base class declared here}} \
+                            // expected-note {{virtual base class declared here}}
+
+
+  constexpr S s; // ref-error {{cannot have non-literal type 'const S'}} \
+                 // expected-error {{cannot have non-literal type 'const S'}}
+
+  S s2;
+  constexpr VB *v = &s2;
+//  static_assert(v->a); FIXME: Loading from s should error out, since
+//                              it's not a constant expression.
+
+};