This contract is for fetching information related to native calls into the runtime.

``` csharp

TargetPointer MapTargetBackToMethodDesc(TargetCodePointer address);

Global variables used

| Global Name | Type | Purpose |

| --- | --- | --- |

| FCallMethods | ECHash[] | Hash table containing ECHash structures |

| FCallHashSize | uint | Number of buckets in the hash table |

Data descriptors used:

| Data Descriptor Name | Field | Meaning |

| --- | --- | --- |

| `ECHash` | `Next` | Pointer to the next ECHash in the chain |

| `ECHash` | `Implementation` | FCall's Entrypoint address |

| `ECHash` | `MethodDesc` | Pointer to the FCall's method desc |

``` csharp

TargetPointer IECall.MapTargetBackToMethodDesc(TargetCodePointer codePointer)

To map an FCall entrypoint back to a MethodDesc, we read the global `FCallMethods` hash table. This is a array of pointers to `ECHash` objects. The length of this array is defined by the global `FCallHashSize` and it uses a simple hash function: `<hash> = codePointer % FCallHashSize`. To find the correct `ECHash` chain, simply take the `<hash>` offset into the `FCallMethods` array.

Once we find the `ECHash` chain, we iterate the chain until we find an `ECHash` where the `Implementation` field matches the `codePointer`. If found, return the `MethodDesc` field.

If no `ECHash` matches return `TargetPointer.Null` to indicate a MethodDesc was not found.

List<TargetPointer> GetAvailableTypeParams(ModuleHandle handle);

List<TargetPointer> GetInstantiatedMethods(ModuleHandle handle);

| `Module` | `AvailableTypeParams` | Pointer to an EETypeHashTable |

| `Module` | `InstMethodHashTable` | Pointer to an InstMethodHashTable |

| `EETypeHashTable` | `Buckets` | Pointer to hash table buckets |

| `EETypeHashTable` | `Count` | Count of elements in the hash table |

| `EETypeHashTable` | `VolatileEntryValue` | The data stored in the hash table entry |

| `EETypeHashTable` | `VolatileEntryNextEntry` | Next pointer in the hash table entry |

| `InstMethodHashTable` | `Buckets` | Pointer to hash table buckets |

| `InstMethodHashTable` | `Count` | Count of elements in the hash table |

| `InstMethodHashTable` | `VolatileEntryValue` | The data stored in the hash table entry |

| `InstMethodHashTable` | `VolatileEntryNextEntry` | Next pointer in the hash table entry |

List<TargetPointer> GetAvailableTypeParams(ModuleHandle handle)

{

TargetPointer availableTypeParams = target.ReadPointer(handle.Address + /* Module::AvailableTypeParams offset */);

if (availableTypeParams == TargetPointer.Null) return [];

EETypeHashTable typeHashTable = // read EETypeHashTable at availableTypeParams

return [.. typeHashTable.Entries];

}

List<TargetPointer> GetInstantiatedMethods(ModuleHandle handle)

{

TargetPointer instMethodHashTable = target.ReadPointer(handle.Address + /* Module::InstMethodHashTable offset */);

if (instMethodHashTable == TargetPointer.Null) return [];

InstMethodHashTable typeHashTable = // read InstMethodHashTable at instMethodHashTable

List<TargetPointer> typeParams = []

foreach (TargetPointer methodDescPtrWithFlags in methodHashTable.Entires)

{

typeParams.Add(methodDescPtrWithFlags & ~0x3ul);

}

return typeParams;

}

Both `EETypeHashTable` and `InstMethodHashTable` are based on the templated `DacEnumerableHash`. Because the base class is templated on the derived type, offsets may be different in derived types.

The base implementation of `DacEnumerableHash` uses four datadescriptors:

| Datadescriptor | Purpose |

| --- | --- |

| `Buckets` | Pointer to the bucket array |

| `Count` | Number of elements in the hash table |

| `VolatileEntryValue` | The data held by an entry, defined by the derived class |

| `VolatileEntryNextEntry` | The next pointer on an hash table entry |

The hash table is laid out as an array of `VolatileEntry` pointers's (buckets), each possibly forming a chain for values that hash into that bucket. The first three buckets are special and reserved for special metadata. Instead of containing a `VolatileEntry`, these pointers are read as values with the following meanings.

| Reserved Bucket offset | Purpose |

| --- | --- |

| `0` | Length of the Bucket array, this value does not include the first 3 slots which are special |

| `1` | Pointer to the next bucket array, not currently used in the cDAC |

| `2` | End sentinel for the current bucket array, not currently used in the cDAC |

To read all entries in the hash table:

1. Read the length bucket to find the number of chains `n`.

2. Initialize a list of elements `entries = []`.

3. For each chain, (buckets with offsets `3..n + 3`):

1. Read the pointer in the bucket as `volatileEntryPtr`.

2. If `volatileEntryPtr & 0x1 == 0x1`, this is the end sentinel and we stop reading this chain.

3. Otherwise, add `volatileEntryPtr + /* VolatileEntryValue offset */` to entries. This points to the derived class defined data type.

4. Set `volatileEntryPtr` to the value of the pointer located at `volatileEntryPtr + /* VolatileEntryNextEntry offset */` and go to step 3.2.

4. Return `entries` to be further parsed by derived classes.

For both EETypeHashTable and InstMethodHashTable, the data type stored on the `VolatileEntry` are simply pointers with a couple of bits used as flags.

EETypeHashTable uses the LSB to indicate if the TypeHandle is a hot entry. Therefore this bit is stripped before values are returned.

InstMethodHashTable uses the 2 most LSBs as flags for the MethodDesc. These must be taken into account before reading values from them.

public virtual TargetPointer GetMethodDescForSlot(TypeHandle typeHandle, ushort slot);

List<TargetPointer> GetAvailableTypeParams(ModuleHandle handle) => throw new NotImplementedException();

List<TargetPointer> GetInstantiatedMethods(ModuleHandle handle) => throw new NotImplementedException();

return [.. typeHashTable.Entries];

foreach (TargetPointer methodDescPtrWithFlags in methodHashTable.Entries)

typeParams.Add(methodDescPtrWithFlags & ~0x3ul);

List<TargetPointer> entries = [];

entries.Add(methodDescPtr);

public IReadOnlyList<TargetPointer> Entries { get; init; }