Revert "Only use metadata patterns for generic types; perform other"

This reverts commit 41efb3d.
LLDB has too many tendrils into our metadata.

Author: rjmccall

Diff for: include/swift/Basic/RelativePointer.h

@@ -17,114 +17,6 @@
 // unnecessary relocation at dynamic linking time. This header contains types
 // to help dereference these relative addresses.
 //
-// Theory of references to objects
-// -------------------------------
-//
-// A reference can be absolute or relative:
-//
-//   - An absolute reference is a pointer to the object.
-//
-//   - A relative reference is a (signed) offset from the address of the
-//     reference to the address of its direct referent.
-//
-// A relative reference can be direct, indirect, or symbolic.
-//
-// In a direct reference, the direct referent is simply the target object.
-// Generally, a statically-emitted relative reference can only be direct
-// if it can be resolved to a constant offset by the linker, because loaders
-// do not support forming relative references.  This means that either the
-// reference and object must lie within the same linkage unit or the
-// difference must be computed at runtime by code.
-//
-// In a symbolic reference, the direct referent is a string holding the symbol
-// name of the object.  A relative reference can only be symbolic if the
-// object actually has a symbol at runtime, which may require exporting
-// many internal symbols that would otherwise be strippable.
-//
-// In an indirect reference, the direct referent is a variable holding an
-// absolute reference to the object.  An indirect relative reference may
-// refer to an arbitrary symbol, be it anonymous within the linkage unit
-// or completely external to it, but it requires the introduction of an
-// intermediate absolute reference that requires load-time initialization.
-// However, this initialization can be shared among all indirect references
-// within the linkage unit, and the linker will generally place all such
-// references adjacent to one another to improve load-time locality.
-//
-// A reference can be made a dynamic union of more than one of these options.
-// This allows the compiler/linker to use a direct reference when possible
-// and a less-efficient option where required.  However, it also requires
-// the cases to be dynamically distinguished.  This can be done by setting
-// a low bit of the offset, as long as the difference between the direct
-// referent's address and the reference is a multiple of 2.  This works well
-// for "indirectable" references because most objects are known to be
-// well-aligned, and the cases that aren't (chiefly functions and strings)
-// rarely need the flexibility of this kind of reference.  It does not
-// work quite as well for "possibly symbolic" references because C strings
-// are not naturally aligned, and making them aligned generally requires
-// moving them out of the linker's ordinary string section; however, it's
-// still workable.
-//
-// Finally, a relative reference can be near or far.  A near reference
-// is potentially smaller, but it requires the direct referent to lie
-// within a certain distance of the reference, even if dynamically
-// initialized.
-//
-// In Swift, we always prefer to use a near direct relative reference
-// when it is possible to do so: that is, when the relationship is always
-// between two global objects emitted in the same linkage unit, and there
-// is no compatibility constraint requiring the use of an absolute reference.
-//
-// When more flexibility is required, there are several options:
-// 
-//   1. Use an absolute reference.  Size penalty on 64-bit.  Requires
-//      load-time work.
-//
-//   2. Use a far direct relative reference.  Size penalty on 64-bit.
-//      Requires load-time work when object is outside linkage unit.
-//      Generally not directly supported by loaders.
-//
-//   3. Use an always-indirect relative reference.  Size penalty of one
-//      pointer (shared).  Requires load-time work even when object is
-//      within linkage unit.
-//
-//   4. Use a near indirectable relative reference.  Size penalty of one
-//      pointer (shared) when reference exceeds range.  Runtime / code-size
-//      penalty on access.  Requires load-time work (shared) only when
-//      object is outside linkage unit.
-//
-//   5. Use a far indirectable relative reference.  Size penalty on 64-bit.
-//      Size penalty of one pointer (shared) when reference exceeds range
-//      and is initialized statically.  Runtime / code-size penalty on access.
-//      Requires load-time work (shared) only when object is outside linkage
-//      unit.
-//
-//   6. Use a near or far symbolic relative reference.  No load-time work.
-//      Severe runtime penalty on access.  Requires custom logic to statically
-//      optimize.  Requires emission of symbol for target even if private
-//      to linkage unit.
-//
-//   7. Use a near or far direct-or-symbolic relative reference.  No
-//      load-time work.  Severe runtime penalty on access if object is
-//      outside of linkage unit.  Requires custom logic to statically optimize.
-//
-// In general, it's our preference in Swift to use option #4 when there
-// is no possibility of initializing the reference dynamically and option #5
-// when there is.  This is because it is infeasible to actually share the
-// memory for the intermediate absolute reference when it must be allocated
-// dynamically.
-//
-// Symbolic references are an interesting idea that we have not yet made
-// use of.  They may be acceptable in reflective metadata cases where it
-// is desireable to heavily bias towards never using the metadata.  However,
-// they're only profitable if there wasn't any other indirect reference
-// to the target, and it is likely that their optimal use requires a more
-// intelligent toolchain from top to bottom.
-//
-// Note that the cost of load-time work also includes a binary-size penalty
-// to store the loader metadata necessary to perform that work.  Therefore
-// it is better to avoid it even when there are dynamic optimizations in
-// place to skip the work itself.
-//
 //===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_BASIC_RELATIVEPOINTER_H
@@ -387,8 +279,7 @@ class RelativeDirectPointer<RetTy (ArgTy...), Nullable, Offset> :
 
 /// A direct relative reference to an aligned object, with an additional
 /// tiny integer value crammed into its low bits.
-template<typename PointeeTy, typename IntTy, bool Nullable = false,
-         typename Offset = int32_t>
+template<typename PointeeTy, typename IntTy, typename Offset = int32_t>
 class RelativeDirectPointerIntPair {
   Offset RelativeOffsetPlusInt;
 
@@ -414,14 +305,9 @@ class RelativeDirectPointerIntPair {
   using PointerTy = PointeeTy*;
 
   PointerTy getPointer() const & {
-    Offset offset = (RelativeOffsetPlusInt & ~getMask());
-
-    // Check for null.
-    if (Nullable && offset == 0)
-      return nullptr;
-
     // The value is addressed relative to `this`.
-    uintptr_t absolute = detail::applyRelativeOffset(this, offset);
+    uintptr_t absolute = detail::applyRelativeOffset(this,
+                                            RelativeOffsetPlusInt & ~getMask());
     return reinterpret_cast<PointerTy>(absolute);
   }
 

Diff for: include/swift/Runtime/Metadata.h

@@ -34,6 +34,31 @@
 
 namespace swift {
 
+/// A bump pointer for metadata allocations. Since metadata is (currently)
+/// never released, it does not support deallocation. This allocator by itself
+/// is not thread-safe; in concurrent uses, allocations must be guarded by
+/// a lock, such as the per-metadata-cache lock used to guard metadata
+/// instantiations. All allocations are pointer-aligned.
+class MetadataAllocator {
+  /// Address of the next available space. The allocator grabs a page at a time,
+  /// so the need for a new page can be determined by page alignment.
+  ///
+  /// Initializing to -1 instead of nullptr ensures that the first allocation
+  /// triggers a page allocation since it will always span a "page" boundary.
+  char *next = (char*)(~(uintptr_t)0U);
+  
+public:
+  MetadataAllocator() = default;
+
+  // Don't copy or move, please.
+  MetadataAllocator(const MetadataAllocator &) = delete;
+  MetadataAllocator(MetadataAllocator &&) = delete;
+  MetadataAllocator &operator=(const MetadataAllocator &) = delete;
+  MetadataAllocator &operator=(MetadataAllocator &&) = delete;
+  
+  void *alloc(size_t size);
+};
+  
 template <unsigned PointerSize>
 struct RuntimeTarget;
 
@@ -65,10 +90,6 @@ struct InProcess {
 
   template <typename T, bool Nullable = false>
   using FarRelativeDirectPointer = FarRelativeDirectPointer<T, Nullable>;
-
-  template <typename T, bool Nullable = false>
-  using FarRelativeIndirectablePointer =
-    FarRelativeIndirectablePointer<T, Nullable>;
 
   template <typename T, bool Nullable = true>
   using RelativeDirectPointer = RelativeDirectPointer<T, Nullable>;
@@ -97,9 +118,6 @@ struct External {
 
   template <typename T, bool Nullable = false>
   using FarRelativeDirectPointer = StoredPointer;
-
-  template <typename T, bool Nullable = false>
-  using FarRelativeIndirectablePointer = StoredSize;
 
   template <typename T, bool Nullable = true>
   using RelativeDirectPointer = int32_t;
@@ -127,10 +145,6 @@ template <typename Runtime, typename Pointee, bool Nullable = true>
 using TargetRelativeDirectPointer
   = typename Runtime::template RelativeDirectPointer<Pointee, Nullable>;
 
-template <typename Runtime, typename Pointee, bool Nullable = true>
-using TargetFarRelativeIndirectablePointer
-  = typename Runtime::template FarRelativeIndirectablePointer<Pointee,Nullable>;
-
 struct HeapObject;
 
 template <typename Runtime> struct TargetMetadata;
@@ -1466,33 +1480,16 @@ struct TargetNominalTypeDescriptor {
   };
 
   RelativeDirectPointerIntPair<TargetGenericMetadata<Runtime>,
-                               NominalTypeKind, /*Nullable*/ true>
+                               NominalTypeKind>
     GenericMetadataPatternAndKind;
 
-  using NonGenericMetadataAccessFunction = const Metadata *();
-
-  /// A pointer to the metadata access function for this type.
-  ///
-  /// The type of the returned function is speculative; in reality, it
-  /// takes one argument for each of the generic requirements, in the order
-  /// they are listed.  Therefore, the function type is correct only if
-  /// this type is non-generic.
-  ///
-  /// Not all type metadata have access functions.
-  TargetRelativeDirectPointer<Runtime, NonGenericMetadataAccessFunction,
-                              /*nullable*/ true> AccessFunction;
-
   /// A pointer to the generic metadata pattern that is used to instantiate
   /// instances of this type. Zero if the type is not generic.
   TargetGenericMetadata<Runtime> *getGenericMetadataPattern() const {
     return const_cast<TargetGenericMetadata<Runtime>*>(
                                     GenericMetadataPatternAndKind.getPointer());
   }
 
-  NonGenericMetadataAccessFunction *getAccessFunction() const {
-    return AccessFunction.get();
-  }
-
   NominalTypeKind getKind() const {
     return GenericMetadataPatternAndKind.getInt();
   }
@@ -1931,9 +1928,9 @@ struct TargetValueMetadata : public TargetMetadata<Runtime> {
   Description;
 
   /// The parent type of this member type, or null if this is not a
-  /// member type.  It's acceptable to make this a direct pointer because
-  /// parent types are relatively uncommon.
-  TargetPointer<Runtime, const TargetMetadata<Runtime>> Parent;
+  /// member type.
+  FarRelativeIndirectablePointer<const TargetMetadata<Runtime>,
+    /*nullable*/ true> Parent;
 
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Struct
@@ -2781,6 +2778,12 @@ struct TargetProtocolConformanceRecord {
 using ProtocolConformanceRecord
   = TargetProtocolConformanceRecord<InProcess>;
 
+/// \brief Fetch a uniqued metadata object for a nominal type with
+/// resilient layout.
+SWIFT_RUNTIME_EXPORT
+extern "C" const Metadata *
+swift_getResilientMetadata(GenericMetadata *pattern);
+
 /// \brief Fetch a uniqued metadata object for a generic nominal type.
 ///
 /// The basic algorithm for fetching a metadata object is:
@@ -3025,16 +3028,11 @@ struct ClassFieldLayout {
 
 /// Initialize the field offset vector for a dependent-layout class, using the
 /// "Universal" layout strategy.
-///
-/// This will relocate the metadata if it doesn't have enough space
-/// for its superclass.  Note that swift_allocateGenericClassMetadata will
-/// never produce a metadata that requires relocation.
 SWIFT_RUNTIME_EXPORT
-extern "C" ClassMetadata *
-swift_initClassMetadata_UniversalStrategy(ClassMetadata *self,
-                                          size_t numFields,
-                                          const ClassFieldLayout *fieldLayouts,
-                                          size_t *fieldOffsets);
+extern "C" void swift_initClassMetadata_UniversalStrategy(ClassMetadata *self,
+                                      size_t numFields,
+                                      const ClassFieldLayout *fieldLayouts,
+                                      size_t *fieldOffsets);
 
 /// \brief Fetch a uniqued metadata for a metatype type.
 SWIFT_RUNTIME_EXPORT

Diff for: include/swift/Runtime/RuntimeFunctions.def

@@ -568,6 +568,12 @@ FUNCTION(GetForeignTypeMetadata, swift_getForeignTypeMetadata, DefaultCC,
          ARGS(TypeMetadataPtrTy),
          ATTRS(NoUnwind, ReadNone)) // only writes to runtime-private fields
 
+// Metadata *swift_getResilientMetadata(GenericMetadata *pattern);
+FUNCTION(GetResilientMetadata, swift_getResilientMetadata, DefaultCC,
+         RETURNS(TypeMetadataPtrTy),
+         ARGS(TypeMetadataPatternPtrTy),
+         ATTRS(NoUnwind, ReadOnly))
+
 // Metadata *swift_getGenericMetadata(GenericMetadata *pattern,
 //                                    const void *arguments);
 FUNCTION(GetGenericMetadata, swift_getGenericMetadata, RegisterPreservingCC,
@@ -658,13 +664,13 @@ FUNCTION(GetExistentialMetadata,
          ATTRS(NoUnwind, ReadOnly))
 
 // struct FieldInfo { size_t Size; size_t AlignMask; };
-// Metadata *swift_initClassMetadata_UniversalStrategy(Metadata *self,
-//                                                     size_t numFields,
-//                                                     const FieldInfo *fields,
-//                                                     size_t *fieldOffsets);
+// void swift_initClassMetadata_UniversalStrategy(Metadata *self,
+//                                                size_t numFields,
+//                                                const FieldInfo *fields,
+//                                                size_t *fieldOffsets);
 FUNCTION(InitClassMetadataUniversal,
          swift_initClassMetadata_UniversalStrategy, DefaultCC,
-         RETURNS(TypeMetadataPtrTy),
+         RETURNS(VoidTy),
          ARGS(TypeMetadataPtrTy, SizeTy,
               SizeTy->getPointerTo(),
               SizeTy->getPointerTo()),
@@ -928,6 +934,10 @@ FUNCTION(RegisterTypeMetadataRecords,
          ARGS(TypeMetadataRecordPtrTy, TypeMetadataRecordPtrTy),
          ATTRS(NoUnwind))
 
+FUNCTION(InitializeSuperclass, swift_initializeSuperclass, DefaultCC,
+         RETURNS(VoidTy),
+         ARGS(TypeMetadataPtrTy, Int1Ty),
+         ATTRS(NoUnwind))
 FUNCTION(InstantiateObjCClass, swift_instantiateObjCClass, DefaultCC,
          RETURNS(VoidTy),
          ARGS(TypeMetadataPtrTy),

Diff for: lib/IRGen/ClassMetadataLayout.h

@@ -95,7 +95,7 @@ template <class Impl> class ClassMetadataLayout : public MetadataLayout<Impl> {
 
     // Add a reference to the parent class, if applicable.
     if (theClass->getDeclContext()->isTypeContext()) {
-      asImpl().addParentMetadataRef(theClass, type);
+      asImpl().addParentMetadataRef(theClass);
     }
 
     // Add space for the generic parameters, if applicable.
@@ -232,7 +232,7 @@ class ClassMetadataScanner : public ClassMetadataLayout<Impl> {
   void addIVarDestroyer() { addPointer(); }
   void addValueWitnessTable() { addPointer(); }
   void addDestructorFunction() { addPointer(); }
-  void addParentMetadataRef(ClassDecl *forClass, Type classType) {addPointer();}
+  void addParentMetadataRef(ClassDecl *forClass) { addPointer(); }
   void addSuperClass() { addPointer(); }
   void addClassFlags() { addInt32(); }
   void addInstanceAddressPoint() { addInt32(); }