IRGen: Support dynamic offsets for various metadata fields

Not hooked up until some more MetadataLayout changes land.

Author: slavapestov

lib/IRGen/MetadataLayout.cpp

@@ -134,18 +134,38 @@ void MetadataLayout::destroy() const {
 
 /******************************* NOMINAL TYPES ********************************/
 
+Offset NominalMetadataLayout::emitOffset(IRGenFunction &IGF,
+                                         StoredOffset offset) const {
+  assert(offset.isValid());
+
+  if (offset.isStatic())
+    return Offset(offset.getStaticOffset());
+
+  Address offsetBaseAddr(
+    IGF.IGM.getAddrOfClassMetadataBaseOffset(cast<ClassDecl>(getDecl()),
+                                             NotForDefinition),
+    IGF.IGM.getPointerAlignment());
+
+  // FIXME: Should this be an invariant load?
+  auto *offsetBaseVal =
+    IGF.Builder.CreateLoad(offsetBaseAddr, "base");
+
+  auto relativeOffset = offset.getRelativeOffset().getValue();
+  auto *offsetVal =
+    IGF.Builder.CreateAdd(offsetBaseVal,
+                          llvm::ConstantInt::get(IGF.IGM.SizeTy,
+                                                 relativeOffset));
+  return Offset(offsetVal);
+}
+
 Size
 NominalMetadataLayout::getStaticGenericRequirementsOffset() const {
-  assert(GenericRequirements.isValid());
-  assert(GenericRequirements.isStatic() && "resilient metadata layout unsupported!");
   return GenericRequirements.getStaticOffset();
 }
 
 Offset
 NominalMetadataLayout::getGenericRequirementsOffset(IRGenFunction &IGF) const {
-  assert(GenericRequirements.isValid());
-  assert(GenericRequirements.isStatic() && "resilient metadata layout unsupported!");
-  return Offset(GenericRequirements.getStaticOffset());
+  return emitOffset(IGF, GenericRequirements);
 }
 
 static llvm::Value *emitLoadOfGenericRequirement(IRGenFunction &IGF,
@@ -323,11 +343,7 @@ Size ClassMetadataLayout::getInstanceAlignMaskOffset() const {
 ClassMetadataLayout::MethodInfo
 ClassMetadataLayout::getMethodInfo(IRGenFunction &IGF, SILDeclRef method) const{
   auto &stored = getStoredMethodInfo(method);
-
-  assert(stored.TheOffset.isStatic() &&
-         "resilient class metadata layout unsupported!");
-  auto offset = Offset(stored.TheOffset.getStaticOffset());
-
+  auto offset = emitOffset(IGF, stored.TheOffset);
   return MethodInfo(offset);
 }
 
@@ -339,45 +355,50 @@ Size ClassMetadataLayout::getStaticMethodOffset(SILDeclRef method) const{
   return stored.TheOffset.getStaticOffset();
 }
 
-Size
-ClassMetadataLayout::getStaticVTableOffset() const {
-  // TODO: if class is resilient, return the offset relative to the start
-  // of immediate class metadata
-  assert(VTableOffset.isStatic());
-  return VTableOffset.getStaticOffset();
-}
-
 Offset
 ClassMetadataLayout::getVTableOffset(IRGenFunction &IGF) const {
-  // TODO: implement resilient metadata layout
-  assert(VTableOffset.isStatic());
-  return Offset(VTableOffset.getStaticOffset());
+  return emitOffset(IGF, VTableOffset);
 }
 
 Offset ClassMetadataLayout::getFieldOffset(IRGenFunction &IGF,
                                            VarDecl *field) const {
-  // TODO: implement resilient metadata layout
-  return Offset(getStaticFieldOffset(field));
+  return emitOffset(IGF, getStoredFieldOffset(field));
 }
+
 Size ClassMetadataLayout::getStaticFieldOffset(VarDecl *field) const {
   auto &stored = getStoredFieldOffset(field);
   assert(stored.isStatic() && "resilient class metadata layout unsupported!");
   return stored.getStaticOffset();
 }
 
+Size
+ClassMetadataLayout::getRelativeGenericRequirementsOffset() const {
+  return GenericRequirements.getRelativeOffset();
+}
+
 Size
 ClassMetadataLayout::getStaticFieldOffsetVectorOffset() const {
-  // TODO: if class is resilient, return the offset relative to the start
-  // of immediate class metadata
-  assert(FieldOffsetVector.isStatic());
   return FieldOffsetVector.getStaticOffset();
 }
 
+Size
+ClassMetadataLayout::getRelativeFieldOffsetVectorOffset() const {
+  return FieldOffsetVector.getRelativeOffset();
+}
+
+Size
+ClassMetadataLayout::getStaticVTableOffset() const {
+  return VTableOffset.getStaticOffset();
+}
+
+Size
+ClassMetadataLayout::getRelativeVTableOffset() const {
+  return VTableOffset.getRelativeOffset();
+}
+
 Offset
 ClassMetadataLayout::getFieldOffsetVectorOffset(IRGenFunction &IGF) const {
-  // TODO: implement resilient metadata layout
-  assert(FieldOffsetVector.isStatic());
-  return Offset(FieldOffsetVector.getStaticOffset());
+  return emitOffset(IGF, FieldOffsetVector);
 }
 
 Size irgen::getClassFieldOffsetOffset(IRGenModule &IGM, ClassDecl *theClass,
@@ -398,8 +419,8 @@ llvm::Value *irgen::emitClassFieldOffset(IRGenFunction &IGF,
 
 Address irgen::emitAddressOfClassFieldOffset(IRGenFunction &IGF,
                                              llvm::Value *metadata,
-                                              ClassDecl *theClass,
-                                              VarDecl *field) {
+                                             ClassDecl *theClass,
+                                             VarDecl *field) {
   auto offset = IGF.IGM.getMetadataLayout(theClass).getFieldOffset(IGF, field);
   auto slot = IGF.emitAddressAtOffset(metadata, offset, IGF.IGM.SizeTy,
                                       IGF.IGM.getPointerAlignment());

lib/IRGen/MetadataLayout.h

@@ -134,6 +134,8 @@ class NominalMetadataLayout : public MetadataLayout {
   NominalMetadataLayout(Kind kind, NominalTypeDecl *nominal)
       : MetadataLayout(kind), Nominal(nominal) {}
 
+  Offset emitOffset(IRGenFunction &IGF, StoredOffset offset) const;
+
 public:
   NominalTypeDecl *getDecl() const {
     return Nominal;
@@ -214,9 +216,6 @@ class ClassMetadataLayout : public NominalMetadataLayout {
 
   Size getInstanceAlignMaskOffset() const;
 
-  /// Should only be used when emitting the nominal type descriptor.
-  Size getStaticVTableOffset() const;
-
   /// Returns the start of the vtable in the class metadata.
   Offset getVTableOffset(IRGenFunction &IGF) const;
 
@@ -244,7 +243,13 @@ class ClassMetadataLayout : public NominalMetadataLayout {
   Size getStaticFieldOffset(VarDecl *field) const;
 
   /// Should only be used when emitting the nominal type descriptor.
+  Size getRelativeGenericRequirementsOffset() const;
+
   Size getStaticFieldOffsetVectorOffset() const;
+  Size getRelativeFieldOffsetVectorOffset() const;
+
+  Size getStaticVTableOffset() const;
+  Size getRelativeVTableOffset() const;
 
   Offset getFieldOffsetVectorOffset(IRGenFunction &IGF) const;