Merge pull request #13612 from slavapestov/class-resilience-part-8

slavapestov · web-flow · commit d6bbf814b791 · 2017-12-23T18:27:21.000-08:00
Class resilience part 8
diff --git a/lib/IRGen/GenClass.cpp b/lib/IRGen/GenClass.cpp
@@ -170,12 +170,6 @@ namespace {
     //   - or has a field with resilient layout.
     bool ClassMetadataRequiresDynamicInitialization = false;
 
-    // Does the superclass have a fixed number of stored properties?
-    // If not, and the class has generally-dependent layout, we have to
-    // access stored properties through an indirect offset into the field
-    // offset vector.
-    bool ClassHasFixedFieldCount = true;
-
     // Does the class have a fixed size up until the current point?
     // If not, we have to access stored properties either ivar offset globals,
     // or through the field offset vector, based on whether the layout has
@@ -304,9 +298,7 @@ namespace {
           //
           // FIXME: We need to implement indirect field/vtable entry access
           // before we can enable this
-          if (IGM.Context.LangOpts.EnableClassResilience) {
-            ClassHasFixedFieldCount = false;
-          } else {
+          if (!IGM.Context.LangOpts.EnableClassResilience) {
             addFieldsForClass(superclass, superclassType);
             NumInherited = Elements.size();
           }
@@ -405,16 +397,7 @@ namespace {
 
       // If layout depends on generic parameters, we have to load the
       // offset from the class metadata.
-
-      // If the layout of the class metadata is statically known, then
-      // there should be a fixed offset to the right offset.
-      if (ClassHasFixedFieldCount) {
-        return FieldAccess::ConstantIndirect;
-      }
-
-      // Otherwise, the offset of the offset is stored in a global variable
-      // that will be set up by the runtime.
-      return FieldAccess::NonConstantIndirect;
+      return FieldAccess::ConstantIndirect;
     }
   };
 } // end anonymous namespace
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -2825,8 +2825,7 @@ namespace {
       
       // Execute the fill ops. Cast the parameters to word pointers because the
       // fill indexes are word-indexed.
-      Address metadataWords(IGF.Builder.CreateBitCast(metadataValue, IGM.Int8PtrPtrTy),
-                            IGM.getPointerAlignment());
+      auto *metadataWords = IGF.Builder.CreateBitCast(metadataValue, IGM.Int8PtrPtrTy);
 
       auto genericReqtOffset = IGM.getMetadataLayout(Target)
           .getGenericRequirementsOffset(IGF);
@@ -2839,13 +2838,15 @@ namespace {
           value = IGF.emitTypeMetadataRef(fillOp.Type);
         }
 
-        auto dest = createPointerSizedGEP(IGF, metadataWords,
-                                          genericReqtOffset.getStatic());
-        genericReqtOffset = genericReqtOffset.offsetBy(
-          IGF, IGM.getPointerSize());
+        auto dest = IGF.emitAddressAtOffset(metadataWords, genericReqtOffset,
+                                            IGM.Int8PtrTy,
+                                            IGM.getPointerAlignment());
 
         value = IGF.Builder.CreateBitCast(value, IGM.Int8PtrTy);
         IGF.Builder.CreateStore(value, dest);
+
+        genericReqtOffset = genericReqtOffset.offsetBy(
+            IGF, IGM.getPointerSize());
       }
 
       // A dependent VWT means that we have dependent metadata.
diff --git a/lib/IRGen/MetadataLayout.cpp b/lib/IRGen/MetadataLayout.cpp
@@ -44,6 +44,8 @@ class LayoutScanner : public Base<Impl> {
   Optional<Size> AddressPoint;
 
 protected:
+  Optional<Size> DynamicOffsetBase;
+
   template <class... As>
   LayoutScanner(As &&... args) : Base<Impl>(std::forward<As>(args)...) {}
 
@@ -52,7 +54,13 @@ class LayoutScanner : public Base<Impl> {
 
   void noteAddressPoint() { AddressPoint = this->NextOffset; }
   StoredOffset getNextOffset() const {
-    return StoredOffset(this->NextOffset - AddressPoint.getValue());
+    if (DynamicOffsetBase) {
+      return StoredOffset(this->NextOffset - *DynamicOffsetBase,
+                          StoredOffset::Dynamic);
+    }
+
+    return StoredOffset(this->NextOffset - *AddressPoint,
+                        StoredOffset::Static);
   }
 
   Size getAddressPoint() const {
@@ -126,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,
@@ -315,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);
 }
 
@@ -331,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,
@@ -390,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());
diff --git a/lib/IRGen/MetadataLayout.h b/lib/IRGen/MetadataLayout.h
@@ -54,14 +54,19 @@ class MetadataLayout {
   };
 
   class StoredOffset {
-    enum State {
+  public:
+    enum Kind {
       /// The high bits are an integer displacement.
       Static = 0,
 
-      /// The high bits are an llvm::Constant* for the displacement,
-      /// which may be null if it hasn't been computed yet.
+      /// The high bits are an integer displacement relative to a offset stored
+      /// in a class metadata base offset global variable. This is used to
+      /// access members of class metadata where the superclass is resilient to
+      /// us, and therefore has an unknown size.
       Dynamic,
     };
+
+  private:
     enum : uint64_t {
       KindBits = 1,
       KindMask = (1 << KindBits) - 1,
@@ -71,29 +76,33 @@ class MetadataLayout {
     mutable uintptr_t Data;
   public:
     StoredOffset() : Data(0) {}
-    explicit StoredOffset(llvm::Constant *offset)
-      : Data(reinterpret_cast<uintptr_t>(offset) | Dynamic) {}
-    explicit StoredOffset(Size offset)
-      : Data((static_cast<uint64_t>(offset.getValue()) << KindBits) | Static) {
-      assert(!offset.isZero() && "cannot store a zero offset");
-      assert(getStaticOffset() == offset && "overflow");
+    explicit StoredOffset(Size offset, Kind kind)
+      : Data((static_cast<uint64_t>(offset.getValue()) << KindBits) | kind) {
+      assert(kind == Kind::Dynamic || !offset.isZero() &&
+             "cannot store a zero static offset");
+      if (kind == Kind::Static)
+        assert(getStaticOffset() == offset && "overflow");
+      if (kind == Kind::Dynamic)
+        assert(getRelativeOffset() == offset && "overflow");
     }
 
     bool isValid() const { return Data != 0; }
     bool isStatic() const { return isValid() && (Data & KindMask) == Static; }
     bool isDynamic() const { return (Data & KindMask) == Dynamic; }
+
+    /// If this is a metadata offset into a resilient class, returns the offset
+    /// relative to the size of the superclass metadata.
+    Size getRelativeOffset() const {
+      assert(isDynamic());
+      return Size(static_cast<int64_t>(Data) >> KindBits);
+    }
+
+    /// Returns the offset relative to start of metadata. Only used for
+    /// metadata fields whose offset is completely known at compile time.
     Size getStaticOffset() const {
       assert(isStatic());
       return Size(static_cast<int64_t>(Data) >> KindBits);
     }
-    llvm::Constant *getDynamicOffsetVariable() const {
-      assert(isDynamic());
-      return reinterpret_cast<llvm::Constant*>(Data & PayloadMask);
-    }
-    void setDynamicOffsetVariable(llvm::Constant *pointer) const {
-      assert(isDynamic());
-      Data = reinterpret_cast<uintptr_t>(pointer) | Dynamic;
-    }
   };
 
 private:
@@ -125,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;
@@ -205,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;
 
@@ -235,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;
 
diff --git a/test/IRGen/class_resilience.swift b/test/IRGen/class_resilience.swift
@@ -14,7 +14,6 @@
 // CHECK: @_T016class_resilience33ClassWithResilientlySizedPropertyC5colors5Int32VvpWvd = {{(protected )?}}global [[INT]] 0
 
 // CHECK: @_T016class_resilience14ResilientChildC5fields5Int32VvpWvd = {{(protected )?}}global [[INT]] {{8|16}}
-// CHECK: @_T016class_resilience21ResilientGenericChildC5fields5Int32VvpWvi = {{(protected )?}}global [[INT]] {{56|88}}
 
 // CHECK: @_T016class_resilience26ClassWithResilientPropertyCMo = {{(protected )?}}constant [[INT]] {{52|80}}
 
@@ -231,10 +230,8 @@ public class MyResilientChild : MyResilientParent {
 
 // CHECK-NEXT: [[ADDR:%.*]] = getelementptr inbounds %T16class_resilience21ResilientGenericChildC, %T16class_resilience21ResilientGenericChildC* %0, i32 0, i32 0, i32 0
 // CHECK-NEXT: [[ISA:%.*]] = load %swift.type*, %swift.type** [[ADDR]]
-// CHECK-NEXT: [[INDIRECT_OFFSET:%.*]] = load [[INT]], [[INT]]* @_T016class_resilience21ResilientGenericChildC5fields5Int32VvpWvi
-// CHECK-NEXT: [[ISA_ADDR:%.*]] = bitcast %swift.type* [[ISA]] to i8*
-// CHECK-NEXT: [[FIELD_OFFSET_TMP:%.*]] = getelementptr inbounds i8, i8* [[ISA_ADDR]], [[INT]] [[INDIRECT_OFFSET]]
-// CHECK-NEXT: [[FIELD_OFFSET_ADDR:%.*]] = bitcast i8* [[FIELD_OFFSET_TMP]] to [[INT]]*
+// CHECK-NEXT: [[ISA_ADDR:%.*]] = bitcast %swift.type* [[ISA]] to [[INT]]*
+// CHECK-NEXT: [[FIELD_OFFSET_ADDR:%.*]] = getelementptr inbounds [[INT]], [[INT]]* [[ISA_ADDR]], [[INT]] {{11|14}}
 // CHECK-NEXT: [[FIELD_OFFSET:%.*]] = load [[INT]], [[INT]]* [[FIELD_OFFSET_ADDR:%.*]]
 // CHECK-NEXT: [[OBJECT:%.*]] = bitcast %T16class_resilience21ResilientGenericChildC* %0 to i8*
 // CHECK-NEXT: [[ADDR:%.*]] = getelementptr inbounds i8, i8* [[OBJECT]], [[INT]] [[FIELD_OFFSET]]
diff --git a/test/IRGen/enum.sil b/test/IRGen/enum.sil
@@ -2693,7 +2693,7 @@ entry(%x : $*MyOptional):
 // CHECK:   [[T:%T]] = load %swift.type*, %swift.type** [[T0]],
 // CHECK:   [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata(%swift.type_pattern* %0, i8** %1)
 // CHECK:   [[METADATA_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
-// CHECK:   [[T1:%.*]] = getelementptr inbounds i8*, i8** [[METADATA_ARRAY]], i32 2
+// CHECK:   [[T1:%.*]] = getelementptr inbounds i8*, i8** [[METADATA_ARRAY]], [[WORD]] 2
 // CHECK:   [[T0:%.*]] = bitcast %swift.type* [[T]] to i8*
 // CHECK:   store i8* [[T0]], i8** [[T1]]
 // CHECK:   [[T_VWTS:%.*]] = bitcast %swift.type* [[T]] to i8***
diff --git a/test/IRGen/generic_classes.sil b/test/IRGen/generic_classes.sil
@@ -324,10 +324,10 @@ entry(%c : $RootGeneric<Int32>):
 // CHECK:   [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* [[T0]], i64 6)
 // CHECK:   [[METADATA_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
 //   Put the generic arguments in their correct positions.
-// CHECK:   [[A_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[METADATA_ARRAY:%.*]], i32 18
+// CHECK:   [[A_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[METADATA_ARRAY:%.*]], i64 18
 // CHECK:   [[T0:%.*]] = bitcast %swift.type* %A to i8*
 // CHECK:   store i8* [[T0]], i8** [[A_ADDR]], align 8
-// CHECK:   [[B_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[METADATA_ARRAY:%.*]], i32 19
+// CHECK:   [[B_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[METADATA_ARRAY:%.*]], i64 19
 // CHECK:   [[T0:%.*]] = bitcast %swift.type* %B to i8*
 // CHECK:   store i8* [[T0]], i8** [[B_ADDR]], align 8
 //   Set up the isa.
diff --git a/test/IRGen/generic_structs.sil b/test/IRGen/generic_structs.sil
@@ -214,7 +214,7 @@ entry(%0 : $*ComplexDynamic<A, B>, %1 : $*Byteful, %2 : $*A, %3 : $*B, %4 : $*Ch
 // CHECK:   [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata(%swift.type_pattern* %0, i8** %1)
 // CHECK:   [[SELF_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
 //   Fill type argument.
-// CHECK:   [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i32 3
+// CHECK:   [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i64 3
 // CHECK:   [[T0:%.*]] = bitcast %swift.type* %T to i8*
 // CHECK:   store i8* [[T0]], i8** [[T1]], align 8
 //   Lay out fields.
diff --git a/test/IRGen/generic_types.swift b/test/IRGen/generic_types.swift
