[clang][Interp] Calculate APValue offsets for base classes

Author: tbaederr

clang/lib/AST/Interp/Descriptor.cpp

@@ -162,7 +162,8 @@ static void initField(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
 }
 
 static void initBase(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
-                     bool IsActive, const Descriptor *D, unsigned FieldOffset) {
+                     bool IsActive, const Descriptor *D, unsigned FieldOffset,
+                     bool IsVirtualBase) {
   assert(D);
   assert(D->ElemRecord);
 
@@ -172,13 +173,14 @@ static void initBase(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
   Desc->Desc = D;
   Desc->IsInitialized = D->IsArray;
   Desc->IsBase = true;
+  Desc->IsVirtualBase = IsVirtualBase;
   Desc->IsActive = IsActive && !IsUnion;
   Desc->IsConst = IsConst || D->IsConst;
   Desc->IsFieldMutable = IsMutable || D->IsMutable;
 
   for (const auto &V : D->ElemRecord->bases())
     initBase(B, Ptr + FieldOffset, IsConst, IsMutable, IsActive, V.Desc,
-             V.Offset);
+             V.Offset, false);
   for (const auto &F : D->ElemRecord->fields())
     initField(B, Ptr + FieldOffset, IsConst, IsMutable, IsActive, IsUnion,
               F.Desc, F.Offset);
@@ -187,11 +189,11 @@ static void initBase(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
 static void ctorRecord(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable,
                        bool IsActive, const Descriptor *D) {
   for (const auto &V : D->ElemRecord->bases())
-    initBase(B, Ptr, IsConst, IsMutable, IsActive, V.Desc, V.Offset);
+    initBase(B, Ptr, IsConst, IsMutable, IsActive, V.Desc, V.Offset, false);
   for (const auto &F : D->ElemRecord->fields())
     initField(B, Ptr, IsConst, IsMutable, IsActive, D->ElemRecord->isUnion(), F.Desc, F.Offset);
   for (const auto &V : D->ElemRecord->virtual_bases())
-    initBase(B, Ptr, IsConst, IsMutable, IsActive, V.Desc, V.Offset);
+    initBase(B, Ptr, IsConst, IsMutable, IsActive, V.Desc, V.Offset, true);
 }
 
 static void destroyField(Block *B, std::byte *Ptr, const Descriptor *D,

clang/lib/AST/Interp/Descriptor.h

@@ -83,6 +83,8 @@ struct InlineDescriptor {
   /// Flag indicating if the field is an embedded base class.
   LLVM_PREFERRED_TYPE(bool)
   unsigned IsBase : 1;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned IsVirtualBase : 1;
   /// Flag indicating if the field is the active member of a union.
   LLVM_PREFERRED_TYPE(bool)
   unsigned IsActive : 1;

clang/lib/AST/Interp/Pointer.cpp

@@ -180,18 +180,30 @@ APValue Pointer::toAPValue(const ASTContext &ASTCtx) const {
       Path.push_back(APValue::LValuePathEntry::ArrayIndex(Index));
       Ptr = Ptr.getArray();
     } else {
-      // TODO: figure out if base is virtual
       bool IsVirtual = false;
 
       // Create a path entry for the field.
       const Descriptor *Desc = Ptr.getFieldDesc();
       if (const auto *BaseOrMember = Desc->asDecl()) {
-        Path.push_back(APValue::LValuePathEntry({BaseOrMember, IsVirtual}));
-        Ptr = Ptr.getBase();
-
-        if (const auto *FD = dyn_cast<FieldDecl>(BaseOrMember))
+        if (const auto *FD = dyn_cast<FieldDecl>(BaseOrMember)) {
+          Ptr = Ptr.getBase();
           Offset += getFieldOffset(FD);
+        } else if (const auto *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
+          IsVirtual = Ptr.isVirtualBaseClass();
+          Ptr = Ptr.getBase();
+          const Record *BaseRecord = Ptr.getRecord();
+
+          const ASTRecordLayout &Layout = ASTCtx.getASTRecordLayout(
+              cast<CXXRecordDecl>(BaseRecord->getDecl()));
+          if (IsVirtual)
+            Offset += Layout.getVBaseClassOffset(RD);
+          else
+            Offset += Layout.getBaseClassOffset(RD);
 
+        } else {
+          Ptr = Ptr.getBase();
+        }
+        Path.push_back(APValue::LValuePathEntry({BaseOrMember, IsVirtual}));
         continue;
       }
       llvm_unreachable("Invalid field type");

clang/lib/AST/Interp/Pointer.h

@@ -487,6 +487,9 @@ class Pointer {
   }
   /// Checks if a structure is a base class.
   bool isBaseClass() const { return isField() && getInlineDesc()->IsBase; }
+  bool isVirtualBaseClass() const {
+    return isField() && getInlineDesc()->IsVirtualBase;
+  }
   /// Checks if the pointer points to a dummy value.
   bool isDummy() const {
     if (!isBlockPointer())

clang/test/AST/Interp/codegen.cpp

@@ -18,3 +18,16 @@ struct S {
 S s;
 // CHECK: @sp = constant ptr getelementptr (i8, ptr @s, i64 16), align 8
 float &sp = s.c[3];
+
+
+namespace BaseClassOffsets {
+  struct A { int a; };
+  struct B { int b; };
+  struct C : A, B { int c; };
+
+  extern C c;
+  // CHECK: @_ZN16BaseClassOffsets1aE = global ptr @_ZN16BaseClassOffsets1cE, align 8
+  A* a = &c;
+  // CHECK: @_ZN16BaseClassOffsets1bE = global ptr getelementptr (i8, ptr @_ZN16BaseClassOffsets1cE, i64 4), align 8
+  B* b = &c;
+}