IRGen/Runtime: Use relative addresses in nominal type descriptors.

Decrease the size of nominal type descriptors and make them true-const by relative-addressing the other metadata they need to reference, which should all be included in the same image as the descriptor itself. Relative-referencing string constants exposes a bug in the Apple linker, which crashes when resolving relative relocations to coalesceable symbols (rdar://problem/22674524); work around this for now by revoking the `unnamed_addr`-ness of string constants that we take relative references to. (I haven't tested whether GNU ld or gold also have this problem on Linux; it may be possible to conditionalize the workaround to only apply to Darwin targets for now.)

Author: jckarter

include/swift/Basic/RelativePointer.h

@@ -26,7 +26,7 @@ namespace swift {
 /// A relative reference to an object stored in memory. The reference may be
 /// direct or indirect, and uses the low bit of the (assumed at least
 /// 2-byte-aligned) pointer to differentiate.
-template<typename ValueTy>
+template<typename ValueTy, bool Nullable = false>
 class RelativeIndirectablePointer {
 private:
   /// The relative offset of the pointer's memory from the `this` pointer.
@@ -44,7 +44,12 @@ class RelativeIndirectablePointer {
   RelativeIndirectablePointer &operator=(const RelativeIndirectablePointer &)
     = delete;
 
+public:
   const ValueTy *get() const & {
+    // Check for null.
+    if (Nullable && RelativeOffset == 0)
+      return nullptr;
+    
     // The pointer is offset relative to `this`.
     auto base = reinterpret_cast<intptr_t>(this);
     intptr_t address = base + (RelativeOffset & ~1);
@@ -57,8 +62,7 @@ class RelativeIndirectablePointer {
       return reinterpret_cast<const ValueTy *>(address);
     }
   }
-
-public:
+  
   operator const ValueTy* () const & {
     return get();
   }
@@ -75,7 +79,7 @@ class RelativeIndirectablePointer {
 /// A relative reference to a function, intended to reference private metadata
 /// functions for the current executable or dynamic library image from
 /// position-independent constant data.
-template<typename T>
+template<typename T, bool Nullable>
 class RelativeDirectPointerImpl {
 private:
   /// The relative offset of the function's entry point from *this.
@@ -96,7 +100,11 @@ class RelativeDirectPointerImpl {
   using PointerTy = T*;
 
   PointerTy get() const & {
-    // The function entry point is addressed relative to `this`.
+    // Check for null.
+    if (Nullable && RelativeOffset == 0)
+      return nullptr;
+    
+    // The value is addressed relative to `this`.
     auto base = reinterpret_cast<intptr_t>(this);
     intptr_t absolute = base + RelativeOffset;
     return reinterpret_cast<PointerTy>(absolute);
@@ -109,12 +117,14 @@ class RelativeDirectPointerImpl {
 };
 
 /// A direct relative reference to an object.
-template<typename T>
+template<typename T, bool Nullable = true>
 class RelativeDirectPointer :
-  private RelativeDirectPointerImpl<T>
+  private RelativeDirectPointerImpl<T, Nullable>
 {
-  using super = RelativeDirectPointerImpl<T>;
+  using super = RelativeDirectPointerImpl<T, Nullable>;
 public:
+  using super::get;
+
   operator typename super::PointerTy() const & {
     return this->get();
   }
@@ -132,12 +142,14 @@ class RelativeDirectPointer :
 
 /// A specialization of RelativeDirectPointer for function pointers,
 /// allowing for calls.
-template<typename RetTy, typename...ArgTy>
-class RelativeDirectPointer<RetTy (ArgTy...)> :
-  private RelativeDirectPointerImpl<RetTy (ArgTy...)>
+template<typename RetTy, typename...ArgTy, bool Nullable>
+class RelativeDirectPointer<RetTy (ArgTy...), Nullable> :
+  private RelativeDirectPointerImpl<RetTy (ArgTy...), Nullable>
 {
-  using super = RelativeDirectPointerImpl<RetTy (ArgTy...)>;
+  using super = RelativeDirectPointerImpl<RetTy (ArgTy...), Nullable>;
 public:
+  using super::get;
+
   operator typename super::PointerTy() const & {
     return this->get();
   }
@@ -149,5 +161,44 @@ class RelativeDirectPointer<RetTy (ArgTy...)> :
   using super::isNull;
 };
 
+/// A direct relative reference to an aligned object, with an additional
+/// tiny integer value crammed into its low bits.
+template<typename PointeeTy, typename IntTy>
+class RelativeDirectPointerIntPair {
+  int32_t RelativeOffsetPlusInt;
+
+  /// RelativePointers should appear in statically-generated metadata. They
+  /// shouldn't be constructed or copied.
+  RelativeDirectPointerIntPair() = delete;
+  RelativeDirectPointerIntPair(RelativeDirectPointerIntPair &&) = delete;
+  RelativeDirectPointerIntPair(const RelativeDirectPointerIntPair &) = delete;
+  RelativeDirectPointerIntPair &operator=(RelativeDirectPointerIntPair &&)
+    = delete;
+  RelativeDirectPointerIntPair &operator=(const RelativeDirectPointerIntPair&)
+    = delete;
+
+  static int32_t getMask() {
+    static_assert(alignof(PointeeTy) >= alignof(int32_t),
+                  "pointee alignment must be at least 32 bit");
+
+    return alignof(int32_t) - 1;
+  }
+
+public:
+  using ValueTy = PointeeTy;
+  using PointerTy = PointeeTy*;
+
+  PointerTy getPointer() const & {
+    // The value is addressed relative to `this`.
+    auto base = reinterpret_cast<intptr_t>(this);
+    intptr_t absolute = base + (RelativeOffsetPlusInt & ~getMask());
+    return reinterpret_cast<PointerTy>(absolute);
+  }
+
+  IntTy getInt() const & {
+    return IntTy(RelativeOffsetPlusInt & getMask());
+  }
+};
+
 }
 

include/swift/Runtime/Metadata.h

@@ -1213,10 +1213,8 @@ struct EnumTypeDescriptor;
 /// Common information about all nominal types. For generic types, this
 /// descriptor is shared for all instantiations of the generic type.
 struct NominalTypeDescriptor {
-  /// The kind of nominal type descriptor.
-  NominalTypeKind Kind;
   /// The mangled name of the nominal type, with no generic parameters.
-  const char *Name;
+  RelativeDirectPointer<char> Name;
 
   /// The following fields are kind-dependent.
   union {
@@ -1236,12 +1234,12 @@ struct NominalTypeDescriptor {
 
       /// The field names. A doubly-null-terminated list of strings, whose
       /// length and order is consistent with that of the field offset vector.
-      const char *FieldNames;
+      RelativeDirectPointer<char, /*nullable*/ true> FieldNames;
 
       /// The field type vector accessor. Returns a pointer to an array of
       /// type metadata references whose order is consistent with that of the
       /// field offset vector.
-      const FieldType *(*GetFieldTypes)(const Metadata *Self);
+      RelativeDirectPointer<const FieldType * (const Metadata *)> GetFieldTypes;
 
       /// True if metadata records for this type have a field offset vector for
       /// its stored properties.
@@ -1260,12 +1258,12 @@ struct NominalTypeDescriptor {
 
       /// The field names. A doubly-null-terminated list of strings, whose
       /// length and order is consistent with that of the field offset vector.
-      const char *FieldNames;
+      RelativeDirectPointer<char, /*nullable*/ true> FieldNames;
 
       /// The field type vector accessor. Returns a pointer to an array of
       /// type metadata references whose order is consistent with that of the
       /// field offset vector.
-      const FieldType *(*GetFieldTypes)(const Metadata *Self);
+      RelativeDirectPointer<const FieldType * (const Metadata *)> GetFieldTypes;
 
       /// True if metadata records for this type have a field offset vector for
       /// its stored properties.
@@ -1283,11 +1281,11 @@ struct NominalTypeDescriptor {
       /// The names of the cases. A doubly-null-terminated list of strings,
       /// whose length is NumNonEmptyCases + NumEmptyCases. Cases are named in
       /// tag order, non-empty cases first, followed by empty cases.
-      const char *CaseNames;
+      RelativeDirectPointer<char, /*nullable*/ true> CaseNames;
       /// The field type vector accessor. Returns a pointer to an array of
       /// type metadata references whose order is consistent with that of the
       /// CaseNames. Only types for payload cases are provided.
-      const FieldType *(*GetCaseTypes)(const Metadata *Self);
+      RelativeDirectPointer<const FieldType * (const Metadata *)> GetCaseTypes;
 
       uint32_t getNumPayloadCases() const {
         return NumPayloadCasesAndPayloadSizeOffset & 0x00FFFFFFU;
@@ -1308,10 +1306,20 @@ struct NominalTypeDescriptor {
     } Enum;
   };
 
+  RelativeDirectPointerIntPair<GenericMetadata, NominalTypeKind>
+    GenericMetadataPatternAndKind;
+
   /// A pointer to the generic metadata pattern that is used to instantiate
-  /// instances of this type. Null if the type is not generic.
-  GenericMetadata *GenericMetadataPattern;
-  
+  /// instances of this type. Zero if the type is not generic.
+  GenericMetadata *getGenericMetadataPattern() const {
+    return const_cast<GenericMetadata*>(
+                                    GenericMetadataPatternAndKind.getPointer());
+  }
+
+  NominalTypeKind getKind() const {
+    return GenericMetadataPatternAndKind.getInt();
+  }
+
   /// The generic parameter descriptor header. This describes how to find and
   /// parse the generic parameter vector in metadata records for this nominal
   /// type.
@@ -1515,7 +1523,7 @@ struct ClassMetadata : public HeapMetadata {
   /// Get a pointer to the field type vector, if present, or null.
   const FieldType *getFieldTypes() const {
     assert(isTypeMetadata());
-    auto *getter = Description->Class.GetFieldTypes;
+    auto *getter = Description->Class.GetFieldTypes.get();
     if (!getter)
       return nullptr;
 
@@ -1693,7 +1701,7 @@ struct StructMetadata : public Metadata {
 
   /// Get a pointer to the field type vector, if present, or null.
   const FieldType *getFieldTypes() const {
-    auto *getter = Description->Struct.GetFieldTypes;
+    auto *getter = Description->Struct.GetFieldTypes.get();
     if (!getter)
       return nullptr;
 

lib/IRGen/GenDecl.cpp

@@ -2701,17 +2701,34 @@ Address IRGenFunction::createFixedSizeBufferAlloca(const llvm::Twine &name) {
 ///
 /// \returns an i8* with a null terminator; note that embedded nulls
 ///   are okay
-llvm::Constant *IRGenModule::getAddrOfGlobalString(StringRef data) {
+///
+/// FIXME: willBeRelativelyAddressed is only needed to work around an ld64 bug
+/// resolving relative references to coalesceable symbols.
+/// It should be removed when fixed. rdar://problem/22674524
+llvm::Constant *IRGenModule::getAddrOfGlobalString(StringRef data,
+                                               bool willBeRelativelyAddressed) {
   // Check whether this string already exists.
   auto &entry = GlobalStrings[data];
-  if (entry) return entry;
+  if (entry.second) {
+    // FIXME: Clear unnamed_addr if the global will be relative referenced
+    // to work around an ld64 bug. rdar://problem/22674524
+    if (willBeRelativelyAddressed)
+      entry.first->setUnnamedAddr(false);
+    return entry.second;
+  }
 
   // If not, create it.  This implicitly adds a trailing null.
   auto init = llvm::ConstantDataArray::getString(LLVMContext, data);
   auto global = new llvm::GlobalVariable(Module, init->getType(), true,
                                          llvm::GlobalValue::PrivateLinkage,
                                          init);
-  global->setUnnamedAddr(true);
+  // FIXME: ld64 crashes resolving relative references to coalesceable symbols.
+  // rdar://problem/22674524
+  // If we intend to relatively address this string, don't mark it with
+  // unnamed_addr to prevent it from going into the cstrings section and getting
+  // coalesced.
+  if (!willBeRelativelyAddressed)
+    global->setUnnamedAddr(true);
 
   // Drill down to make an i8*.
   auto zero = llvm::ConstantInt::get(SizeTy, 0);
@@ -2720,7 +2737,7 @@ llvm::Constant *IRGenModule::getAddrOfGlobalString(StringRef data) {
       global->getValueType(), global, indices);
 
   // Cache and return.
-  entry = address;
+  entry = {global, address};
   return address;
 }
 

lib/IRGen/GenEnum.cpp

@@ -158,7 +158,8 @@ llvm::Constant *EnumImplStrategy::emitCaseNames() const {
     fieldNames.push_back('\0');
   }
   // The final null terminator is provided by getAddrOfGlobalString.
-  return IGM.getAddrOfGlobalString(fieldNames);
+  return IGM.getAddrOfGlobalString(fieldNames,
+                                   /*willBeRelativelyAddressed*/ true);
 }
 
 unsigned EnumImplStrategy::getPayloadSizeForMetadata() const {
@@ -1048,7 +1049,7 @@ namespace {
       // C enums have arbitrary values and we don't preserve the mapping
       // between the case and raw value at runtime, so don't emit any
       // case names at all so that reflection can give up in this case.
-      return llvm::ConstantPointerNull::get(IGM.Int8PtrTy);
+      return nullptr;
     }
   };