Implementation of SOSDacApi GetMethodDescName for cDAC #106169
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -92,12 +92,49 @@ struct MethodDescHandle | |
| } | ||
| ``` | ||
|
|
||
| ```csharp | ||
| public enum ArrayFunctionType | ||
| { | ||
| Get = 0, | ||
| Set = 1, | ||
| Address = 2, | ||
| Constructor = 3 | ||
| } | ||
| ``` | ||
|
|
||
| ```csharp | ||
| partial interface IRuntimeTypeSystem : IContract | ||
| { | ||
| public virtual MethodDescHandle GetMethodDescHandle(TargetPointer methodDescPointer); | ||
|
|
||
| public virtual TargetPointer GetMethodTable(MethodDescHandle methodDesc); | ||
|
|
||
| // Return true for an uninstantiated generic method | ||
| public virtual bool IsGenericMethodDefinition(MethodDescHandle methodDesc); | ||
|
|
||
| public virtual ReadOnlySpan<TypeHandle> GetGenericMethodInstantiation(MethodDescHandle methodDesc); | ||
|
|
||
| // Return mdTokenNil (0x06000000) if the method doesn't have a token, otherwise return the token of the method | ||
| public virtual uint GetMethodToken(MethodDescHandle methodDesc); | ||
|
|
||
| // Return true if a MethodDesc represents an array method | ||
| // An array method is also a StoredSigMethodDesc | ||
| public virtual bool IsArrayMethod(MethodDescHandle methodDesc, out ArrayFunctionType functionType); | ||
|
|
||
| // Return true if a MethodDesc represents a dynamically generated method, either an IL Stub dynamically | ||
| // generated by the runtime, or a MethodDesc that describes a method represented by the System.Reflection.Emit.DynamicMethod class | ||
| // A dynamic method is also a StoredSigMethodDesc | ||
| public virtual bool IsDynamicMethod(MethodDescHandle methodDesc, out ReadOnlySpan<byte> methodName); | ||
|
|
||
| // A StoredSigMethodDesc is a MethodDesc for which the signature isn't found in metadata. | ||
| public virtual bool IsStoredSigMethodDesc(MethodDescHandle methodDesc, out ReadOnlySpan<byte> signature); | ||
|
|
||
| // Return true for a MethodDesc that describes a method represented by the System.Reflection.Emit.DynamicMethod class | ||
| // A LCG method is also a StoredSigMethodDesc | ||
| public virtual bool IsLCGMethod(MethodDescHandle methodDesc); | ||
|
||
|
|
||
| // Return true if a MethodDesc represents an IL Stub dynamically generated by the runtime | ||
| public virtual bool IsILStub(MethodDescHandle methodDesc); | ||
| } | ||
| ``` | ||
|
|
||
|
|
@@ -563,7 +600,8 @@ The version 1 `MethodDesc` APIs depend on the `MethodDescAlignment` global and t | |
|
|
||
| | Global name | Meaning | | ||
| | --- | --- | | ||
| | `MethodDescAlignment` | `MethodDescChunk` trailing data is allocated in multiples of this constant. The size (in bytes) of each `MethodDesc` (or subclass) instance is a multiple of this constant. | | ||
| | `MethodDescTokenRemainderBitCount` | Number of bits in the token remainder in `MethodDesc` | | ||
|
|
||
|
|
||
| In the runtime a `MethodDesc` implicitly belongs to a single `MethodDescChunk` and some common data is shared between method descriptors that belong to the same chunk. A single method table | ||
|
|
@@ -572,12 +610,211 @@ will typically have multiple chunks. There are subkinds of MethodDescs at runti | |
| We depend on the following data descriptors: | ||
| | Data Descriptor Name | Field | Meaning | | ||
| | --- | --- | --- | | ||
| | `MethodDesc` | `ChunkIndex` | Offset of this `MethodDesc` relative to the end of its containing `MethodDescChunk` - in multiples of `MethodDescAlignment` | | ||
| | `MethodDesc` | `Slot` | The method's slot | | ||
| | `MethodDesc` | `Flags` | The method's flags | | ||
| | `MethodDesc` | `Flags3AndTokenRemainder` | More flags for the method, and the low bits of the method's token's RID | | ||
| | `MethodDescChunk` | `MethodTable` | The method table set of methods belongs to | | ||
| | `MethodDescChunk` | `Next` | The next chunk of methods | | ||
| | `MethodDescChunk` | `Size` | The size of this `MethodDescChunk` following this `MethodDescChunk` header, minus 1. In multiples of `MethodDescAlignment` | | ||
| | `MethodDescChunk` | `Count` | The number of `MethodDesc` entries in this chunk, minus 1. | | ||
| | `MethodDescChunk` | `FlagsAndTokenRange` | `MethodDescChunk` flags, and the upper bits of the method token's RID | | ||
| | `InstantiatedMethodDesc` | `PerInstInfo` | The pointer to the method's type arguments | | ||
| | `InstantiatedMethodDesc` | `Flags2` | Flags for the `InstantiatedMethodDesc` | | ||
| | `InstantiatedMethodDesc` | `NumGenericArgs` | How many generic args the method has | | ||
| | `StoredSigMethodDesc` | `Sig` | Pointer to a metadata signature | | ||
| | `StoredSigMethodDesc` | `cSig` | Count of bytes in the metadata signature | | ||
| | `StoredSigMethodDesc` | `ExtendedFlags` | Flags field for the `StoredSigMethodDesc` | | ||
| | `DynamicMethodDesc` | `MethodName` | Pointer to Null-terminated UTF8 string describing the Method desc | | ||
|
|
||
|
|
||
| And the following enumeration definitions | ||
|
|
||
| ```csharp | ||
| internal enum MethodDescClassification | ||
| { | ||
| IL = 0, // IL | ||
| FCall = 1, // FCall (also includes tlbimped ctor, Delegate ctor) | ||
| PInvoke = 2, // PInvoke method | ||
| EEImpl = 3, // special method; implementation provided by EE (like Delegate Invoke) | ||
| Array = 4, // Array ECall | ||
| Instantiated = 5, // Instantiated generic methods, including descriptors | ||
| // for both shared and unshared code (see InstantiatedMethodDesc) | ||
| ComInterop = 6, | ||
| Dynamic = 7, // for method desc with no metadata behind | ||
| } | ||
|
|
||
| [Flags] | ||
| internal enum MethodDescFlags : ushort | ||
| { | ||
| ClassificationMask = 0x7, | ||
| HasNonVtableSlot = 0x0008, | ||
| } | ||
|
|
||
| internal enum InstantiatedMethodDescFlags2 : ushort | ||
| { | ||
| KindMask = 0x07, | ||
| GenericMethodDefinition = 0x01, | ||
| UnsharedMethodInstantiation = 0x02, | ||
| SharedMethodInstantiation = 0x03, | ||
| WrapperStubWithInstantiations = 0x04, | ||
| } | ||
|
|
||
| [Flags] | ||
| internal enum DynamicMethodDescExtendedFlags : uint | ||
| { | ||
| IsLCGMethod = 0x00004000, | ||
| IsILStub = 0x00008000, | ||
| } | ||
| ``` | ||
|
|
||
|
|
||
| And the various apis are implemented with the following algorithms | ||
|
|
||
| ```csharp | ||
| public bool IsGenericMethodDefinition(MethodDescHandle methodDescHandle) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| if (methodDesc.Classification != MethodDescClassification.Instantiated) | ||
| return false; | ||
|
|
||
| ushort Flags2 = // Read Flags2 field from InstantiatedMethodDesc contract using address methodDescHandle.Address | ||
|
|
||
| return ((int)Flags2 & (int)InstantiatedMethodDescFlags2.KindMask) == (int)InstantiatedMethodDescFlags2.GenericMethodDefinition; | ||
| } | ||
|
|
||
| public ReadOnlySpan<TypeHandle> GetGenericMethodInstantiation(MethodDescHandle methodDescHandle) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| if (methodDesc.Classification != MethodDescClassification.Instantiated) | ||
| return default; | ||
|
|
||
| TargetPointer dictionaryPointer = // Read PerInstInfo field from InstantiatedMethodDesc contract using address methodDescHandle.Address | ||
| if (dictionaryPointer == 0) | ||
| return default; | ||
|
|
||
| int NumTypeArgs = // Read NumGenericArgs from methodDescHandle.Address using InstantiatedMethodDesc contract | ||
| TypeHandle[] instantiation = new TypeHandle[NumTypeArgs]; | ||
| for (int i = 0; i < NumTypeArgs; i++) | ||
| instantiation[i] = GetTypeHandle(_target.ReadPointer(dictionaryPointer + _target.PointerSize * i)); | ||
|
|
||
| return instantiation; | ||
| } | ||
|
|
||
| public uint GetMethodToken(MethodDescHandle methodDescHandle) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| TargetPointer methodDescChunk = // Using ChunkIndex from methodDesc, compute the wrapping MethodDescChunk | ||
|
|
||
| ushort Flags3AndTokenRemainder = // Read Flags3AndTokenRemainder field from MethodDesc contract using address methodDescHandle.Address | ||
|
|
||
| ushort FlagsAndTokenRange = // Read FlagsAndTokenRange field from MethodDescChunk contract using address methodDescChunk | ||
|
|
||
| int tokenRemainderBitCount = _target.ReadGlobal<byte>(Constants.Globals.MethodDescTokenRemainderBitCount); | ||
| int tokenRangeBitCount = 24 - tokenRemainderBitCount; | ||
| uint allRidBitsSet = 0xFFFFFF; | ||
| uint tokenRemainderMask = allRidBitsSet >> tokenRangeBitCount; | ||
| uint tokenRangeMask = allRidBitsSet >> tokenRemainderBitCount; | ||
|
|
||
| uint tokenRemainder = (uint)(_desc.Flags3AndTokenRemainder & tokenRemainderMask); | ||
| uint tokenRange = ((uint)(_chunk.FlagsAndTokenRange & tokenRangeMask)) << tokenRemainderBitCount; | ||
|
|
||
| return 0x06000000 | tokenRange | tokenRemainder; | ||
| } | ||
|
|
||
| public bool IsArrayMethod(MethodDescHandle methodDescHandle, out ArrayFunctionType functionType) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| if (methodDesc.Classification != MethodDescClassification.Array) | ||
| { | ||
| functionType = default; | ||
| return false; | ||
| } | ||
|
|
||
| int arrayMethodIndex = methodDesc.Slot - GetNumVtableSlots(GetTypeHandle(methodDesc.MethodTable)); | ||
|
|
||
| functionType = arrayMethodIndex switch | ||
| { | ||
| 0 => ArrayFunctionType.Get, | ||
| 1 => ArrayFunctionType.Set, | ||
| 2 => ArrayFunctionType.Address, | ||
| > 3 => ArrayFunctionType.Constructor, | ||
| _ => throw new InvalidOperationException() | ||
| }; | ||
|
|
||
| return true; | ||
| } | ||
|
|
||
| public bool IsDynamicMethod(MethodDescHandle methodDescHandle, out ReadOnlySpan<byte> methodName) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| if (methodDesc.Classification != MethodDescClassification.Dynamic) | ||
| { | ||
| methodName = default; | ||
| return false; | ||
| } | ||
|
|
||
| TargetPointer methodNamePointer = // Read MethodName field from DynamicMethodDesc contract using address methodDescHandle.Address | ||
|
|
||
| methodName = // ReadBuffer from target of a utf8 null terminated string, starting at address methodNamePointer | ||
| return true; | ||
| } | ||
|
|
||
| public bool IsStoredSigMethodDesc(MethodDescHandle methodDescHandle, out ReadOnlySpan<byte> signature) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| switch (methodDesc.Classification) | ||
| { | ||
| case MethodDescClassification.Dynamic: | ||
| case MethodDescClassification.EEImpl: | ||
| case MethodDescClassification.Array: | ||
| break; // These have stored sigs | ||
|
|
||
| default: | ||
| signature = default; | ||
| return false; | ||
| } | ||
|
|
||
| TargetPointer Sig = // Read Sig field from StoredSigMethodDesc contract using address methodDescHandle.Address | ||
| uint cSig = // Read cSig field from StoredSigMethodDesc contract using address methodDescHandle.Address | ||
|
|
||
| TargetPointer methodNamePointer = // Read S field from DynamicMethodDesc contract using address methodDescHandle.Address | ||
| signature = // Read buffer from target memory starting at address Sig, with cSig bytes in it. | ||
| return true; | ||
| } | ||
|
|
||
| public bool IsLCGMethod(MethodDescHandle methodDescHandle) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| if (methodDesc.Classification != MethodDescClassification.Dynamic) | ||
| { | ||
| return false; | ||
| } | ||
|
|
||
| uint ExtendedFlags = // Read ExtendedFlags field from StoredSigMethodDesc contract using address methodDescHandle.Address | ||
|
|
||
| return ((DynamicMethodDescExtendedFlags)ExtendedFlags).HasFlag(DynamicMethodDescExtendedFlags.IsLCGMethod); | ||
| } | ||
|
|
||
| public bool IsILStub(MethodDescHandle methodDescHandle) | ||
| { | ||
| MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; | ||
|
|
||
| if (methodDesc.Classification != MethodDescClassification.Dynamic) | ||
| { | ||
| return false; | ||
| } | ||
|
|
||
| uint ExtendedFlags = // Read ExtendedFlags field from StoredSigMethodDesc contract using address methodDescHandle.Address | ||
|
|
||
| return ((DynamicMethodDescExtendedFlags)ExtendedFlags).HasFlag(DynamicMethodDescExtendedFlags.IsILStub); | ||
| } | ||
| ``` | ||
| **TODO(cdac)** | ||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Would it make sense to just make
methodNameastringinstead ofReadOnlySpan<byte>, so the consumer doesn't have to know the encoding?There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Not a bad idea. In general, I don't want to expose arrays to contract users, as its far to easy to mutate them, but strings are nice in that they are our only truly immutable type in the BCL, and work nicely for this sort of thing.