MetadataReader: Add an API for reading absolute pointers.

Pointer data in some remote reflection targets may required relocation, or may not be
fully resolvable, such as when we're dumping info from a single image on disk that
references other dynamic libraries. Add a `RemoteAbsolutePointer` type that can hold a
symbol, offset, or combination of both, and add APIs to `MemoryReader` and `MetadataReader`
for reading pointers that can get unresolved relocation info from an image, or apply
relocations to pointer information. MetadataReader can use the symbol name information to
fill in demanglings of symbolic-reference-bearing mangled names by using the information
from the symbol name to fill in the name even though the context descriptors are not
available.

For now, this is NFC (MemoryReader::resolvePointer just forwards the pointer data), but
lays the groundwork for implementation of relocation in ObjectMemoryReader.

Author: jckarter

include/swift/Basic/ExternalUnion.h

@@ -433,27 +433,27 @@ struct MembersHelper<> {
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void copyConstruct(void *self, int index, const void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveConstruct(void *self, int index, void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void copyAssignSame(int index, void *self, const void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveAssignSame(int index, void *self, void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void destruct(int index, void *self) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 };
 

include/swift/Reflection/ReflectionContext.h

@@ -608,14 +608,17 @@ class ReflectionContext
       auto CDAddr = this->readCaptureDescriptorFromMetadata(*MetadataAddress);
       if (!CDAddr)
         return nullptr;
+      if (!CDAddr->isResolved())
+        return nullptr;
 
       // FIXME: Non-generic SIL boxes also use the HeapLocalVariable metadata
       // kind, but with a null capture descriptor right now (see
       // FixedBoxTypeInfoBase::allocate).
       //
       // Non-generic SIL boxes share metadata among types with compatible
       // layout, but we need some way to get an outgoing pointer map for them.
-      auto CD = getBuilder().getCaptureDescriptor(*CDAddr);
+      auto CD = getBuilder().getCaptureDescriptor(
+                                CDAddr->getResolvedAddress().getAddressData());
       if (CD == nullptr)
         return nullptr;
 

include/swift/Remote/MemoryReader.h

@@ -69,7 +69,7 @@ class MemoryReader {
   /// NOTE: subclasses MUST override at least one of the readBytes functions. The default
   /// implementation calls through to the other one.
   virtual ReadBytesResult
-    readBytes(RemoteAddress address, uint64_t size) {
+  readBytes(RemoteAddress address, uint64_t size) {
     auto *Buf = malloc(size);
     ReadBytesResult Result(Buf, [](const void *ptr) {
       free(const_cast<void *>(ptr));
@@ -96,6 +96,34 @@ class MemoryReader {
     memcpy(dest, Ptr.get(), size);
     return true;
   }
+  
+  /// Attempts to resolve a pointer value read from the given remote address.
+  virtual RemoteAbsolutePointer resolvePointer(RemoteAddress address,
+                                               uint64_t readValue) {
+    // Default implementation returns the read value as is.
+    return RemoteAbsolutePointer("", readValue);
+  }
+  
+  /// Attempt to read and resolve a pointer value at the given remote address.
+  llvm::Optional<RemoteAbsolutePointer> readPointer(RemoteAddress address,
+                                                    unsigned pointerSize) {
+    auto result = readBytes(address, pointerSize);
+    if (!result)
+      return llvm::None;
+    
+    uint64_t pointerData;
+    if (pointerSize == 4) {
+      uint32_t theData;
+      memcpy(&theData, result.get(), 4);
+      pointerData = theData;
+    } else if (pointerSize == 8) {
+      memcpy(&pointerData, result.get(), 8);
+    } else {
+      return llvm::None;
+    }
+    
+    return resolvePointer(address, pointerData);
+  }
 
   virtual ~MemoryReader() = default;
 };