public MethodFixupSignature MethodSignature(
ReadyToRunFixupKind fixupKind,
MethodDesc methodDesc,
TypeDesc constrainedType,
ModuleToken methodToken,
SignatureContext signatureContext,
bool isUnboxingStub,
bool isInstantiatingStub)
{
Dictionary <TypeAndMethod, MethodFixupSignature> perFixupKindMap;
if (!_methodSignatures.TryGetValue(fixupKind, out perFixupKindMap))
{
perFixupKindMap = new Dictionary <TypeAndMethod, MethodFixupSignature>();
_methodSignatures.Add(fixupKind, perFixupKindMap);
}
TypeAndMethod key = new TypeAndMethod(constrainedType, methodDesc, methodToken, isUnboxingStub, isInstantiatingStub);
MethodFixupSignature signature;
if (!perFixupKindMap.TryGetValue(key, out signature))
{
signature = new MethodFixupSignature(fixupKind, methodDesc, constrainedType,
methodToken, signatureContext, isUnboxingStub, isInstantiatingStub);
perFixupKindMap.Add(key, signature);
}
return(signature);
}
public IMethodNode ImportedMethodNode(
MethodDesc targetMethod,
TypeDesc constrainedType,
ModuleToken methodToken,
SignatureContext signatureContext,
bool unboxingStub)
{
IMethodNode methodImport;
TypeAndMethod key = new TypeAndMethod(constrainedType, targetMethod, methodToken, unboxingStub, isInstantiatingStub: false);
if (!_importMethods.TryGetValue(key, out methodImport))
{
// First time we see a given external method - emit indirection cell and the import entry
ExternalMethodImport indirectionCell = new ExternalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
targetMethod,
constrainedType,
methodToken,
unboxingStub,
signatureContext);
_importMethods.Add(key, indirectionCell);
methodImport = indirectionCell;
}
return(methodImport);
}
private IMethodNode CreateMethodEntrypoint(TypeAndMethod key)
{
MethodWithToken method = key.Method;
bool isInstantiatingStub = key.IsInstantiatingStub;
bool isPrecodeImportRequired = key.IsPrecodeImportRequired;
MethodDesc compilableMethod = method.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);
MethodWithGCInfo methodWithGCInfo = null;
if (CompilationModuleGroup.ContainsMethodBody(compilableMethod, false))
{
methodWithGCInfo = CompiledMethodNode(compilableMethod);
}
if (isPrecodeImportRequired)
{
Debug.Assert(!key.IsJumpableImportRequired);
return(new PrecodeMethodImport(
this,
ReadyToRunFixupKind.MethodEntry,
method,
methodWithGCInfo,
isInstantiatingStub));
}
else
{
return(new DelayLoadMethodImport(
this,
ReadyToRunFixupKind.MethodEntry,
method,
methodWithGCInfo,
isInstantiatingStub,
isJump: key.IsJumpableImportRequired));
}
}
public IMethodNode MethodEntrypoint(MethodWithToken method, bool isInstantiatingStub, bool isPrecodeImportRequired, bool isJumpableImportRequired)
{
Debug.Assert(!isJumpableImportRequired || !isPrecodeImportRequired);
TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isInstantiatingStub, isPrecodeImportRequired, isJumpableImportRequired);
return(_importMethods.GetOrAdd(key));
}
public MethodFixupSignature MethodSignature(
ReadyToRunFixupKind fixupKind,
MethodWithToken method,
bool isInstantiatingStub)
{
TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isInstantiatingStub, false, false);
return(_methodSignatures.GetOrAdd(new MethodFixupKey(fixupKind, key)));
}
public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodWithToken method)
{
TypeAndMethod ctorKey = new TypeAndMethod(
delegateType,
method,
isInstantiatingStub: false,
isPrecodeImportRequired: false);
return(_delegateCtors.GetOrAdd(ctorKey));
}
public IMethodNode MethodEntrypoint(
MethodWithToken method,
bool isUnboxingStub,
bool isInstantiatingStub,
bool isPrecodeImportRequired,
SignatureContext signatureContext)
{
TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, isPrecodeImportRequired, signatureContext);
return(_importMethods.GetOrAdd(key));
}
public IMethodNode MethodEntrypoint(
MethodWithToken method,
bool isUnboxingStub,
bool isInstantiatingStub,
bool isPrecodeImportRequired,
SignatureContext signatureContext)
{
IMethodNode methodImport;
TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, isPrecodeImportRequired);
if (!_importMethods.TryGetValue(key, out methodImport))
{
if (CompilationModuleGroup.ContainsMethodBody(method.Method, false))
{
if (isPrecodeImportRequired)
{
methodImport = new PrecodeMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
method,
CreateMethodEntrypointNode(method, isUnboxingStub, isInstantiatingStub, signatureContext),
isUnboxingStub,
isInstantiatingStub,
signatureContext);
}
else
{
methodImport = new LocalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
method,
CreateMethodEntrypointNode(method, isUnboxingStub, isInstantiatingStub, signatureContext),
isUnboxingStub,
isInstantiatingStub,
signatureContext);
}
}
else
{
// First time we see a given external method - emit indirection cell and the import entry
methodImport = new ExternalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
method,
isUnboxingStub,
isInstantiatingStub,
signatureContext);
}
_importMethods.Add(key, methodImport);
}
return(methodImport);
}
public IMethodNode MethodEntrypoint(
MethodDesc targetMethod,
TypeDesc constrainedType,
MethodDesc originalMethod,
ModuleToken methodToken,
bool isUnboxingStub,
bool isInstantiatingStub,
SignatureContext signatureContext)
{
bool isLocalMethod = CompilationModuleGroup.ContainsMethodBody(targetMethod, false);
if (targetMethod == originalMethod || isLocalMethod)
{
constrainedType = null;
}
IMethodNode methodImport;
TypeAndMethod key = new TypeAndMethod(constrainedType, targetMethod, methodToken, isUnboxingStub, isInstantiatingStub);
if (!_importMethods.TryGetValue(key, out methodImport))
{
if (!isLocalMethod)
{
// First time we see a given external method - emit indirection cell and the import entry
methodImport = new ExternalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
targetMethod,
constrainedType,
methodToken,
isUnboxingStub,
isInstantiatingStub,
signatureContext);
}
else
{
MethodWithToken methodWithToken = new MethodWithToken(targetMethod, methodToken);
methodImport = new LocalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
methodWithToken,
CreateMethodEntrypointNode(methodWithToken, isUnboxingStub, isInstantiatingStub, signatureContext),
isUnboxingStub,
isInstantiatingStub,
signatureContext);
}
_importMethods.Add(key, methodImport);
}
return(methodImport);
}
private MethodWithGCInfo CreateMethodEntrypointNodeHelper(MethodWithToken targetMethod)
{
Debug.Assert(CompilationModuleGroup.ContainsMethodBody(targetMethod.Method, false));
MethodDesc localMethod = targetMethod.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);
TypeAndMethod localMethodKey = new TypeAndMethod(localMethod.OwningType,
new MethodWithToken(localMethod, default(ModuleToken), constrainedType: null),
isUnboxingStub: false,
isInstantiatingStub: false,
isPrecodeImportRequired: false);
return(_localMethodCache.GetOrAdd(localMethodKey));
}
public IMethodNode ShadowConcreteMethod(MethodDesc targetMethod, TypeDesc constrainedType, MethodDesc originalMethod,
ModuleToken methodToken, SignatureContext signatureContext, bool isUnboxingStub = false)
{
IMethodNode result;
TypeAndMethod key = new TypeAndMethod(constrainedType, constrainedType != null ? originalMethod : targetMethod,
methodToken, isUnboxingStub, isInstantiatingStub: false);
if (!_shadowConcreteMethods.TryGetValue(key, out result))
{
result = MethodEntrypoint(targetMethod, constrainedType, originalMethod, methodToken, signatureContext, isUnboxingStub);
_shadowConcreteMethods.Add(key, result);
}
return(result);
}
private IMethodNode CreateMethodEntrypointNode(MethodWithToken targetMethod, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext)
{
Debug.Assert(CompilationModuleGroup.ContainsMethodBody(targetMethod.Method, false));
MethodDesc localMethod = targetMethod.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);
TypeAndMethod localMethodKey = new TypeAndMethod(localMethod.OwningType, localMethod, default(ModuleToken), isUnboxingStub: false, isInstantiatingStub: false);
MethodWithGCInfo localMethodNode;
if (!_localMethodCache.TryGetValue(localMethodKey, out localMethodNode))
{
localMethodNode = new MethodWithGCInfo(localMethod, signatureContext);
_localMethodCache.Add(localMethodKey, localMethodNode);
}
return(localMethodNode);
}
private IMethodNode CreateMethodEntrypoint(TypeAndMethod key)
{
MethodWithToken method = key.Method;
bool isUnboxingStub = key.IsUnboxingStub;
bool isInstantiatingStub = key.IsInstantiatingStub;
bool isPrecodeImportRequired = key.IsPrecodeImportRequired;
SignatureContext signatureContext = key.SignatureContext;
if (CompilationModuleGroup.ContainsMethodBody(method.Method, false))
{
if (isPrecodeImportRequired)
{
return(new PrecodeMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
method,
CreateMethodEntrypointNodeHelper(method, isUnboxingStub, isInstantiatingStub, signatureContext),
isUnboxingStub,
isInstantiatingStub,
signatureContext));
}
else
{
return(new LocalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
method,
CreateMethodEntrypointNodeHelper(method, isUnboxingStub, isInstantiatingStub, signatureContext),
isUnboxingStub,
isInstantiatingStub,
signatureContext));
}
}
else
{
// First time we see a given external method - emit indirection cell and the import entry
return(new ExternalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
method,
isUnboxingStub,
isInstantiatingStub,
signatureContext));
}
}
private IMethodNode CreateMethodEntrypoint(TypeAndMethod key)
{
MethodWithToken method = key.Method;
bool isUnboxingStub = key.IsUnboxingStub;
bool isInstantiatingStub = key.IsInstantiatingStub;
bool isPrecodeImportRequired = key.IsPrecodeImportRequired;
MethodDesc compilableMethod = method.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);
if (CompilationModuleGroup.ContainsMethodBody(compilableMethod, false))
{
if (isPrecodeImportRequired)
{
return(new PrecodeMethodImport(
this,
ReadyToRunFixupKind.MethodEntry,
method,
CompiledMethodNode(compilableMethod),
isUnboxingStub,
isInstantiatingStub));
}
else
{
return(new LocalMethodImport(
this,
ReadyToRunFixupKind.MethodEntry,
method,
CompiledMethodNode(compilableMethod),
isUnboxingStub,
isInstantiatingStub));
}
}
else
{
// First time we see a given external method - emit indirection cell and the import entry
return(new ExternalMethodImport(
this,
ReadyToRunFixupKind.MethodEntry,
method,
isUnboxingStub,
isInstantiatingStub));
}
}
public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodWithToken method, SignatureContext signatureContext)
{
TypeAndMethod ctorKey = new TypeAndMethod(delegateType, method, isUnboxingStub: false, isInstantiatingStub: false);
if (!_delegateCtors.TryGetValue(ctorKey, out ISymbolNode ctorNode))
{
IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint(
method,
isUnboxingStub: false,
isInstantiatingStub: false,
signatureContext: signatureContext);
ctorNode = new DelayLoadHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.HelperImports,
ILCompiler.ReadyToRunHelper.DelayLoad_Helper,
new DelegateCtorSignature(delegateType, targetMethodNode, method.Token, signatureContext));
_delegateCtors.Add(ctorKey, ctorNode);
}
return(ctorNode);
}
private IMethodNode CreateMethodEntrypointNode(MethodWithToken targetMethod, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext)
{
MethodDesc localMethod = targetMethod.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);
TypeAndMethod localMethodKey = new TypeAndMethod(localMethod.OwningType, localMethod, default(ModuleToken), isUnboxingStub: false, isInstantiatingStub: false);
MethodWithGCInfo localMethodNode;
if (!_localMethodCache.TryGetValue(localMethodKey, out localMethodNode))
{
localMethodNode = new MethodWithGCInfo(localMethod, signatureContext);
_localMethodCache.Add(localMethodKey, localMethodNode);
}
return(new LocalMethodImport(
this,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
targetMethod,
localMethodNode,
isUnboxingStub,
isInstantiatingStub,
signatureContext));
}
public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodDesc targetMethod, ModuleToken methodToken, SignatureContext signatureContext)
{
TypeAndMethod ctorKey = new TypeAndMethod(delegateType, targetMethod, methodToken: methodToken, isUnboxingStub: false, isInstantiatingStub: false);
if (!_delegateCtors.TryGetValue(ctorKey, out ISymbolNode ctorNode))
{
IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint(
targetMethod,
constrainedType: null,
originalMethod: null,
methodToken: methodToken,
signatureContext: signatureContext,
isUnboxingStub: false);
ctorNode = new DelayLoadHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.HelperImports,
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_DelayLoad_Helper,
new DelegateCtorSignature(delegateType, targetMethodNode, methodToken, signatureContext));
_delegateCtors.Add(ctorKey, ctorNode);
}
return(ctorNode);
}
public MethodFixupKey(ReadyToRunFixupKind fixupKind, TypeAndMethod typeAndMethod)
{
FixupKind = fixupKind;
TypeAndMethod = typeAndMethod;
}
