Teach RemoteMirror how to project enum values (#30161)

Teach RemoteMirror how to project enum values

This adds two new functions to the SwiftRemoteMirror
facility that support inspecting enum values.

Currently, these support non-payload enums and
single-payload enums, including nested enums and
payloads with struct, tuple, and reference payloads.
In particular, it handles nested `Optional` types.

TODO: Multi-payload enums use different strategies for
encoding the cases that aren't yet supported by this
code.

Note: This relies on information from dataLayoutQuery
to correctly decode invalid pointer values that are used
to encode enums.  Existing clients will need to augment
their DLQ functions before using these new APIs.

Resolves rdar://59961527

```
/// Projects the value of an enum.
///
/// Takes the address and typeref for an enum and determines the
/// index of the currently-selected case within the enum.
///
/// Returns true iff the enum case could be successfully determined.
/// In particular, note that this code may fail for valid in-memory data
/// if the compiler is using a strategy we do not yet understand.
SWIFT_REMOTE_MIRROR_LINKAGE
int swift_reflection_projectEnumValue(SwiftReflectionContextRef ContextRef,
                                      swift_addr_t EnumAddress,
                                      swift_typeref_t EnumTypeRef,
                                      uint64_t *CaseIndex);

/// Finds information about a particular enum case.
///
/// Given an enum typeref and index of a case, returns:
/// * Typeref of the associated payload or zero if there is no payload
/// * Name of the case if known.
///
/// The Name points to a freshly-allocated C string on the heap.  You
/// are responsible for freeing the string (via `free()`) when you are finished.
SWIFT_REMOTE_MIRROR_LINKAGE
int swift_reflection_getEnumCaseTypeRef(SwiftReflectionContextRef ContextRef,
                                        swift_typeref_t EnumTypeRef,
                                        unsigned CaseIndex,
                                        char **CaseName,
                                        swift_typeref_t *PayloadTypeRef);
```


Co-authored-by: Mike Ash <mikeash@apple.com>

include/swift/Remote/MemoryReader.h

@@ -61,6 +61,50 @@ public:
                      sizeof(IntegerType));
   }
 
+  /// Attempts to read an integer of the specified size from the given
+  /// address in the remote process.
+  ///
+  /// Returns false if the operation failed, the request size is not
+  /// 1, 2, 4, or 8, or the request size is larger than the provided destination.
+  template <typename IntegerType>
+  bool readInteger(RemoteAddress address, size_t bytes, IntegerType *dest) {
+    if (bytes > sizeof(IntegerType))
+      return false;
+    switch (bytes) {
+    case 1: {
+      uint8_t n;
+      if (!readInteger(address, &n))
+        return false;
+      *dest = n;
+      break;
+    }
+    case 2: {
+      uint16_t n;
+      if (!readInteger(address, &n))
+        return false;
+      *dest = n;
+      break;
+    }
+    case 4: {
+      uint32_t n;
+      if (!readInteger(address, &n))
+        return false;
+      *dest = n;
+      break;
+    }
+    case 8: {
+      uint64_t n;
+      if (!readInteger(address, &n))
+        return false;
+      *dest = n;
+      break;
+    }
+    default:
+      return false;
+    }
+    return true;
+  }
+
   /// Attempts to read 'size' bytes from the given address in the remote process.
   ///
   /// Returns a pointer to the requested data and a function that must be called to
@@ -125,6 +169,65 @@ public:
     return resolvePointer(address, pointerData);
   }
           
+
+  // Parse extra inhabitants stored in a pointer.
+  // Sets *extraInhabitant to -1 if the pointer at this address
+  // is actually a valid pointer.
+  // Otherwise, it sets *extraInhabitant to the inhabitant
+  // index (counting from 0).
+  bool readHeapObjectExtraInhabitantIndex(RemoteAddress address,
+                                          int *extraInhabitantIndex) {
+    uint8_t PointerSize;
+    if (!queryDataLayout(DataLayoutQueryType::DLQ_GetPointerSize,
+                         nullptr, &PointerSize)) {
+      return false;
+    }
+    uint64_t LeastValidPointerValue;
+    if (!queryDataLayout(DataLayoutQueryType::DLQ_GetLeastValidPointerValue,
+                         nullptr, &LeastValidPointerValue)) {
+      return false;
+    }
+    uint8_t ObjCReservedLowBits;
+    if (!queryDataLayout(DataLayoutQueryType::DLQ_GetObjCReservedLowBits,
+                         nullptr, &ObjCReservedLowBits)) {
+      return false;
+    }
+    uint64_t RawPointerValue;
+    if (!readInteger(address, PointerSize, &RawPointerValue)) {
+      return false;
+    }
+    if (RawPointerValue >= LeastValidPointerValue) {
+      *extraInhabitantIndex = -1; // Valid value, not an XI
+    } else {
+      *extraInhabitantIndex = (RawPointerValue >> ObjCReservedLowBits);
+    }
+    return true;
+  }
+
+  bool readFunctionPointerExtraInhabitantIndex(RemoteAddress address,
+                                               int *extraInhabitantIndex) {
+    uint8_t PointerSize;
+    if (!queryDataLayout(DataLayoutQueryType::DLQ_GetPointerSize,
+                         nullptr, &PointerSize)) {
+      return false;
+    }
+    uint64_t LeastValidPointerValue;
+    if (!queryDataLayout(DataLayoutQueryType::DLQ_GetLeastValidPointerValue,
+                         nullptr, &LeastValidPointerValue)) {
+      return false;
+    }
+    uint64_t RawPointerValue;
+    if (!readInteger(address, PointerSize, &RawPointerValue)) {
+      return false;
+    }
+    if (RawPointerValue >= LeastValidPointerValue) {
+      *extraInhabitantIndex = -1; // Valid value, not an XI
+    } else {
+      *extraInhabitantIndex = RawPointerValue;
+    }
+    return true;
+  }
+
   virtual ~MemoryReader() = default;
 };