Reflection: Move resolveRelativeField functionality onto RemoteRef

Resolving a direct relative reference given a RemoteRef doesn't need the MetadataReader,
since the offset should already be in the local buffer; we can add it to RemoteRef's
saved remote address and get a new remote address. Refactor the API to make as much as
possible of it available directly on RemoteRef.

Author: jckarter

include/swift/Reflection/TypeRefBuilder.h

@@ -532,7 +532,7 @@ class TypeRefBuilder {
         if (context->getKind() == ContextDescriptorKind::OpaqueType) {
           return Dem.createNode(
                             Node::Kind::OpaqueTypeDescriptorSymbolicReference,
-                            (uintptr_t)context.template getAddress<Runtime>());
+                            context.getAddressData());
         }
 
         return reader.buildContextMangling(context, Dem);

include/swift/Remote/MetadataReader.h

@@ -62,11 +62,6 @@ class RemoteRef {
     return Address;
   }
 
-  template<typename Runtime>
-  typename Runtime::StoredPointer getAddress() const {
-    return (typename Runtime::StoredPointer)getAddressData();
-  }
-
   const T *getLocalBuffer() const {
     return LocalBuffer;
   }
@@ -87,6 +82,26 @@ class RemoteRef {
   bool operator!=(RemoteRef<T> other) const {
     return !operator==(other);
   }
+  
+  /// Project a reference for a field. The field must be projected from the same
+  /// LocalBuffer pointer as this RemoteRef.
+  template<typename U>
+  RemoteRef<U> getField(U &field) const {
+    auto offset = (intptr_t)&field - (intptr_t)LocalBuffer;
+    return RemoteRef<U>((uint64_t)(Address + (int64_t)offset), &field);
+  }
+  
+  /// Resolve the remote address of a relative offset stored at the remote address.
+  uint64_t resolveRelativeAddressData() const {
+    int32_t offset;
+    memcpy(&offset, LocalBuffer, sizeof(int32_t));
+    return Address + (int64_t)offset;
+  }
+  
+  template<typename U>
+  uint64_t resolveRelativeFieldData(U &field) const {
+    return getField(field).resolveRelativeAddressData();
+  }
 };
 
 /// A structure, designed for use with std::unique_ptr, which destroys
@@ -1077,14 +1092,13 @@ class MetadataReader {
       return ClassMetadataBounds::forSwiftRootClass();
 
     auto rawSuperclass =
-      resolveNullableRelativeField(subclassRef,
-                                   subclass->getResilientSuperclass());
+      resolveRelativeField(subclassRef, subclass->getResilientSuperclass());
     if (!rawSuperclass) {
       return ClassMetadataBounds::forSwiftRootClass();
     }
 
     return forTypeReference<ClassMetadataBounds>(
-      subclass->getResilientSuperclassReferenceKind(), *rawSuperclass,
+      subclass->getResilientSuperclassReferenceKind(), rawSuperclass,
       [&](ContextDescriptorRef superclass)
             -> Optional<ClassMetadataBounds> {
         if (!isa<TargetClassDescriptor<Runtime>>(superclass))
@@ -1175,7 +1189,7 @@ class MetadataReader {
       return None;
 
     auto addressOfGenericArgAddress =
-      (Meta.template getAddress<Runtime>() +
+      (getAddress(Meta) +
        *offsetToGenericArgs * sizeof(StoredPointer) +
        index * sizeof(StoredPointer));
 
@@ -1246,31 +1260,6 @@ class MetadataReader {
   }
 
 protected:
-  template<typename Offset>
-  StoredPointer resolveRelativeOffset(StoredPointer targetAddress) {
-    Offset relative;
-    if (!Reader->readInteger(RemoteAddress(targetAddress), &relative))
-      return 0;
-    using SignedOffset = typename std::make_signed<Offset>::type;
-    using SignedPointer = typename std::make_signed<StoredPointer>::type;
-    auto signext = (SignedPointer)(SignedOffset)relative;
-    return targetAddress + signext;
-  }
-
-  template<typename Offset>
-  Optional<StoredPointer>
-  resolveNullableRelativeOffset(StoredPointer targetAddress) {
-    Offset relative;
-    if (!Reader->readInteger(RemoteAddress(targetAddress), &relative))
-      return None;
-    if (relative == 0)
-      return 0;
-    using SignedOffset = typename std::make_signed<Offset>::type;
-    using SignedPointer = typename std::make_signed<StoredPointer>::type;
-    auto signext = (SignedPointer)(SignedOffset)relative;
-    return targetAddress + signext;
-  }
-
   template<typename Offset>
   Optional<StoredPointer>
   resolveNullableRelativeIndirectableOffset(StoredPointer targetAddress) {
@@ -1299,33 +1288,44 @@ class MetadataReader {
     return resultAddress;
   }
 
-  template<typename Base, typename Field>
-  StoredPointer resolveRelativeField(
-                            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.template getAddress<Runtime>() + distance);
+  template<typename Base>
+  StoredPointer getAddress(RemoteRef<Base> base) {
+    return (StoredPointer)base.getAddressData();
   }
 
   template<typename Base, typename Field>
-  Optional<StoredPointer> resolveNullableRelativeField(
+  StoredPointer resolveRelativeField(
                             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.template getAddress<Runtime>() + distance);
+    return (StoredPointer)base.resolveRelativeFieldData(field);
   }
-
+  
   template<typename Base, typename Field>
-  Optional<StoredPointer> resolveNullableRelativeIndirectableField(
+  Optional<StoredPointer> resolveRelativeIndirectableField(
                             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();
+    auto fieldRef = base.getField(field);
+    int32_t offset;
+    memcpy(&offset, fieldRef.getLocalBuffer(), sizeof(int32_t));
+    
+    if (offset == 0)
+      return 0;
+    bool indirect = offset & 1;
+    offset &= ~1u;
 
-    return resolveNullableRelativeIndirectableOffset<int32_t>(
-                                base.template getAddress<Runtime>() + distance);
+    using SignedPointer = typename std::make_signed<StoredPointer>::type;
+    
+    StoredPointer resultAddress = getAddress(fieldRef) + (SignedPointer)offset;
+    
+    // Low bit set in the offset indicates that the offset leads to the absolute
+    // address in memory.
+    if (indirect) {
+      if (!Reader->readBytes(RemoteAddress(resultAddress),
+                             (uint8_t *)&resultAddress,
+                             sizeof(StoredPointer))) {
+        return None;
+      }
+    }
+    
+    return resultAddress;
   }
 
   /// Given a pointer to an Objective-C class, try to read its class name.
@@ -1532,8 +1532,7 @@ class MetadataReader {
   /// Returns None if there was an error reading the parent descriptor.
   Optional<ContextDescriptorRef>
   readParentContextDescriptor(ContextDescriptorRef base) {
-    auto parentAddress =
-                  resolveNullableRelativeIndirectableField(base, base->Parent);
+    auto parentAddress = resolveRelativeIndirectableField(base, base->Parent);
     if (!parentAddress)
       return None;
     if (!*parentAddress)
@@ -1849,8 +1848,7 @@ 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.template getAddress<Runtime>() + distance);
+    StoredPointer targetAddress(getAddress(descriptor) + distance);
 
     // Read the relative offset.
     int32_t relative;
@@ -2083,8 +2081,7 @@ class MetadataReader {
             // address.
             auto distance =
               (intptr_t)&req.Layout - (intptr_t)descriptor.getLocalBuffer();
-            StoredPointer targetAddress(
-                          descriptor.template getAddress<Runtime>() + distance);
+            StoredPointer targetAddress(getAddress(descriptor) + distance);
 
             GenericRequirementLayoutKind kind;
             if (!Reader->readBytes(RemoteAddress(targetAddress),
@@ -2282,7 +2279,7 @@ class MetadataReader {
     if (!offsetToGenericArgs)
       return {};
 
-    auto genericArgsAddr = metadata.template getAddress<Runtime>()
+    auto genericArgsAddr = getAddress(metadata)
       + sizeof(StoredPointer) * *offsetToGenericArgs;
 
     std::vector<BuiltType> builtSubsts;
@@ -2340,7 +2337,7 @@ class MetadataReader {
     // If we've skipped an artificial subclasses, check the cache at
     // the superclass.  (This also protects against recursion.)
     if (skipArtificialSubclasses && metadata != origMetadata) {
-      auto it = TypeCache.find(metadata.template getAddress<Runtime>());
+      auto it = TypeCache.find(getAddress(metadata));
       if (it != TypeCache.end())
         return it->second;
     }
@@ -2370,12 +2367,12 @@ class MetadataReader {
     if (!nominal)
       return BuiltType();
 
-    TypeCache[metadata.template getAddress<Runtime>()] = nominal;
+    TypeCache[getAddress(metadata)] = nominal;
 
     // If we've skipped an artificial subclass, remove the
     // recursion-protection entry we made for it.
     if (skipArtificialSubclasses && metadata != origMetadata) {
-      TypeCache.erase(origMetadata.template getAddress<Runtime>());
+      TypeCache.erase(getAddress(origMetadata));
     }
 
     return nominal;
@@ -2388,7 +2385,7 @@ class MetadataReader {
       return readNominalTypeFromMetadata(origMetadata, skipArtificialSubclasses);
 
     std::string className;
-    auto origMetadataPtr = origMetadata.template getAddress<Runtime>();
+    auto origMetadataPtr = getAddress(origMetadata);
     if (!readObjCClassName(origMetadataPtr, className))
       return BuiltType();