private void ImportCall(ILOpcode opcode, int token)
{
// Strip runtime determined characteristics off of the method (because that's how RyuJIT operates)
var runtimeDeterminedMethod = (MethodDesc)_methodIL.GetObject(token);
MethodDesc method = runtimeDeterminedMethod;
if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)
{
method = runtimeDeterminedMethod.GetCanonMethodTarget(CanonicalFormKind.Specific);
}
if (method.IsRawPInvoke())
{
// Raw P/invokes don't have any dependencies.
return;
}
string reason = null;
switch (opcode)
{
case ILOpcode.newobj:
reason = "newobj"; break;
case ILOpcode.call:
reason = "call"; break;
case ILOpcode.callvirt:
reason = "callvirt"; break;
case ILOpcode.ldftn:
reason = "ldftn"; break;
case ILOpcode.ldvirtftn:
reason = "ldvirtftn"; break;
default:
Debug.Assert(false); break;
}
if (opcode == ILOpcode.newobj)
{
TypeDesc owningType = runtimeDeterminedMethod.OwningType;
if (owningType.IsString)
{
// String .ctor handled specially below
}
else if (owningType.IsGCPointer)
{
if (owningType.IsRuntimeDeterminedSubtype)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, owningType), reason);
}
else
{
_dependencies.Add(_factory.ConstructedTypeSymbol(owningType), reason);
}
if (owningType.IsMdArray)
{
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewMultiDimArr_NonVarArg), reason);
return;
}
else
{
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewObject), reason);
}
}
if (owningType.IsDelegate)
{
// If this is a verifiable delegate construction sequence, the previous instruction is a ldftn/ldvirtftn
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.prefix1)
{
// TODO: for ldvirtftn we need to also check for the `dup` instruction, otherwise this is a normal newobj.
ILOpcode previousOpcode = (ILOpcode)(0x100 + _ilBytes[_previousInstructionOffset + 1]);
if (previousOpcode == ILOpcode.ldvirtftn || previousOpcode == ILOpcode.ldftn)
{
int delTargetToken = ReadILTokenAt(_previousInstructionOffset + 2);
var delTargetMethod = (MethodDesc)_methodIL.GetObject(delTargetToken);
TypeDesc canonDelegateType = method.OwningType.ConvertToCanonForm(CanonicalFormKind.Specific);
DelegateCreationInfo info = _compilation.GetDelegateCtor(canonDelegateType, delTargetMethod, previousOpcode == ILOpcode.ldvirtftn);
if (info.NeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.DelegateCtor, info), reason);
}
else
{
_dependencies.Add(_factory.ReadyToRunHelper(ReadyToRunHelperId.DelegateCtor, info), reason);
}
return;
}
}
}
}
if (method.OwningType.IsDelegate && method.Name == "Invoke")
{
// TODO: might not want to do this if scanning for reflection.
// This is expanded as an intrinsic, not a function call.
return;
}
if (method.IsIntrinsic)
{
if (IsRuntimeHelpersInitializeArray(method))
{
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken)
{
return;
}
}
if (IsRuntimeTypeHandleGetValueInternal(method))
{
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken)
{
return;
}
}
if (IsActivatorDefaultConstructorOf(method))
{
if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.DefaultConstructor, runtimeDeterminedMethod.Instantiation[0]), reason);
}
else
{
MethodDesc ctor = method.Instantiation[0].GetDefaultConstructor();
if (ctor == null)
{
MetadataType activatorType = _compilation.TypeSystemContext.SystemModule.GetKnownType("System", "Activator");
MetadataType classWithMissingCtor = activatorType.GetKnownNestedType("ClassWithMissingConstructor");
ctor = classWithMissingCtor.GetParameterlessConstructor();
}
_dependencies.Add(_factory.CanonicalEntrypoint(ctor), reason);
}
return;
}
if (method.OwningType.IsByReferenceOfT && (method.IsConstructor || method.Name == "get_Value"))
{
return;
}
if (IsEETypePtrOf(method))
{
if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.Instantiation[0]), reason);
}
else
{
_dependencies.Add(_factory.ConstructedTypeSymbol(method.Instantiation[0]), reason);
}
return;
}
}
TypeDesc exactType = method.OwningType;
if (method.IsNativeCallable && (opcode != ILOpcode.ldftn && opcode != ILOpcode.ldvirtftn))
{
ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramNativeCallable, method);
}
bool resolvedConstraint = false;
bool forceUseRuntimeLookup = false;
MethodDesc methodAfterConstraintResolution = method;
if (_constrained != null)
{
// We have a "constrained." call. Try a partial resolve of the constraint call. Note that this
// will not necessarily resolve the call exactly, since we might be compiling
// shared generic code - it may just resolve it to a candidate suitable for
// JIT compilation, and require a runtime lookup for the actual code pointer
// to call.
TypeDesc constrained = _constrained;
if (constrained.IsRuntimeDeterminedSubtype)
{
constrained = constrained.ConvertToCanonForm(CanonicalFormKind.Specific);
}
MethodDesc directMethod = constrained.GetClosestDefType().TryResolveConstraintMethodApprox(method.OwningType, method, out forceUseRuntimeLookup);
if (directMethod == null && constrained.IsEnum)
{
// Constrained calls to methods on enum methods resolve to System.Enum's methods. System.Enum is a reference
// type though, so we would fail to resolve and box. We have a special path for those to avoid boxing.
directMethod = _compilation.TypeSystemContext.TryResolveConstrainedEnumMethod(constrained, method);
}
if (directMethod != null)
{
// Either
// 1. no constraint resolution at compile time (!directMethod)
// OR 2. no code sharing lookup in call
// OR 3. we have have resolved to an instantiating stub
methodAfterConstraintResolution = directMethod;
Debug.Assert(!methodAfterConstraintResolution.OwningType.IsInterface);
resolvedConstraint = true;
exactType = constrained;
}
else if (constrained.IsValueType)
{
// We'll need to box `this`. Note we use _constrained here, because the other one is canonical.
AddBoxingDependencies(_constrained, reason);
}
}
MethodDesc targetMethod = methodAfterConstraintResolution;
bool exactContextNeedsRuntimeLookup;
if (targetMethod.HasInstantiation)
{
exactContextNeedsRuntimeLookup = targetMethod.IsSharedByGenericInstantiations;
}
else
{
exactContextNeedsRuntimeLookup = exactType.IsCanonicalSubtype(CanonicalFormKind.Any);
}
//
// Determine whether to perform direct call
//
bool directCall = false;
if (targetMethod.Signature.IsStatic)
{
// Static methods are always direct calls
directCall = true;
}
else if (targetMethod.OwningType.IsInterface)
{
// Force all interface calls to be interpreted as if they are virtual.
directCall = false;
}
else if ((opcode != ILOpcode.callvirt && opcode != ILOpcode.ldvirtftn) || resolvedConstraint)
{
directCall = true;
}
else
{
if (!targetMethod.IsVirtual || targetMethod.IsFinal || targetMethod.OwningType.IsSealed())
{
directCall = true;
}
}
bool allowInstParam = opcode != ILOpcode.ldvirtftn && opcode != ILOpcode.ldftn;
if (directCall && !allowInstParam && targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific).RequiresInstArg())
{
// Needs a single address to call this method but the method needs a hidden argument.
// We need a fat function pointer for this that captures both things.
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodEntry, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.FatFunctionPointer(runtimeDeterminedMethod), reason);
}
}
else if (directCall)
{
bool referencingArrayAddressMethod = false;
if (targetMethod.IsIntrinsic)
{
// If this is an intrinsic method with a callsite-specific expansion, this will replace
// the method with a method the intrinsic expands into. If it's not the special intrinsic,
// method stays unchanged.
targetMethod = _compilation.ExpandIntrinsicForCallsite(targetMethod, _canonMethod);
// Array address method requires special dependency tracking.
referencingArrayAddressMethod = targetMethod.IsArrayAddressMethod();
}
MethodDesc concreteMethod = targetMethod;
targetMethod = targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific);
if (targetMethod.IsConstructor && targetMethod.OwningType.IsString)
{
_dependencies.Add(_factory.StringAllocator(targetMethod), reason);
}
else if (exactContextNeedsRuntimeLookup)
{
if (targetMethod.IsSharedByGenericInstantiations && !resolvedConstraint && !referencingArrayAddressMethod)
{
ISymbolNode instParam = null;
if (targetMethod.RequiresInstMethodDescArg())
{
instParam = GetGenericLookupHelper(ReadyToRunHelperId.MethodDictionary, runtimeDeterminedMethod);
}
else if (targetMethod.RequiresInstMethodTableArg())
{
bool hasHiddenParameter = true;
if (targetMethod.IsIntrinsic)
{
if (_factory.TypeSystemContext.IsSpecialUnboxingThunkTargetMethod(targetMethod))
{
hasHiddenParameter = false;
}
}
if (hasHiddenParameter)
{
instParam = GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.OwningType);
}
}
if (instParam != null)
{
_dependencies.Add(instParam, reason);
}
_dependencies.Add(_factory.CanonicalEntrypoint(targetMethod), reason);
}
else
{
Debug.Assert(!forceUseRuntimeLookup);
_dependencies.Add(_factory.MethodEntrypoint(targetMethod), reason);
if (targetMethod.RequiresInstMethodTableArg() && resolvedConstraint)
{
if (_constrained.IsRuntimeDeterminedSubtype)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, _constrained), reason);
}
else
{
_dependencies.Add(_factory.ConstructedTypeSymbol(_constrained), reason);
}
}
if (referencingArrayAddressMethod && !_isReadOnly)
{
// Address method is special - it expects an instantiation argument, unless a readonly prefix was applied.
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, runtimeDeterminedMethod.OwningType), reason);
}
}
}
else
{
ISymbolNode instParam = null;
if (targetMethod.RequiresInstMethodDescArg())
{
instParam = _compilation.NodeFactory.MethodGenericDictionary(concreteMethod);
}
else if (targetMethod.RequiresInstMethodTableArg() || (referencingArrayAddressMethod && !_isReadOnly))
{
// Ask for a constructed type symbol because we need the vtable to get to the dictionary
instParam = _compilation.NodeFactory.ConstructedTypeSymbol(concreteMethod.OwningType);
}
if (instParam != null)
{
_dependencies.Add(instParam, reason);
if (!referencingArrayAddressMethod)
{
_dependencies.Add(_compilation.NodeFactory.ShadowConcreteMethod(concreteMethod), reason);
}
else
{
// We don't want array Address method to be modeled in the generic dependency analysis.
// The method doesn't actually have runtime determined dependencies (won't do
// any generic lookups).
_dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(targetMethod), reason);
}
}
else if (targetMethod.AcquiresInstMethodTableFromThis())
{
_dependencies.Add(_compilation.NodeFactory.ShadowConcreteMethod(concreteMethod), reason);
}
else
{
_dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(targetMethod), reason);
}
}
}
else if (method.HasInstantiation)
{
// Generic virtual method call
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodHandle, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.RuntimeMethodHandle(runtimeDeterminedMethod), reason);
}
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.GVMLookupForSlot), reason);
}
else if (method.OwningType.IsInterface)
{
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.VirtualDispatchCell, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.InterfaceDispatchCell(method), reason);
}
}
else if (_compilation.HasFixedSlotVTable(method.OwningType))
{
// No dependencies: virtual call through the vtable
}
else
{
MethodDesc slotDefiningMethod = targetMethod.IsNewSlot ?
targetMethod : MetadataVirtualMethodAlgorithm.FindSlotDefiningMethodForVirtualMethod(targetMethod).Normalize();
_dependencies.Add(_factory.VirtualMethodUse(slotDefiningMethod), reason);
}
}
private void ImportCall(ILOpcode opcode, int token)
{
// Strip runtime determined characteristics off of the method (because that's how RyuJIT operates)
var runtimeDeterminedMethod = (MethodDesc)_methodIL.GetObject(token);
MethodDesc method = runtimeDeterminedMethod;
if (runtimeDeterminedMethod.IsRuntimeDeterminedExactMethod)
{
method = runtimeDeterminedMethod.GetCanonMethodTarget(CanonicalFormKind.Specific);
}
if (method.IsRawPInvoke())
{
// Raw P/invokes don't have any dependencies.
return;
}
string reason = null;
switch (opcode)
{
case ILOpcode.newobj:
reason = "newobj"; break;
case ILOpcode.call:
reason = "call"; break;
case ILOpcode.callvirt:
reason = "callvirt"; break;
case ILOpcode.ldftn:
reason = "ldftn"; break;
case ILOpcode.ldvirtftn:
reason = "ldvirtftn"; break;
default:
Debug.Assert(false); break;
}
// If we're scanning the fallback body because scanning the real body failed, don't trigger cctor.
// Accessing the cctor could have been a reason why we failed.
if (!_isFallbackBodyCompilation)
{
// Do we need to run the cctor?
TypeDesc owningType = runtimeDeterminedMethod.OwningType;
if (_factory.TypeSystemContext.HasLazyStaticConstructor(owningType))
{
// For beforefieldinit, we can wait for field access.
if (!((MetadataType)owningType).IsBeforeFieldInit)
{
// Accessing the static base will trigger the cctor.
if (owningType.IsRuntimeDeterminedSubtype)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.GetNonGCStaticBase, owningType), reason);
}
else
{
_dependencies.Add(_factory.ReadyToRunHelper(ReadyToRunHelperId.GetNonGCStaticBase, owningType), reason);
}
}
}
}
if (opcode == ILOpcode.newobj)
{
TypeDesc owningType = runtimeDeterminedMethod.OwningType;
if (owningType.IsString)
{
// String .ctor handled specially below
}
else
{
// Nullable needs to be unwrapped.
if (owningType.IsNullable)
{
owningType = owningType.Instantiation[0];
}
if (owningType.IsRuntimeDeterminedSubtype)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.TypeHandle, owningType), reason);
}
else
{
_dependencies.Add(_factory.ConstructedTypeSymbol(owningType), reason);
}
if (owningType.IsMdArray)
{
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewMultiDimArr_NonVarArg), reason);
return;
}
else
{
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.NewObject), reason);
}
}
if (owningType.IsDelegate)
{
// If this is a verifiable delegate construction sequence, the previous instruction is a ldftn/ldvirtftn
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.prefix1)
{
// TODO: for ldvirtftn we need to also check for the `dup` instruction, otherwise this is a normal newobj.
ILOpcode previousOpcode = (ILOpcode)(0x100 + _ilBytes[_previousInstructionOffset + 1]);
if (previousOpcode == ILOpcode.ldvirtftn || previousOpcode == ILOpcode.ldftn)
{
int delTargetToken = ReadILTokenAt(_previousInstructionOffset + 2);
var delTargetMethod = (MethodDesc)_methodIL.GetObject(delTargetToken);
TypeDesc canonDelegateType = method.OwningType.ConvertToCanonForm(CanonicalFormKind.Specific);
DelegateCreationInfo info = _compilation.GetDelegateCtor(canonDelegateType, delTargetMethod, previousOpcode == ILOpcode.ldvirtftn);
if (info.NeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.DelegateCtor, info), reason);
}
else
{
_dependencies.Add(_factory.ReadyToRunHelper(ReadyToRunHelperId.DelegateCtor, info), reason);
}
return;
}
}
}
}
if (method.OwningType.IsDelegate && method.Name == "Invoke")
{
// TODO: might not want to do this if scanning for reflection.
// This is expanded as an intrinsic, not a function call.
return;
}
if (method.IsIntrinsic)
{
if (IsRuntimeHelpersInitializeArray(method))
{
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken)
{
return;
}
}
if (IsRuntimeTypeHandleGetValueInternal(method))
{
if (_previousInstructionOffset >= 0 && _ilBytes[_previousInstructionOffset] == (byte)ILOpcode.ldtoken)
{
return;
}
}
}
TypeDesc exactType = method.OwningType;
bool resolvedConstraint = false;
bool forceUseRuntimeLookup = false;
MethodDesc methodAfterConstraintResolution = method;
if (_constrained != null)
{
// We have a "constrained." call. Try a partial resolve of the constraint call. Note that this
// will not necessarily resolve the call exactly, since we might be compiling
// shared generic code - it may just resolve it to a candidate suitable for
// JIT compilation, and require a runtime lookup for the actual code pointer
// to call.
MethodDesc directMethod = _constrained.GetClosestDefType().TryResolveConstraintMethodApprox(method.OwningType, method, out forceUseRuntimeLookup);
if (directMethod == null && _constrained.IsEnum)
{
// Constrained calls to methods on enum methods resolve to System.Enum's methods. System.Enum is a reference
// type though, so we would fail to resolve and box. We have a special path for those to avoid boxing.
directMethod = _compilation.TypeSystemContext.TryResolveConstrainedEnumMethod(_constrained, method);
}
if (directMethod != null)
{
// Either
// 1. no constraint resolution at compile time (!directMethod)
// OR 2. no code sharing lookup in call
// OR 3. we have have resolved to an instantiating stub
methodAfterConstraintResolution = directMethod;
Debug.Assert(!methodAfterConstraintResolution.OwningType.IsInterface);
resolvedConstraint = true;
exactType = _constrained;
}
else if (_constrained.IsValueType)
{
// We'll need to box `this`.
AddBoxingDependencies(_constrained, reason);
}
_constrained = null;
}
MethodDesc targetMethod = methodAfterConstraintResolution;
bool exactContextNeedsRuntimeLookup;
if (targetMethod.HasInstantiation)
{
exactContextNeedsRuntimeLookup = targetMethod.IsSharedByGenericInstantiations;
}
else
{
exactContextNeedsRuntimeLookup = exactType.IsCanonicalSubtype(CanonicalFormKind.Any);
}
//
// Determine whether to perform direct call
//
bool directCall = false;
if (targetMethod.Signature.IsStatic)
{
// Static methods are always direct calls
directCall = true;
}
else if (targetMethod.OwningType.IsInterface)
{
// Force all interface calls to be interpreted as if they are virtual.
directCall = false;
}
else if ((opcode != ILOpcode.callvirt && opcode != ILOpcode.ldvirtftn) || resolvedConstraint)
{
directCall = true;
}
else
{
if (!targetMethod.IsVirtual || targetMethod.IsFinal || targetMethod.OwningType.IsSealed())
{
directCall = true;
}
}
bool allowInstParam = opcode != ILOpcode.ldvirtftn && opcode != ILOpcode.ldftn;
if (directCall && !allowInstParam && targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific).RequiresInstArg())
{
// Needs a single address to call this method but the method needs a hidden argument.
// We need a fat function pointer for this that captures both things.
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodEntry, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.FatFunctionPointer(runtimeDeterminedMethod), reason);
}
}
else if (directCall)
{
bool referencingArrayAddressMethod = false;
if (targetMethod.IsIntrinsic)
{
// If this is an intrinsic method with a callsite-specific expansion, this will replace
// the method with a method the intrinsic expands into. If it's not the special intrinsic,
// method stays unchanged.
targetMethod = _compilation.ExpandIntrinsicForCallsite(targetMethod, _canonMethod);
// Array address method requires special dependency tracking.
referencingArrayAddressMethod = targetMethod.IsArrayAddressMethod();
}
MethodDesc concreteMethod = targetMethod;
targetMethod = targetMethod.GetCanonMethodTarget(CanonicalFormKind.Specific);
if (targetMethod.IsConstructor && targetMethod.OwningType.IsString)
{
_dependencies.Add(_factory.StringAllocator(targetMethod), reason);
}
else if (exactContextNeedsRuntimeLookup)
{
if (targetMethod.IsSharedByGenericInstantiations && !resolvedConstraint && !referencingArrayAddressMethod)
{
_dependencies.Add(_factory.RuntimeDeterminedMethod(runtimeDeterminedMethod), reason);
}
else
{
Debug.Assert(!forceUseRuntimeLookup);
_dependencies.Add(_factory.MethodEntrypoint(targetMethod), reason);
}
}
else
{
ISymbolNode instParam = null;
if (targetMethod.RequiresInstMethodDescArg())
{
instParam = _compilation.NodeFactory.MethodGenericDictionary(concreteMethod);
}
else if (targetMethod.RequiresInstMethodTableArg() || referencingArrayAddressMethod)
{
// Ask for a constructed type symbol because we need the vtable to get to the dictionary
instParam = _compilation.NodeFactory.ConstructedTypeSymbol(concreteMethod.OwningType);
}
if (instParam != null)
{
_dependencies.Add(instParam, reason);
if (!referencingArrayAddressMethod)
{
_dependencies.Add(_compilation.NodeFactory.ShadowConcreteMethod(concreteMethod), reason);
}
else
{
// We don't want array Address method to be modeled in the generic dependency analysis.
// The method doesn't actually have runtime determined dependencies (won't do
// any generic lookups).
_dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(targetMethod), reason);
}
}
else if (targetMethod.AcquiresInstMethodTableFromThis())
{
_dependencies.Add(_compilation.NodeFactory.ShadowConcreteMethod(concreteMethod), reason);
}
else
{
_dependencies.Add(_compilation.NodeFactory.MethodEntrypoint(targetMethod), reason);
}
}
}
else if (method.HasInstantiation)
{
// Generic virtual method call
if (exactContextNeedsRuntimeLookup)
{
_dependencies.Add(GetGenericLookupHelper(ReadyToRunHelperId.MethodHandle, runtimeDeterminedMethod), reason);
}
else
{
_dependencies.Add(_factory.RuntimeMethodHandle(runtimeDeterminedMethod), reason);
}
_dependencies.Add(GetHelperEntrypoint(ReadyToRunHelper.GVMLookupForSlot), reason);
}
else
{
ReadyToRunHelperId helper;
if (opcode == ILOpcode.ldvirtftn)
{
helper = ReadyToRunHelperId.ResolveVirtualFunction;
}
else
{
Debug.Assert(opcode == ILOpcode.callvirt);
helper = ReadyToRunHelperId.VirtualCall;
}
if (exactContextNeedsRuntimeLookup && targetMethod.OwningType.IsInterface)
{
_dependencies.Add(GetGenericLookupHelper(helper, runtimeDeterminedMethod), reason);
}
else
{
// Get the slot defining method to make sure our virtual method use tracking gets this right.
// For normal C# code the targetMethod will always be newslot.
MethodDesc slotDefiningMethod = targetMethod.IsNewSlot ?
targetMethod : MetadataVirtualMethodAlgorithm.FindSlotDefiningMethodForVirtualMethod(targetMethod);
_dependencies.Add(_factory.ReadyToRunHelper(helper, slotDefiningMethod), reason);
}
}
}