public RuntimeMethodHandle GetRuntimeMethodHandle(Type[] genericArgs)
{
Debug.Assert(genericArgs == null || genericArgs.Length > 0);
RuntimeTypeHandle[] genericArgHandles;
if (genericArgs != null)
{
genericArgHandles = new RuntimeTypeHandle[genericArgs.Length];
for (int i = 0; i < genericArgHandles.Length; i++)
{
genericArgHandles[i] = genericArgs[i].TypeHandle;
}
}
else
{
genericArgHandles = null;
}
IntPtr dynamicModule = ModuleList.Instance.GetModuleInfoForMetadataReader(Reader).DynamicModulePtrAsIntPtr;
return(TypeLoaderEnvironment.Instance.GetRuntimeMethodHandleForComponents(
DeclaringType.TypeHandle,
Name,
RuntimeSignature.CreateFromMethodHandle(dynamicModule, MetadataToken),
genericArgHandles));
}
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;
#if CORERT
// 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;
RuntimeSignature signature = RuntimeSignature.CreateFromNativeLayoutSignature(
new TypeManagerHandle(*(IntPtr *)nativeLayoutInfoSignatureData[0]),
(uint)nativeLayoutInfoSignatureData[1].ToInt32());
#else
IntPtr moduleHandle = RuntimeAugments.GetOSModuleFromPointer(methodData->NativeLayoutInfoSignature);
RuntimeSignature 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 TryGetMethodNameAndSignaturePointersFromNativeLayoutSignature(TypeManagerHandle module, uint methodNameAndSigToken, out RuntimeSignature methodNameSig, out RuntimeSignature methodSig)
{
methodNameSig = default(RuntimeSignature);
methodSig = default(RuntimeSignature);
NativeReader reader = GetNativeLayoutInfoReader(module);
NativeParser parser = new NativeParser(reader, methodNameAndSigToken);
if (parser.IsNull)
{
return(false);
}
methodNameSig = RuntimeSignature.CreateFromNativeLayoutSignature(module, parser.Offset);
string methodName = parser.GetString();
// Signatures are indirected to through a relative offset so that we don't have to parse them
// when not comparing signatures (parsing them requires resolving types and is tremendously
// expensive).
NativeParser sigParser = parser.GetParserFromRelativeOffset();
methodSig = RuntimeSignature.CreateFromNativeLayoutSignature(module, sigParser.Offset);
return(true);
}
/// <summary>
/// Create a runtime method handle from name, signature and generic arguments. If the methodSignature
/// is constructed from a metadata token, the methodName should be IntPtr.Zero, as it already encodes the method
/// name.
/// </summary>
internal unsafe IntPtr TryGetRuntimeMethodHandleForComponents(RuntimeTypeHandle declaringTypeHandle, IntPtr methodName, RuntimeSignature methodSignature, RuntimeTypeHandle[] genericMethodArgs)
{
int sizeToAllocate = sizeof(DynamicMethodHandleInfo);
// Use checked arithmetics to ensure there aren't any overflows/truncations
sizeToAllocate = checked (sizeToAllocate + (genericMethodArgs.Length > 0 ? sizeof(IntPtr) * (genericMethodArgs.Length - 1) : 0));
IntPtr runtimeMethodHandleValue = MemoryHelpers.AllocateMemory(sizeToAllocate);
DynamicMethodHandleInfo *methodData = (DynamicMethodHandleInfo *)runtimeMethodHandleValue.ToPointer();
methodData->DeclaringType = *(IntPtr *)&declaringTypeHandle;
methodData->MethodName = methodName;
methodData->MethodSignature = methodSignature;
methodData->NumGenericArgs = genericMethodArgs.Length;
IntPtr *genericArgPtr = &(methodData->GenericArgsArray);
for (int i = 0; i < genericMethodArgs.Length; i++)
{
RuntimeTypeHandle currentArg = genericMethodArgs[i];
genericArgPtr[i] = *(IntPtr *)¤tArg;
}
// Special flag in the handle value to indicate it was dynamically allocated, and doesn't point into the InvokeMap blob
return(runtimeMethodHandleValue + 1);
}
/// <summary>
/// Create a runtime method handle from name, signature and generic arguments. If the methodSignature
/// is constructed from a metadata token, the methodName should be IntPtr.Zero, as it already encodes the method
/// name.
/// </summary>
public unsafe RuntimeMethodHandle GetRuntimeMethodHandleForComponents(RuntimeTypeHandle declaringTypeHandle, IntPtr methodName, RuntimeSignature methodSignature, RuntimeTypeHandle[] genericMethodArgs)
{
// TODO! Consider interning these!, but if we do remember this function is called from code which isn't under the type builder lock
int sizeToAllocate = sizeof(DynamicMethodHandleInfo);
// Use checked arithmetics to ensure there aren't any overflows/truncations
sizeToAllocate = checked (sizeToAllocate + (genericMethodArgs.Length > 0 ? sizeof(IntPtr) * (genericMethodArgs.Length - 1) : 0));
IntPtr runtimeMethodHandleValue = MemoryHelpers.AllocateMemory(sizeToAllocate);
if (runtimeMethodHandleValue == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
DynamicMethodHandleInfo *methodData = (DynamicMethodHandleInfo *)runtimeMethodHandleValue.ToPointer();
methodData->DeclaringType = *(IntPtr *)&declaringTypeHandle;
methodData->MethodName = methodName;
methodData->MethodSignature = methodSignature;
methodData->NumGenericArgs = genericMethodArgs.Length;
IntPtr *genericArgPtr = &(methodData->GenericArgsArray);
for (int i = 0; i < genericMethodArgs.Length; i++)
{
RuntimeTypeHandle currentArg = genericMethodArgs[i];
genericArgPtr[i] = *(IntPtr *)¤tArg;
}
// Special flag in the handle value to indicate it was dynamically allocated, and doesn't point into the InvokeMap blob
runtimeMethodHandleValue = runtimeMethodHandleValue + 1;
return(*(RuntimeMethodHandle *)&runtimeMethodHandleValue);
}
public static bool TryCreate(MethodDesc method, out RuntimeSignature methodSignature)
{
#if SUPPORTS_NATIVE_METADATA_TYPE_LOADING
MethodDesc typicalMethod = method.GetTypicalMethodDefinition();
if (typicalMethod is TypeSystem.NativeFormat.NativeFormatMethod)
{
TypeSystem.NativeFormat.NativeFormatMethod nativeFormatMethod = (TypeSystem.NativeFormat.NativeFormatMethod)typicalMethod;
methodSignature = RuntimeSignature.CreateFromMethodHandle(nativeFormatMethod.MetadataUnit.RuntimeModule, nativeFormatMethod.Handle.ToInt());
return(true);
}
#if ECMA_METADATA_SUPPORT
if (typicalMethod is TypeSystem.Ecma.EcmaMethod)
{
unsafe
{
TypeSystem.Ecma.EcmaMethod ecmaMethod = (TypeSystem.Ecma.EcmaMethod)typicalMethod;
methodSignature = RuntimeSignature.CreateFromMethodHandle(new IntPtr(ecmaMethod.Module.RuntimeModuleInfo.DynamicModulePtr), System.Reflection.Metadata.Ecma335.MetadataTokens.GetToken(ecmaMethod.Handle));
}
return(true);
}
#endif
#endif
methodSignature = default(RuntimeSignature);
return(false);
}
public RuntimeMethodHandle GetRuntimeMethodHandle(Type[] genericArgs)
{
Debug.Assert(genericArgs == null || genericArgs.Length > 0);
RuntimeTypeHandle[] genericArgHandles;
if (genericArgs != null)
{
genericArgHandles = new RuntimeTypeHandle[genericArgs.Length];
for (int i = 0; i < genericArgHandles.Length; i++)
{
genericArgHandles[i] = genericArgs[i].TypeHandle;
}
}
else
{
genericArgHandles = null;
}
TypeManagerHandle typeManager = TypeLoaderEnvironment.Instance.ModuleList.GetModuleForMetadataReader(Reader);
return(TypeLoaderEnvironment.Instance.GetRuntimeMethodHandleForComponents(
DeclaringType.TypeHandle,
Name,
RuntimeSignature.CreateFromMethodHandle(typeManager, MethodHandle.AsInt()),
genericArgHandles));
}
public static IntPtr NativeLayoutSignature(this RuntimeSignature signature)
{
if (!signature.IsNativeLayoutSignature)
Environment.FailFast("Not a valid native layout signature");
NativeReader reader = TypeLoaderEnvironment.Instance.GetNativeLayoutInfoReader(signature);
return reader.OffsetToAddress(signature.NativeLayoutOffset);
}
/// <summary>
/// Look up module containing given nativesignature and return the appropriate native parser.
/// </summary>
/// <param name="signature">Signature to look up</param>
/// <returns>Native parser for the signature</param>
internal static NativeParser GetNativeParserForSignature(RuntimeSignature signature)
{
Debug.Assert(signature.IsNativeLayoutSignature);
NativeReader reader = TypeLoaderEnvironment.GetNativeReaderForBlob(signature.ModuleHandle, ReflectionMapBlob.NativeLayoutInfo);
return(new NativeParser(reader, signature.NativeLayoutOffset));
}
/// <summary>
/// Look up module containing given nativesignature and return the appropriate native parser.
/// </summary>
/// <param name="signature">Signature to look up</param>
/// <returns>Native parser for the signature</returns>
internal static NativeParser GetNativeParserForSignature(RuntimeSignature signature)
{
Debug.Assert(signature.IsNativeLayoutSignature);
NativeFormatModuleInfo module = ModuleList.Instance.GetModuleInfoByHandle(new TypeManagerHandle(signature.ModuleHandle));
NativeReader reader = TypeLoaderEnvironment.GetNativeReaderForBlob(module, ReflectionMapBlob.NativeLayoutInfo);
return(new NativeParser(reader, signature.NativeLayoutOffset));
}
public RuntimeMethodHandleKey(RuntimeTypeHandle declaringType, string methodName, RuntimeSignature signature, RuntimeTypeHandle[] genericArgs)
{
Debug.Assert(genericArgs != null);
_declaringType = declaringType;
_methodName = methodName;
_signature = signature;
_genericArgs = genericArgs;
_hashcode = TypeHashingAlgorithms.ComputeGenericInstanceHashCode(declaringType.GetHashCode(), genericArgs) ^ methodName.GetHashCode() ^ signature.GetHashCode();
}
internal bool GetCallingConverterDataFromMethodSignature_NativeLayout_Common(
TypeSystemContext context,
RuntimeSignature methodSig,
Instantiation typeInstantiation,
Instantiation methodInstantiation,
out bool hasThis,
out TypeDesc[] parameters,
out bool[] parametersWithGenericDependentLayout,
NativeReader nativeReader)
{
NativeLayoutInfoLoadContext nativeLayoutContext = new NativeLayoutInfoLoadContext();
nativeLayoutContext._module = (NativeFormatModuleInfo)methodSig.GetModuleInfo();
nativeLayoutContext._typeSystemContext = context;
nativeLayoutContext._typeArgumentHandles = typeInstantiation;
nativeLayoutContext._methodArgumentHandles = methodInstantiation;
NativeFormatModuleInfo module = ModuleList.Instance.GetModuleInfoByHandle(new TypeManagerHandle(methodSig.ModuleHandle));
NativeReader reader = GetNativeLayoutInfoReader(methodSig);
NativeParser parser = new NativeParser(reader, methodSig.NativeLayoutOffset);
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
hasThis = !callingConvention.HasFlag(MethodCallingConvention.Static);
if (callingConvention.HasFlag(MethodCallingConvention.Generic))
{
parser.SkipInteger(); // numGenArgs
}
uint parameterCount = parser.GetUnsigned();
parameters = new TypeDesc[parameterCount + 1];
parametersWithGenericDependentLayout = new bool[parameterCount + 1];
// One extra parameter to account for the return type
for (uint i = 0; i <= parameterCount; i++)
{
// NativeParser is a struct, so it can be copied.
NativeParser parserCopy = parser;
// Parse the signature twice. The first time to find out the exact type of the signature
// The second time to identify if the parameter loaded via the signature should be forced to be
// passed byref as part of the universal generic calling convention.
parameters[i] = GetConstructedTypeFromParserAndNativeLayoutContext(ref parser, nativeLayoutContext);
parametersWithGenericDependentLayout[i] = TypeSignatureHasVarsNeedingCallingConventionConverter(ref parserCopy, module, context, HasVarsInvestigationLevel.Parameter);
if (parameters[i] == null)
{
return(false);
}
}
return(true);
}
//
// 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 type but any data beyond that is user-defined and returned in "remainingSignature"
//
internal bool GetTypeFromSignatureAndContext(RuntimeSignature signature, RuntimeTypeHandle[] typeArgs, RuntimeTypeHandle[] methodArgs, out RuntimeTypeHandle createdType, out RuntimeSignature remainingSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(signature.ModuleHandle);
NativeParser parser = new NativeParser(reader, signature.NativeLayoutOffset);
bool result = GetTypeFromSignatureAndContext(ref parser, signature.ModuleHandle, typeArgs, methodArgs, out createdType);
remainingSignature = RuntimeSignature.CreateFromNativeLayoutSignature(signature.ModuleHandle, parser.Offset);
return result;
}
//
// 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 CompareMethodSignatures(RuntimeSignature signature1, RuntimeSignature signature2)
{
if (signature1.IsNativeLayoutSignature && signature2.IsNativeLayoutSignature)
{
if (signature1.StructuralEquals(signature2))
{
return(true);
}
NativeFormatModuleInfo module1 = ModuleList.GetModuleInfoByHandle(new TypeManagerHandle(signature1.ModuleHandle));
NativeReader reader1 = GetNativeLayoutInfoReader(signature1);
NativeParser parser1 = new NativeParser(reader1, signature1.NativeLayoutOffset);
NativeFormatModuleInfo module2 = ModuleList.GetModuleInfoByHandle(new TypeManagerHandle(signature2.ModuleHandle));
NativeReader reader2 = GetNativeLayoutInfoReader(signature2);
NativeParser parser2 = new NativeParser(reader2, signature2.NativeLayoutOffset);
return(CompareMethodSigs(parser1, module1, parser2, module2));
}
else if (signature1.IsNativeLayoutSignature)
{
int token = signature2.Token;
MetadataReader metadataReader = ModuleList.Instance.GetMetadataReaderForModule(new TypeManagerHandle(signature2.ModuleHandle));
MethodSignatureComparer comparer = new MethodSignatureComparer(metadataReader, token.AsHandle().ToMethodHandle(metadataReader));
return(comparer.IsMatchingNativeLayoutMethodSignature(signature1));
}
else if (signature2.IsNativeLayoutSignature)
{
int token = signature1.Token;
MetadataReader metadataReader = ModuleList.Instance.GetMetadataReaderForModule(new TypeManagerHandle(signature1.ModuleHandle));
MethodSignatureComparer comparer = new MethodSignatureComparer(metadataReader, token.AsHandle().ToMethodHandle(metadataReader));
return(comparer.IsMatchingNativeLayoutMethodSignature(signature2));
}
else
{
// For now, RuntimeSignatures are only used to compare for method signature equality (along with their Name)
// So we can implement this with the simple equals check
if (signature1.Token != signature2.Token)
{
return(false);
}
if (signature1.ModuleHandle != signature2.ModuleHandle)
{
return(false);
}
return(true);
}
}
internal MethodNameAndSignature GetMethodNameAndSignature(ref NativeParser parser, TypeManagerHandle moduleHandle, out RuntimeSignature methodNameSig, out RuntimeSignature methodSig)
{
methodNameSig = RuntimeSignature.CreateFromNativeLayoutSignature(moduleHandle, parser.Offset);
string methodName = parser.GetString();
// Signatures are indirected to through a relative offset so that we don't have to parse them
// when not comparing signatures (parsing them requires resolving types and is tremendously
// expensive).
NativeParser sigParser = parser.GetParserFromRelativeOffset();
methodSig = RuntimeSignature.CreateFromNativeLayoutSignature(moduleHandle, sigParser.Offset);
return(new MethodNameAndSignature(methodName, methodSig));
}
private MethodNameAndSignature GetMethodNameAndSignatureFromNativeReader(NativeReader nativeLayoutReader, IntPtr moduleHandle, uint nativeLayoutOffset)
{
NativeParser parser = new NativeParser(nativeLayoutReader, nativeLayoutOffset);
string methodName = parser.GetString();
// Signatures are indirected to through a relative offset so that we don't have to parse them
// when not comparing signatures (parsing them requires resolving types and is tremendously
// expensive).
NativeParser sigParser = parser.GetParserFromRelativeOffset();
RuntimeSignature methodSig = RuntimeSignature.CreateFromNativeLayoutSignature(moduleHandle, sigParser.Offset);
return(new MethodNameAndSignature(methodName, methodSig));
}
private unsafe bool TryGetStaticRuntimeFieldHandleComponents(RuntimeFieldHandle runtimeFieldHandle, out RuntimeTypeHandle declaringTypeHandle, out string fieldName)
{
fieldName = null;
declaringTypeHandle = default(RuntimeTypeHandle);
// Make sure it's not a dynamically allocated RuntimeFieldHandle before we attempt to use it to parse native layout data
Debug.Assert(((*(IntPtr *)&runtimeFieldHandle).ToInt64() & 0x1) == 0);
RuntimeFieldHandleInfo *fieldData = *(RuntimeFieldHandleInfo **)&runtimeFieldHandle;
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 *)fieldData->NativeLayoutInfoSignature;
signature = RuntimeSignature.CreateFromNativeLayoutSignature(
new TypeManagerHandle(*(IntPtr *)nativeLayoutInfoSignatureData[0]),
(uint)nativeLayoutInfoSignatureData[1].ToInt32());
}
#if !CORERT
else
{
IntPtr moduleHandle = RuntimeAugments.GetOSModuleFromPointer(fieldData->NativeLayoutInfoSignature);
signature = RuntimeSignature.CreateFromNativeLayoutSignature(
new TypeManagerHandle(moduleHandle),
GetNativeLayoutInfoReader(new TypeManagerHandle(moduleHandle)).AddressToOffset(fieldData->NativeLayoutInfoSignature));
}
#endif
RuntimeSignature remainingSignature;
if (!GetTypeFromSignatureAndContext(signature, null, null, out declaringTypeHandle, out remainingSignature))
{
return(false);
}
// GetTypeFromSignatureAndContext parses the type from the signature and returns a pointer to the next
// part of the native layout signature to read which we get the field name from
var reader = GetNativeLayoutInfoReader(remainingSignature);
var parser = new NativeParser(reader, remainingSignature.NativeLayoutOffset);
fieldName = parser.GetString();
return(true);
}
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 IsMatchingNativeLayoutMethodSignature(RuntimeSignature signature)
{
NativeParser parser = GetNativeParserForSignature(signature);
if (!CompareCallingConventions((MethodCallingConvention)parser.GetUnsigned()))
{
return(false);
}
if (_isGeneric)
{
uint genericParamCount1 = parser.GetUnsigned();
int genericParamCount2 = _methodSignature.GenericParameterCount;
if (genericParamCount1 != genericParamCount2)
{
return(false);
}
}
uint parameterCount = parser.GetUnsigned();
if (!CompareTypeSigWithType(ref parser, new TypeManagerHandle(signature.ModuleHandle), _methodSignature.ReturnType))
{
return(false);
}
uint parameterIndexToMatch = 0;
foreach (Handle parameterSignature in _methodSignature.Parameters)
{
if (parameterIndexToMatch >= parameterCount)
{
// The metadata-defined _method has more parameters than the native layout
return(false);
}
if (!CompareTypeSigWithType(ref parser, new TypeManagerHandle(signature.ModuleHandle), parameterSignature))
{
return(false);
}
parameterIndexToMatch++;
}
// Make sure that all native layout parameters have been matched
return(parameterIndexToMatch == parameterCount);
}
public RuntimeSignature GetSignature(Internal.Metadata.NativeFormat.Handle token)
{
switch (token.HandleType)
{
// These are the only valid token types for creating a method signature
case Internal.Metadata.NativeFormat.HandleType.Method:
case Internal.Metadata.NativeFormat.HandleType.MemberReference:
case Internal.Metadata.NativeFormat.HandleType.QualifiedMethod:
case Internal.Metadata.NativeFormat.HandleType.MethodInstantiation:
case Internal.Metadata.NativeFormat.HandleType.MethodSignature:
break;
default:
Environment.FailFast("Unknown and invalid handle type");
break;
}
return(RuntimeSignature.CreateFromMethodHandle(_metadataUnit.RuntimeModule, token.ToInt()));
}
internal bool IsStaticMethodSignature(RuntimeSignature methodSig)
{
if (methodSig.IsNativeLayoutSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(methodSig.ModuleHandle);
NativeParser parser = new NativeParser(reader, methodSig.NativeLayoutOffset);
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
return(callingConvention.HasFlag(MethodCallingConvention.Static));
}
else
{
var metadataReader = ModuleList.Instance.GetMetadataReaderForModule(methodSig.ModuleHandle);
var methodHandle = methodSig.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
return((method.Flags & MethodAttributes.Static) != 0);
}
}
/// <summary>
/// Create a runtime method handle from name, signature and generic arguments. If the methodSignature
/// is constructed from a metadata token, the methodName should be IntPtr.Zero, as it already encodes the method
/// name.
/// </summary>
public unsafe RuntimeMethodHandle GetRuntimeMethodHandleForComponents(RuntimeTypeHandle declaringTypeHandle, IntPtr methodName, RuntimeSignature methodSignature, RuntimeTypeHandle[] genericMethodArgs)
{
string methodNameStr = methodName == IntPtr.Zero ? null : GetStringFromMemoryInNativeFormat(methodName);
RuntimeMethodHandleKey key = new RuntimeMethodHandleKey(declaringTypeHandle, methodNameStr, methodSignature, genericMethodArgs);
RuntimeMethodHandle runtimeMethodHandle = default(RuntimeMethodHandle);
lock (_runtimeMethodHandles)
{
if (!_runtimeMethodHandles.TryGetValue(key, out runtimeMethodHandle))
{
int sizeToAllocate = sizeof(DynamicMethodHandleInfo);
int numGenericMethodArgs = genericMethodArgs == null ? 0 : genericMethodArgs.Length;
// Use checked arithmetics to ensure there aren't any overflows/truncations
sizeToAllocate = checked (sizeToAllocate + (numGenericMethodArgs > 0 ? sizeof(IntPtr) * (numGenericMethodArgs - 1) : 0));
IntPtr runtimeMethodHandleValue = MemoryHelpers.AllocateMemory(sizeToAllocate);
if (runtimeMethodHandleValue == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
DynamicMethodHandleInfo *methodData = (DynamicMethodHandleInfo *)runtimeMethodHandleValue.ToPointer();
methodData->DeclaringType = *(IntPtr *)&declaringTypeHandle;
methodData->MethodName = methodName;
methodData->MethodSignature = methodSignature;
methodData->NumGenericArgs = numGenericMethodArgs;
IntPtr *genericArgPtr = &(methodData->GenericArgsArray);
for (int i = 0; i < numGenericMethodArgs; i++)
{
RuntimeTypeHandle currentArg = genericMethodArgs[i];
genericArgPtr[i] = *(IntPtr *)¤tArg;
}
// Special flag in the handle value to indicate it was dynamically allocated, and doesn't point into the InvokeMap blob
runtimeMethodHandleValue = runtimeMethodHandleValue + 1;
runtimeMethodHandle = *(RuntimeMethodHandle *)&runtimeMethodHandleValue;
_runtimeMethodHandles.Add(key, runtimeMethodHandle);
}
return(runtimeMethodHandle);
}
}
public bool TryGetMethodNameAndSignatureFromNativeLayoutSignature(RuntimeSignature signature, out MethodNameAndSignature nameAndSignature)
{
nameAndSignature = null;
NativeReader reader = GetNativeLayoutInfoReader(signature.ModuleHandle);
uint offset = signature.NativeLayoutOffset;
NativeParser parser = new NativeParser(reader, offset);
if (parser.IsNull)
{
return(false);
}
RuntimeSignature methodSig;
RuntimeSignature methodNameSig;
nameAndSignature = GetMethodNameAndSignature(ref parser, signature.ModuleHandle, out methodNameSig, out methodSig);
return(true);
}
internal bool IsStaticMethodSignature(RuntimeSignature methodSig)
{
if (methodSig.IsNativeLayoutSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(methodSig);
NativeParser parser = new NativeParser(reader, methodSig.NativeLayoutOffset);
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
return(callingConvention.HasFlag(MethodCallingConvention.Static));
}
else
{
ModuleInfo module = methodSig.GetModuleInfo();
#if ECMA_METADATA_SUPPORT
if (module is NativeFormatModuleInfo)
#endif
{
NativeFormatModuleInfo nativeFormatModule = (NativeFormatModuleInfo)module;
var metadataReader = nativeFormatModule.MetadataReader;
var methodHandle = methodSig.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
return((method.Flags & MethodAttributes.Static) != 0);
}
#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(methodSig.Token);
var method = metadataReader.GetMethodDefinition(ecmaHandle);
var blobHandle = method.Signature;
var blobReader = metadataReader.GetBlobReader(blobHandle);
byte sigByte = blobReader.ReadByte();
return((sigByte & (byte)System.Reflection.Metadata.SignatureAttributes.Instance) == 0);
}
#endif
}
}
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 RuntimeMethodHandleKey(RuntimeTypeHandle declaringType, string methodName, RuntimeSignature signature, RuntimeTypeHandle[] genericArgs)
{
// genericArgs will be null if this is a (typical or not) method definition
// genericArgs are non-null only for instantiated generic methods.
Debug.Assert(genericArgs == null || genericArgs.Length > 0);
_declaringType = declaringType;
_methodName = methodName;
_signature = signature;
_genericArgs = genericArgs;
int methodNameHashCode = methodName == null ? 0 : methodName.GetHashCode();
_hashcode = methodNameHashCode ^ signature.GetHashCode();
if (genericArgs != null)
{
_hashcode ^= TypeHashingAlgorithms.ComputeGenericInstanceHashCode(declaringType.GetHashCode(), genericArgs);
}
else
{
_hashcode ^= declaringType.GetHashCode();
}
}
public abstract bool TryGetGenericVirtualTargetForTypeAndSlot(RuntimeTypeHandle targetHandle, ref RuntimeTypeHandle declaringType, RuntimeTypeHandle[] genericArguments, ref string methodName, ref RuntimeSignature methodSignature, bool lookForDefaultImplementations, out IntPtr methodPointer, out IntPtr dictionaryPointer, out bool slotUpdated);
public abstract bool CompareMethodSignatures(RuntimeSignature signature1, RuntimeSignature signature2);
public abstract RuntimeMethodHandle GetRuntimeMethodHandleForComponents(RuntimeTypeHandle declaringTypeHandle, string methodName, RuntimeSignature methodSignature, RuntimeTypeHandle[] genericMethodArgs);
