cDac work necessary to get the MethodTableName

docs/design/datacontracts/DacStreams.md

@@ -0,0 +1,66 @@
+# 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 |
+
+Magic numbers
+| Name | Value |
+| --- | --- |
+| MiniMetadataSignature | 0x6d727473 |
+| EENameStreamSignature | 0x614e4545 |
+
+The format of the MiniMetadataStream begins with a Streams header, which has 3 fields
+
+| Field | Type | Offset | Meaning |
+| --- | --- | --- | --- |
+| MiniMetadataSignature| uint | 0 | Magic value used to identify that there are streams |
+| TotalSize | uint | 4 | Total size of the entire set of MiniMetadata streams including this header |
+| Count of Streams | uint | 8 | Number of streams in the MiniMetadata |
+
+The concept is that each stream simply follows the previous stream in the buffer.
+There is no padding, so the data is not expected to be aligned within the buffer.
+NOTE: At the moment there is only 1 supported stream type, so Count of Streams can only be 1.
+
+The `EENameStream` is structured as a header, plus a series of null-terminated utf8 strings, and pointers.
+
+The EENameStream header
+| Field | Type | Offset | Meaning |
+| --- | --- | --- | --- |
+| EENameStreamSignature | uint | 0 | Magic value used to identify that the bytes immediately following are an `EENameStream` |
+| CountOfNames | uint | 4 | Number of names encoded |
+
+EENameStream entry
+| Field | Type | Offset | Meaning |
+| --- | --- | --- | --- |
+| Pointer | pointer | 0 | Pointer to type system structure |
+| String | null-terminated UTF-8 sting | 4 or 8 based on target pointer size | Pointer to type system structure |
+
+Following the EENameStream header, there are CountOfNames entries. Each entry begins with a target pointer sized block which identifies a particular type system data structure, followed by a utf8 encoded null-terminated string.
+
+``` 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));
+
+ // Parse MiniMetadataStream according the the format described above to produce a dictionary from pointer to string from the EENameStream.
+ // Then lookup in the dictionary, to produce a result if it was present in the table.
+ // In general, since this api is intended for fallback scenarios, implementations of this api should attempt
+ // to return null instead of producing errors.
+ // Since in normal execution of the runtime no stream is constructed, it is normal when examining full dumps and live process state without a stream encoded.
+}
+```

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(