internal HandleBasedGenericMethodLookup(InstantiatedMethod methodToLookup) : base(methodToLookup)
{
Debug.Assert(methodToLookup != null);
_declaringType = _methodToLookup.OwningType.RuntimeTypeHandle;
_nameAndSignature = _methodToLookup.NameAndSignature;
// _genericMethodArgumentHandles not initialized here to avoid allocation of a new array (and it's not used if we initialize _typeToLookup).
}
private bool FindMatchingInterfaceSlot(IntPtr moduleHandle, NativeReader nativeLayoutReader, ref NativeParser entryParser, ref ExternalReferencesTable extRefs, ref RuntimeTypeHandle declaringType, ref MethodNameAndSignature methodNameAndSignature, RuntimeTypeHandle openTargetTypeHandle, RuntimeTypeHandle[] targetTypeInstantiation, bool variantDispatch)
{
uint numTargetImplementations = entryParser.GetUnsigned();
for (uint j = 0; j < numTargetImplementations; j++)
{
uint nameAndSigToken = extRefs.GetRvaFromIndex(entryParser.GetUnsigned());
MethodNameAndSignature targetMethodNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, nameAndSigToken);
RuntimeTypeHandle targetTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine(" Searching for GVM implementation on targe type = " + GetTypeNameDebug(targetTypeHandle));
#endif
uint numIfaceImpls = entryParser.GetUnsigned();
for (uint k = 0; k < numIfaceImpls; k++)
{
RuntimeTypeHandle implementingTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
uint numIfaceSigs = entryParser.GetUnsigned();
if (!openTargetTypeHandle.Equals(implementingTypeHandle))
{
// Skip over signatures data
for (uint l = 0; l < numIfaceSigs; l++)
entryParser.GetUnsigned();
continue;
}
for (uint l = 0; l < numIfaceSigs; l++)
{
RuntimeTypeHandle currentIfaceTypeHandle = default(RuntimeTypeHandle);
NativeParser ifaceSigParser = new NativeParser(nativeLayoutReader, extRefs.GetRvaFromIndex(entryParser.GetUnsigned()));
IntPtr currentIfaceSigPtr = ifaceSigParser.Reader.OffsetToAddress(ifaceSigParser.Offset);
if (TypeLoaderEnvironment.Instance.GetTypeFromSignatureAndContext(currentIfaceSigPtr, targetTypeInstantiation, null, out currentIfaceTypeHandle, out currentIfaceSigPtr))
{
Debug.Assert(!currentIfaceTypeHandle.IsNull());
if ((!variantDispatch && declaringType.Equals(currentIfaceTypeHandle)) ||
(variantDispatch && RuntimeAugments.IsAssignableFrom(declaringType, currentIfaceTypeHandle)))
{
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine(" " + (declaringType.Equals(currentIfaceTypeHandle) ? "Exact" : "Variant-compatible") + " match found on this target type!");
#endif
// We found the GVM slot target for the input interface GVM call, so let's update the interface GVM slot and return success to the caller
declaringType = targetTypeHandle;
methodNameAndSignature = targetMethodNameAndSignature;
return true;
}
}
}
}
}
return false;
}
public unsafe override sealed bool TryGetGenericVirtualTargetForTypeAndSlot(RuntimeTypeHandle targetHandle, ref RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, ref string methodName, ref IntPtr methodSignature, out IntPtr methodPointer, out IntPtr dictionaryPointer, out bool slotUpdated)
{
MethodNameAndSignature methodNameAndSignature = new MethodNameAndSignature(methodName, methodSignature);
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine("GVM resolution starting for " + GetTypeNameDebug(declaringType) + "." + methodNameAndSignature.Name + "(...) on a target of type " + GetTypeNameDebug(targetHandle) + " ...");
#endif
if (RuntimeAugments.IsInterface(declaringType))
{
methodPointer = IntPtr.Zero;
dictionaryPointer = IntPtr.Zero;
slotUpdated = ResolveInterfaceGenericVirtualMethodSlot(targetHandle, ref declaringType, ref methodNameAndSignature);
methodName = methodNameAndSignature.Name;
methodSignature = methodNameAndSignature.Signature;
return slotUpdated;
}
else
{
slotUpdated = false;
return ResolveGenericVirtualMethodTarget(targetHandle, declaringType, genericArguments, methodNameAndSignature, out methodPointer, out dictionaryPointer);
}
}
public bool TryGetGenericVirtualTargetForTypeAndSlot(RuntimeTypeHandle targetHandle, ref RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, ref string methodName, ref RuntimeSignature methodSignature, out IntPtr methodPointer, out IntPtr dictionaryPointer, out bool slotUpdated)
{
MethodNameAndSignature methodNameAndSignature = new MethodNameAndSignature(methodName, methodSignature);
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine("GVM resolution starting for " + GetTypeNameDebug(declaringType) + "." + methodNameAndSignature.Name + "(...) on a target of type " + GetTypeNameDebug(targetHandle) + " ...");
#endif
if (RuntimeAugments.IsInterface(declaringType))
{
methodPointer = IntPtr.Zero;
dictionaryPointer = IntPtr.Zero;
slotUpdated = ResolveInterfaceGenericVirtualMethodSlot(targetHandle, ref declaringType, ref methodNameAndSignature);
methodName = methodNameAndSignature.Name;
methodSignature = methodNameAndSignature.Signature;
return(slotUpdated);
}
else
{
slotUpdated = false;
return(ResolveGenericVirtualMethodTarget(targetHandle, declaringType, genericArguments, methodNameAndSignature, out methodPointer, out dictionaryPointer));
}
}
internal HandleBasedGenericMethodLookup(RuntimeTypeHandle declaringType, MethodNameAndSignature nameAndSignature, RuntimeTypeHandle[] genericMethodArgumentHandles) : base(null)
{
Debug.Assert(!declaringType.IsNull() && nameAndSignature != null && genericMethodArgumentHandles != null);
_declaringType = declaringType;
_nameAndSignature = nameAndSignature;
_genericMethodArgumentHandles = genericMethodArgumentHandles;
}
public RuntimeMethodKey(bool unboxingStub, DefType owningType, MethodNameAndSignature nameAndSignature)
{
_unboxingStub = unboxingStub;
_owningType = owningType;
_methodNameAndSignature = nameAndSignature;
_hashCode = TypeHashingAlgorithms.ComputeMethodHashCode(owningType.GetHashCode(), TypeHashingAlgorithms.ComputeNameHashCode(nameAndSignature.Name));
}
public bool TryGetGenericVirtualTargetForTypeAndSlot(RuntimeTypeHandle targetHandle, ref RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, ref string methodName, ref RuntimeSignature methodSignature, bool lookForDefaultImplementation, out IntPtr methodPointer, out IntPtr dictionaryPointer, out bool slotUpdated)
{
MethodNameAndSignature methodNameAndSignature = new MethodNameAndSignature(methodName, methodSignature);
#if GVM_RESOLUTION_TRACE
Debug.WriteLine("GVM resolution starting for " + GetTypeNameDebug(declaringType) + "." + methodNameAndSignature.Name + "(...) on a target of type " + GetTypeNameDebug(targetHandle) + " ...");
#endif
if (RuntimeAugments.IsInterface(declaringType))
{
if (!ResolveInterfaceGenericVirtualMethodSlot(targetHandle, lookForDefaultImplementation, ref declaringType, ref methodNameAndSignature))
{
methodPointer = dictionaryPointer = IntPtr.Zero;
slotUpdated = false;
return(false);
}
if (RuntimeAugments.IsInterface(declaringType))
{
slotUpdated = false;
if (!TryGetGenericVirtualMethodPointer(declaringType, methodNameAndSignature, genericArguments, out methodPointer, out dictionaryPointer))
{
var sb = new System.Text.StringBuilder();
sb.AppendLine("Generic virtual method pointer lookup failure.");
sb.AppendLine();
sb.AppendLine("Declaring type handle: " + declaringType.LowLevelToStringRawEETypeAddress());
sb.AppendLine("Target type handle: " + targetHandle.LowLevelToStringRawEETypeAddress());
sb.AppendLine("Method name: " + methodNameAndSignature.Name);
sb.AppendLine("Instantiation:");
for (int i = 0; i < genericArguments.Length; i++)
{
sb.AppendLine(" Argument " + i.LowLevelToString() + ": " + genericArguments[i].LowLevelToStringRawEETypeAddress());
}
Environment.FailFast(sb.ToString());
}
}
else
{
methodPointer = IntPtr.Zero;
dictionaryPointer = IntPtr.Zero;
slotUpdated = true;
methodName = methodNameAndSignature.Name;
methodSignature = methodNameAndSignature.Signature;
}
return(true);
}
else
{
slotUpdated = false;
return(ResolveGenericVirtualMethodTarget(targetHandle, declaringType, genericArguments, methodNameAndSignature, out methodPointer, out dictionaryPointer));
}
}
public RuntimeMethodDesc(bool unboxingStub, DefType owningType,
MethodNameAndSignature nameAndSignature, int hashcode)
{
_owningType = owningType;
_nameAndSignature = nameAndSignature;
_unboxingStub = unboxingStub;
SetHashCode(hashcode);
#if DEBUG
DebugName = this.ToString();
#endif
}
public uint GetGenericArgumentCountFromMethodNameAndSignature(MethodNameAndSignature signature)
{
if (signature.Signature.IsNativeLayoutSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(signature.Signature);
NativeParser parser = new NativeParser(reader, signature.Signature.NativeLayoutOffset);
return(GetGenericArgCountFromSig(parser));
}
else
{
ModuleInfo module = signature.Signature.GetModuleInfo();
#if ECMA_METADATA_SUPPORT
if (module is NativeFormatModuleInfo)
#endif
{
NativeFormatModuleInfo nativeFormatModule = (NativeFormatModuleInfo)module;
var metadataReader = nativeFormatModule.MetadataReader;
var methodHandle = signature.Signature.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
var methodSignature = method.Signature.GetMethodSignature(metadataReader);
return(checked ((uint)methodSignature.GenericParameterCount));
}
#if ECMA_METADATA_SUPPORT
else
{
EcmaModuleInfo ecmaModuleInfo = (EcmaModuleInfo)module;
var metadataReader = ecmaModuleInfo.MetadataReader;
var ecmaHandle = (System.Reflection.Metadata.MethodDefinitionHandle)System.Reflection.Metadata.Ecma335.MetadataTokens.Handle(signature.Signature.Token);
var method = metadataReader.GetMethodDefinition(ecmaHandle);
var blobHandle = method.Signature;
var blobReader = metadataReader.GetBlobReader(blobHandle);
byte sigByte = blobReader.ReadByte();
if ((sigByte & (byte)System.Reflection.Metadata.SignatureAttributes.Generic) == 0)
{
return(0);
}
uint genArgCount = checked ((uint)blobReader.ReadCompressedInteger());
return(genArgCount);
}
#endif
}
}
private unsafe bool TryGetDynamicRuntimeMethodHandleComponents(RuntimeMethodHandle runtimeMethodHandle, out RuntimeTypeHandle declaringTypeHandle, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgs)
{
IntPtr runtimeMethodHandleValue = *(IntPtr *)&runtimeMethodHandle;
Debug.Assert((runtimeMethodHandleValue.ToInt64() & 0x1) == 0x1);
// Special flag in the handle value to indicate it was dynamically allocated, and doesn't point into the InvokeMap blob
runtimeMethodHandleValue = runtimeMethodHandleValue - 1;
DynamicMethodHandleInfo *methodData = (DynamicMethodHandleInfo *)runtimeMethodHandleValue.ToPointer();
declaringTypeHandle = *(RuntimeTypeHandle *)&(methodData->DeclaringType);
genericMethodArgs = Empty <RuntimeTypeHandle> .Array;
if (methodData->NumGenericArgs > 0)
{
IntPtr *genericArgPtr = &(methodData->GenericArgsArray);
genericMethodArgs = new RuntimeTypeHandle[methodData->NumGenericArgs];
for (int i = 0; i < methodData->NumGenericArgs; i++)
{
genericMethodArgs[i] = *(RuntimeTypeHandle *)&(genericArgPtr[i]);
}
}
if (methodData->MethodSignature.IsNativeLayoutSignature)
{
// MethodName points to the method name in NativeLayout format, so we parse it using a NativeParser
IntPtr methodNamePtr = methodData->MethodName;
string name = GetStringFromMemoryInNativeFormat(methodNamePtr);
nameAndSignature = new MethodNameAndSignature(name, methodData->MethodSignature);
}
else
{
// method signature is NativeFormat
var metadataReader = ModuleList.Instance.GetMetadataReaderForModule(methodData->MethodSignature.ModuleHandle);
var methodHandle = methodData->MethodSignature.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
nameAndSignature = new MethodNameAndSignature(metadataReader.GetConstantStringValue(method.Name).Value, methodData->MethodSignature);
}
return(true);
}
public uint GetGenericArgumentCountFromMethodNameAndSignature(MethodNameAndSignature signature)
{
if (signature.Signature.IsNativeLayoutSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(signature.Signature.ModuleHandle);
NativeParser parser = new NativeParser(reader, signature.Signature.NativeLayoutOffset);
return(GetGenericArgCountFromSig(parser));
}
else
{
var metadataReader = ModuleList.Instance.GetMetadataReaderForModule(signature.Signature.ModuleHandle);
var methodHandle = signature.Signature.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
var methodSignature = method.Signature.GetMethodSignature(metadataReader);
return(checked ((uint)methodSignature.GenericParameterCount));
}
}
internal MethodDesc GetMethod(ref NativeParser parser, out RuntimeSignature methodNameSig, out RuntimeSignature methodSig)
{
MethodFlags flags = (MethodFlags)parser.GetUnsigned();
IntPtr functionPointer = IntPtr.Zero;
if ((flags & MethodFlags.HasFunctionPointer) != 0)
{
functionPointer = GetExternalReferencePointer(parser.GetUnsigned());
}
DefType containingType = (DefType)GetType(ref parser);
MethodNameAndSignature nameAndSignature = TypeLoaderEnvironment.Instance.GetMethodNameAndSignature(ref parser, _module.Handle, out methodNameSig, out methodSig);
bool unboxingStub = (flags & MethodFlags.IsUnboxingStub) != 0;
MethodDesc retVal = null;
if ((flags & MethodFlags.HasInstantiation) != 0)
{
TypeDesc[] typeArguments = GetTypeSequence(ref parser);
Debug.Assert(typeArguments.Length > 0);
retVal = this._typeSystemContext.ResolveGenericMethodInstantiation(unboxingStub, containingType, nameAndSignature, new Instantiation(typeArguments), functionPointer, (flags & MethodFlags.FunctionPointerIsUSG) != 0);
}
else
{
retVal = this._typeSystemContext.ResolveRuntimeMethod(unboxingStub, containingType, nameAndSignature, functionPointer, (flags & MethodFlags.FunctionPointerIsUSG) != 0);
}
if ((flags & MethodFlags.FunctionPointerIsUSG) != 0)
{
// TODO, consider a change such that if a USG function pointer is passed in, but we have
// a way to get a non-usg pointer, that may be preferable
Debug.Assert(retVal.UsgFunctionPointer != IntPtr.Zero);
}
return(retVal);
}
public bool TryGetMethodNameAndSignatureFromNativeLayoutSignature(ref IntPtr signature, out MethodNameAndSignature nameAndSignature)
{
nameAndSignature = null;
NativeReader reader = GetNativeLayoutInfoReader(RuntimeAugments.GetModuleFromPointer(signature));
uint offset = reader.AddressToOffset(signature);
NativeParser parser = new NativeParser(reader, offset);
if (parser.IsNull)
{
return(false);
}
IntPtr methodSigPtr;
IntPtr methodNameSigPtr;
nameAndSignature = GetMethodNameAndSignature(ref parser, out methodNameSigPtr, out methodSigPtr);
signature = (IntPtr)((long)signature + (parser.Offset - offset));
return(true);
}
public bool TryGetMethodNameAndSignatureFromNativeLayoutOffset(IntPtr moduleHandle, uint nativeLayoutOffset, out MethodNameAndSignature nameAndSignature)
{
nameAndSignature = null;
NativeReader reader = GetNativeLayoutInfoReader(moduleHandle);
NativeParser parser = new NativeParser(reader, nativeLayoutOffset);
if (parser.IsNull)
{
return(false);
}
IntPtr methodSigPtr;
IntPtr methodNameSigPtr;
nameAndSignature = GetMethodNameAndSignature(ref parser, out methodNameSigPtr, out methodSigPtr);
return(true);
}
private bool ResolveInterfaceGenericVirtualMethodSlot(RuntimeTypeHandle targetTypeHandle, ref RuntimeTypeHandle declaringType, ref MethodNameAndSignature methodNameAndSignature)
{
// Get the open type definition of the containing type of the generic virtual method being resolved
RuntimeTypeHandle openCallingTypeHandle;
RuntimeTypeHandle[] callingTypeInstantiation;
if (!TryGetOpenTypeDefinition(declaringType, out openCallingTypeHandle, out callingTypeInstantiation))
return false;
// Get the open type definition of the current type of the object instance on which the GVM is being resolved
RuntimeTypeHandle openTargetTypeHandle;
RuntimeTypeHandle[] targetTypeInstantiation;
if (!TryGetOpenTypeDefinition(targetTypeHandle, out openTargetTypeHandle, out targetTypeInstantiation))
return false;
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine("INTERFACE GVM call = " + GetTypeNameDebug(declaringType) + "." + methodNameAndSignature.Name);
#endif
foreach (IntPtr moduleHandle in ModuleList.Enumerate(RuntimeAugments.GetModuleFromTypeHandle(openTargetTypeHandle)))
{
NativeReader gvmTableReader;
if (!TryGetNativeReaderForBlob(moduleHandle, ReflectionMapBlob.InterfaceGenericVirtualMethodTable, out gvmTableReader))
continue;
NativeReader nativeLayoutReader;
if (!TryGetNativeReaderForBlob(moduleHandle, ReflectionMapBlob.NativeLayoutInfo, out nativeLayoutReader))
continue;
NativeParser gvmTableParser = new NativeParser(gvmTableReader, 0);
NativeHashtable gvmHashtable = new NativeHashtable(gvmTableParser);
ExternalReferencesTable extRefs = default(ExternalReferencesTable);
extRefs.InitializeCommonFixupsTable(moduleHandle);
var lookup = gvmHashtable.Lookup(openCallingTypeHandle.GetHashCode());
NativeParser entryParser;
while (!(entryParser = lookup.GetNext()).IsNull)
{
RuntimeTypeHandle interfaceTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
if (!openCallingTypeHandle.Equals(interfaceTypeHandle))
continue;
uint nameAndSigToken = extRefs.GetRvaFromIndex(entryParser.GetUnsigned());
MethodNameAndSignature interfaceMethodNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, nameAndSigToken);
if (!interfaceMethodNameAndSignature.Equals(methodNameAndSignature))
continue;
// For each of the possible GVM slot targets for the current interface call, we will do the following:
//
// Step 1: Scan the types that currently provide implementations for the current GVM slot target, and look
// for ones that match the target object's type.
//
// Step 2: For each type that we find in step #1, get a list of all the interfaces that the current GVM target
// provides an implementation for
//
// Step 3: For each interface in the list in step #2, parse the signature of that interface, do the generic argument
// substitution (in case of a generic interface), and check if this interface signature is assignable from the
// calling interface signature (from the name and sig input). if there is an exact match based on
// interface type, then we've found the right slot. Otherwise, re-scan the entry again and see if some interface
// type is compatible with the initial slots interface by means of variance.
// This is done by calling the TypeLoaderEnvironment helper function.
//
// Example:
// public interface IFoo<out T, out U>
// {
// string M1<V>();
// }
// public class Foo1<T, U> : IFoo<T, U>, IFoo<Kvp<T, string>, U>
// {
// string IFoo<T, U>.M1<V>() { ... }
// public virtual string M1<V>() { ... }
// }
// public class Foo2<T, U> : Foo1<object, U>, IFoo<U, T>
// {
// string IFoo<U, T>.M1<V>() { ... }
// }
//
// GVM Table layout for IFoo<T, U>.M1<V>:
// {
// InterfaceTypeHandle = IFoo<T, U>
// InterfaceMethodNameAndSignature = { "M1", SigOf(string M1) }
// GVMTargetSlots[] =
// {
// {
// TargetMethodNameAndSignature = { "M1", SigOf(M1) }
// TargetTypeHandle = Foo1<T, U>
// ImplementingTypes[] = {
// ImplementingTypeHandle = Foo1<T, U>
// ImplementedInterfacesSignatures[] = { SigOf(IFoo<!0, !1>) }
// }
// },
//
// {
// TargetMethodNameAndSignature = { "M1", SigOf(M1) }
// TargetTypeHandle = Foo1<T, U>
// ImplementingTypes[] = {
// ImplementingTypeHandle = Foo1<T, U>
// ImplementedInterfacesSignatures[] = { SigOf(IFoo<Kvp<!0, string>, !1>) }
// }
// },
//
// {
// TargetMethodNameAndSignature = { "M1", SigOf(M1) }
// TargetTypeHandle = Foo2<T, U>
// ImplementingTypes = {
// ImplementingTypeHandle = Foo2<T, U>
// ImplementedInterfacesSignatures[] = { SigOf(IFoo<!1, !0>) }
// }
// },
// }
// }
//
uint currentOffset = entryParser.Offset;
// Non-variant dispatch of a variant generic interface generic virtual method.
if (FindMatchingInterfaceSlot(moduleHandle, nativeLayoutReader, ref entryParser, ref extRefs, ref declaringType, ref methodNameAndSignature, openTargetTypeHandle, targetTypeInstantiation, false))
{
return true;
}
entryParser.Offset = currentOffset;
// Variant dispatch of a variant generic interface generic virtual method.
if (FindMatchingInterfaceSlot(moduleHandle, nativeLayoutReader, ref entryParser, ref extRefs, ref declaringType, ref methodNameAndSignature, openTargetTypeHandle, targetTypeInstantiation, true))
{
return true;
}
}
}
return false;
}
public override bool GetRuntimeMethodHandleComponents(RuntimeMethodHandle runtimeMethodHandle, out RuntimeTypeHandle declaringTypeHandle, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgs)
{
return TypeLoaderEnvironment.Instance.TryGetRuntimeMethodHandleComponents(runtimeMethodHandle, out declaringTypeHandle, out nameAndSignature, out genericMethodArgs);
}
//
// Parse a native layout signature pointed to by "signature" in the executable image, optionally using
// "typeArgs" and "methodArgs" for generic type parameter substitution. The first field in "signature"
// must be an encoded method but any data beyond that is user-defined and returned in "remainingSignature"
//
public bool GetMethodFromSignatureAndContext(RuntimeSignature signature, RuntimeTypeHandle[] typeArgs, RuntimeTypeHandle[] methodArgs, out RuntimeTypeHandle createdType, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodTypeArgumentHandles, out RuntimeSignature remainingSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(signature);
NativeParser parser = new NativeParser(reader, signature.NativeLayoutOffset);
bool result = GetMethodFromSignatureAndContext(ref parser, new TypeManagerHandle(signature.ModuleHandle), typeArgs, methodArgs, out createdType, out nameAndSignature, out genericMethodTypeArgumentHandles);
remainingSignature = RuntimeSignature.CreateFromNativeLayoutSignature(signature, parser.Offset);
return result;
}
public bool TryGetMethodNameAndSignatureFromNativeLayoutOffset(TypeManagerHandle moduleHandle, uint nativeLayoutOffset, out MethodNameAndSignature nameAndSignature)
{
nameAndSignature = null;
NativeReader reader = GetNativeLayoutInfoReader(moduleHandle);
NativeParser parser = new NativeParser(reader, nativeLayoutOffset);
if (parser.IsNull)
{
return(false);
}
RuntimeSignature methodSig;
RuntimeSignature methodNameSig;
nameAndSignature = GetMethodNameAndSignature(ref parser, moduleHandle, out methodNameSig, out methodSig);
return(true);
}
private unsafe bool TryGetDynamicRuntimeMethodHandleComponents(RuntimeMethodHandle runtimeMethodHandle, out RuntimeTypeHandle declaringTypeHandle, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgs)
{
IntPtr runtimeMethodHandleValue = *(IntPtr *)&runtimeMethodHandle;
Debug.Assert((runtimeMethodHandleValue.ToInt64() & 0x1) == 0x1);
// Special flag in the handle value to indicate it was dynamically allocated, and doesn't point into the InvokeMap blob
runtimeMethodHandleValue = runtimeMethodHandleValue - 1;
DynamicMethodHandleInfo *methodData = (DynamicMethodHandleInfo *)runtimeMethodHandleValue.ToPointer();
declaringTypeHandle = *(RuntimeTypeHandle *)&(methodData->DeclaringType);
genericMethodArgs = null;
if (methodData->NumGenericArgs > 0)
{
IntPtr *genericArgPtr = &(methodData->GenericArgsArray);
genericMethodArgs = new RuntimeTypeHandle[methodData->NumGenericArgs];
for (int i = 0; i < methodData->NumGenericArgs; i++)
{
genericMethodArgs[i] = *(RuntimeTypeHandle *)&(genericArgPtr[i]);
}
}
if (methodData->MethodSignature.IsNativeLayoutSignature)
{
// MethodName points to the method name in NativeLayout format, so we parse it using a NativeParser
IntPtr methodNamePtr = methodData->MethodName;
string name = GetStringFromMemoryInNativeFormat(methodNamePtr);
nameAndSignature = new MethodNameAndSignature(name, methodData->MethodSignature);
}
else
{
ModuleInfo moduleInfo = methodData->MethodSignature.GetModuleInfo();
string name;
#if ECMA_METADATA_SUPPORT
if (moduleInfo is NativeFormatModuleInfo)
#endif
{
var metadataReader = ((NativeFormatModuleInfo)moduleInfo).MetadataReader;
var methodHandle = methodData->MethodSignature.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
name = metadataReader.GetConstantStringValue(method.Name).Value;
}
#if ECMA_METADATA_SUPPORT
else
{
var ecmaReader = ((EcmaModuleInfo)moduleInfo).MetadataReader;
var ecmaHandle = System.Reflection.Metadata.Ecma335.MetadataTokens.Handle(methodData->MethodSignature.Token);
var ecmaMethodHandle = (System.Reflection.Metadata.MethodDefinitionHandle)ecmaHandle;
var ecmaMethod = ecmaReader.GetMethodDefinition(ecmaMethodHandle);
name = ecmaReader.GetString(ecmaMethod.Name);
}
#endif
nameAndSignature = new MethodNameAndSignature(name, methodData->MethodSignature);
}
return(true);
}
/// <summary>
/// Find a method based on owner type and nativelayout name, method instantiation, and signature.
/// </summary>
public MethodDesc ResolveGenericMethodInstantiation(bool unboxingStub, DefType owningType, MethodNameAndSignature nameAndSignature, Instantiation methodInstantiation, IntPtr functionPointer, bool usgFunctionPointer)
{
var uninstantiatedMethod = ResolveRuntimeMethod(unboxingStub, owningType, nameAndSignature, IntPtr.Zero, false);
MethodDesc returnedMethod;
if (methodInstantiation.IsNull || (methodInstantiation.Length == 0))
{
returnedMethod = uninstantiatedMethod;
}
else
{
returnedMethod = GetInstantiatedMethod(uninstantiatedMethod, methodInstantiation);
}
if (functionPointer != IntPtr.Zero)
{
returnedMethod.SetFunctionPointer(functionPointer, usgFunctionPointer);
}
return(returnedMethod);
}
internal MethodDesc ResolveRuntimeMethod(bool unboxingStub, DefType owningType, MethodNameAndSignature nameAndSignature, IntPtr functionPointer, bool usgFunctionPointer)
{
if (_runtimeMethods == null)
{
_runtimeMethods = new RuntimeMethodKey.RuntimeMethodKeyHashtable();
}
MethodDesc retVal = _runtimeMethods.GetOrCreateValue(new RuntimeMethodKey(unboxingStub, owningType, nameAndSignature));
if (functionPointer != IntPtr.Zero)
{
retVal.SetFunctionPointer(functionPointer, usgFunctionPointer);
}
return(retVal);
}
public bool TryGetMethodNameAndSignatureFromNativeLayoutSignature(RuntimeSignature signature, out MethodNameAndSignature nameAndSignature)
{
nameAndSignature = null;
NativeReader reader = GetNativeLayoutInfoReader(signature);
NativeParser parser = new NativeParser(reader, signature.NativeLayoutOffset);
if (parser.IsNull)
{
return(false);
}
nameAndSignature = GetMethodNameAndSignature(ref parser, new TypeManagerHandle(signature.ModuleHandle), out _, out _);
return(true);
}
public bool TryGetRuntimeMethodHandleComponents(RuntimeMethodHandle runtimeMethodHandle, out RuntimeTypeHandle declaringTypeHandle, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgs)
{
return(runtimeMethodHandle.IsDynamic() ?
TryGetDynamicRuntimeMethodHandleComponents(runtimeMethodHandle, out declaringTypeHandle, out nameAndSignature, out genericMethodArgs) :
TryGetStaticRuntimeMethodHandleComponents(runtimeMethodHandle, out declaringTypeHandle, out nameAndSignature, out genericMethodArgs));
}
public bool TryGetMethodNameAndSignatureFromNativeLayoutSignature(ref IntPtr signature, out MethodNameAndSignature nameAndSignature)
{
throw new NotImplementedException();
}
private unsafe bool TryGetStaticRuntimeMethodHandleComponents(RuntimeMethodHandle runtimeMethodHandle, out RuntimeTypeHandle declaringTypeHandle, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgs)
{
declaringTypeHandle = default(RuntimeTypeHandle);
nameAndSignature = null;
genericMethodArgs = null;
// Make sure it's not a dynamically allocated RuntimeMethodHandle before we attempt to use it to parse native layout data
Debug.Assert(((*(IntPtr *)&runtimeMethodHandle).ToInt64() & 0x1) == 0);
RuntimeMethodHandleInfo *methodData = *(RuntimeMethodHandleInfo **)&runtimeMethodHandle;
RuntimeSignature signature;
#if !CORERT
// If the system module is compiled with as a type manager, all modules are compiled as such
if (ModuleList.Instance.SystemModule.Handle.IsTypeManager)
#endif
{
// The native layout info signature is a pair.
// The first is a pointer that points to the TypeManager indirection cell.
// The second is the offset into the native layout info blob in that TypeManager, where the native signature is encoded.
IntPtr *nativeLayoutInfoSignatureData = (IntPtr *)methodData->NativeLayoutInfoSignature;
signature = RuntimeSignature.CreateFromNativeLayoutSignature(
new TypeManagerHandle(*(IntPtr *)nativeLayoutInfoSignatureData[0]),
(uint)nativeLayoutInfoSignatureData[1].ToInt32());
}
#if !CORERT
else
{
IntPtr moduleHandle = RuntimeAugments.GetOSModuleFromPointer(methodData->NativeLayoutInfoSignature);
signature = RuntimeSignature.CreateFromNativeLayoutSignature(
new TypeManagerHandle(moduleHandle),
GetNativeLayoutInfoReader(new TypeManagerHandle(moduleHandle)).AddressToOffset(methodData->NativeLayoutInfoSignature));
}
#endif
RuntimeSignature remainingSignature;
return(GetMethodFromSignatureAndContext(signature, null, null, out declaringTypeHandle, out nameAndSignature, out genericMethodArgs, out remainingSignature));
}
public bool TryGetGenericMethodDictionaryForComponents(RuntimeTypeHandle declaringTypeHandle, RuntimeTypeHandle[] genericMethodArgHandles, MethodNameAndSignature nameAndSignature, out IntPtr methodDictionary)
{
throw new NotImplementedException();
}
public bool TryGetMethodNameAndSignatureFromNativeLayoutOffset(IntPtr moduleHandle, uint nativeLayoutOffset, out MethodNameAndSignature nameAndSignature)
{
throw new NotImplementedException();
}
public bool TryGetRuntimeMethodHandleComponents(RuntimeMethodHandle runtimeMethodHandle, out RuntimeTypeHandle declaringTypeHandle, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgs)
{
throw new NotImplementedException();
}
internal bool GetMethodFromSignatureAndContext(ref NativeParser parser, TypeManagerHandle moduleHandle, RuntimeTypeHandle[] typeArgs, RuntimeTypeHandle[] methodArgs, out RuntimeTypeHandle createdType, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodTypeArgumentHandles)
{
createdType = default(RuntimeTypeHandle);
nameAndSignature = null;
genericMethodTypeArgumentHandles = null;
TypeSystemContext context = TypeSystemContextFactory.Create();
MethodDesc parsedMethod = TryParseNativeSignatureWorker(context, moduleHandle, ref parser, typeArgs, methodArgs, true) as MethodDesc;
if (parsedMethod == null)
return false;
if (!EnsureTypeHandleForType(parsedMethod.OwningType))
return false;
createdType = parsedMethod.OwningType.RuntimeTypeHandle;
nameAndSignature = parsedMethod.NameAndSignature;
if (!parsedMethod.IsMethodDefinition && parsedMethod.Instantiation.Length > 0)
{
genericMethodTypeArgumentHandles = new RuntimeTypeHandle[parsedMethod.Instantiation.Length];
for (int i = 0; i < parsedMethod.Instantiation.Length; ++i)
{
if (!EnsureTypeHandleForType(parsedMethod.Instantiation[i]))
return false;
genericMethodTypeArgumentHandles[i] = parsedMethod.Instantiation[i].RuntimeTypeHandle;
}
}
TypeSystemContextFactory.Recycle(context);
return true;
}
public bool TryGetGenericMethodComponents(IntPtr methodDictionary, out RuntimeTypeHandle declaringType, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgumentHandles)
{
throw new NotImplementedException();
}
public bool TryGetGenericMethodDictionaryForComponents(RuntimeTypeHandle declaringTypeHandle, RuntimeTypeHandle[] genericMethodArgHandles, MethodNameAndSignature nameAndSignature, out IntPtr methodDictionary)
{
if (TryLookupGenericMethodDictionaryForComponents(declaringTypeHandle, nameAndSignature, genericMethodArgHandles, out methodDictionary))
return true;
using (LockHolder.Hold(_typeLoaderLock))
{
return TypeBuilder.TryBuildGenericMethod(declaringTypeHandle, genericMethodArgHandles, nameAndSignature, out methodDictionary);
}
}
public bool TryGetGenericVirtualMethodPointer(RuntimeTypeHandle targetTypeHandle, MethodNameAndSignature nameAndSignature, RuntimeTypeHandle[] genericMethodArgumentHandles, out IntPtr methodPointer, out IntPtr dictionaryPointer)
{
throw new NotImplementedException();
}
public abstract bool GetRuntimeMethodHandleComponents(RuntimeMethodHandle runtimeMethodHandle, out RuntimeTypeHandle declaringTypeHandle, out MethodNameAndSignature nameAndSignature, out RuntimeTypeHandle[] genericMethodArgs);
private unsafe bool ResolveGenericVirtualMethodTarget(RuntimeTypeHandle targetTypeHandle, RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, MethodNameAndSignature callingMethodNameAndSignature, out IntPtr methodPointer, out IntPtr dictionaryPointer)
{
methodPointer = dictionaryPointer = IntPtr.Zero;
// Get the open type definition of the containing type of the generic virtual method being resolved
RuntimeTypeHandle openCallingTypeHandle;
RuntimeTypeHandle[] callingTypeInstantiation;
if (!TryGetOpenTypeDefinition(declaringType, out openCallingTypeHandle, out callingTypeInstantiation))
return false;
// Get the open type definition of the current type of the object instance on which the GVM is being resolved
RuntimeTypeHandle openTargetTypeHandle;
RuntimeTypeHandle[] targetTypeInstantiation;
if (!TryGetOpenTypeDefinition(targetTypeHandle, out openTargetTypeHandle, out targetTypeInstantiation))
return false;
int hashCode = openCallingTypeHandle.GetHashCode();
hashCode = ((hashCode << 13) ^ hashCode) ^ openTargetTypeHandle.GetHashCode();
#if REFLECTION_EXECUTION_TRACE
ReflectionExecutionLogger.WriteLine("GVM Target Resolution = " + GetTypeNameDebug(targetTypeHandle) + "." + callingMethodNameAndSignature.Name);
#endif
foreach (IntPtr moduleHandle in ModuleList.Enumerate(RuntimeAugments.GetModuleFromTypeHandle(openTargetTypeHandle)))
{
NativeReader gvmTableReader;
if (!TryGetNativeReaderForBlob(moduleHandle, ReflectionMapBlob.GenericVirtualMethodTable, out gvmTableReader))
continue;
NativeReader nativeLayoutReader;
if (!TryGetNativeReaderForBlob(moduleHandle, ReflectionMapBlob.NativeLayoutInfo, out nativeLayoutReader))
continue;
NativeParser gvmTableParser = new NativeParser(gvmTableReader, 0);
NativeHashtable gvmHashtable = new NativeHashtable(gvmTableParser);
ExternalReferencesTable extRefs = default(ExternalReferencesTable);
extRefs.InitializeCommonFixupsTable(moduleHandle);
var lookup = gvmHashtable.Lookup(hashCode);
NativeParser entryParser;
while (!(entryParser = lookup.GetNext()).IsNull)
{
RuntimeTypeHandle parsedCallingTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
if (!parsedCallingTypeHandle.Equals(openCallingTypeHandle))
continue;
RuntimeTypeHandle parsedTargetTypeHandle = extRefs.GetRuntimeTypeHandleFromIndex(entryParser.GetUnsigned());
if (!parsedTargetTypeHandle.Equals(openTargetTypeHandle))
continue;
uint parsedCallingNameAndSigToken = extRefs.GetRvaFromIndex(entryParser.GetUnsigned());
MethodNameAndSignature parsedCallingNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, parsedCallingNameAndSigToken);
if (!parsedCallingNameAndSignature.Equals(callingMethodNameAndSignature))
continue;
uint parsedTargetMethodNameAndSigToken = extRefs.GetRvaFromIndex(entryParser.GetUnsigned());
MethodNameAndSignature targetMethodNameAndSignature = GetMethodNameAndSignatureFromNativeReader(nativeLayoutReader, parsedTargetMethodNameAndSigToken);
Debug.Assert(targetMethodNameAndSignature != null);
return TypeLoaderEnvironment.Instance.TryGetGenericVirtualMethodPointer(targetTypeHandle, targetMethodNameAndSignature, genericArguments, out methodPointer, out dictionaryPointer);
}
}
return false;
}
