public static void AddDependenciesDueToMethodCodePresence(ref DependencyList dependencies, NodeFactory factory, MethodDesc method)
{
factory.MetadataManager.GetDependenciesDueToReflectability(ref dependencies, factory, method);
if (method.HasInstantiation)
{
ExactMethodInstantiationsNode.GetExactMethodInstantiationDependenciesForMethod(ref dependencies, factory, method);
if (method.IsVirtual)
{
// Generic virtual methods dependency tracking
dependencies = dependencies ?? new DependencyList();
dependencies.Add(new DependencyListEntry(factory.GVMDependencies(method), "GVM Dependencies Support"));
}
GenericMethodsTemplateMap.GetTemplateMethodDependencies(ref dependencies, factory, method);
}
else
{
TypeDesc owningTemplateType = method.OwningType;
// Unboxing and Instantiating stubs use a different type as their template
if (factory.TypeSystemContext.IsSpecialUnboxingThunk(method))
{
owningTemplateType = factory.TypeSystemContext.GetTargetOfSpecialUnboxingThunk(method).OwningType;
}
GenericTypesTemplateMap.GetTemplateTypeDependencies(ref dependencies, factory, owningTemplateType);
}
factory.InteropStubManager.AddDependeciesDueToPInvoke(ref dependencies, factory, method);
}
public static void AddDependenciesDueToMethodCodePresence(ref DependencyList dependencies, NodeFactory factory, MethodDesc method)
{
factory.MetadataManager.GetDependenciesDueToReflectability(ref dependencies, factory, method);
if (method.HasInstantiation)
{
ExactMethodInstantiationsNode.GetExactMethodInstantiationDependenciesForMethod(ref dependencies, factory, method);
if (method.IsVirtual)
{
// Generic virtual methods dependency tracking
dependencies = dependencies ?? new DependencyList();
dependencies.Add(new DependencyListEntry(factory.GVMDependencies(method), "GVM Dependencies Support"));
}
GenericMethodsTemplateMap.GetTemplateMethodDependencies(ref dependencies, factory, method);
}
else
{
TypeDesc owningTemplateType = method.OwningType;
// Unboxing and Instantiating stubs use a different type as their template
if (factory.TypeSystemContext.IsSpecialUnboxingThunk(method))
{
owningTemplateType = factory.TypeSystemContext.GetTargetOfSpecialUnboxingThunk(method).OwningType;
}
GenericTypesTemplateMap.GetTemplateTypeDependencies(ref dependencies, factory, owningTemplateType);
}
// On Project N, the compiler doesn't generate the interop code on the fly
if (method.Context.Target.Abi != TargetAbi.ProjectN)
{
if (method.IsPInvoke)
{
if (dependencies == null)
{
dependencies = new DependencyList();
}
MethodSignature methodSig = method.Signature;
AddPInvokeParameterDependencies(ref dependencies, factory, methodSig.ReturnType);
for (int i = 0; i < methodSig.Length; i++)
{
AddPInvokeParameterDependencies(ref dependencies, factory, methodSig[i]);
}
}
}
}
static void AddSignatureDependency(ref DependencyList dependencies, NodeFactory factory, TypeDesc type)
{
if (type.IsByRef)
{
type = ((ParameterizedType)type).ParameterType;
}
// Pointer runtime type handles can be created at runtime if necessary
while (type.IsPointer)
{
type = ((ParameterizedType)type).ParameterType;
}
// Skip tracking dependencies for primitive types. Assume that they are always present.
if (type.IsPrimitive || type.IsVoid)
{
return;
}
// Function pointers are not supported yet.
// https://github.com/dotnet/runtime/issues/71883
if (type.IsFunctionPointer)
{
return;
}
TypeDesc canonType = type.ConvertToCanonForm(CanonicalFormKind.Specific);
if (canonType.IsCanonicalSubtype(CanonicalFormKind.Any))
{
GenericTypesTemplateMap.GetTemplateTypeDependencies(ref dependencies, factory, type.ConvertToCanonForm(CanonicalFormKind.Specific));
}
else
{
dependencies.Add(factory.MaximallyConstructableType(canonType), "Reflection invoke");
}
}
public static void AddDependenciesDueToMethodCodePresence(ref DependencyList dependencies, NodeFactory factory, MethodDesc method)
{
factory.MetadataManager.GetDependenciesDueToReflectability(ref dependencies, factory, method);
if (method.HasInstantiation)
{
ExactMethodInstantiationsNode.GetExactMethodInstantiationDependenciesForMethod(ref dependencies, factory, method);
GenericMethodsTemplateMap.GetTemplateMethodDependencies(ref dependencies, factory, method);
}
else
{
TypeDesc owningTemplateType = method.OwningType;
// Unboxing and Instantiating stubs use a different type as their template
if (factory.TypeSystemContext.IsSpecialUnboxingThunk(method))
{
owningTemplateType = factory.TypeSystemContext.GetTargetOfSpecialUnboxingThunk(method).OwningType;
}
GenericTypesTemplateMap.GetTemplateTypeDependencies(ref dependencies, factory, owningTemplateType);
}
factory.InteropStubManager.AddDependeciesDueToPInvoke(ref dependencies, factory, method);
if (method.IsIntrinsic && factory.MetadataManager.SupportsReflection)
{
if (method.OwningType is MetadataType owningType)
{
string name = method.Name;
switch (name)
{
// The general purpose code in Comparer/EqualityComparer Create method depends on the template
// type loader being able to load the necessary types at runtime.
case "Create":
if (method.IsSharedByGenericInstantiations &&
owningType.Module == factory.TypeSystemContext.SystemModule &&
owningType.Namespace == "System.Collections.Generic")
{
TypeDesc[] templateDependencies = null;
if (owningType.Name == "Comparer`1")
{
templateDependencies = Internal.IL.Stubs.ComparerIntrinsics.GetPotentialComparersForType(
owningType.Instantiation[0]);
}
else if (owningType.Name == "EqualityComparer`1")
{
templateDependencies = Internal.IL.Stubs.ComparerIntrinsics.GetPotentialEqualityComparersForType(
owningType.Instantiation[0]);
}
if (templateDependencies != null)
{
dependencies = dependencies ?? new DependencyList();
foreach (TypeDesc templateType in templateDependencies)
{
dependencies.Add(factory.NativeLayout.TemplateTypeLayout(templateType), "Generic comparer");
}
}
}
break;
}
}
}
}
public static void AddDependenciesDueToMethodCodePresence(ref DependencyList dependencies, NodeFactory factory, MethodDesc method)
{
// Reflection invoke stub handling is here because in the current reflection model we reflection-enable
// all methods that are compiled. Ideally the list of reflection enabled methods should be known before
// we even start the compilation process (with the invocation stubs being compilation roots like any other).
// The existing model has it's problems: e.g. the invocability of the method depends on inliner decisions.
if (factory.MetadataManager.IsReflectionInvokable(method))
{
if (dependencies == null)
{
dependencies = new DependencyList();
}
if (factory.MetadataManager.HasReflectionInvokeStubForInvokableMethod(method) && !method.IsCanonicalMethod(CanonicalFormKind.Any) /* Shared generics handled in the shadow concrete method node */)
{
MethodDesc invokeStub = factory.MetadataManager.GetReflectionInvokeStub(method);
MethodDesc canonInvokeStub = invokeStub.GetCanonMethodTarget(CanonicalFormKind.Specific);
if (invokeStub != canonInvokeStub)
{
dependencies.Add(new DependencyListEntry(factory.FatFunctionPointer(invokeStub), "Reflection invoke"));
}
else
{
dependencies.Add(new DependencyListEntry(factory.MethodEntrypoint(invokeStub), "Reflection invoke"));
}
}
bool skipUnboxingStubDependency = false;
if (factory.Target.Abi == TargetAbi.ProjectN)
{
// ProjectN compilation currently computes the presence of these stubs independent from dependency analysis here
// TODO: fix that issue and remove this odd treatment of unboxing stubs
if (!method.HasInstantiation && method.OwningType.IsValueType && method.OwningType.IsCanonicalSubtype(CanonicalFormKind.Any) && !method.Signature.IsStatic)
{
skipUnboxingStubDependency = true;
}
}
if (method.OwningType.IsValueType && !method.Signature.IsStatic && !skipUnboxingStubDependency)
{
dependencies.Add(new DependencyListEntry(factory.MethodEntrypoint(method, unboxingStub: true), "Reflection unboxing stub"));
}
dependencies.AddRange(ReflectionVirtualInvokeMapNode.GetVirtualInvokeMapDependencies(factory, method));
}
if (method.HasInstantiation)
{
var exactMethodInstantiationDependencies = ExactMethodInstantiationsNode.GetExactMethodInstantiationDependenciesForMethod(factory, method);
if (exactMethodInstantiationDependencies != null)
{
dependencies = dependencies ?? new DependencyList();
dependencies.AddRange(exactMethodInstantiationDependencies);
}
if (method.IsVirtual)
{
// Generic virtual methods dependency tracking
dependencies = dependencies ?? new DependencyList();
dependencies.Add(new DependencyListEntry(factory.GVMDependencies(method), "GVM Dependencies Support"));
}
var templateMethodDependencies = GenericMethodsTemplateMap.GetTemplateMethodDependencies(factory, method);
if (templateMethodDependencies != null)
{
dependencies = dependencies ?? new DependencyList();
dependencies.AddRange(templateMethodDependencies);
}
}
else
{
TypeDesc owningTemplateType = method.OwningType;
// Unboxing and Instantiating stubs use a different type as their template
if (factory.TypeSystemContext.IsSpecialUnboxingThunk(method))
{
owningTemplateType = factory.TypeSystemContext.GetTargetOfSpecialUnboxingThunk(method).OwningType;
}
var templateTypeDepedencies = GenericTypesTemplateMap.GetTemplateTypeDependencies(factory, owningTemplateType);
if (templateTypeDepedencies != null)
{
dependencies = dependencies ?? new DependencyList();
dependencies.AddRange(templateTypeDepedencies);
}
}
}