IRGen: ElementLayout now stores two TypeInfos

This allows us to perform fragile layout of resilient fields without
completely disabling value type resilience.

Author: slavapestov

lib/IRGen/GenClass.cpp

@@ -199,7 +199,7 @@ namespace {
       Elements.push_back(Elt);
       if (!addField(Elements.back(), LayoutStrategy::Universal)) {
         // For empty tail allocated elements we still add 1 padding byte.
-        assert(cast<FixedTypeInfo>(Elt.getType()).getFixedStride() == Size(1) &&
+        assert(cast<FixedTypeInfo>(Elt.getTypeForLayout()).getFixedStride() == Size(1) &&
                "empty elements should have stride 1");
         StructFields.push_back(llvm::ArrayType::get(IGM.Int8Ty, 1));
         CurSize += Size(1);
@@ -335,7 +335,7 @@ namespace {
         assert(!abstractLayout ||
                abstractLayout->getFieldIndex(var) == fieldIndex);
 
-        Elements.push_back(ElementLayout::getIncomplete(eltType));
+        Elements.push_back(ElementLayout::getIncomplete(eltType, eltType));
         AllStoredProperties.push_back(var);
         AllFieldAccesses.push_back(getFieldAccess(abstractLayout, fieldIndex));
       }
@@ -414,7 +414,7 @@ ClassTypeInfo::createLayoutWithTailElems(IRGenModule &IGM,
   // Add the tail elements.
   for (SILType TailTy : tailTypes) {
     const TypeInfo &tailTI = IGM.getTypeInfo(TailTy);
-    builder.addTailElement(ElementLayout::getIncomplete(tailTI));
+    builder.addTailElement(ElementLayout::getIncomplete(tailTI, tailTI));
   }
 
   // Create a name for the new llvm type.

lib/IRGen/GenFunc.cpp

@@ -1093,7 +1093,7 @@ static llvm::Function *emitPartialApplicationForwarder(IRGenModule &IGM,
       auto &fieldTy = layout->getElementTypes()[nextCapturedField];
       auto fieldConvention = conventions[nextCapturedField];
       Address fieldAddr = fieldLayout.project(subIGF, data, offsets);
-      auto &fieldTI = fieldLayout.getType();
+      auto &fieldTI = fieldLayout.getTypeForAccess();
       auto fieldSchema = fieldTI.getSchema();
 
       Explosion param;
@@ -1575,9 +1575,9 @@ void irgen::emitFunctionPartialApplication(
       case ParameterConvention::Indirect_In:
       case ParameterConvention::Indirect_In_Constant:
       case ParameterConvention::Indirect_In_Guaranteed: {
-        auto addr = fieldLayout.getType().getAddressForPointer(args.claimNext());
-        fieldLayout.getType().initializeWithTake(IGF, fieldAddr, addr, fieldTy,
-                                                 isOutlined);
+        auto addr = fieldLayout.getTypeForAccess().getAddressForPointer(args.claimNext());
+        fieldLayout.getTypeForAccess().initializeWithTake(IGF, fieldAddr, addr, fieldTy,
+                                                          isOutlined);
         break;
       }
       // Take direct value arguments and inout pointers by value.
@@ -1586,7 +1586,7 @@ void irgen::emitFunctionPartialApplication(
       case ParameterConvention::Direct_Guaranteed:
       case ParameterConvention::Indirect_Inout:
       case ParameterConvention::Indirect_InoutAliasable:
-        cast<LoadableTypeInfo>(fieldLayout.getType())
+        cast<LoadableTypeInfo>(fieldLayout.getTypeForAccess())
             .initialize(IGF, args, fieldAddr, isOutlined);
         break;
       }

lib/IRGen/GenHeap.cpp

@@ -96,7 +96,7 @@ HeapNonFixedOffsets::HeapNonFixedOffsets(IRGenFunction &IGF,
       case ElementLayout::Kind::InitialNonFixedSize:
         // Factor the non-fixed-size field's alignment into the total alignment.
         totalAlign = IGF.Builder.CreateOr(totalAlign,
-                                    elt.getType().getAlignmentMask(IGF, eltTy));
+                                    elt.getTypeForLayout().getAlignmentMask(IGF, eltTy));
         LLVM_FALLTHROUGH;
       case ElementLayout::Kind::Empty:
       case ElementLayout::Kind::Fixed:
@@ -108,7 +108,7 @@ HeapNonFixedOffsets::HeapNonFixedOffsets(IRGenFunction &IGF,
         // Start calculating non-fixed offsets from the end of the first fixed
         // field.
         if (i == 0) {
-          totalAlign = elt.getType().getAlignmentMask(IGF, eltTy);
+          totalAlign = elt.getTypeForLayout().getAlignmentMask(IGF, eltTy);
           offset = totalAlign;
           Offsets.push_back(totalAlign);
           break;
@@ -120,7 +120,7 @@ HeapNonFixedOffsets::HeapNonFixedOffsets(IRGenFunction &IGF,
         // Start calculating offsets from the last fixed-offset field.
         if (!offset) {
           Size lastFixedOffset = layout.getElement(i-1).getByteOffset();
-          if (auto *fixedType = dyn_cast<FixedTypeInfo>(&prevElt.getType())) {
+          if (auto *fixedType = dyn_cast<FixedTypeInfo>(&prevElt.getTypeForLayout())) {
             // If the last fixed-offset field is also fixed-size, we can
             // statically compute the end of the fixed-offset fields.
             auto fixedEnd = lastFixedOffset + fixedType->getFixedSize();
@@ -133,12 +133,12 @@ HeapNonFixedOffsets::HeapNonFixedOffsets(IRGenFunction &IGF,
               = llvm::ConstantInt::get(IGF.IGM.SizeTy,
                                        lastFixedOffset.getValue());
             offset = IGF.Builder.CreateAdd(offset,
-                                     prevElt.getType().getSize(IGF, prevType));
+                                     prevElt.getTypeForLayout().getSize(IGF, prevType));
           }
         }
 
         // Round up to alignment to get the offset.
-        auto alignMask = elt.getType().getAlignmentMask(IGF, eltTy);
+        auto alignMask = elt.getTypeForLayout().getAlignmentMask(IGF, eltTy);
         auto notAlignMask = IGF.Builder.CreateNot(alignMask);
         offset = IGF.Builder.CreateAdd(offset, alignMask);
         offset = IGF.Builder.CreateAnd(offset, notAlignMask);
@@ -147,7 +147,7 @@ HeapNonFixedOffsets::HeapNonFixedOffsets(IRGenFunction &IGF,
 
         // Advance by the field's size to start the next field.
         offset = IGF.Builder.CreateAdd(offset,
-                                       elt.getType().getSize(IGF, eltTy));
+                                       elt.getTypeForLayout().getSize(IGF, eltTy));
         totalAlign = IGF.Builder.CreateOr(totalAlign, alignMask);
 
         break;
@@ -237,7 +237,7 @@ static llvm::Function *createDtorFn(IRGenModule &IGM,
     if (field.isPOD())
       continue;
 
-    field.getType().destroy(
+    field.getTypeForAccess().destroy(
         IGF, field.project(IGF, structAddr, offsets), fieldTy,
         true /*Called from metadata constructors: must be outlined*/);
   }

lib/IRGen/GenObjC.cpp

@@ -934,8 +934,8 @@ void irgen::emitObjCPartialApplication(IRGenFunction &IGF,
   Address fieldAddr = fieldLayout.project(IGF, dataAddr, offsets);
   Explosion selfParams;
   selfParams.add(self);
-  fieldLayout.getType().initializeFromParams(IGF, selfParams, fieldAddr,
-                                             fieldType, false);
+  fieldLayout.getTypeForAccess().initializeFromParams(IGF, selfParams, fieldAddr,
+                                                      fieldType, false);
 
   // Create the forwarding stub.
   llvm::Function *forwarder = emitObjCPartialApplicationForwarder(IGF.IGM,

lib/IRGen/GenRecord.h

@@ -45,7 +45,7 @@ template <class FieldImpl> class RecordField {
 
 protected:
   explicit RecordField(const TypeInfo &elementTI)
-    : Layout(ElementLayout::getIncomplete(elementTI)) {}
+    : Layout(ElementLayout::getIncomplete(elementTI, elementTI)) {}
 
   explicit RecordField(const ElementLayout &layout,
                        unsigned begin, unsigned end)
@@ -55,7 +55,7 @@ template <class FieldImpl> class RecordField {
     return static_cast<const FieldImpl*>(this);
   }
 public:
-  const TypeInfo &getTypeInfo() const { return Layout.getType(); }
+  const TypeInfo &getTypeInfo() const { return Layout.getTypeForLayout(); }
 
   void completeFrom(const ElementLayout &layout) {
     Layout.completeFrom(layout);

lib/IRGen/GenStruct.cpp

@@ -766,7 +766,7 @@ class ClangRecordLowering {
     NextExplosionIndex += explosionSize;
     unsigned explosionEnd = NextExplosionIndex;
 
-    ElementLayout layout = ElementLayout::getIncomplete(fieldType);
+    ElementLayout layout = ElementLayout::getIncomplete(fieldType, fieldType);
     auto isEmpty = fieldType.isKnownEmpty(ResilienceExpansion::Maximal);
     if (isEmpty)
       layout.completeEmpty(fieldType.isPOD(ResilienceExpansion::Maximal),

lib/IRGen/StructLayout.cpp

@@ -49,7 +49,7 @@ StructLayout::StructLayout(IRGenModule &IGM, CanType astTy,
 
   // Fill in the Elements array.
   for (auto type : types)
-    Elements.push_back(ElementLayout::getIncomplete(*type));
+    Elements.push_back(ElementLayout::getIncomplete(*type, *type));
 
   assert(typeToFill == nullptr || typeToFill->isOpaque());
 
@@ -153,7 +153,7 @@ Address ElementLayout::project(IRGenFunction &IGF, Address baseAddr,
                                const llvm::Twine &suffix) const {
   switch (getKind()) {
   case Kind::Empty:
-    return getType().getUndefAddress();
+    return getTypeForAccess().getUndefAddress();
 
   case Kind::Fixed:
     return IGF.Builder.CreateStructGEP(baseAddr,
@@ -165,13 +165,13 @@ Address ElementLayout::project(IRGenFunction &IGF, Address baseAddr,
     assert(offsets.hasValue());
     llvm::Value *offset =
       offsets.getValue()->getOffsetForIndex(IGF, getNonFixedElementIndex());
-    return IGF.emitByteOffsetGEP(baseAddr.getAddress(), offset, getType(),
+    return IGF.emitByteOffsetGEP(baseAddr.getAddress(), offset, getTypeForAccess(),
                                  baseAddr.getAddress()->getName() + suffix);
   }
 
   case Kind::InitialNonFixedSize:
     return IGF.Builder.CreateBitCast(baseAddr,
-                                 getType().getStorageType()->getPointerTo(),
+                                 getTypeForAccess().getStorageType()->getPointerTo(),
                                  baseAddr.getAddress()->getName() + suffix);
   }
   llvm_unreachable("bad element layout kind");
@@ -207,7 +207,7 @@ bool StructLayoutBuilder::addFields(llvm::MutableArrayRef<ElementLayout> elts,
 
 bool StructLayoutBuilder::addField(ElementLayout &elt,
                                   LayoutStrategy strategy) {
-  auto &eltTI = elt.getType();
+  auto &eltTI = elt.getTypeForLayout();
   IsKnownPOD &= eltTI.isPOD(ResilienceExpansion::Maximal);
   IsKnownBitwiseTakable &= eltTI.isBitwiseTakable(ResilienceExpansion::Maximal);
   IsKnownAlwaysFixedSize &= eltTI.isFixedSize(ResilienceExpansion::Minimal);
@@ -235,7 +235,7 @@ bool StructLayoutBuilder::addField(ElementLayout &elt,
 }
 
 void StructLayoutBuilder::addFixedSizeElement(ElementLayout &elt) {
-  auto &eltTI = cast<FixedTypeInfo>(elt.getType());
+  auto &eltTI = cast<FixedTypeInfo>(elt.getTypeForLayout());
 
   // Note that, even in the presence of elements with non-fixed
   // size, we continue to compute the minimum size and alignment
@@ -302,19 +302,19 @@ void StructLayoutBuilder::addNonFixedSizeElement(ElementLayout &elt) {
 
 /// Add an empty element to the aggregate.
 void StructLayoutBuilder::addEmptyElement(ElementLayout &elt) {
-  elt.completeEmpty(elt.getType().isPOD(ResilienceExpansion::Maximal),
+  elt.completeEmpty(elt.getTypeForLayout().isPOD(ResilienceExpansion::Maximal),
                     CurSize);
 }
 
 /// Add an element at the fixed offset of the current end of the
 /// aggregate.
 void StructLayoutBuilder::addElementAtFixedOffset(ElementLayout &elt) {
   assert(isFixedLayout());
-  auto &eltTI = cast<FixedTypeInfo>(elt.getType());
+  auto &eltTI = cast<FixedTypeInfo>(elt.getTypeForLayout());
 
-  elt.completeFixed(elt.getType().isPOD(ResilienceExpansion::Maximal),
+  elt.completeFixed(elt.getTypeForLayout().isPOD(ResilienceExpansion::Maximal),
                     CurSize, StructFields.size());
-  StructFields.push_back(elt.getType().getStorageType());
+  StructFields.push_back(elt.getTypeForLayout().getStorageType());
 
   // Carry over the spare bits from the element.
   CurSpareBits.append(eltTI.getSpareBits());
@@ -323,17 +323,17 @@ void StructLayoutBuilder::addElementAtFixedOffset(ElementLayout &elt) {
 /// Add an element at a non-fixed offset to the aggregate.
 void StructLayoutBuilder::addElementAtNonFixedOffset(ElementLayout &elt) {
   assert(!isFixedLayout());
-  elt.completeNonFixed(elt.getType().isPOD(ResilienceExpansion::Maximal),
+  elt.completeNonFixed(elt.getTypeForLayout().isPOD(ResilienceExpansion::Maximal),
                        NextNonFixedOffsetIndex);
   CurSpareBits.clear();
 }
 
 /// Add a non-fixed-size element to the aggregate at offset zero.
 void StructLayoutBuilder::addNonFixedSizeElementAtOffsetZero(ElementLayout &elt) {
   assert(isFixedLayout());
-  assert(!isa<FixedTypeInfo>(elt.getType()));
+  assert(!isa<FixedTypeInfo>(elt.getTypeForLayout()));
   assert(CurSize.isZero());
-  elt.completeInitialNonFixedSize(elt.getType().isPOD(ResilienceExpansion::Maximal));
+  elt.completeInitialNonFixedSize(elt.getTypeForLayout().isPOD(ResilienceExpansion::Maximal));
   CurSpareBits.clear();
 }
 

lib/IRGen/StructLayout.h

@@ -100,8 +100,16 @@ class ElementLayout {
 private:
   enum : unsigned { IncompleteKind  = 4 };
 
-  /// The swift type information for this element.
-  const TypeInfo *Type;
+  /// The swift type information for this element's layout.
+  const TypeInfo *TypeLayout;
+
+  /// The swift type information for this element's access.
+  ///
+  /// Almost always the same as the layout type info, except for classes
+  /// we have a workaround where we must perform layout as if the type
+  /// was completely fragile, since the Objective-C runtime does not
+  /// support classes with an unknown instance size.
+  const TypeInfo *TypeAccess;
 
   /// The offset in bytes from the start of the struct.
   unsigned ByteOffset;
@@ -117,16 +125,18 @@ class ElementLayout {
   /// The kind of layout performed for this element.
   unsigned TheKind : 3;
 
-  explicit ElementLayout(const TypeInfo &type)
-    : Type(&type), TheKind(IncompleteKind) {}
+  explicit ElementLayout(const TypeInfo &typeLayout,
+                         const TypeInfo &typeAccess)
+    : TypeLayout(&typeLayout), TypeAccess(&typeAccess), TheKind(IncompleteKind) {}
 
   bool isCompleted() const {
     return (TheKind != IncompleteKind);
   }
 
 public:
-  static ElementLayout getIncomplete(const TypeInfo &type) {
-    return ElementLayout(type);
+  static ElementLayout getIncomplete(const TypeInfo &typeLayout,
+                                     const TypeInfo &typeAccess) {
+    return ElementLayout(typeLayout, typeAccess);
   }
 
   void completeFrom(const ElementLayout &other) {
@@ -171,7 +181,9 @@ class ElementLayout {
     Index = nonFixedElementIndex;
   }
 
-  const TypeInfo &getType() const { return *Type; }
+  const TypeInfo &getTypeForLayout() const { return *TypeLayout; }
+
+  const TypeInfo &getTypeForAccess() const { return *TypeAccess; }
 
   Kind getKind() const {
     assert(isCompleted());