Reflection: Make RemoteRef template not depend on Runtime.

The only thing the Runtime affects is the width of the StoredPointer for the remote address, for
which storing a uint64_t ought to be enough for anyone we care about so far. This will make it
easier to store and use RemoteRefs in code that isn't or shouldn't ideally be templatized on
Runtime (such as TypeRefBuilder, and ultimately ReflectionContext, from the Reflection library.)

Author: jckarter

include/swift/Reflection/TypeRefBuilder.h

@@ -531,8 +531,8 @@ class TypeRefBuilder {
         // underlying type if available.
         if (context->getKind() == ContextDescriptorKind::OpaqueType) {
           return Dem.createNode(
-                              Node::Kind::OpaqueTypeDescriptorSymbolicReference,
-                              (uintptr_t)context.getAddress());
+                            Node::Kind::OpaqueTypeDescriptorSymbolicReference,
+                            (uintptr_t)context.template getAddress<Runtime>());
         }
 
         return reader.buildContextMangling(context, Dem);

include/swift/Remote/MetadataReader.h

@@ -43,26 +43,29 @@ using TypeDecoder = swift::Demangle::TypeDecoder<BuilderType>;
 
 /// A pointer to the local buffer of an object that also remembers the
 /// address at which it was stored remotely.
-template <typename Runtime, typename T>
+template <typename T>
 class RemoteRef {
-public:
-  using StoredPointer = typename Runtime::StoredPointer;
-
 private:
-  StoredPointer Address;
+  uint64_t Address;
   const T *LocalBuffer;
 
 public:
   /*implicit*/
   RemoteRef(std::nullptr_t _)
     : Address(0), LocalBuffer(nullptr) {}
 
+  template<typename StoredPointer>
   explicit RemoteRef(StoredPointer address, const T *localBuffer)
-    : Address(address), LocalBuffer(localBuffer) {}
+    : Address((uint64_t)address), LocalBuffer(localBuffer) {}
 
-  StoredPointer getAddress() const {
+  uint64_t getAddressData() const {
     return Address;
   }
+  
+  template<typename Runtime>
+  typename Runtime::StoredPointer getAddress() const {
+    return (typename Runtime::StoredPointer)getAddressData();
+  }
 
   const T *getLocalBuffer() const {
     return LocalBuffer;
@@ -76,6 +79,14 @@ class RemoteRef {
     assert(LocalBuffer);
     return LocalBuffer;
   }
+  
+  bool operator==(RemoteRef<T> other) const {
+    return Address == other.Address;
+  }
+  
+  bool operator!=(RemoteRef<T> other) const {
+    return !operator==(other);
+  }
 };
 
 /// A structure, designed for use with std::unique_ptr, which destroys
@@ -127,17 +138,15 @@ class MetadataReader {
   /// A cache of built types, keyed by the address of the type.
   std::unordered_map<StoredPointer, BuiltType> TypeCache;
 
-  using MetadataRef =
-    RemoteRef<Runtime, TargetMetadata<Runtime>>;
+  using MetadataRef = RemoteRef<TargetMetadata<Runtime>>;
   using OwnedMetadataRef =
     std::unique_ptr<const TargetMetadata<Runtime>, delete_with_free>;
 
   /// A cache of read type metadata, keyed by the address of the metadata.
   std::unordered_map<StoredPointer, OwnedMetadataRef>
     MetadataCache;
 
-  using ContextDescriptorRef =
-    RemoteRef<Runtime, TargetContextDescriptor<Runtime>>;
+  using ContextDescriptorRef = RemoteRef<TargetContextDescriptor<Runtime>>;
   using OwnedContextDescriptorRef =
     std::unique_ptr<const TargetContextDescriptor<Runtime>,
                     delete_with_free>;
@@ -1166,7 +1175,7 @@ class MetadataReader {
       return None;
 
     auto addressOfGenericArgAddress =
-      (Meta.getAddress() +
+      (Meta.template getAddress<Runtime>() +
        *offsetToGenericArgs * sizeof(StoredPointer) +
        index * sizeof(StoredPointer));
 
@@ -1292,29 +1301,31 @@ class MetadataReader {
 
   template<typename Base, typename Field>
   StoredPointer resolveRelativeField(
-                            RemoteRef<Runtime, Base> base, const Field &field) {
+                            RemoteRef<Base> base, const Field &field) {
     // Map the offset from within our local buffer to the remote address.
     auto distance = (intptr_t)&field - (intptr_t)base.getLocalBuffer();
-    return resolveRelativeOffset<int32_t>(base.getAddress() + distance);
+    return resolveRelativeOffset<int32_t>(
+                                base.template getAddress<Runtime>() + distance);
   }
 
   template<typename Base, typename Field>
   Optional<StoredPointer> resolveNullableRelativeField(
-                            RemoteRef<Runtime, Base> base, const Field &field) {
+                            RemoteRef<Base> base, const Field &field) {
     // Map the offset from within our local buffer to the remote address.
     auto distance = (intptr_t)&field - (intptr_t)base.getLocalBuffer();
 
-    return resolveNullableRelativeOffset<int32_t>(base.getAddress() + distance);
+    return resolveNullableRelativeOffset<int32_t>(
+                                base.template getAddress<Runtime>() + distance);
   }
 
   template<typename Base, typename Field>
   Optional<StoredPointer> resolveNullableRelativeIndirectableField(
-                            RemoteRef<Runtime, Base> base, const Field &field) {
+                            RemoteRef<Base> base, const Field &field) {
     // Map the offset from within our local buffer to the remote address.
     auto distance = (intptr_t)&field - (intptr_t)base.getLocalBuffer();
 
     return resolveNullableRelativeIndirectableOffset<int32_t>(
-                                                  base.getAddress() + distance);
+                                base.template getAddress<Runtime>() + distance);
   }
 
   /// Given a pointer to an Objective-C class, try to read its class name.
@@ -1838,7 +1849,8 @@ class MetadataReader {
       const RelativeTargetProtocolDescriptorPointer<Runtime> &protocol) {
     // Map the offset from within our local buffer to the remote address.
     auto distance = (intptr_t)&protocol - (intptr_t)descriptor.getLocalBuffer();
-    StoredPointer targetAddress(descriptor.getAddress() + distance);
+    StoredPointer targetAddress(
+                          descriptor.template getAddress<Runtime>() + distance);
 
     // Read the relative offset.
     int32_t relative;
@@ -2071,7 +2083,8 @@ class MetadataReader {
             // address.
             auto distance =
               (intptr_t)&req.Layout - (intptr_t)descriptor.getLocalBuffer();
-            StoredPointer targetAddress(descriptor.getAddress() + distance);
+            StoredPointer targetAddress(
+                          descriptor.template getAddress<Runtime>() + distance);
 
             GenericRequirementLayoutKind kind;
             if (!Reader->readBytes(RemoteAddress(targetAddress),
@@ -2106,7 +2119,7 @@ class MetadataReader {
       // Use the remote address to identify the anonymous context.
       char addressBuf[18];
       snprintf(addressBuf, sizeof(addressBuf), "$%" PRIx64,
-               (uint64_t)descriptor.getAddress());
+               (uint64_t)descriptor.getAddressData());
       auto anonNode = dem.createNode(Node::Kind::AnonymousContext);
       CharVector addressStr;
       addressStr.append(addressBuf, dem);
@@ -2269,7 +2282,7 @@ class MetadataReader {
     if (!offsetToGenericArgs)
       return {};
 
-    auto genericArgsAddr = metadata.getAddress()
+    auto genericArgsAddr = metadata.template getAddress<Runtime>()
       + sizeof(StoredPointer) * *offsetToGenericArgs;
 
     std::vector<BuiltType> builtSubsts;
@@ -2326,9 +2339,8 @@ class MetadataReader {
 
     // If we've skipped an artificial subclasses, check the cache at
     // the superclass.  (This also protects against recursion.)
-    if (skipArtificialSubclasses &&
-        metadata.getAddress() != origMetadata.getAddress()) {
-      auto it = TypeCache.find(metadata.getAddress());
+    if (skipArtificialSubclasses && metadata != origMetadata) {
+      auto it = TypeCache.find(metadata.template getAddress<Runtime>());
       if (it != TypeCache.end())
         return it->second;
     }
@@ -2358,13 +2370,12 @@ class MetadataReader {
     if (!nominal)
       return BuiltType();
 
-    TypeCache[metadata.getAddress()] = nominal;
+    TypeCache[metadata.template getAddress<Runtime>()] = nominal;
 
     // If we've skipped an artificial subclass, remove the
     // recursion-protection entry we made for it.
-    if (skipArtificialSubclasses &&
-        metadata.getAddress() != origMetadata.getAddress()) {
-      TypeCache.erase(origMetadata.getAddress());
+    if (skipArtificialSubclasses && metadata != origMetadata) {
+      TypeCache.erase(origMetadata.template getAddress<Runtime>());
     }
 
     return nominal;
@@ -2377,7 +2388,8 @@ class MetadataReader {
       return readNominalTypeFromMetadata(origMetadata, skipArtificialSubclasses);
 
     std::string className;
-    if (!readObjCClassName(origMetadata.getAddress(), className))
+    auto origMetadataPtr = origMetadata.template getAddress<Runtime>();
+    if (!readObjCClassName(origMetadataPtr, className))
       return BuiltType();
 
     BuiltType BuiltObjCClass = Builder.createObjCClassType(std::move(className));
@@ -2390,7 +2402,7 @@ class MetadataReader {
                                             skipArtificialSubclasses);
     }
 
-    TypeCache[origMetadata.getAddress()] = BuiltObjCClass;
+    TypeCache[origMetadataPtr] = BuiltObjCClass;
     return BuiltObjCClass;
   }
 
@@ -2583,11 +2595,11 @@ class MetadataReader {
 } // end namespace swift
 
 namespace llvm {
-  template<typename Runtime, typename T>
-  struct simplify_type<swift::remote::RemoteRef<Runtime, T>> {
+  template<typename T>
+  struct simplify_type<swift::remote::RemoteRef<T>> {
     using SimpleType = const T *;
     static SimpleType
-    getSimplifiedValue(swift::remote::RemoteRef<Runtime, T> value) {
+    getSimplifiedValue(swift::remote::RemoteRef<T> value) {
       return value.getLocalBuffer();
     }
   };