cDac work necessary to get the MethodTableName

docs/design/datacontracts/DacStreams.md

@@ -0,0 +1,81 @@
+# Contract DacStreams
+
+This contract is for getting information from the streams embedded into a dump file as it crashes
+
+## APIs of contract
+
+``` csharp
+// Return string corresponding to type system data structure if it exists, or null otherwise
+string StringFromEEAddress(TargetPointer address);
+```
+
+## Version 1
+
+Global variables used
+| Global Name | Type | Purpose |
+| --- | --- | --- |
+| MiniMetaDataBuffAddress | TargetPointer | Identify where the mini metadata stream exists |
+| MiniMetaDataBuffMaxSize | uint | Identify where the size of the mini metadata stream |
+
+``` csharp
+string StringFromEEAddress(TargetPointer address)
+{
+    TargetPointer miniMetaDataBuffAddress = _target.Read<uint>(_target.ReadGlobalPointer(Constants.Globals.MiniMetaDataBuffAddress));
+    uint miniMetaDataBuffMaxSize = _target.Read<uint>(_target.ReadGlobalPointer(Constants.Globals.MiniMetaDataBuffMaxSize));
+
+    if (miniMetaDataBuffMaxSize < 20)
+    {
+        // buffer isn't long enough to hold required headers
+        return null;
+    }
+
+    if (_target.Read<uint>(miniMetaDataBuffAddress) != 0x6d727473)
+    {
+        // Magic number is incorrect, data is either corrupt, or this is not a crash dump with embedded mini metadata streams
+        return null;
+    }
+
+    uint totalSize = _target.Read<uint>(miniMetaDataBuffAddress + 0x4);
+    if (totalSize > miniMetaDataBuffMaxSize)
+    {
+        // totalSize is inconsistent with miniMetaDataBuffMaxSize
+        return stringToAddress;
+    }
+    uint countStreams = _target.Read<uint>(miniMetaDataBuffAddress + 0x8);
+    if (countStreams != 1)
+    {
+        // This implementation is only aware of 1 possible stream type, so only 1 can exist
+        return stringToAddress;
+    }
+    uint eeNameSig = _target.Read<uint>(miniMetaDataBuffAddress + 0xC);
+    if (eeNameSig != 0x614e4545)
+    {
+        // name of first stream is not 0x614e4545 == "EENa"
+        return stringToAddress;
+    }
+    uint countNames = _target.Read<uint>(miniMetaDataBuffAddress + 0x10);
+
+    uint currentOffset = 20;
+
+    for (int i = 0; i < countNames; i++)
+    {
+        if ((currentOffset + _target.PointerSize) > miniMetaDataBuffMaxSize)
+            break;
+        TargetPointer eeObjectPointer = _target.ReadPointer(miniMetaDataBuffAddress + currentOffset);
+        currentOffset += (uint)_target.PointerSize;
+        int stringLen = // Compute IndexOf null terminator starting at currentOffset, or -1 if it can't be found within miniMetaDataBuffMaxSize
+        if (stringLen == -1)
+            break;
+
+        if (eeObjectPointer != address)
+        {
+            currentOffset += stringLen + 1;
+            continue;
+        }
+
+        return Encoding.UTF8.GetString(miniMdBuffer.Slice((int)currentOffset, stringLen));
+    }
+
+    return null;
+}
+```

docs/design/datacontracts/Loader.md

@@ -26,6 +26,75 @@ record struct ModuleLookupTables(
     TargetPointer MethodDefToDesc,
     TargetPointer TypeDefToMethodTable,
     TargetPointer TypeRefToMethodTable);
+
+internal struct EcmaMetadataSchema
+{
+    public EcmaMetadataSchema(string metadataVersion, bool largeStringHeap, bool largeBlobHeap, bool largeGuidHeap, int[] rowCount, bool[] isSorted, bool variableSizedColumnsAre4BytesLong)
+    {
+        MetadataVersion = metadataVersion;
+        LargeStringHeap = largeStringHeap;
+        LargeBlobHeap = largeBlobHeap;
+        LargeGuidHeap = largeGuidHeap;
+
+        _rowCount = rowCount;
+        _isSorted = isSorted;
+
+        VariableSizedColumnsAreAll4BytesLong = variableSizedColumnsAre4BytesLong;
+    }
+
+    public readonly string MetadataVersion;
+
+    public readonly bool LargeStringHeap;
+    public readonly bool LargeBlobHeap;
+    public readonly bool LargeGuidHeap;
+
+    // Table data, these structures hold MetadataTable.Count entries
+    private readonly int[] _rowCount;
+    public readonly ReadOnlySpan<int> RowCount => _rowCount;
+
+    private readonly bool[] _isSorted;
+    public readonly ReadOnlySpan<bool> IsSorted => _isSorted;
+
+    // In certain scenarios the size of the tables is forced to be the maximum size
+    // Otherwise the size of columns should be computed based on RowSize/the various heap flags
+    public readonly bool VariableSizedColumnsAreAll4BytesLong;
+}
+
+internal class TargetEcmaMetadata
+{
+    public TargetEcmaMetadata(EcmaMetadataSchema schema,
+                        TargetSpan[] tables,
+                        TargetSpan stringHeap,
+                        TargetSpan userStringHeap,
+                        TargetSpan blobHeap,
+                        TargetSpan guidHeap)
+    {
+        Schema = schema;
+        _tables = tables;
+        StringHeap = stringHeap;
+        UserStringHeap = userStringHeap;
+        BlobHeap = blobHeap;
+        GuidHeap = guidHeap;
+    }
+
+    public EcmaMetadataSchema Schema { get; init; }
+
+    private TargetSpan[] _tables;
+    public ReadOnlySpan<TargetSpan> Tables => _tables;
+    public TargetSpan StringHeap { get; init; }
+    public TargetSpan UserStringHeap { get; init; }
+    public TargetSpan BlobHeap { get; init; }
+    public TargetSpan GuidHeap { get; init; }
+}
+
+[Flags]
+internal enum AvailableMetadataType
+{
+    None = 0,
+    ReadOnly = 1,
+    ReadWriteSavedCopy = 2,
+    ReadWrite = 4
+}
 ```
 
 ``` csharp
@@ -36,13 +105,31 @@ TargetPointer GetLoaderAllocator(ModuleHandle handle);
 TargetPointer GetThunkHeap(ModuleHandle handle);
 TargetPointer GetILBase(ModuleHandle handle);
 TargetPointer GetMetadataAddress(ModuleHandle handle, out ulong size);
+AvailableMetadataType GetAvailableMetadataType(ModuleHandle handle);
+TargetPointer GetReadWriteSavedMetadataAddress(ModuleHandle handle, out ulong size);
+TargetEcmaMetadata GetReadWriteMetadata(ModuleHandle handle);
 ModuleLookupTables GetLookupTables(ModuleHandle handle);
 ```
 
 ## Version 1
 
 Data descriptors used:
-- `Module`
+| Data Descriptor Name | Field | Meaning |
+| --- | --- | --- |
+| `Module` | `Assembly` | Assembly of the Module |
+| `Module` | `Base` | Pointer to start of PE file in memory |
+| `Module` | `Flags` | Assembly of the Module |
+| `Module` | `LoaderAllocator` | LoaderAllocator of the Module |
+| `Module` | `ThunkHeap` | Pointer to the thunk heap |
+| `Module` | `DynamicMetadata` | Pointer to saved metadata for reflection emit modules |
+| `Module` | `FieldDefToDescMap` | Mapping table |
+| `Module` | `ManifestModuleReferencesMap` | Mapping table |
+| `Module` | `MemberRefToDescMap` | Mapping table |
+| `Module` | `MethodDefToDescMap` | Mapping table |
+| `Module` | `TypeDefToMethodTableMap` | Mapping table |
+| `Module` | `TypeRefToMethodTableMap` | Mapping table |
+| `DynamicMetadata` | `Size` | Size of the dynamic metadata blob (as a 32bit uint) |
+| `DynamicMetadata` | `Data` | Start of dynamic metadata data array |
 
 ``` csharp
 ModuleHandle GetModuleHandle(TargetPointer modulePointer)
@@ -94,6 +181,32 @@ TargetPointer GetMetadataAddress(ModuleHandle handle, out ulong size)
     return baseAddress + rva;
 }
 
+AvailableMetadataType ILoader.GetAvailableMetadataType(ModuleHandle handle)
+{
+    Data.Module module = _target.ProcessedData.GetOrAdd<Data.Module>(handle.Address);
+
+    AvailableMetadataType flags = AvailableMetadataType.None;
+
+    TargetPointer dynamicMetadata = target.ReadPointer(handle.Address + /* Module::DynamicMetadata offset */);
+
+    if (dynamicMetadata != TargetPointer.Null)
+        flags |= AvailableMetadataType.ReadWriteSavedCopy;
+    else
+        flags |= AvailableMetadataType.ReadOnly;
+
+    return flags;
+}
+
+TargetPointer ILoader.GetReadWriteSavedMetadataAddress(ModuleHandle handle, out ulong size)
+{
+    Data.Module module = _target.ProcessedData.GetOrAdd<Data.Module>(handle.Address);
+    TargetPointer dynamicMetadata = target.ReadPointer(handle.Address + /* Module::DynamicMetadata offset */);
+
+    size = target.Read<uint>(handle.Address + /* DynamicMetadata::Size offset */);
+    TargetPointer result = handle.Address + /* DynamicMetadata::Data offset */;
+    return result;
+}
+
 ModuleLookupTables GetLookupTables(ModuleHandle handle)
 {
     return new ModuleLookupTables(