[NFC] Split the basic target-layout logic into its own file

Author: rjmccall

include/swift/ABI/Metadata.h

@@ -33,6 +33,7 @@
 #include "swift/Runtime/Once.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/ABI/System.h"
+#include "swift/ABI/TargetLayout.h"
 #include "swift/ABI/TrailingObjects.h"
 #include "swift/Basic/Malloc.h"
 #include "swift/Basic/FlaggedPointer.h"
@@ -66,146 +67,6 @@ template <typename Runtime> class TargetEnumDescriptor;
 template <typename Runtime> class TargetStructDescriptor;
 template <typename Runtime> struct TargetGenericMetadataPattern;
 
-template <unsigned PointerSize>
-struct RuntimeTarget;
-
-template <>
-struct RuntimeTarget<4> {
-  using StoredPointer = uint32_t;
-  // To avoid implicit conversions from StoredSignedPointer to StoredPointer.
-  using StoredSignedPointer = struct {
-    uint32_t SignedValue;
-  };
-  using StoredSize = uint32_t;
-  using StoredPointerDifference = int32_t;
-  static constexpr size_t PointerSize = 4;
-};
-
-template <>
-struct RuntimeTarget<8> {
-  using StoredPointer = uint64_t;
-  // To avoid implicit conversions from StoredSignedPointer to StoredPointer.
-  using StoredSignedPointer = struct {
-    uint64_t SignedValue;
-  };
-  using StoredSize = uint64_t;
-  using StoredPointerDifference = int64_t;
-  static constexpr size_t PointerSize = 8;
-};
-
-namespace reflection {
-  class FieldDescriptor;
-}
-
-/// In-process native runtime target.
-///
-/// For interactions in the runtime, this should be the equivalent of working
-/// with a plain old pointer type.
-struct InProcess {
-  static constexpr size_t PointerSize = sizeof(uintptr_t);
-  using StoredPointer = uintptr_t;
-  using StoredSignedPointer = uintptr_t;
-  using StoredSize = size_t;
-  using StoredPointerDifference = ptrdiff_t;
-
-#if SWIFT_OBJC_INTEROP
-  static constexpr bool ObjCInterop = true;
-  template <typename T>
-  using TargetAnyClassMetadata = TargetAnyClassMetadataObjCInterop<T>;
-#else
-  static constexpr bool ObjCInterop = false;
-  template <typename T>
-  using TargetAnyClassMetadata = TargetAnyClassMetadata<T>;
-#endif
-  template <typename T>
-  using TargetClassMetadata = TargetClassMetadata<T, TargetAnyClassMetadata<T>>;
-
-  static_assert(sizeof(StoredSize) == sizeof(StoredPointerDifference),
-                "target uses differently-sized size_t and ptrdiff_t");
-  
-  template <typename T>
-  using Pointer = T*;
-
-  template <typename T>
-  using SignedPointer = T;
-  
-  template <typename T, bool Nullable = false>
-  using FarRelativeDirectPointer = FarRelativeDirectPointer<T, Nullable>;
-
-  template <typename T, bool Nullable = false>
-  using RelativeIndirectablePointer =
-    RelativeIndirectablePointer<T, Nullable>;
-  
-  template <typename T, bool Nullable = true>
-  using RelativeDirectPointer = RelativeDirectPointer<T, Nullable>;
-};
-
-/// Represents a pointer in another address space.
-///
-/// This type should not have * or -> operators -- you must as a memory reader
-/// to read the data at the stored address on your behalf.
-template <typename Runtime, typename Pointee>
-struct ExternalPointer {
-  using StoredPointer = typename Runtime::StoredPointer;
-  StoredPointer PointerValue;
-};
-
-template <typename Runtime> struct WithObjCInterop {
-  using StoredPointer = typename Runtime::StoredPointer;
-  using StoredSignedPointer = typename Runtime::StoredSignedPointer;
-  using StoredSize = typename Runtime::StoredSize;
-  using StoredPointerDifference = typename Runtime::StoredPointerDifference;
-  static constexpr size_t PointerSize = Runtime::PointerSize;
-  static constexpr bool ObjCInterop = true;
-  template <typename T>
-  using TargetAnyClassMetadata = TargetAnyClassMetadataObjCInterop<T>;
-};
-
-template <typename Runtime> struct NoObjCInterop {
-  using StoredPointer = typename Runtime::StoredPointer;
-  using StoredSignedPointer = typename Runtime::StoredSignedPointer;
-  using StoredSize = typename Runtime::StoredSize;
-  using StoredPointerDifference = typename Runtime::StoredPointerDifference;
-  static constexpr size_t PointerSize = Runtime::PointerSize;
-  static constexpr bool ObjCInterop = false;
-  template <typename T>
-  using TargetAnyClassMetadata = TargetAnyClassMetadata<T>;
-};
-
-/// An external process's runtime target, which may be a different architecture,
-/// and may or may not have Objective-C interoperability.
-template <typename Runtime>
-struct External {
-  using StoredPointer = typename Runtime::StoredPointer;
-  using StoredSignedPointer = typename Runtime::StoredSignedPointer;
-  using StoredSize = typename Runtime::StoredSize;
-  using StoredPointerDifference = typename Runtime::StoredPointerDifference;
-  template <typename T>
-  using TargetAnyClassMetadata =
-      typename Runtime::template TargetAnyClassMetadata<T>;
-  template <typename T>
-  using TargetClassMetadata = TargetClassMetadata<T, TargetAnyClassMetadata<T>>;
-
-  static constexpr size_t PointerSize = Runtime::PointerSize;
-  static constexpr bool ObjCInterop = Runtime::ObjCInterop;
-  const StoredPointer PointerValue;
-  
-  template <typename T>
-  using Pointer = StoredPointer;
-
-  template <typename T>
-  using SignedPointer = StoredSignedPointer;
-  
-  template <typename T, bool Nullable = false>
-  using FarRelativeDirectPointer = StoredPointer;
-
-  template <typename T, bool Nullable = false>
-  using RelativeIndirectablePointer = int32_t;
-  
-  template <typename T, bool Nullable = true>
-  using RelativeDirectPointer = int32_t;
-};
-
 /// Template for branching on native pointer types versus external ones
 template <typename Runtime, template <typename> class Pointee>
 using TargetMetadataPointer
@@ -214,37 +75,28 @@ using TargetMetadataPointer
 template <typename Runtime, template <typename> class Pointee>
 using ConstTargetMetadataPointer
   = typename Runtime::template Pointer<const Pointee<Runtime>>;
-  
-template <typename Runtime, typename T>
-using TargetPointer = typename Runtime::template Pointer<T>;
-
-template <typename Runtime, typename T>
-using TargetSignedPointer = typename Runtime::template SignedPointer<T>;
-  
-template <typename Runtime, typename T>
-using ConstTargetPointer = typename Runtime::template Pointer<const T>;
-
-
-template <typename Runtime, template <typename> class Pointee,
-          bool Nullable = true>
-using ConstTargetFarRelativeDirectPointer
-  = typename Runtime::template FarRelativeDirectPointer<const Pointee<Runtime>,
-                                                        Nullable>;
-
-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 TargetRelativeIndirectablePointer
-  = typename Runtime::template RelativeIndirectablePointer<Pointee,Nullable>;
 
 struct HeapObject;
 class WeakReference;
 struct UnownedReference;
 
-template <typename Runtime> struct TargetMetadata;
-using Metadata = TargetMetadata<InProcess>;
+template <typename Runtime, bool ObjCInterop = Runtime::ObjCInterop>
+struct TargetAnyClassMetadataTypeImpl;
+template <typename Runtime>
+struct TargetAnyClassMetadataTypeImpl<Runtime, /*ObjCInterop*/ true> {
+  using type = TargetAnyClassMetadataObjCInterop<Runtime>;
+};
+template <typename Runtime>
+struct TargetAnyClassMetadataTypeImpl<Runtime, /*ObjCInterop*/ false> {
+  using type = TargetAnyClassMetadata<Runtime>;
+};
+template <typename Runtime>
+using TargetAnyClassMetadataType =
+  typename TargetAnyClassMetadataTypeImpl<Runtime>::type;
+
+template <typename Runtime>
+using TargetClassMetadataType =
+  TargetClassMetadata<Runtime, TargetAnyClassMetadataType<Runtime>>;
 
 /// The result of requesting type metadata.  Generally the return value of
 /// a function.
@@ -730,23 +582,13 @@ struct TargetMetadata {
   getTypeContextDescriptor() const {
     switch (getKind()) {
     case MetadataKind::Class: {
-      if (Runtime::ObjCInterop) {
-        const auto cls = static_cast<const TargetClassMetadata<
-            Runtime, TargetAnyClassMetadataObjCInterop<Runtime>> *>(this);
-        if (!cls->isTypeMetadata())
-          return nullptr;
-        if (cls->isArtificialSubclass())
-          return nullptr;
-        return cls->getDescription();
-      } else {
-        const auto cls = static_cast<const TargetClassMetadata<
-            Runtime, TargetAnyClassMetadata<Runtime>> *>(this);
-        if (!cls->isTypeMetadata())
-          return nullptr;
-        if (cls->isArtificialSubclass())
-          return nullptr;
-        return cls->getDescription();
-      }
+      const auto cls =
+        static_cast<const TargetClassMetadataType<Runtime> *>(this);
+      if (!cls->isTypeMetadata())
+        return nullptr;
+      if (cls->isArtificialSubclass())
+        return nullptr;
+      return cls->getDescription();
     }
     case MetadataKind::Struct:
     case MetadataKind::Enum:
@@ -763,7 +605,7 @@ struct TargetMetadata {
 
   /// Get the class object for this type if it has one, or return null if the
   /// type is not a class (or not a class with a class object).
-  const typename Runtime::template TargetClassMetadata<Runtime> *
+  const TargetClassMetadataType<Runtime> *
   getClassObject() const;
 
   /// Retrieve the generic arguments of this type, if it has any.
@@ -1008,8 +850,7 @@ struct TargetClassMetadataBounds : TargetMetadataBounds<Runtime> {
 
   using TargetMetadataBounds<Runtime>::NegativeSizeInWords;
   using TargetMetadataBounds<Runtime>::PositiveSizeInWords;
-  using TargetClassMetadata =
-      typename Runtime::template TargetClassMetadata<Runtime>;
+  using TargetClassMetadata = TargetClassMetadataType<Runtime>;
 
   /// The offset from the address point of the metadata to the immediate
   /// members.
@@ -1022,13 +863,10 @@ struct TargetClassMetadataBounds : TargetMetadataBounds<Runtime> {
     : TargetMetadataBounds<Runtime>{negativeSizeInWords, positiveSizeInWords},
       ImmediateMembersOffset(immediateMembersOffset) {}
 
-  template <typename T>
-    using TargetClassMetadataT = typename Runtime::template TargetClassMetadata<T>;
-
   /// Return the basic bounds of all Swift class metadata.
   /// The immediate members offset will not be meaningful.
   static constexpr TargetClassMetadataBounds<Runtime> forSwiftRootClass() {
-    using Metadata = FullMetadata<TargetClassMetadataT<Runtime>>;
+    using Metadata = FullMetadata<TargetClassMetadataType<Runtime>>;
     return forAddressPointAndSize(sizeof(typename Metadata::HeaderType),
                                   sizeof(Metadata));
   }
@@ -1071,8 +909,7 @@ template <typename Runtime>
 struct TargetAnyClassMetadata : public TargetHeapMetadata<Runtime> {
   using StoredPointer = typename Runtime::StoredPointer;
   using StoredSize = typename Runtime::StoredSize;
-  using TargetClassMetadata =
-      typename Runtime::template TargetClassMetadata<Runtime>;
+  using TargetClassMetadata = TargetClassMetadataType<Runtime>;
 
 protected:
   constexpr TargetAnyClassMetadata(
@@ -1109,9 +946,7 @@ struct TargetAnyClassMetadataObjCInterop
     : public TargetAnyClassMetadata<Runtime> {
   using StoredPointer = typename Runtime::StoredPointer;
   using StoredSize = typename Runtime::StoredSize;
-
-  using TargetClassMetadataObjCInterop =
-      swift::TargetClassMetadata<Runtime, TargetAnyClassMetadataObjCInterop<Runtime>>;
+  using TargetClassMetadataObjCInterop = TargetClassMetadataType<Runtime>;
 
   constexpr TargetAnyClassMetadataObjCInterop(
       TargetAnyClassMetadataObjCInterop<Runtime> *isa,
@@ -1156,11 +991,7 @@ struct TargetAnyClassMetadataObjCInterop
   }
 };
 
-#if SWIFT_OBJC_INTEROP
-using AnyClassMetadata = TargetAnyClassMetadataObjCInterop<InProcess>;
-#else
-using AnyClassMetadata = TargetAnyClassMetadata<InProcess>;
-#endif
+using AnyClassMetadata = TargetAnyClassMetadataType<InProcess>;
 
 using ClassIVarDestroyer =
   SWIFT_CC(swift) void(SWIFT_CONTEXT HeapObject *);
@@ -2594,7 +2425,7 @@ class RelativeTargetProtocolDescriptorPointer {
 template <typename Runtime>
 struct TargetTypeReference {
   template <typename T>
-  using TargetClassMetadata = typename T::template TargetClassMetadata<T>;
+  using TargetClassMetadata = TargetClassMetadataType<T>;
 
   union {
     /// A direct reference to a TypeContextDescriptor or ProtocolDescriptor.