[IRGen] Adjust element size of offset vector to 32-bit for structs

Type of elements contained by field offsets vector can be adjusted
to 32-bit integers (from being pointer sized) to safe space in the
binary since segment size is limited to 4 GB.

Resolves: rdar://problem/36560486

Author: xedin

include/swift/Runtime/Metadata.h

@@ -1706,12 +1706,12 @@ struct TargetStructMetadata : public TargetValueMetadata<Runtime> {
   // argument array.
 
   /// Get a pointer to the field offset vector, if present, or null.
-  const StoredPointer *getFieldOffsets() const {
+  const uint32_t *getFieldOffsets() const {
     auto offset = getDescription()->FieldOffsetVectorOffset;
     if (offset == 0)
       return nullptr;
     auto asWords = reinterpret_cast<const void * const*>(this);
-    return reinterpret_cast<const StoredPointer *>(asWords + offset);
+    return reinterpret_cast<const uint32_t *>(asWords + offset);
   }
 
   static constexpr int32_t getGenericArgumentOffset() {
@@ -4212,7 +4212,7 @@ void swift_initStructMetadata(StructMetadata *self,
                               StructLayoutFlags flags,
                               size_t numFields,
                               const TypeLayout * const *fieldTypes,
-                              size_t *fieldOffsets);
+                              uint32_t *fieldOffsets);
 
 /// Relocate the metadata for a class and copy fields from the given template.
 /// The final size of the metadata is calculated at runtime from the size of

include/swift/Runtime/RuntimeFunctions.def

@@ -942,13 +942,13 @@ FUNCTION(InitClassMetadata,
 //                               StructLayoutFlags flags,
 //                               size_t numFields,
 //                               TypeLayout * const *fieldTypes,
-//                               size_t *fieldOffsets);
+//                               uint32_t *fieldOffsets);
 FUNCTION(InitStructMetadata,
          swift_initStructMetadata, C_CC,
          RETURNS(VoidTy),
          ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
               Int8PtrPtrTy->getPointerTo(0),
-              SizeTy->getPointerTo()),
+              Int32Ty->getPointerTo()),
          ATTRS(NoUnwind))
 
 // void swift_initEnumMetadataSingleCase(Metadata *enumType,

lib/IRGen/ConstantBuilder.h

@@ -106,7 +106,7 @@ class ConstantAggregateBuilderBase
   Size getNextOffsetFromGlobal() const {
     return Size(super::getNextOffsetFromGlobal().getQuantity());
   }
-  
+
   void addAlignmentPadding(Alignment align) {
     auto misalignment = getNextOffsetFromGlobal() % IGM().getPointerAlignment();
     if (misalignment != Size(0))
@@ -119,10 +119,26 @@ class ConstantAggregateBuilderBase
 class ConstantArrayBuilder
     : public clang::CodeGen::ConstantArrayBuilderTemplateBase<
                                                     ConstantInitBuilderTraits> {
+private:
+  llvm::Type *EltTy;
+
 public:
-  template <class... As>
-  ConstantArrayBuilder(As &&... args)
-    : ConstantArrayBuilderTemplateBase(std::forward<As>(args)...) {}
+  ConstantArrayBuilder(InitBuilder &builder,
+                       AggregateBuilderBase *parent,
+                       llvm::Type *eltTy)
+    : ConstantArrayBuilderTemplateBase(builder, parent, eltTy), EltTy(eltTy) {}
+
+  void addAlignmentPadding(Alignment align) {
+    auto misalignment = getNextOffsetFromGlobal() % align;
+    if (misalignment == Size(0))
+      return;
+
+    auto eltSize = IGM().DataLayout.getTypeStoreSize(EltTy);
+    assert(misalignment.getValue() % eltSize == 0);
+
+    for (unsigned i = 0, n = misalignment.getValue() / eltSize; i != n; ++i)
+      add(llvm::Constant::getNullValue(EltTy));
+  }
 };
 
 class ConstantStructBuilder

lib/IRGen/GenClass.cpp

@@ -461,7 +461,7 @@ llvm::Value *IRGenFunction::emitByteOffsetGEP(llvm::Value *base,
                                               llvm::Value *offset,
                                               llvm::Type *objectType,
                                               const llvm::Twine &name) {
-  assert(offset->getType() == IGM.SizeTy);
+  assert(offset->getType() == IGM.SizeTy || offset->getType() == IGM.Int32Ty);
   auto addr = Builder.CreateBitCast(base, IGM.Int8PtrTy);
   addr = Builder.CreateInBoundsGEP(addr, offset);
   return Builder.CreateBitCast(addr, objectType->getPointerTo(), name);

lib/IRGen/GenMeta.cpp

@@ -2629,10 +2629,14 @@ namespace {
         B.add(offset);
       } else {
         asImpl().flagUnfilledFieldOffset();
-        B.addInt(IGM.IntPtrTy, 0);
+        B.addInt(IGM.Int32Ty, 0);
       }
     }
 
+    void noteEndOfFieldOffsets() {
+      B.addAlignmentPadding(super::IGM.getPointerAlignment());
+    }
+
     void addGenericArgument(CanType type) {
       B.addNullPointer(IGM.TypeMetadataPtrTy);
     }
@@ -2727,7 +2731,7 @@ namespace {
     /// Fill in a constant field offset vector if possible.
     PartialPattern buildExtraDataPattern() {
       ConstantInitBuilder builder(IGM);
-      auto init = builder.beginArray(IGM.SizeTy);
+      auto init = builder.beginArray(IGM.Int32Ty);
 
       struct Scanner : StructMetadataScanner<Scanner> {
         SILType Type;
@@ -2744,7 +2748,11 @@ namespace {
           }
           assert(IGM.isKnownEmpty(Type.getFieldType(field, IGM.getSILModule()),
                                   ResilienceExpansion::Maximal));
-          B.addInt(IGM.SizeTy, 0);
+          B.addInt32(0);
+        }
+
+        void noteEndOfFieldOffsets() {
+          B.addAlignmentPadding(IGM.getPointerAlignment());
         }
       };
       Scanner(IGM, Target, getLoweredType(), init).layout();

lib/IRGen/GenStruct.cpp

@@ -158,16 +158,16 @@ namespace {
       auto offsets = asImpl().getNonFixedOffsets(IGF, T);
       return fieldInfo.projectAddress(IGF, addr, offsets);
     }
-       
-    /// Return the constant offset of a field as a SizeTy, or nullptr if the
+
+    /// Return the constant offset of a field as a Int32Ty, or nullptr if the
     /// field is not at a fixed offset.
     llvm::Constant *getConstantFieldOffset(IRGenModule &IGM,
                                            VarDecl *field) const {
       auto &fieldInfo = getFieldInfo(field);
       if (fieldInfo.getKind() == ElementLayout::Kind::Fixed
           || fieldInfo.getKind() == ElementLayout::Kind::Empty) {
-        return llvm::ConstantInt::get(IGM.SizeTy,
-                                    fieldInfo.getFixedByteOffset().getValue());
+        return llvm::ConstantInt::get(
+            IGM.Int32Ty, fieldInfo.getFixedByteOffset().getValue());
       }
       return nullptr;
     }

lib/IRGen/MetadataLayout.cpp

@@ -248,7 +248,11 @@ Address irgen::emitAddressOfFieldOffsetVector(IRGenFunction &IGF,
     }
   }();
 
-  return IGF.emitAddressAtOffset(metadata, offset, IGF.IGM.SizeTy,
+  auto *elementSize = IGF.IGM.SizeTy;
+  if (isa<StructDecl>(decl))
+    elementSize = IGF.IGM.Int32Ty;
+
+  return IGF.emitAddressAtOffset(metadata, offset, elementSize,
                                  IGF.IGM.getPointerAlignment());
 }
 
@@ -564,6 +568,10 @@ StructMetadataLayout::StructMetadataLayout(IRGenModule &IGM, StructDecl *decl)
       super::addFieldOffset(field);
     }
 
+    void noteEndOfFieldOffsets() {
+      super::noteEndOfFieldOffsets();
+    }
+
     void layout() {
       super::layout();
       Layout.TheSize = getMetadataSize();

lib/IRGen/StructMetadataVisitor.h

@@ -59,10 +59,15 @@ template <class Impl> class StructMetadataVisitor
     asImpl().noteStartOfFieldOffsets();
     for (VarDecl *prop : Target->getStoredProperties())
       asImpl().addFieldOffset(prop);
+
+    asImpl().noteEndOfFieldOffsets();
   }
 
   // Note the start of the field offset vector.
   void noteStartOfFieldOffsets() {}
+
+  // Note the end of the field offset vector.
+  void noteEndOfFieldOffsets() {}
 };
 
 /// An "implementation" of StructMetadataVisitor that just scans through
@@ -81,17 +86,22 @@ class StructMetadataScanner : public StructMetadataVisitor<Impl> {
   void addMetadataFlags() { addPointer(); }
   void addValueWitnessTable() { addPointer(); }
   void addNominalTypeDescriptor() { addPointer(); }
-  void addFieldOffset(VarDecl*) { addPointer(); }
+  void addFieldOffset(VarDecl *) { addInt32(); }
   void addGenericArgument(CanType argument) { addPointer(); }
   void addGenericWitnessTable(CanType argument, ProtocolConformanceRef conf) {
     addPointer();
   }
   void noteStartOfTypeSpecificMembers() {}
 
+  void noteEndOfFieldOffsets() {
+    NextOffset = NextOffset.roundUpToAlignment(super::IGM.getPointerAlignment());
+  }
+
 private:
   void addPointer() {
     NextOffset += super::IGM.getPointerSize();
   }
+  void addInt32() { NextOffset += Size(4); }
 };
 
 } // end namespace irgen

stdlib/public/core/KeyPath.swift

@@ -2404,8 +2404,16 @@ internal func _instantiateKeyPathBuffer(
         // offset within the metadata object.
         let metadataPtr = unsafeBitCast(base, to: UnsafeRawPointer.self)
         let offsetOfOffset = patternBuffer.pop(UInt32.self)
-        let offset = UInt32(metadataPtr.load(fromByteOffset: Int(offsetOfOffset),
-                                       as: UInt.self))
+
+        let offset: UInt32
+        if (header.kind == .struct) {
+          offset = UInt32(metadataPtr.load(fromByteOffset: Int(offsetOfOffset),
+                                           as: UInt32.self))
+        } else {
+          offset = UInt32(metadataPtr.load(fromByteOffset: Int(offsetOfOffset),
+                                           as: UInt.self))
+        }
+
         // Rewrite the header for a resolved offset.
         var newHeader = header
         newHeader.payload = RawKeyPathComponent.Header.outOfLineOffsetPayload

stdlib/public/runtime/Metadata.cpp

@@ -1758,12 +1758,12 @@ static ValueWitnessTable *getMutableVWTableForInit(StructMetadata *self,
 void swift::swift_initStructMetadata(StructMetadata *structType,
                                      StructLayoutFlags layoutFlags,
                                      size_t numFields,
-                                     const TypeLayout * const *fieldTypes,
-                                     size_t *fieldOffsets) {
+                                     const TypeLayout *const *fieldTypes,
+                                     uint32_t *fieldOffsets) {
   auto layout = getInitialLayoutForValueType();
   performBasicLayout(layout, fieldTypes, numFields,
     [&](const TypeLayout *fieldType) { return fieldType; },
-    [&](size_t i, const TypeLayout *fieldType, size_t offset) {
+    [&](size_t i, const TypeLayout *fieldType, uint32_t offset) {
       assignUnlessEqual(fieldOffsets[i], offset);
     });