Implement 'offset_of' for base class relationships.

Closes llvm#129.

Author: katzdm

clang/include/clang/Basic/DiagnosticMetafnKinds.td

@@ -71,6 +71,10 @@ def metafn_function_is_not_member_of_object : Note<
 def metafn_function_returns_void : Note<
    "cannot invoke reflection of void-returning function">;
 
+// Layout.
+def metafn_offset_virtual_base_of_abstract : Note<
+  "cannot query the layout of a virtual base class of an abstract class">;
+
 // Accessibility.
 def metafn_access_query_class_being_defined : Note<
   "cannot query the access of a member of class %0 currently being defined">;

clang/lib/AST/ExprConstantMeta.cpp

@@ -1265,6 +1265,24 @@ static size_t getBitOffsetOfField(ASTContext &C, const FieldDecl *FD) {
   return Layout.getFieldOffset(FD->getFieldIndex());
 }
 
+static size_t getOffsetOfBase(ASTContext &C, const CXXBaseSpecifier *Base) {
+  const CXXRecordDecl *Derived = Base->getDerived();
+  assert(Derived && "no parent for field!");
+
+  const ASTRecordLayout &Layout = C.getASTRecordLayout(Derived);
+
+  QualType BaseQT = Base->getType();
+  BaseQT = desugarType(BaseQT, /*UnwrapAliases=*/true, /*DropCV=*/false,
+                       /*DropRefs=*/false);
+  CXXRecordDecl *RD = BaseQT->getAsCXXRecordDecl();
+  assert(RD && "base isn't a record type?");
+
+  if (Base->isVirtual())
+    return Layout.getVBaseClassOffset(RD).getQuantity();
+  else
+    return Layout.getBaseClassOffset(RD).getQuantity();
+}
+
 static bool ensureDeclared(ASTContext &C, QualType QT, SourceLocation SpecLoc) {
   // If it's an ElaboratedType, get the underlying NamedType.
   if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(QT))
@@ -4903,7 +4921,6 @@ bool offset_of(APValue &Result, ASTContext &C, MetaActions &Meta,
   case ReflectionKind::Value:
   case ReflectionKind::Template:
   case ReflectionKind::Namespace:
-  case ReflectionKind::BaseSpecifier:
   case ReflectionKind::DataMemberSpec:
   case ReflectionKind::Annotation:
     return DiagnoseReflectionKind(Diagnoser, Range, "a non-static data member",
@@ -4916,6 +4933,16 @@ bool offset_of(APValue &Result, ASTContext &C, MetaActions &Meta,
     return DiagnoseReflectionKind(Diagnoser, Range, "a non-static data member",
                                   DescriptionOf(RV));
   }
+  case ReflectionKind::BaseSpecifier: {
+    CXXBaseSpecifier *Base = RV.getReflectedBaseSpecifier();
+    if (Base->isVirtual() && Base->getDerived()->isAbstract())
+      return Diagnoser(Range.getBegin(),
+                       diag::metafn_offset_virtual_base_of_abstract)
+          << Range;
+
+    size_t Offset = getOffsetOfBase(C, Base);
+    return SetAndSucceed(Result, APValue(C.MakeIntValue(Offset, ResultTy)));
+  }
   }
   llvm_unreachable("unknown reflection kind");
 }
@@ -4990,7 +5017,6 @@ bool bit_offset_of(APValue &Result, ASTContext &C, MetaActions &Meta,
   case ReflectionKind::Value:
   case ReflectionKind::Template:
   case ReflectionKind::Namespace:
-  case ReflectionKind::BaseSpecifier:
   case ReflectionKind::DataMemberSpec:
   case ReflectionKind::Annotation:
     return DiagnoseReflectionKind(Diagnoser, Range, "a non-static data member",
@@ -5003,6 +5029,8 @@ bool bit_offset_of(APValue &Result, ASTContext &C, MetaActions &Meta,
     return DiagnoseReflectionKind(Diagnoser, Range, "a non-static data member",
                                   DescriptionOf(RV));
   }
+  case ReflectionKind::BaseSpecifier:
+    return SetAndSucceed(Result, APValue(C.MakeIntValue(0, ResultTy)));
   }
   llvm_unreachable("unknown reflection kind");
 }

libcxx/test/std/experimental/reflection/layout.pass.cpp

@@ -9,7 +9,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03 || c++11 || c++14 || c++17 || c++20
-// ADDITIONAL_COMPILE_FLAGS: -freflection
+// ADDITIONAL_COMPILE_FLAGS: -freflection -faccess-contexts
 
 // <experimental/reflection>
 //
@@ -50,20 +50,20 @@ struct BitField {
 };
 static_assert(offset_of(^^BitField::bf1) == std::meta::member_offset{0, 0});
 static_assert(offset_of(^^BitField::bf2) == std::meta::member_offset{0, 1});
-static_assert(offset_of(nonstatic_data_members_of(^^BitField)[2]) ==
+static_assert(offset_of(nonstatic_data_members_of(^^BitField, {})[2]) ==
               std::meta::member_offset{1, 0});
 static_assert(offset_of(^^BitField::bf3) == std::meta::member_offset{1, 0});
 static_assert(offset_of(^^BitField::bf4) == std::meta::member_offset{1, 3});
 static_assert(bit_size_of(^^BitField::bf1) == 1);
 static_assert(bit_size_of(^^BitField::bf2) == 2);
-static_assert(bit_size_of((members_of(^^BitField) |
+static_assert(bit_size_of((members_of(^^BitField, {}) |
                   std::views::filter(std::meta::is_bit_field) |
                   std::ranges::to<std::vector>())[2]) == 0);
 static_assert(bit_size_of(^^BitField::bf3) == 3);
 static_assert(bit_size_of(^^BitField::bf4) == 3);
 
 // unnamed bitfield not included.
-static_assert(nonstatic_data_members_of(^^BitField).size() == 4);
+static_assert(nonstatic_data_members_of(^^BitField, {}).size() == 4);
 static_assert(size_of(^^BitField) == 4);
 
 alignas(64) int i1;
@@ -116,4 +116,22 @@ static_assert(bit_size_of(dms2) == 0);
 static_assert(bit_size_of(dms3) == 3);
 static_assert(bit_size_of(dms4) == sizeof(int) * 8);
 
+                                // ============
+                                // base_offsets
+                                // ============
+
+namespace base_offsets {
+struct A { char a; };
+struct B { bool b; };
+struct C : A, B {};
+
+static_assert(offset_of(bases_of(^^C, {})[0]) == std::meta::member_offset{0, 0});
+static_assert(offset_of(bases_of(^^C, {})[1]) == std::meta::member_offset{1, 0});
+
+struct V { };
+struct D : V { virtual void fn() = 0; };
+static_assert(offset_of(bases_of(^^D, {})[0]) == std::meta::member_offset{0, 0});
+
+}  // namespace base_offsets
+
 int main() { }