private void EmitInstantiatedTypeSignature(InstantiatedType type, SignatureContext context)
{
EcmaModule targetModule = context.GetTargetModule(type);
EmitModuleOverride(targetModule, context);
EmitElementType(CorElementType.ELEMENT_TYPE_GENERICINST);
EmitTypeSignature(type.GetTypeDefinition(), context.InnerContext(targetModule));
EmitUInt((uint)type.Instantiation.Length);
for (int paramIndex = 0; paramIndex < type.Instantiation.Length; paramIndex++)
{
EmitTypeSignature(type.Instantiation[paramIndex], context);
}
}
public SignatureContext EmitFixup(NodeFactory factory, ReadyToRunFixupKind fixupKind, EcmaModule targetModule, SignatureContext outerContext)
{
if (targetModule == outerContext.LocalContext)
{
EmitByte((byte)fixupKind);
return(outerContext);
}
else
{
EmitByte((byte)(fixupKind | ReadyToRunFixupKind.ModuleOverride));
EmitUInt((uint)factory.ManifestMetadataTable.ModuleToIndex(targetModule));
return(outerContext.InnerContext(targetModule));
}
}
private void EmitMethodSpecificationSignature(MethodWithToken method,
uint flags, bool enforceDefEncoding, bool enforceOwningType, SignatureContext context)
{
ModuleToken methodToken = method.Token;
if (method.Method.HasInstantiation && !method.Method.IsGenericMethodDefinition)
{
flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MethodInstantiation;
if (!method.Token.IsNull)
{
if (method.Token.TokenType == CorTokenType.mdtMethodSpec)
{
MethodSpecification methodSpecification = methodToken.MetadataReader.GetMethodSpecification((MethodSpecificationHandle)methodToken.Handle);
methodToken = new ModuleToken(methodToken.Module, methodSpecification.Method);
}
}
}
Debug.Assert(!methodToken.IsNull);
switch (methodToken.TokenType)
{
case CorTokenType.mdtMethodDef:
break;
case CorTokenType.mdtMemberRef:
flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MemberRefToken;
break;
default:
throw new NotImplementedException();
}
if ((method.Token.Module != context.LocalContext) && (!enforceOwningType || (enforceDefEncoding && methodToken.TokenType == CorTokenType.mdtMemberRef)))
{
// If enforeOwningType is set, this is an entry for the InstanceEntryPoint or InstrumentationDataTable nodes
// which are not used in quite the same way, and for which the MethodDef is always matched to the module
// which defines the type
flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_UpdateContext;
}
EmitUInt(flags);
if ((flags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_UpdateContext) != 0)
{
uint moduleIndex = (uint)context.Resolver.GetModuleIndex(method.Token.Module);
EmitUInt(moduleIndex);
context = context.InnerContext(method.Token.Module);
}
if ((flags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_OwnerType) != 0)
{
// The type here should be the type referred to by the memberref (if this is one, not the type where the method was eventually found!
EmitTypeSignature(method.OwningType, context);
}
EmitTokenRid(methodToken.Token);
if ((flags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MethodInstantiation) != 0)
{
Instantiation instantiation = method.Method.Instantiation;
EmitUInt((uint)instantiation.Length);
SignatureContext methodInstantiationsContext;
if ((flags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_UpdateContext) != 0)
{
methodInstantiationsContext = context;
}
else
{
methodInstantiationsContext = context.OuterContext;
}
for (int typeParamIndex = 0; typeParamIndex < instantiation.Length; typeParamIndex++)
{
EmitTypeSignature(instantiation[typeParamIndex], methodInstantiationsContext);
}
}
}
