public ReadyToRunGenericHelperNode(NodeFactory factory, ReadyToRunHelperId helperId, object target, TypeSystemEntity dictionaryOwner) { _id = helperId; _dictionaryOwner = dictionaryOwner; _target = target; _lookupSignature = GetLookupSignature(factory, helperId, target); }
private static GenericLookupResult GetLookupSignature(NodeFactory factory, ReadyToRunHelperId id, object target) { switch (id) { case ReadyToRunHelperId.TypeHandle: return factory.GenericLookup.Type((TypeDesc)target); case ReadyToRunHelperId.GetGCStaticBase: return factory.GenericLookup.TypeGCStaticBase((TypeDesc)target); case ReadyToRunHelperId.GetNonGCStaticBase: return factory.GenericLookup.TypeNonGCStaticBase((TypeDesc)target); case ReadyToRunHelperId.MethodDictionary: return factory.GenericLookup.MethodDictionary((MethodDesc)target); case ReadyToRunHelperId.VirtualCall: return factory.GenericLookup.VirtualCall((MethodDesc)target); case ReadyToRunHelperId.MethodEntry: return factory.GenericLookup.MethodEntry((MethodDesc)target); default: throw new NotImplementedException(); } }
public ReadyToRunHelperNode(NodeFactory factory, ReadyToRunHelperId id, Object target) { _id = id; _target = target; switch (id) { case ReadyToRunHelperId.NewHelper: case ReadyToRunHelperId.NewArr1: { // Make sure that if the EEType can't be generated, we throw the exception now. // This way we can fail generating code for the method that references the EEType // and (depending on the policy), we could avoid scraping the entire compilation. TypeDesc type = (TypeDesc)target; factory.ConstructedTypeSymbol(type); } break; case ReadyToRunHelperId.IsInstanceOf: case ReadyToRunHelperId.CastClass: { // Make sure that if the EEType can't be generated, we throw the exception now. // This way we can fail generating code for the method that references the EEType // and (depending on the policy), we could avoid scraping the entire compilation. TypeDesc type = (TypeDesc)target; factory.NecessaryTypeSymbol(type); Debug.Assert(!type.IsNullable, "Nullable needs to be unwrapped"); } break; case ReadyToRunHelperId.GetNonGCStaticBase: case ReadyToRunHelperId.GetGCStaticBase: case ReadyToRunHelperId.GetThreadStaticBase: { // Make sure we can compute static field layout now so we can fail early DefType defType = (DefType)target; defType.ComputeStaticFieldLayout(StaticLayoutKind.StaticRegionSizesAndFields); } break; } }
public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId helperId, object entity, SignatureContext signatureContext) { return(_compilation.SymbolNodeFactory.ReadyToRunHelper(helperId, entity, signatureContext)); }
public ReadyToRunHelperKey(ReadyToRunHelperId helperId, object target) { HelperId = helperId; Target = target; }
public ReadyToRunHelperNode(ReadyToRunHelperId id, Object target) { _id = id; _target = target; }
public ISymbolNode ReadyToRunHelperFromTypeLookup(ReadyToRunHelperId id, Object target, TypeSystemEntity dictionaryOwner) { return(_genericReadyToRunHelpersFromType.GetOrAdd(new ReadyToRunGenericHelperKey(id, target, dictionaryOwner))); }
public WebAssemblyReadyToRunGenericLookupFromTypeNode(NodeFactory factory, ReadyToRunHelperId helperId, object target, TypeSystemEntity dictionaryOwner) : base(factory, helperId, target, dictionaryOwner) { }
public GenericDictionaryLookup ComputeGenericLookup(MethodDesc contextMethod, ReadyToRunHelperId lookupKind, object targetOfLookup) { GenericContextSource contextSource; if (contextMethod.RequiresInstMethodDescArg()) { contextSource = GenericContextSource.MethodParameter; } else if (contextMethod.RequiresInstMethodTableArg()) { contextSource = GenericContextSource.TypeParameter; } else { Debug.Assert(contextMethod.AcquiresInstMethodTableFromThis()); contextSource = GenericContextSource.ThisObject; } // Can we do a fixed lookup? Start by checking if we can get to the dictionary. // Context source having a vtable with fixed slots is a prerequisite. if (contextSource == GenericContextSource.MethodParameter || HasFixedSlotVTable(contextMethod.OwningType)) { DictionaryLayoutNode dictionaryLayout; if (contextSource == GenericContextSource.MethodParameter) { dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod); } else { dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod.OwningType); } // If the dictionary layout has fixed slots, we can compute the lookup now. Otherwise defer to helper. if (dictionaryLayout.HasFixedSlots) { int pointerSize = _nodeFactory.Target.PointerSize; GenericLookupResult lookup = ReadyToRunGenericHelperNode.GetLookupSignature(_nodeFactory, lookupKind, targetOfLookup); int dictionarySlot = dictionaryLayout.GetSlotForEntry(lookup); int dictionaryOffset = dictionarySlot * pointerSize; if (contextSource == GenericContextSource.MethodParameter) { return(GenericDictionaryLookup.CreateFixedLookup(contextSource, dictionaryOffset)); } else { int vtableSlot = VirtualMethodSlotHelper.GetGenericDictionarySlot(_nodeFactory, contextMethod.OwningType); int vtableOffset = EETypeNode.GetVTableOffset(pointerSize) + vtableSlot * pointerSize; return(GenericDictionaryLookup.CreateFixedLookup(contextSource, vtableOffset, dictionaryOffset)); } } } // Fixed lookup not possible - use helper. return(GenericDictionaryLookup.CreateHelperLookup(contextSource)); }
private void ComputeLookup(ref CORINFO_RESOLVED_TOKEN pResolvedToken, object entity, ReadyToRunHelperId helperId, ref CORINFO_LOOKUP lookup) { if (_compilation.NeedsRuntimeLookup(helperId, entity)) { lookup.lookupKind.needsRuntimeLookup = true; lookup.runtimeLookup.signature = null; MethodDesc contextMethod = methodFromContext(pResolvedToken.tokenContext); // Do not bother computing the runtime lookup if we are inlining. The JIT is going // to abort the inlining attempt anyway. if (contextMethod != MethodBeingCompiled) { return; } // Necessary type handle is not something that can be in a dictionary (only a constructed type). // We only use necessary type handles if we can do a constant lookup. if (helperId == ReadyToRunHelperId.NecessaryTypeHandle) { helperId = ReadyToRunHelperId.TypeHandle; } GenericDictionaryLookup genericLookup = _compilation.ComputeGenericLookup(contextMethod, helperId, entity); if (genericLookup.UseHelper) { lookup.runtimeLookup.indirections = CORINFO.USEHELPER; lookup.lookupKind.runtimeLookupFlags = (ushort)helperId; lookup.lookupKind.runtimeLookupArgs = (void *)ObjectToHandle(entity); } else { if (genericLookup.ContextSource == GenericContextSource.MethodParameter) { lookup.runtimeLookup.helper = CorInfoHelpFunc.CORINFO_HELP_RUNTIMEHANDLE_METHOD; } else { lookup.runtimeLookup.helper = CorInfoHelpFunc.CORINFO_HELP_RUNTIMEHANDLE_CLASS; } lookup.runtimeLookup.indirections = (ushort)genericLookup.NumberOfIndirections; lookup.runtimeLookup.offset0 = (IntPtr)genericLookup[0]; if (genericLookup.NumberOfIndirections > 1) { lookup.runtimeLookup.offset1 = (IntPtr)genericLookup[1]; } lookup.runtimeLookup.testForFixup = false; // TODO: this will be needed in true multifile lookup.runtimeLookup.testForNull = false; lookup.runtimeLookup.indirectFirstOffset = false; lookup.runtimeLookup.indirectSecondOffset = false; lookup.lookupKind.runtimeLookupFlags = 0; lookup.lookupKind.runtimeLookupArgs = null; } lookup.lookupKind.runtimeLookupKind = GetLookupKindFromContextSource(genericLookup.ContextSource); } else { lookup.lookupKind.needsRuntimeLookup = false; ISymbolNode constLookup = _compilation.ComputeConstantLookup(helperId, entity); lookup.constLookup = CreateConstLookupToSymbol(constLookup); } }
private ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper GetGenericStaticHelper(ReadyToRunHelperId helperId) { ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper r2rHelper; switch (helperId) { case ReadyToRunHelperId.GetGCStaticBase: r2rHelper = ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_GenericGcStaticBase; break; case ReadyToRunHelperId.GetNonGCStaticBase: r2rHelper = ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_GenericNonGcStaticBase; break; case ReadyToRunHelperId.GetThreadStaticBase: r2rHelper = ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_GenericGcTlsBase; break; case ReadyToRunHelperId.GetThreadNonGcStaticBase: r2rHelper = ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_GenericNonGcTlsBase; break; default: throw new NotImplementedException(); } return(r2rHelper); }
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, Object target) { return(_readyToRunHelpers.GetOrAdd(new Tuple <ReadyToRunHelperId, object>(id, target))); }
private void ComputeLookup(ref CORINFO_RESOLVED_TOKEN pResolvedToken, object entity, ReadyToRunHelperId helperId, ref CORINFO_LOOKUP lookup) { if (_compilation.NeedsRuntimeLookup(helperId, entity)) { lookup.lookupKind.needsRuntimeLookup = true; lookup.runtimeLookup.signature = null; MethodDesc contextMethod = methodFromContext(pResolvedToken.tokenContext); // Do not bother computing the runtime lookup if we are inlining. The JIT is going // to abort the inlining attempt anyway. if (contextMethod != _methodCodeNode.Method) { return; } // There is a pathological case where invalid IL refereces __Canon type directly, but there is no dictionary available to store the lookup. // All callers of ComputeRuntimeLookupForSharedGenericToken have to filter out this case. We can't do much about it here. Debug.Assert(contextMethod.IsSharedByGenericInstantiations); if (contextMethod.RequiresInstMethodDescArg()) { lookup.lookupKind.runtimeLookupKind = CORINFO_RUNTIME_LOOKUP_KIND.CORINFO_LOOKUP_METHODPARAM; } else { if (contextMethod.RequiresInstMethodTableArg()) { lookup.lookupKind.runtimeLookupKind = CORINFO_RUNTIME_LOOKUP_KIND.CORINFO_LOOKUP_CLASSPARAM; } else { lookup.lookupKind.runtimeLookupKind = CORINFO_RUNTIME_LOOKUP_KIND.CORINFO_LOOKUP_THISOBJ; } } // Unless we decide otherwise, just do the lookup via a helper function lookup.runtimeLookup.indirections = CORINFO.USEHELPER; lookup.lookupKind.runtimeLookupFlags = (ushort)helperId; lookup.lookupKind.runtimeLookupArgs = (void *)ObjectToHandle(entity); lookup.runtimeLookup.indirectFirstOffset = false; lookup.runtimeLookup.indirectSecondOffset = false; // For R2R compilations, we don't generate the dictionary lookup signatures (dictionary lookups are done in a // different way that is more version resilient... plus we can't have pointers to existing MTs/MDs in the sigs) } else { lookup.lookupKind.needsRuntimeLookup = false; ISymbolNode constLookup = _compilation.SymbolNodeFactory.ComputeConstantLookup(helperId, entity, _signatureContext); lookup.constLookup = CreateConstLookupToSymbol(constLookup); } }
private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref CORINFO_LOOKUP_KIND pGenericLookupKind, CorInfoHelpFunc id, ref CORINFO_CONST_LOOKUP pLookup) { switch (id) { case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_NEW: { var type = HandleToObject(pResolvedToken.hClass); Debug.Assert(type.IsDefType); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.ReadyToRunHelper(ReadyToRunHelperId.NewHelper, type, _signatureContext)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_NEWARR_1: { var type = HandleToObject(pResolvedToken.hClass); Debug.Assert(type.IsSzArray); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.ReadyToRunHelper(ReadyToRunHelperId.NewArr1, type, _signatureContext)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_ISINSTANCEOF: { var type = HandleToObject(pResolvedToken.hClass); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } // ECMA-335 III.4.3: If typeTok is a nullable type, Nullable<T>, it is interpreted as "boxed" T if (type.IsNullable) { type = type.Instantiation[0]; } pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.ReadyToRunHelper(ReadyToRunHelperId.IsInstanceOf, type, _signatureContext)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_CHKCAST: { var type = HandleToObject(pResolvedToken.hClass); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } // ECMA-335 III.4.3: If typeTok is a nullable type, Nullable<T>, it is interpreted as "boxed" T if (type.IsNullable) { type = type.Instantiation[0]; } pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.ReadyToRunHelper(ReadyToRunHelperId.CastClass, type, _signatureContext)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_STATIC_BASE: { var type = HandleToObject(pResolvedToken.hClass); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.ReadyToRunHelper(ReadyToRunHelperId.CctorTrigger, type, _signatureContext)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_GENERIC_HANDLE: { Debug.Assert(pGenericLookupKind.needsRuntimeLookup); ReadyToRunHelperId helperId = (ReadyToRunHelperId)pGenericLookupKind.runtimeLookupFlags; object helperArg = HandleToObject((IntPtr)pGenericLookupKind.runtimeLookupArgs); if (helperArg is MethodDesc methodArg) { helperArg = new MethodWithToken(methodArg, new ModuleToken(_tokenContext, pResolvedToken.token)); } GenericContext methodContext = new GenericContext(entityFromContext(pResolvedToken.tokenContext)); ISymbolNode helper = _compilation.SymbolNodeFactory.GenericLookupHelper( pGenericLookupKind.runtimeLookupKind, helperId, helperArg, methodContext, _signatureContext); pLookup = CreateConstLookupToSymbol(helper); } break; default: throw new NotImplementedException("ReadyToRun: " + id.ToString()); } return(true); }
public static GenericDictionaryLookup CreateHelperLookup(GenericContextSource contextSource, ReadyToRunHelperId helperId, object helperObject) { return(new GenericDictionaryLookup(contextSource, UseHelperOffset, checked ((short)helperId), helperObject)); }
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, Object target) { throw new NotImplementedException(); }
public ISymbolNode ReadyToRunHelperFromTypeLookup(ReadyToRunHelperId id, Object target, TypeSystemEntity dictionaryOwner) { throw new NotImplementedException(); }
public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId lookupKind, object targetOfLookup) { // The current plan seem to be to copy paste from ILCompiler.Compilation, but that's not a sustainable plan throw new NotImplementedException(); }
public ISymbolNode ReadyToRunHelperFromDictionaryLookup(ReadyToRunHelperId id, Object target, TypeSystemEntity dictionaryOwner) { return(_genericReadyToRunHelpersFromDict.GetOrAdd(new Tuple <ReadyToRunHelperId, object, TypeSystemEntity>(id, target, dictionaryOwner))); }
public GenericDictionaryLookup ComputeGenericLookup(MethodDesc contextMethod, ReadyToRunHelperId lookupKind, object targetOfLookup) { // The current plan seem to be to copy paste from ILCompiler.Compilation, but that's not a sustainable plan throw new NotImplementedException(); }
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, object target, SignatureContext signatureContext) { if (!_r2rHelpers.TryGetValue(id, out Dictionary <object, ISymbolNode> helperNodeMap)) { helperNodeMap = new Dictionary <object, ISymbolNode>(); _r2rHelpers.Add(id, helperNodeMap); } if (helperNodeMap.TryGetValue(target, out ISymbolNode helperNode)) { return(helperNode); } switch (id) { case ReadyToRunHelperId.NewHelper: helperNode = CreateNewHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.NewArr1: helperNode = CreateNewArrayHelper((ArrayType)target, signatureContext); break; case ReadyToRunHelperId.GetGCStaticBase: helperNode = CreateGCStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.GetNonGCStaticBase: helperNode = CreateNonGCStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.GetThreadStaticBase: helperNode = CreateThreadGcStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.GetThreadNonGcStaticBase: helperNode = CreateThreadNonGcStaticBaseHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.IsInstanceOf: helperNode = CreateIsInstanceOfHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.CastClass: helperNode = CreateCastClassHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.TypeHandle: helperNode = CreateTypeHandleHelper((TypeDesc)target, signatureContext); break; case ReadyToRunHelperId.FieldHandle: helperNode = CreateFieldHandleHelper((FieldDesc)target, signatureContext); break; case ReadyToRunHelperId.VirtualCall: helperNode = CreateVirtualCallHelper((MethodWithToken)target, signatureContext); break; case ReadyToRunHelperId.DelegateCtor: helperNode = CreateDelegateCtorHelper((DelegateCreationInfo)target, signatureContext); break; default: throw new NotImplementedException(); } helperNodeMap.Add(target, helperNode); return(helperNode); }
private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref CORINFO_LOOKUP_KIND pGenericLookupKind, CorInfoHelpFunc id, ref CORINFO_CONST_LOOKUP pLookup) { switch (id) { case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_NEW: { var type = HandleToObject(pResolvedToken.hClass); Debug.Assert(type.IsDefType); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } pLookup = CreateConstLookupToSymbol(_compilation.NodeFactory.ReadyToRunHelper(ReadyToRunHelperId.NewHelper, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_NEWARR_1: { var type = HandleToObject(pResolvedToken.hClass); Debug.Assert(type.IsSzArray); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } pLookup = CreateConstLookupToSymbol(_compilation.NodeFactory.ReadyToRunHelper(ReadyToRunHelperId.NewArr1, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_ISINSTANCEOF: { var type = HandleToObject(pResolvedToken.hClass); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } // ECMA-335 III.4.3: If typeTok is a nullable type, Nullable<T>, it is interpreted as "boxed" T if (type.IsNullable) { type = type.Instantiation[0]; } pLookup = CreateConstLookupToSymbol(_compilation.NodeFactory.ReadyToRunHelper(ReadyToRunHelperId.IsInstanceOf, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_CHKCAST: { var type = HandleToObject(pResolvedToken.hClass); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } // ECMA-335 III.4.3: If typeTok is a nullable type, Nullable<T>, it is interpreted as "boxed" T if (type.IsNullable) { type = type.Instantiation[0]; } pLookup = CreateConstLookupToSymbol(_compilation.NodeFactory.ReadyToRunHelper(ReadyToRunHelperId.CastClass, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_STATIC_BASE: { var type = HandleToObject(pResolvedToken.hClass); if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) { return(false); } pLookup = CreateConstLookupToSymbol(_compilation.NodeFactory.ReadyToRunHelper(ReadyToRunHelperId.GetNonGCStaticBase, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_GENERIC_STATIC_BASE: { // Token == 0 means "initialize this class". We only expect RyuJIT to call it for this case. Debug.Assert(pResolvedToken.token == 0 && pResolvedToken.tokenScope == null); Debug.Assert(pGenericLookupKind.needsRuntimeLookup); DefType typeToInitialize = (DefType)MethodBeingCompiled.OwningType; Debug.Assert(typeToInitialize.IsCanonicalSubtype(CanonicalFormKind.Any)); DefType helperArg = typeToInitialize.ConvertToSharedRuntimeDeterminedForm(); ISymbolNode helper = GetGenericLookupHelper(pGenericLookupKind.runtimeLookupKind, ReadyToRunHelperId.GetNonGCStaticBase, helperArg); pLookup = CreateConstLookupToSymbol(helper); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_GENERIC_HANDLE: { Debug.Assert(pGenericLookupKind.needsRuntimeLookup); ReadyToRunHelperId helperId = (ReadyToRunHelperId)pGenericLookupKind.runtimeLookupFlags; object helperArg = HandleToObject((IntPtr)pGenericLookupKind.runtimeLookupArgs); ISymbolNode helper = GetGenericLookupHelper(pGenericLookupKind.runtimeLookupKind, helperId, helperArg); pLookup = CreateConstLookupToSymbol(helper); } break; default: throw new NotImplementedException("ReadyToRun: " + id.ToString()); } return(true); }
public ReadyToRunHelperKey(ReadyToRunHelperId id, object target) { Id = id; Target = target; }
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, Object target) { return(_readyToRunHelpers.GetOrAdd(new ReadyToRunHelperKey(id, target))); }
public ReadyToRunGenericLookupFromTypeNode(NodeFactory factory, ReadyToRunHelperId helperId, object target, TypeSystemEntity dictionaryOwner) : base(factory, helperId, target, dictionaryOwner) { }
public ReadyToRunGenericHelperKey(ReadyToRunHelperId helperId, object target, TypeSystemEntity dictionaryOwner) { HelperId = helperId; Target = target; DictionaryOwner = dictionaryOwner; }
private object GetTargetForFixup(object resolvedToken, ReadyToRunHelperId helperId) { switch (helperId) { case ReadyToRunHelperId.TypeHandle: if (resolvedToken is TypeDesc) return resolvedToken; else if (resolvedToken is MethodDesc) return ((MethodDesc)resolvedToken).OwningType; else return ((FieldDesc)resolvedToken).OwningType; default: return resolvedToken; } }
public GenericDictionaryLookup ComputeGenericLookup(MethodDesc contextMethod, ReadyToRunHelperId lookupKind, object targetOfLookup) { if (targetOfLookup is TypeSystemEntity typeSystemEntity) { _nodeFactory.TypeSystemContext.DetectGenericCycles(contextMethod, typeSystemEntity); } GenericContextSource contextSource; if (contextMethod.RequiresInstMethodDescArg()) { contextSource = GenericContextSource.MethodParameter; } else if (contextMethod.RequiresInstMethodTableArg()) { contextSource = GenericContextSource.TypeParameter; } else { Debug.Assert(contextMethod.AcquiresInstMethodTableFromThis()); contextSource = GenericContextSource.ThisObject; } // // Some helpers represent logical concepts that might not be something that can be looked up in a dictionary // // Downgrade type handle for casting to a normal type handle if possible if (lookupKind == ReadyToRunHelperId.TypeHandleForCasting) { var type = (TypeDesc)targetOfLookup; if (!type.IsRuntimeDeterminedType || (!((RuntimeDeterminedType)type).CanonicalType.IsCanonicalDefinitionType(CanonicalFormKind.Universal) && !((RuntimeDeterminedType)type).CanonicalType.IsNullable)) { if (type.IsNullable) { targetOfLookup = type.Instantiation[0]; } lookupKind = ReadyToRunHelperId.NecessaryTypeHandle; } } // We don't have separate entries for necessary type handles to avoid possible duplication if (lookupKind == ReadyToRunHelperId.NecessaryTypeHandle) { lookupKind = ReadyToRunHelperId.TypeHandle; } // Can we do a fixed lookup? Start by checking if we can get to the dictionary. // Context source having a vtable with fixed slots is a prerequisite. if (contextSource == GenericContextSource.MethodParameter || HasFixedSlotVTable(contextMethod.OwningType)) { DictionaryLayoutNode dictionaryLayout; if (contextSource == GenericContextSource.MethodParameter) { dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod); } else { dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod.OwningType); } // If the dictionary layout has fixed slots, we can compute the lookup now. Otherwise defer to helper. if (dictionaryLayout.HasFixedSlots) { int pointerSize = _nodeFactory.Target.PointerSize; GenericLookupResult lookup = ReadyToRunGenericHelperNode.GetLookupSignature(_nodeFactory, lookupKind, targetOfLookup); int dictionarySlot = dictionaryLayout.GetSlotForFixedEntry(lookup); if (dictionarySlot != -1) { int dictionaryOffset = dictionarySlot * pointerSize; bool indirectLastOffset = lookup.LookupResultReferenceType(_nodeFactory) == GenericLookupResultReferenceType.Indirect; if (contextSource == GenericContextSource.MethodParameter) { return(GenericDictionaryLookup.CreateFixedLookup(contextSource, dictionaryOffset, indirectLastOffset: indirectLastOffset)); } else { int vtableSlot = VirtualMethodSlotHelper.GetGenericDictionarySlot(_nodeFactory, contextMethod.OwningType); int vtableOffset = EETypeNode.GetVTableOffset(pointerSize) + vtableSlot * pointerSize; return(GenericDictionaryLookup.CreateFixedLookup(contextSource, vtableOffset, dictionaryOffset, indirectLastOffset: indirectLastOffset)); } } } } // Fixed lookup not possible - use helper. return(GenericDictionaryLookup.CreateHelperLookup(contextSource, lookupKind, targetOfLookup)); }
public ReadyToRunHelperKey(ReadyToRunHelperId id, Object obj) { _id = id; _obj = obj; }
public ReadyToRunHelperKey(ReadyToRunHelperId id, object target, SignatureContext signatureContext) { Id = id; Target = target; SignatureContext = signatureContext; }
private ISymbolNode GetGenericLookupHelper(CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunHelperId helperId, object helperArgument) { if (runtimeLookupKind == CORINFO_RUNTIME_LOOKUP_KIND.CORINFO_LOOKUP_THISOBJ || runtimeLookupKind == CORINFO_RUNTIME_LOOKUP_KIND.CORINFO_LOOKUP_CLASSPARAM) { return _compilation.NodeFactory.ReadyToRunHelperFromTypeLookup(helperId, helperArgument, MethodBeingCompiled.OwningType); } Debug.Assert(runtimeLookupKind == CORINFO_RUNTIME_LOOKUP_KIND.CORINFO_LOOKUP_METHODPARAM); return _compilation.NodeFactory.ReadyToRunHelperFromDictionaryLookup(helperId, helperArgument, MethodBeingCompiled); }
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, object target, SignatureContext signatureContext) { return(_r2rHelpers.GetOrAdd(new ReadyToRunHelperKey(id, target, signatureContext))); }
public ISymbolNode GenericLookupHelper( CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunHelperId helperId, object helperArgument, GenericContext methodContext, SignatureContext signatureContext) { switch (helperId) { case ReadyToRunHelperId.TypeHandle: return(GenericLookupTypeHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_TypeHandle, helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.MethodHandle: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_MethodHandle, (MethodWithToken)helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.MethodEntry: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry, (MethodWithToken)helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.MethodDictionary: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_MethodHandle, (MethodWithToken)helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.TypeDictionary: return(GenericLookupTypeHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_TypeDictionary, (TypeDesc)helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.VirtualDispatchCell: return(GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry, (MethodWithToken)helperArgument, methodContext, signatureContext)); case ReadyToRunHelperId.FieldHandle: return(GenericLookupFieldHelper( runtimeLookupKind, ReadyToRunFixupKind.READYTORUN_FIXUP_FieldHandle, (FieldDesc)helperArgument, methodContext, signatureContext)); default: throw new NotImplementedException(helperId.ToString()); } }
public ReadyToRunHelperNode(ReadyToRunHelperId id, Object target) { _id = id; _target = target; }
public static void EmitHelperNYIAssert(NodeFactory factory, ref ARMEmitter encoder, ReadyToRunHelperId hId, [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = null, [System.Runtime.CompilerServices.CallerMemberName] string memberName = null, [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0) { EmitNYIAssert(factory, ref encoder, hId.ToString() + " is not implemented", sourceFilePath, memberName, sourceLineNumber); }