diff --git a/src/coreclr/src/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/src/tools/Common/JitInterface/CorInfoImpl.cs index 63f817fba5631..0ec04f0e71161 100644 --- a/src/coreclr/src/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/src/tools/Common/JitInterface/CorInfoImpl.cs @@ -2232,7 +2232,7 @@ private void getFieldInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_MET // Static fields outside of the version bubble need to be accessed using the ENCODE_FIELD_ADDRESS // helper in accordance with ZapInfo::getFieldInfo in CoreCLR. - pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldAddress(field, GetSignatureContext())); + pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldAddress(field)); pResult->helper = CorInfoHelpFunc.CORINFO_HELP_READYTORUN_STATIC_BASE; @@ -2246,7 +2246,7 @@ private void getFieldInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_MET { pResult->fieldLookup = CreateConstLookupToSymbol( #if READYTORUN - _compilation.SymbolNodeFactory.CreateReadyToRunHelper(helperId, field.OwningType, GetSignatureContext()) + _compilation.SymbolNodeFactory.CreateReadyToRunHelper(helperId, field.OwningType) #else _compilation.NodeFactory.ReadyToRunHelper(helperId, field.OwningType) #endif diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelayLoadHelperMethodImport.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelayLoadHelperMethodImport.cs index 994246b3337af..dbf106844ed7d 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelayLoadHelperMethodImport.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelayLoadHelperMethodImport.cs @@ -22,8 +22,6 @@ public class DelayLoadHelperMethodImport : DelayLoadHelperImport, IMethodNode private readonly bool _useInstantiatingStub; - private readonly SignatureContext _signatureContext; - public DelayLoadHelperMethodImport( NodeFactory factory, ImportSectionNode importSectionNode, @@ -32,13 +30,11 @@ public DelayLoadHelperMethodImport( bool useVirtualCall, bool useInstantiatingStub, Signature instanceSignature, - SignatureContext signatureContext, string callSite = null) : base(factory, importSectionNode, helper, instanceSignature, useVirtualCall, callSite) { _method = method; _useInstantiatingStub = useInstantiatingStub; - _signatureContext = signatureContext; } public override IEnumerable GetStaticDependencies(NodeFactory factory) @@ -55,8 +51,7 @@ public override IEnumerable GetStaticDependencies(NodeFacto new MethodWithToken(canonMethod, _method.Token, constrainedType: null), isUnboxingStub: false, isInstantiatingStub: false, - isPrecodeImportRequired: false, - signatureContext: _signatureContext); + isPrecodeImportRequired: false); yield return new DependencyListEntry(canonMethodNode, "Canonical method for instantiating stub"); } } @@ -72,10 +67,6 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer if (result != 0) return result; - result = _signatureContext.CompareTo(otherNode._signatureContext, comparer); - if (result != 0) - return result; - result = _method.CompareTo(otherNode._method, comparer); if (result != 0) return result; diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelegateCtorSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelegateCtorSignature.cs index 43876f5b18cbc..4a3566fbdcab8 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelegateCtorSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelegateCtorSignature.cs @@ -17,22 +17,19 @@ public class DelegateCtorSignature : Signature private readonly ModuleToken _methodToken; - private readonly SignatureContext _signatureContext; - public DelegateCtorSignature( TypeDesc delegateType, IMethodNode targetMethod, - ModuleToken methodToken, - SignatureContext signatureContext) + ModuleToken methodToken) { _delegateType = delegateType; _targetMethod = targetMethod; _methodToken = methodToken; - _signatureContext = signatureContext; // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature - signatureContext.Resolver.CompilerContext.EnsureLoadableType(delegateType); - signatureContext.Resolver.CompilerContext.EnsureLoadableMethod(targetMethod.Method); + CompilerTypeSystemContext compilerContext = (CompilerTypeSystemContext)delegateType.Context; + compilerContext.EnsureLoadableType(delegateType); + compilerContext.EnsureLoadableMethod(targetMethod.Method); } public override int ClassCode => 99885741; @@ -44,7 +41,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) if (!relocsOnly) { - SignatureContext innerContext = builder.EmitFixup(factory, ReadyToRunFixupKind.DelegateCtor, _methodToken.Module, _signatureContext); + SignatureContext innerContext = builder.EmitFixup(factory, ReadyToRunFixupKind.DelegateCtor, _methodToken.Module, factory.SignatureContext); builder.EmitMethodSignature( new MethodWithToken(_targetMethod.Method, _methodToken, constrainedType: null), @@ -93,11 +90,7 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer if (result != 0) return result; - result = _methodToken.CompareTo(otherNode._methodToken); - if (result != 0) - return result; - - return _signatureContext.CompareTo(otherNode._signatureContext, comparer); + return _methodToken.CompareTo(otherNode._methodToken); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ExternalMethodImport.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ExternalMethodImport.cs index d827b34abf86c..1e57fe0312dd0 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ExternalMethodImport.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/ExternalMethodImport.cs @@ -18,8 +18,7 @@ public ExternalMethodImport( ReadyToRunFixupKind fixupKind, MethodWithToken method, bool isUnboxingStub, - bool isInstantiatingStub, - SignatureContext signatureContext) + bool isInstantiatingStub) : base( factory, factory.MethodImports, @@ -28,8 +27,7 @@ public ExternalMethodImport( fixupKind, method, isUnboxingStub, - isInstantiatingStub, - signatureContext)) + isInstantiatingStub)) { _method = method; } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/FieldFixupSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/FieldFixupSignature.cs index 8ced922f0c49e..32cae03ba4016 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/FieldFixupSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/FieldFixupSignature.cs @@ -18,16 +18,13 @@ public class FieldFixupSignature : Signature private readonly FieldDesc _fieldDesc; - private readonly SignatureContext _signatureContext; - - public FieldFixupSignature(ReadyToRunFixupKind fixupKind, FieldDesc fieldDesc, SignatureContext signatureContext) + public FieldFixupSignature(ReadyToRunFixupKind fixupKind, FieldDesc fieldDesc) { _fixupKind = fixupKind; _fieldDesc = fieldDesc; - _signatureContext = signatureContext; // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature - signatureContext.Resolver.CompilerContext.EnsureLoadableType(fieldDesc.OwningType); + ((CompilerTypeSystemContext)fieldDesc.Context).EnsureLoadableType(fieldDesc.OwningType); } public override int ClassCode => 271828182; @@ -40,8 +37,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { dataBuilder.AddSymbol(this); - EcmaModule targetModule = _signatureContext.GetTargetModule(_fieldDesc); - SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, _signatureContext); + EcmaModule targetModule = factory.SignatureContext.GetTargetModule(_fieldDesc); + SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, factory.SignatureContext); dataBuilder.EmitFieldSignature(_fieldDesc, innerContext); } @@ -62,11 +59,7 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer if (result != 0) return result; - result = comparer.Compare(_fieldDesc, otherNode._fieldDesc); - if (result != 0) - return result; - - return _signatureContext.CompareTo(otherNode._signatureContext, comparer); + return comparer.Compare(_fieldDesc, otherNode._fieldDesc); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/GenericLookupSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/GenericLookupSignature.cs index 3ce636aa106c5..a0aa10fe80c5c 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/GenericLookupSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/GenericLookupSignature.cs @@ -27,16 +27,13 @@ public class GenericLookupSignature : Signature private readonly GenericContext _methodContext; - private readonly SignatureContext _signatureContext; - public GenericLookupSignature( CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunFixupKind fixupKind, TypeDesc typeArgument, MethodWithToken methodArgument, FieldDesc fieldArgument, - GenericContext methodContext, - SignatureContext signatureContext) + GenericContext methodContext) { Debug.Assert(typeArgument != null || methodArgument != null || fieldArgument != null); _runtimeLookupKind = runtimeLookupKind; @@ -45,7 +42,6 @@ public GenericLookupSignature( _methodArgument = methodArgument; _fieldArgument = fieldArgument; _methodContext = methodContext; - _signatureContext = signatureContext; } public override int ClassCode => 258608008; @@ -65,11 +61,11 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) } else if (_typeArgument != null) { - targetModule = _signatureContext.GetTargetModule(_typeArgument); + targetModule = factory.SignatureContext.GetTargetModule(_typeArgument); } else if (_fieldArgument != null) { - targetModule = _signatureContext.GetTargetModule(_fieldArgument); + targetModule = factory.SignatureContext.GetTargetModule(_fieldArgument); } else { @@ -101,7 +97,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) ObjectDataSignatureBuilder dataBuilder = new ObjectDataSignatureBuilder(); dataBuilder.AddSymbol(this); - SignatureContext innerContext = dataBuilder.EmitFixup(factory, fixupToEmit, targetModule, _signatureContext); + SignatureContext innerContext = dataBuilder.EmitFixup(factory, fixupToEmit, targetModule, factory.SignatureContext); if (contextTypeToEmit != null) { dataBuilder.EmitTypeSignature(contextTypeToEmit, innerContext); @@ -214,11 +210,7 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer return result; } - result = comparer.Compare(_methodContext.ContextMethod, otherNode._methodContext.ContextMethod); - if (result != 0) - return result; - - return _signatureContext.CompareTo(otherNode._signatureContext, comparer); + return comparer.Compare(_methodContext.ContextMethod, otherNode._methodContext.ContextMethod); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstanceEntryPointTableNode.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstanceEntryPointTableNode.cs index 148853d802d2e..e2e5b21082cb0 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstanceEntryPointTableNode.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstanceEntryPointTableNode.cs @@ -53,8 +53,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) int methodIndex = factory.RuntimeFunctionsTable.GetIndex(method); bool enforceOwningType = false; - ModuleToken moduleToken = method.SignatureContext.GetModuleTokenForMethod(method.Method.GetTypicalMethodDefinition()); - if (moduleToken.Module != factory.InputModuleContext.GlobalContext) + ModuleToken moduleToken = factory.SignatureContext.GetModuleTokenForMethod(method.Method.GetTypicalMethodDefinition()); + if (moduleToken.Module != factory.SignatureContext.GlobalContext) { enforceOwningType = true; } @@ -64,7 +64,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) new MethodWithToken(method.Method, moduleToken, constrainedType: null), enforceDefEncoding: true, enforceOwningType, - method.SignatureContext, + factory.SignatureContext, isUnboxingStub: false, isInstantiatingStub: false); byte[] signature = signatureBuilder.ToArray(); diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/LocalMethodImport.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/LocalMethodImport.cs index bd93d1a621d3f..cfc5b3075cabe 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/LocalMethodImport.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/LocalMethodImport.cs @@ -21,8 +21,7 @@ public LocalMethodImport( MethodWithToken method, MethodWithGCInfo localMethod, bool isUnboxingStub, - bool isInstantiatingStub, - SignatureContext signatureContext) + bool isInstantiatingStub) : base( factory, factory.MethodImports, @@ -31,8 +30,7 @@ public LocalMethodImport( fixupKind, method, isUnboxingStub, - isInstantiatingStub, - signatureContext)) + isInstantiatingStub)) { _localMethod = localMethod; } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodFixupSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodFixupSignature.cs index fb0db4e4d0747..7461e662a291c 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodFixupSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodFixupSignature.cs @@ -19,8 +19,6 @@ public class MethodFixupSignature : Signature private readonly MethodWithToken _method; - private readonly SignatureContext _signatureContext; - private readonly bool _isUnboxingStub; private readonly bool _isInstantiatingStub; @@ -28,20 +26,19 @@ public class MethodFixupSignature : Signature public MethodFixupSignature( ReadyToRunFixupKind fixupKind, MethodWithToken method, - SignatureContext signatureContext, bool isUnboxingStub, bool isInstantiatingStub) { _fixupKind = fixupKind; _method = method; - _signatureContext = signatureContext; _isUnboxingStub = isUnboxingStub; _isInstantiatingStub = isInstantiatingStub; // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature - signatureContext.Resolver.CompilerContext.EnsureLoadableMethod(method.Method); + CompilerTypeSystemContext compilerContext = (CompilerTypeSystemContext)method.Method.Context; + compilerContext.EnsureLoadableMethod(method.Method); if (method.ConstrainedType != null) - signatureContext.Resolver.CompilerContext.EnsureLoadableType(method.ConstrainedType); + compilerContext.EnsureLoadableType(method.ConstrainedType); } public MethodDesc Method => _method.Method; @@ -88,18 +85,18 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { if (method.Token.TokenType == CorTokenType.mdtMethodSpec) { - method = new MethodWithToken(method.Method, _signatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType); + method = new MethodWithToken(method.Method, factory.SignatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType); } else if (!optimized && (method.Token.TokenType == CorTokenType.mdtMemberRef)) { if (method.Method.OwningType.GetTypeDefinition() is EcmaType) { - method = new MethodWithToken(method.Method, _signatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType); + method = new MethodWithToken(method.Method, factory.SignatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType); } } } - SignatureContext innerContext = dataBuilder.EmitFixup(factory, fixupKind, method.Token.Module, _signatureContext); + SignatureContext innerContext = dataBuilder.EmitFixup(factory, fixupKind, method.Token.Module, factory.SignatureContext); if (optimized && method.Token.TokenType == CorTokenType.mdtMethodDef) { @@ -149,11 +146,7 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer if (result != 0) return result; - result = _method.CompareTo(otherNode._method, comparer); - if (result != 0) - return result; - - return _signatureContext.CompareTo(otherNode._signatureContext, comparer); + return _method.CompareTo(otherNode._method, comparer); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodWithGCInfo.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodWithGCInfo.cs index bd5962b9d01b9..b82737e07152e 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodWithGCInfo.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodWithGCInfo.cs @@ -17,7 +17,6 @@ public class MethodWithGCInfo : ObjectNode, IReadyToRunMethodCodeNode, IMethodBo public readonly MethodGCInfoNode GCInfoNode; private readonly MethodDesc _method; - public SignatureContext SignatureContext { get; } private ObjectData _methodCode; private FrameInfo[] _frameInfos; @@ -29,12 +28,11 @@ public class MethodWithGCInfo : ObjectNode, IReadyToRunMethodCodeNode, IMethodBo private List _fixups; private MethodDesc[] _inlinedMethods; - public MethodWithGCInfo(MethodDesc methodDesc, SignatureContext signatureContext) + public MethodWithGCInfo(MethodDesc methodDesc) { GCInfoNode = new MethodGCInfoNode(this); _fixups = new List(); _method = methodDesc; - SignatureContext = signatureContext; } public void SetCode(ObjectData data) @@ -294,11 +292,7 @@ public void InitializeDebugEHClauseInfos(DebugEHClauseInfo[] debugEHClauseInfos) public override int CompareToImpl(ISortableNode other, CompilerComparer comparer) { MethodWithGCInfo otherNode = (MethodWithGCInfo)other; - int result = comparer.Compare(_method, otherNode._method); - if (result != 0) - return result; - - return SignatureContext.CompareTo(otherNode.SignatureContext, comparer); + return comparer.Compare(_method, otherNode._method); } public void InitializeInliningInfo(MethodDesc[] inlinedMethods) diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewArrayFixupSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewArrayFixupSignature.cs index da57ac0bf7232..7372d0235de3d 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewArrayFixupSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewArrayFixupSignature.cs @@ -12,15 +12,13 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun public class NewArrayFixupSignature : Signature { private readonly ArrayType _arrayType; - private readonly SignatureContext _signatureContext; - public NewArrayFixupSignature(ArrayType arrayType, SignatureContext signatureContext) + public NewArrayFixupSignature(ArrayType arrayType) { _arrayType = arrayType; - _signatureContext = signatureContext; // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature - signatureContext.Resolver.CompilerContext.EnsureLoadableType(arrayType); + ((CompilerTypeSystemContext)arrayType.Context).EnsureLoadableType(arrayType); } public override int ClassCode => 815543321; @@ -33,8 +31,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { dataBuilder.AddSymbol(this); - EcmaModule targetModule = _signatureContext.GetTargetModule(_arrayType); - SignatureContext innerContext = dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.NewArray, targetModule, _signatureContext); + EcmaModule targetModule = factory.SignatureContext.GetTargetModule(_arrayType); + SignatureContext innerContext = dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.NewArray, targetModule, factory.SignatureContext); dataBuilder.EmitTypeSignature(_arrayType, innerContext); } @@ -51,11 +49,7 @@ public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilde public override int CompareToImpl(ISortableNode other, CompilerComparer comparer) { NewArrayFixupSignature otherNode = (NewArrayFixupSignature)other; - int result = comparer.Compare(_arrayType, otherNode._arrayType); - if (result != 0) - return result; - - return _signatureContext.CompareTo(otherNode._signatureContext, comparer); + return comparer.Compare(_arrayType, otherNode._arrayType); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewObjectFixupSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewObjectFixupSignature.cs index 9b3a96d460d90..acfeb03b34fd9 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewObjectFixupSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/NewObjectFixupSignature.cs @@ -12,15 +12,13 @@ namespace ILCompiler.DependencyAnalysis.ReadyToRun public class NewObjectFixupSignature : Signature { private readonly TypeDesc _typeDesc; - private readonly SignatureContext _signatureContext; - public NewObjectFixupSignature(TypeDesc typeDesc, SignatureContext signatureContext) + public NewObjectFixupSignature(TypeDesc typeDesc) { _typeDesc = typeDesc; - _signatureContext = signatureContext; // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature - signatureContext.Resolver.CompilerContext.EnsureLoadableType(typeDesc); + ((CompilerTypeSystemContext)typeDesc.Context).EnsureLoadableType(typeDesc); } public override int ClassCode => 551247760; @@ -33,8 +31,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { dataBuilder.AddSymbol(this); - EcmaModule targetModule = _signatureContext.GetTargetModule(_typeDesc); - SignatureContext innerContext = dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.NewObject, targetModule, _signatureContext); + EcmaModule targetModule = factory.SignatureContext.GetTargetModule(_typeDesc); + SignatureContext innerContext = dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.NewObject, targetModule, factory.SignatureContext); dataBuilder.EmitTypeSignature(_typeDesc, innerContext); } @@ -51,11 +49,7 @@ public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilde public override int CompareToImpl(ISortableNode other, CompilerComparer comparer) { NewObjectFixupSignature otherNode = (NewObjectFixupSignature)other; - int result = comparer.Compare(_typeDesc, otherNode._typeDesc); - if (result != 0) - return result; - - return _signatureContext.CompareTo(otherNode._signatureContext, comparer); + return comparer.Compare(_typeDesc, otherNode._typeDesc); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/PrecodeMethodImport.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/PrecodeMethodImport.cs index cf6442294c9d0..7b691c4e30826 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/PrecodeMethodImport.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/PrecodeMethodImport.cs @@ -22,16 +22,14 @@ public PrecodeMethodImport( MethodWithToken method, MethodWithGCInfo localMethod, bool isUnboxingStub, - bool isInstantiatingStub, - SignatureContext signatureContext) : + bool isInstantiatingStub) : base ( factory, factory.MethodSignature( fixupKind, method, isUnboxingStub, - isInstantiatingStub, - signatureContext) + isInstantiatingStub) ) { _localMethod = localMethod; diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImport.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImport.cs index 9bcc778415b46..ef9f5bb378b33 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImport.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImport.cs @@ -10,8 +10,8 @@ public class StringImport : Import { private readonly ModuleToken _token; - public StringImport(ImportSectionNode table, ModuleToken token, SignatureContext signatureContext) - : base(table, new StringImportSignature(token, signatureContext)) + public StringImport(ImportSectionNode table, ModuleToken token) + : base(table, new StringImportSignature(token)) { _token = token; } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImportSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImportSignature.cs index c264da91a1eac..b44e178738b73 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImportSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/StringImportSignature.cs @@ -11,12 +11,9 @@ public class StringImportSignature : Signature { private readonly ModuleToken _token; - private readonly SignatureContext _signatureContext; - - public StringImportSignature(ModuleToken token, SignatureContext signatureContext) + public StringImportSignature(ModuleToken token) { _token = token; - _signatureContext = signatureContext; } public override int ClassCode => 324832559; @@ -29,7 +26,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { dataBuilder.AddSymbol(this); - dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.StringHandle, _token.Module, _signatureContext); + dataBuilder.EmitFixup(factory, ReadyToRunFixupKind.StringHandle, _token.Module, factory.SignatureContext); dataBuilder.EmitUInt(_token.TokenRid); } @@ -45,10 +42,6 @@ public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilde public override int CompareToImpl(ISortableNode other, CompilerComparer comparer) { StringImportSignature otherNode = (StringImportSignature)other; - int result = _signatureContext.CompareTo(otherNode._signatureContext, comparer); - if (result != 0) - return result; - return _token.CompareTo(otherNode._token); } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/TypeFixupSignature.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/TypeFixupSignature.cs index c0dc4a8ab62af..3ae821d2dbf77 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/TypeFixupSignature.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/TypeFixupSignature.cs @@ -17,16 +17,13 @@ public class TypeFixupSignature : Signature private readonly TypeDesc _typeDesc; - private readonly SignatureContext _signatureContext; - - public TypeFixupSignature(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc, SignatureContext signatureContext) + public TypeFixupSignature(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc) { _fixupKind = fixupKind; _typeDesc = typeDesc; - _signatureContext = signatureContext; // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature - signatureContext.Resolver.CompilerContext.EnsureLoadableType(typeDesc); + ((CompilerTypeSystemContext)typeDesc.Context).EnsureLoadableType(typeDesc); } public override int ClassCode => 255607008; @@ -39,8 +36,8 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) { dataBuilder.AddSymbol(this); - EcmaModule targetModule = _signatureContext.GetTargetModule(_typeDesc); - SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, _signatureContext); + EcmaModule targetModule = factory.SignatureContext.GetTargetModule(_typeDesc); + SignatureContext innerContext = dataBuilder.EmitFixup(factory, _fixupKind, targetModule, factory.SignatureContext); dataBuilder.EmitTypeSignature(_typeDesc, innerContext); } @@ -61,11 +58,7 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer if (result != 0) return result; - result = comparer.Compare(_typeDesc, otherNode._typeDesc); - if (result != 0) - return result; - - return _signatureContext.CompareTo(otherNode._signatureContext, comparer); + return comparer.Compare(_typeDesc, otherNode._typeDesc); } protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs index 3e9e6937ac61b..c962c668f7a91 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs @@ -73,8 +73,7 @@ public IMethodNode MethodEntrypoint(MethodDesc method) new MethodWithToken(method, moduleToken, constrainedType: null), isUnboxingStub: false, isInstantiatingStub: false, - isPrecodeImportRequired: false, - signatureContext: InputModuleContext); + isPrecodeImportRequired: false); } private NodeCache _allMethodsOnType; @@ -189,7 +188,7 @@ public NodeFactory( NameMangler = nameMangler; MetadataManager = new ReadyToRunTableManager(context); Resolver = moduleTokenResolver; - InputModuleContext = signatureContext; + SignatureContext = signatureContext; CopiedCorHeaderNode = corHeaderNode; DebugDirectoryNode = debugDirectoryNode; AttributePresenceFilter = attributePresenceFilterNode; @@ -215,8 +214,7 @@ private void CreateNodeCaches() GetGenericStaticHelper(helperKey.HelperId), TypeSignature( ReadyToRunFixupKind.Invalid, - (TypeDesc)helperKey.Target, - InputModuleContext)); + (TypeDesc)helperKey.Target)); }); _genericReadyToRunHelpersFromType = new NodeCache(helperKey => @@ -227,8 +225,7 @@ private void CreateNodeCaches() GetGenericStaticHelper(helperKey.HelperId), TypeSignature( ReadyToRunFixupKind.Invalid, - (TypeDesc)helperKey.Target, - InputModuleContext)); + (TypeDesc)helperKey.Target)); }); _readOnlyDataBlobs = new NodeCache(key => @@ -245,7 +242,7 @@ private void CreateNodeCaches() _localMethodCache = new NodeCache(key => { - return new MethodWithGCInfo(key.Method.Method, key.SignatureContext); + return new MethodWithGCInfo(key.Method.Method); }); _methodSignatures = new NodeCache(key => @@ -253,7 +250,6 @@ private void CreateNodeCaches() return new MethodFixupSignature( key.FixupKind, key.TypeAndMethod.Method, - key.TypeAndMethod.SignatureContext, key.TypeAndMethod.IsUnboxingStub, key.TypeAndMethod.IsInstantiatingStub ); @@ -261,7 +257,7 @@ private void CreateNodeCaches() _typeSignatures = new NodeCache(key => { - return new TypeFixupSignature(key.FixupKind, key.TypeDesc, InputModuleContext); + return new TypeFixupSignature(key.FixupKind, key.TypeDesc); }); _dynamicHelperCellCache = new NodeCache(key => @@ -276,10 +272,8 @@ private void CreateNodeCaches() MethodSignature( ReadyToRunFixupKind.VirtualEntry, key.Method, - signatureContext: key.SignatureContext, isUnboxingStub: key.IsUnboxingStub, - isInstantiatingStub: key.IsInstantiatingStub), - key.SignatureContext); + isInstantiatingStub: key.IsInstantiatingStub)); }); _copiedCorHeaders = new NodeCache(module => @@ -326,7 +320,7 @@ private void CreateNodeCaches() }); } - public SignatureContext InputModuleContext; + public SignatureContext SignatureContext; public ModuleTokenResolver Resolver; @@ -393,7 +387,6 @@ private IMethodNode CreateMethodEntrypoint(TypeAndMethod key) bool isUnboxingStub = key.IsUnboxingStub; bool isInstantiatingStub = key.IsInstantiatingStub; bool isPrecodeImportRequired = key.IsPrecodeImportRequired; - SignatureContext signatureContext = key.SignatureContext; if (CompilationModuleGroup.ContainsMethodBody(method.Method, false)) { if (isPrecodeImportRequired) @@ -402,10 +395,9 @@ private IMethodNode CreateMethodEntrypoint(TypeAndMethod key) this, ReadyToRunFixupKind.MethodEntry, method, - CreateMethodEntrypointNodeHelper(method, signatureContext), + CreateMethodEntrypointNodeHelper(method), isUnboxingStub, - isInstantiatingStub, - signatureContext); + isInstantiatingStub); } else { @@ -413,10 +405,9 @@ private IMethodNode CreateMethodEntrypoint(TypeAndMethod key) this, ReadyToRunFixupKind.MethodEntry, method, - CreateMethodEntrypointNodeHelper(method, signatureContext), + CreateMethodEntrypointNodeHelper(method), isUnboxingStub, - isInstantiatingStub, - signatureContext); + isInstantiatingStub); } } else @@ -427,25 +418,19 @@ private IMethodNode CreateMethodEntrypoint(TypeAndMethod key) ReadyToRunFixupKind.MethodEntry, method, isUnboxingStub, - isInstantiatingStub, - signatureContext); + isInstantiatingStub); } } - public IMethodNode MethodEntrypoint( - MethodWithToken method, - bool isUnboxingStub, - bool isInstantiatingStub, - bool isPrecodeImportRequired, - SignatureContext signatureContext) + public IMethodNode MethodEntrypoint(MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, bool isPrecodeImportRequired) { - TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, isPrecodeImportRequired, signatureContext); + TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, isPrecodeImportRequired); return _importMethods.GetOrAdd(key); } private NodeCache _localMethodCache = new NodeCache(); - private MethodWithGCInfo CreateMethodEntrypointNodeHelper(MethodWithToken targetMethod, SignatureContext signatureContext) + private MethodWithGCInfo CreateMethodEntrypointNodeHelper(MethodWithToken targetMethod) { Debug.Assert(CompilationModuleGroup.ContainsMethodBody(targetMethod.Method, false)); @@ -455,8 +440,7 @@ private MethodWithGCInfo CreateMethodEntrypointNodeHelper(MethodWithToken target new MethodWithToken(localMethod, default(ModuleToken), constrainedType: null), isUnboxingStub: false, isInstantiatingStub: false, - isPrecodeImportRequired: false, - signatureContext); + isPrecodeImportRequired: false); return _localMethodCache.GetOrAdd(localMethodKey); } @@ -515,10 +499,9 @@ public MethodFixupSignature MethodSignature( ReadyToRunFixupKind fixupKind, MethodWithToken method, bool isUnboxingStub, - bool isInstantiatingStub, - SignatureContext signatureContext) + bool isInstantiatingStub) { - TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, false, signatureContext); + TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, false); return _methodSignatures.GetOrAdd(new MethodFixupKey(fixupKind, key)); } @@ -526,19 +509,16 @@ private struct TypeFixupKey : IEquatable { public readonly ReadyToRunFixupKind FixupKind; public readonly TypeDesc TypeDesc; - public readonly SignatureContext SignatureContext; - public TypeFixupKey(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc, SignatureContext signatureContext) + + public TypeFixupKey(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc) { FixupKind = fixupKind; TypeDesc = typeDesc; - SignatureContext = signatureContext; } public bool Equals(TypeFixupKey other) { - return FixupKind == other.FixupKind - && TypeDesc == other.TypeDesc - && SignatureContext.Equals(other.SignatureContext); + return FixupKind == other.FixupKind && TypeDesc == other.TypeDesc; } public override bool Equals(object obj) @@ -548,17 +528,15 @@ public override bool Equals(object obj) public override int GetHashCode() { - return FixupKind.GetHashCode() - ^ (31 * TypeDesc.GetHashCode()) - ^ (23 * SignatureContext.GetHashCode()); + return FixupKind.GetHashCode() ^ (31 * TypeDesc.GetHashCode()); } } private NodeCache _typeSignatures; - public TypeFixupSignature TypeSignature(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc, SignatureContext signatureContext) + public TypeFixupSignature TypeSignature(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc) { - TypeFixupKey fixupKey = new TypeFixupKey(fixupKind, typeDesc, signatureContext); + TypeFixupKey fixupKey = new TypeFixupKey(fixupKind, typeDesc); return _typeSignatures.GetOrAdd(fixupKey); } @@ -583,7 +561,7 @@ public void AttachToDependencyGraph(DependencyAnalyzerBase graph) MethodEntryPointTable = new MethodEntryPointTableNode(Target); Header.Add(Internal.Runtime.ReadyToRunSectionType.MethodDefEntryPoints, MethodEntryPointTable, MethodEntryPointTable); - ManifestMetadataTable = new ManifestMetadataTableNode(InputModuleContext.GlobalContext, this); + ManifestMetadataTable = new ManifestMetadataTableNode(SignatureContext.GlobalContext, this); Header.Add(Internal.Runtime.ReadyToRunSectionType.ManifestMetadata, ManifestMetadataTable, ManifestMetadataTable); Resolver.SetModuleIndexLookup(ManifestMetadataTable.ModuleToIndex); @@ -600,7 +578,7 @@ public void AttachToDependencyGraph(DependencyAnalyzerBase graph) DebugInfoTable = new DebugInfoTableNode(Target); Header.Add(Internal.Runtime.ReadyToRunSectionType.DebugInfo, DebugInfoTable, DebugInfoTable); - InliningInfoTable = new InliningInfoNode(Target, InputModuleContext.GlobalContext); + InliningInfoTable = new InliningInfoNode(Target, SignatureContext.GlobalContext); Header.Add(Internal.Runtime.ReadyToRunSectionType.InliningInfo2, InliningInfoTable, InliningInfoTable); // Core library attributes are checked FAR more often than other dlls @@ -738,22 +716,19 @@ struct DynamicHelperCellKey : IEquatable public readonly MethodWithToken Method; public readonly bool IsUnboxingStub; public readonly bool IsInstantiatingStub; - public readonly SignatureContext SignatureContext; - public DynamicHelperCellKey(MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext) + public DynamicHelperCellKey(MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub) { Method = method; IsUnboxingStub = isUnboxingStub; IsInstantiatingStub = isInstantiatingStub; - SignatureContext = signatureContext; } public bool Equals(DynamicHelperCellKey other) { return Method.Equals(other.Method) && IsUnboxingStub == other.IsUnboxingStub - && IsInstantiatingStub == other.IsInstantiatingStub - && SignatureContext.Equals(other.SignatureContext); + && IsInstantiatingStub == other.IsInstantiatingStub; } public override bool Equals(object obj) @@ -765,16 +740,15 @@ public override int GetHashCode() { return Method.GetHashCode() ^ (IsUnboxingStub ? -0x80000000 : 0) - ^ (IsInstantiatingStub ? -0x40000000 : 0) - ^ (31 * SignatureContext.GetHashCode()); + ^ (IsInstantiatingStub ? -0x40000000 : 0); } } private NodeCache _dynamicHelperCellCache; - public ISymbolNode DynamicHelperCell(MethodWithToken methodWithToken, bool isInstantiatingStub, SignatureContext signatureContext) + public ISymbolNode DynamicHelperCell(MethodWithToken methodWithToken, bool isInstantiatingStub) { - DynamicHelperCellKey key = new DynamicHelperCellKey(methodWithToken, isUnboxingStub: false, isInstantiatingStub, signatureContext); + DynamicHelperCellKey key = new DynamicHelperCellKey(methodWithToken, isUnboxingStub: false, isInstantiatingStub); return _dynamicHelperCellCache.GetOrAdd(key); } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs index 61ff66fbcdaae..735ada49e6191 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs @@ -47,36 +47,36 @@ public ReadyToRunSymbolNodeFactory(NodeFactory codegenNodeFactory) private void CreateNodeCaches() { - _importStrings = new NodeCache(key => + _importStrings = new NodeCache(key => { - return new StringImport(_codegenNodeFactory.StringImports, key.ModuleToken, key.SignatureContext); + return new StringImport(_codegenNodeFactory.StringImports, key); }); _r2rHelpers = new NodeCache(CreateReadyToRunHelper); - _fieldAddressCache = new NodeCache(key => + _fieldAddressCache = new NodeCache(key => { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - new FieldFixupSignature(ReadyToRunFixupKind.FieldAddress, key.Field, key.SignatureContext) + new FieldFixupSignature(ReadyToRunFixupKind.FieldAddress, key) ); }); - _fieldOffsetCache = new NodeCache(key => + _fieldOffsetCache = new NodeCache(key => { return new PrecodeHelperImport( _codegenNodeFactory, - new FieldFixupSignature(ReadyToRunFixupKind.FieldOffset, key.Field, key.SignatureContext) + new FieldFixupSignature(ReadyToRunFixupKind.FieldOffset, key) ); }); - _fieldBaseOffsetCache = new NodeCache(key => + _fieldBaseOffsetCache = new NodeCache(key => { return new PrecodeHelperImport( _codegenNodeFactory, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.FieldBaseOffset, key.Type, key.SignatureContext) + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.FieldBaseOffset, key) ); }); @@ -91,26 +91,23 @@ private void CreateNodeCaches() useInstantiatingStub: false, _codegenNodeFactory.MethodSignature(ReadyToRunFixupKind.VirtualEntry, cellKey.Method, - cellKey.IsUnboxingStub, isInstantiatingStub: false, cellKey.SignatureContext), - cellKey.SignatureContext, + cellKey.IsUnboxingStub, isInstantiatingStub: false), cellKey.CallSite); }); _delegateCtors = new NodeCache(ctorKey => { - SignatureContext signatureContext = ctorKey.SignatureContext; IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint( ctorKey.Method, isUnboxingStub: false, isInstantiatingStub: ctorKey.Method.Method.HasInstantiation, - isPrecodeImportRequired: false, - signatureContext: signatureContext); + isPrecodeImportRequired: false); return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper_ObjObj, - new DelegateCtorSignature(ctorKey.Type, targetMethodNode, ctorKey.Method.Token, signatureContext)); + new DelegateCtorSignature(ctorKey.Type, targetMethodNode, ctorKey.Method.Token)); }); _genericLookupHelpers = new NodeCache(key => @@ -125,8 +122,7 @@ private void CreateNodeCaches() key.TypeArgument, key.MethodArgument, key.FieldArgument, - key.MethodContext, - key.SignatureContext)); + key.MethodContext)); }); _pInvokeTargetNodes = new NodeCache(key => @@ -136,65 +132,32 @@ private void CreateNodeCaches() _codegenNodeFactory.MethodSignature( key.IsIndirect ? ReadyToRunFixupKind.IndirectPInvokeTarget : ReadyToRunFixupKind.PInvokeTarget, key.MethodWithToken, - signatureContext: key.SignatureContext, isUnboxingStub: false, isInstantiatingStub: false)); }); } - private struct ModuleTokenAndSignatureContext : IEquatable - { - public readonly ModuleToken ModuleToken; - public readonly SignatureContext SignatureContext; - - public ModuleTokenAndSignatureContext(ModuleToken moduleToken, SignatureContext signatureContext) - { - ModuleToken = moduleToken; - SignatureContext = signatureContext; - } - - public bool Equals(ModuleTokenAndSignatureContext other) - { - return ModuleToken.Equals(other.ModuleToken) - && SignatureContext.Equals(other.SignatureContext); - } - - public override bool Equals(object obj) - { - return obj is ModuleTokenAndSignatureContext other && Equals(other); - } - - public override int GetHashCode() - { - return ModuleToken.GetHashCode() ^ (SignatureContext.GetHashCode() * 31); - } - } - - private NodeCache _importStrings; + private NodeCache _importStrings; - public ISymbolNode StringLiteral(ModuleToken moduleToken, SignatureContext signatureContext) + public ISymbolNode StringLiteral(ModuleToken moduleToken) { - return _importStrings.GetOrAdd(new ModuleTokenAndSignatureContext(moduleToken, signatureContext)); + return _importStrings.GetOrAdd(moduleToken); } private struct ReadyToRunHelperKey { public readonly ReadyToRunHelperId Id; public readonly object Target; - public readonly SignatureContext SignatureContext; - public ReadyToRunHelperKey(ReadyToRunHelperId id, object target, SignatureContext signatureContext) + public ReadyToRunHelperKey(ReadyToRunHelperId id, object target) { Id = id; Target = target; - SignatureContext = signatureContext; } public bool Equals(ReadyToRunHelperKey other) { - return Id == other.Id - && Target.Equals(other.Target) - && SignatureContext.Equals(other.SignatureContext); + return Id == other.Id && Target.Equals(other.Target); } public override bool Equals(object obj) @@ -204,9 +167,7 @@ public override bool Equals(object obj) public override int GetHashCode() { - return Id.GetHashCode() - ^ (Target.GetHashCode() * 23) - ^ (SignatureContext.GetHashCode() * 31); + return Id.GetHashCode() ^ (Target.GetHashCode() * 23); } } @@ -217,137 +178,137 @@ private ISymbolNode CreateReadyToRunHelper(ReadyToRunHelperKey key) switch (key.Id) { case ReadyToRunHelperId.NewHelper: - return CreateNewHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateNewHelper((TypeDesc)key.Target); case ReadyToRunHelperId.NewArr1: - return CreateNewArrayHelper((ArrayType)key.Target, key.SignatureContext); + return CreateNewArrayHelper((ArrayType)key.Target); case ReadyToRunHelperId.GetGCStaticBase: - return CreateGCStaticBaseHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateGCStaticBaseHelper((TypeDesc)key.Target); case ReadyToRunHelperId.GetNonGCStaticBase: - return CreateNonGCStaticBaseHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateNonGCStaticBaseHelper((TypeDesc)key.Target); case ReadyToRunHelperId.GetThreadStaticBase: - return CreateThreadGcStaticBaseHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateThreadGcStaticBaseHelper((TypeDesc)key.Target); case ReadyToRunHelperId.GetThreadNonGcStaticBase: - return CreateThreadNonGcStaticBaseHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateThreadNonGcStaticBaseHelper((TypeDesc)key.Target); case ReadyToRunHelperId.IsInstanceOf: - return CreateIsInstanceOfHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateIsInstanceOfHelper((TypeDesc)key.Target); case ReadyToRunHelperId.CastClass: - return CreateCastClassHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateCastClassHelper((TypeDesc)key.Target); case ReadyToRunHelperId.TypeHandle: - return CreateTypeHandleHelper((TypeDesc)key.Target, key.SignatureContext); + return CreateTypeHandleHelper((TypeDesc)key.Target); case ReadyToRunHelperId.MethodHandle: - return CreateMethodHandleHelper((MethodWithToken)key.Target, key.SignatureContext); + return CreateMethodHandleHelper((MethodWithToken)key.Target); case ReadyToRunHelperId.FieldHandle: - return CreateFieldHandleHelper((FieldDesc)key.Target, key.SignatureContext); + return CreateFieldHandleHelper((FieldDesc)key.Target); case ReadyToRunHelperId.CctorTrigger: - return CreateCctorTrigger((TypeDesc)key.Target, key.SignatureContext); + return CreateCctorTrigger((TypeDesc)key.Target); case ReadyToRunHelperId.TypeDictionary: - return CreateTypeDictionary((TypeDesc)key.Target, key.SignatureContext); + return CreateTypeDictionary((TypeDesc)key.Target); case ReadyToRunHelperId.MethodDictionary: - return CreateMethodDictionary((MethodWithToken)key.Target, key.SignatureContext); + return CreateMethodDictionary((MethodWithToken)key.Target); default: throw new NotImplementedException(key.Id.ToString()); } } - public ISymbolNode CreateReadyToRunHelper(ReadyToRunHelperId id, object target, SignatureContext signatureContext) + public ISymbolNode CreateReadyToRunHelper(ReadyToRunHelperId id, object target) { - return _r2rHelpers.GetOrAdd(new ReadyToRunHelperKey(id, target, signatureContext)); + return _r2rHelpers.GetOrAdd(new ReadyToRunHelperKey(id, target)); } - private ISymbolNode CreateNewHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateNewHelper(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - new NewObjectFixupSignature(type, signatureContext)); + new NewObjectFixupSignature(type)); } - private ISymbolNode CreateNewArrayHelper(ArrayType type, SignatureContext signatureContext) + private ISymbolNode CreateNewArrayHelper(ArrayType type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - new NewArrayFixupSignature(type, signatureContext)); + new NewArrayFixupSignature(type)); } - private ISymbolNode CreateGCStaticBaseHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateGCStaticBaseHelper(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.StaticBaseGC, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.StaticBaseGC, type)); } - private ISymbolNode CreateNonGCStaticBaseHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateNonGCStaticBaseHelper(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.StaticBaseNonGC, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.StaticBaseNonGC, type)); } - private ISymbolNode CreateThreadGcStaticBaseHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateThreadGcStaticBaseHelper(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.ThreadStaticBaseGC, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.ThreadStaticBaseGC, type)); } - private ISymbolNode CreateThreadNonGcStaticBaseHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateThreadNonGcStaticBaseHelper(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.ThreadStaticBaseNonGC, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.ThreadStaticBaseNonGC, type)); } - private ISymbolNode CreateIsInstanceOfHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateIsInstanceOfHelper(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper_Obj, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.IsInstanceOf, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.IsInstanceOf, type)); } - private ISymbolNode CreateCastClassHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateCastClassHelper(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper_Obj, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.ChkCast, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.ChkCast, type)); } - private ISymbolNode CreateTypeHandleHelper(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateTypeHandleHelper(TypeDesc type) { return new PrecodeHelperImport( _codegenNodeFactory, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.TypeHandle, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.TypeHandle, type)); } - private ISymbolNode CreateMethodHandleHelper(MethodWithToken method, SignatureContext signatureContext) + private ISymbolNode CreateMethodHandleHelper(MethodWithToken method) { bool useUnboxingStub = method.Method.IsUnboxingThunk(); if (useUnboxingStub) @@ -363,35 +324,34 @@ private ISymbolNode CreateMethodHandleHelper(MethodWithToken method, SignatureCo ReadyToRunFixupKind.MethodHandle, method, isUnboxingStub: useUnboxingStub, - isInstantiatingStub: useInstantiatingStub, - signatureContext)); + isInstantiatingStub: useInstantiatingStub)); } - private ISymbolNode CreateFieldHandleHelper(FieldDesc field, SignatureContext signatureContext) + private ISymbolNode CreateFieldHandleHelper(FieldDesc field) { return new PrecodeHelperImport( _codegenNodeFactory, - new FieldFixupSignature(ReadyToRunFixupKind.FieldHandle, field, signatureContext)); + new FieldFixupSignature(ReadyToRunFixupKind.FieldHandle, field)); } - private ISymbolNode CreateCctorTrigger(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateCctorTrigger(TypeDesc type) { return new DelayLoadHelperImport( _codegenNodeFactory, _codegenNodeFactory.HelperImports, ReadyToRunHelper.DelayLoad_Helper, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.CctorTrigger, type, signatureContext)); + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.CctorTrigger, type)); } - private ISymbolNode CreateTypeDictionary(TypeDesc type, SignatureContext signatureContext) + private ISymbolNode CreateTypeDictionary(TypeDesc type) { return new PrecodeHelperImport( _codegenNodeFactory, - _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.TypeDictionary, type, signatureContext) + _codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.TypeDictionary, type) ); } - private ISymbolNode CreateMethodDictionary(MethodWithToken method, SignatureContext signatureContext) + private ISymbolNode CreateMethodDictionary(MethodWithToken method) { return new PrecodeHelperImport( _codegenNodeFactory, @@ -399,106 +359,48 @@ private ISymbolNode CreateMethodDictionary(MethodWithToken method, SignatureCont ReadyToRunFixupKind.MethodDictionary, method, isUnboxingStub: false, - isInstantiatingStub: true, - signatureContext)); + isInstantiatingStub: true)); } - private struct FieldAndSignatureContext : IEquatable - { - public readonly FieldDesc Field; - public readonly SignatureContext SignatureContext; + private NodeCache _fieldAddressCache; - public FieldAndSignatureContext(FieldDesc fieldDesc, SignatureContext signatureContext) - { - Field = fieldDesc; - SignatureContext = signatureContext; - } - - public bool Equals(FieldAndSignatureContext other) - { - return Field.Equals(other.Field) && - SignatureContext.Equals(other.SignatureContext); - } - - public override bool Equals(object obj) - { - return obj is FieldAndSignatureContext other && Equals(other); - } - - public override int GetHashCode() - { - return Field.GetHashCode() ^ (SignatureContext.GetHashCode() * 31); - } - } - - private NodeCache _fieldAddressCache; - - public ISymbolNode FieldAddress(FieldDesc fieldDesc, SignatureContext signatureContext) + public ISymbolNode FieldAddress(FieldDesc fieldDesc) { - return _fieldAddressCache.GetOrAdd(new FieldAndSignatureContext(fieldDesc, signatureContext)); + return _fieldAddressCache.GetOrAdd(fieldDesc); } - private NodeCache _fieldOffsetCache; - - public ISymbolNode FieldOffset(FieldDesc fieldDesc, SignatureContext signatureContext) - { - return _fieldOffsetCache.GetOrAdd(new FieldAndSignatureContext(fieldDesc, signatureContext)); - } + private NodeCache _fieldOffsetCache; - private struct TypeAndSignatureContext : IEquatable + public ISymbolNode FieldOffset(FieldDesc fieldDesc) { - public readonly TypeDesc Type; - public readonly SignatureContext SignatureContext; - - public TypeAndSignatureContext(TypeDesc typeDesc, SignatureContext signatureContext) - { - Type = typeDesc; - SignatureContext = signatureContext; - } - - public bool Equals(TypeAndSignatureContext other) - { - return Type.Equals(other.Type) && - SignatureContext.Equals(other.SignatureContext); - } - - public override bool Equals(object obj) - { - return obj is FieldAndSignatureContext other && Equals(other); - } - - public override int GetHashCode() - { - return Type.GetHashCode() ^ (SignatureContext.GetHashCode() * 31); - } + return _fieldOffsetCache.GetOrAdd(fieldDesc); } - private NodeCache _fieldBaseOffsetCache; + private NodeCache _fieldBaseOffsetCache; - public ISymbolNode FieldBaseOffset(TypeDesc typeDesc, SignatureContext signatureContext) + public ISymbolNode FieldBaseOffset(TypeDesc typeDesc) { - return _fieldBaseOffsetCache.GetOrAdd(new TypeAndSignatureContext(typeDesc, signatureContext)); + return _fieldBaseOffsetCache.GetOrAdd(typeDesc); } private NodeCache _interfaceDispatchCells = new NodeCache(); - public ISymbolNode InterfaceDispatchCell(MethodWithToken method, SignatureContext signatureContext, bool isUnboxingStub, string callSite) + public ISymbolNode InterfaceDispatchCell(MethodWithToken method, bool isUnboxingStub, string callSite) { - MethodAndCallSite cellKey = new MethodAndCallSite(method, isUnboxingStub, callSite, signatureContext); + MethodAndCallSite cellKey = new MethodAndCallSite(method, isUnboxingStub, callSite); return _interfaceDispatchCells.GetOrAdd(cellKey); } private NodeCache _delegateCtors = new NodeCache(); - public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodWithToken method, SignatureContext signatureContext) + public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodWithToken method) { TypeAndMethod ctorKey = new TypeAndMethod( delegateType, method, isUnboxingStub: false, isInstantiatingStub: false, - isPrecodeImportRequired: false, - signatureContext); + isPrecodeImportRequired: false); return _delegateCtors.GetOrAdd(ctorKey); } @@ -507,22 +409,17 @@ struct MethodAndCallSite : IEquatable public readonly MethodWithToken Method; public readonly bool IsUnboxingStub; public readonly string CallSite; - public readonly SignatureContext SignatureContext; - public MethodAndCallSite(MethodWithToken method, bool isUnboxingStub, string callSite, SignatureContext signatureContext) + public MethodAndCallSite(MethodWithToken method, bool isUnboxingStub, string callSite) { CallSite = callSite; IsUnboxingStub = isUnboxingStub; Method = method; - SignatureContext = signatureContext; } public bool Equals(MethodAndCallSite other) { - return CallSite == other.CallSite - && Method.Equals(other.Method) - && IsUnboxingStub == other.IsUnboxingStub - && SignatureContext.Equals(other.SignatureContext); + return CallSite == other.CallSite && Method.Equals(other.Method) && IsUnboxingStub == other.IsUnboxingStub; } public override bool Equals(object obj) @@ -532,10 +429,9 @@ public override bool Equals(object obj) public override int GetHashCode() { - return (CallSite != null ? CallSite.GetHashCode() : 0) + return (CallSite != null ? CallSite.GetHashCode() : 0) ^ unchecked(31 * Method.GetHashCode()) - ^ (IsUnboxingStub ? -0x80000000 : 0) - ^ (23 * SignatureContext.GetHashCode()); + ^ (IsUnboxingStub ? -0x80000000 : 0); } } @@ -547,7 +443,6 @@ private struct GenericLookupKey : IEquatable public readonly MethodWithToken MethodArgument; public readonly FieldDesc FieldArgument; public readonly GenericContext MethodContext; - public readonly SignatureContext SignatureContext; public GenericLookupKey( CORINFO_RUNTIME_LOOKUP_KIND lookupKind, @@ -555,8 +450,7 @@ public GenericLookupKey( TypeDesc typeArgument, MethodWithToken methodArgument, FieldDesc fieldArgument, - GenericContext methodContext, - SignatureContext signatureContext) + GenericContext methodContext) { LookupKind = lookupKind; FixupKind = fixupKind; @@ -564,7 +458,6 @@ public GenericLookupKey( MethodArgument = methodArgument; FieldArgument = fieldArgument; MethodContext = methodContext; - SignatureContext = signatureContext; } public bool Equals(GenericLookupKey other) @@ -599,8 +492,7 @@ public ISymbolNode GenericLookupHelper( CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunHelperId helperId, object helperArgument, - GenericContext methodContext, - SignatureContext signatureContext) + GenericContext methodContext) { switch (helperId) { @@ -609,56 +501,49 @@ public ISymbolNode GenericLookupHelper( runtimeLookupKind, ReadyToRunFixupKind.TypeHandle, helperArgument, - methodContext, - signatureContext); + methodContext); case ReadyToRunHelperId.MethodHandle: return GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.MethodHandle, (MethodWithToken)helperArgument, - methodContext, - signatureContext); + methodContext); case ReadyToRunHelperId.MethodEntry: return GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.MethodEntry, (MethodWithToken)helperArgument, - methodContext, - signatureContext); + methodContext); case ReadyToRunHelperId.MethodDictionary: return GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.MethodHandle, (MethodWithToken)helperArgument, - methodContext, - signatureContext); + methodContext); case ReadyToRunHelperId.TypeDictionary: return GenericLookupTypeHelper( runtimeLookupKind, ReadyToRunFixupKind.TypeDictionary, (TypeDesc)helperArgument, - methodContext, - signatureContext); + methodContext); case ReadyToRunHelperId.VirtualDispatchCell: return GenericLookupMethodHelper( runtimeLookupKind, ReadyToRunFixupKind.VirtualEntry, (MethodWithToken)helperArgument, - methodContext, - signatureContext); + methodContext); case ReadyToRunHelperId.FieldHandle: return GenericLookupFieldHelper( runtimeLookupKind, ReadyToRunFixupKind.FieldHandle, (FieldDesc)helperArgument, - methodContext, - signatureContext); + methodContext); default: throw new NotImplementedException(helperId.ToString()); @@ -669,8 +554,7 @@ private ISymbolNode GenericLookupTypeHelper( CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunFixupKind fixupKind, object helperArgument, - GenericContext methodContext, - SignatureContext signatureContext) + GenericContext methodContext) { TypeDesc typeArgument; if (helperArgument is MethodWithToken methodWithToken) @@ -686,7 +570,7 @@ private ISymbolNode GenericLookupTypeHelper( typeArgument = (TypeDesc)helperArgument; } - GenericLookupKey key = new GenericLookupKey(runtimeLookupKind, fixupKind, typeArgument, methodArgument: null, fieldArgument: null, methodContext, signatureContext); + GenericLookupKey key = new GenericLookupKey(runtimeLookupKind, fixupKind, typeArgument, methodArgument: null, fieldArgument: null, methodContext); return _genericLookupHelpers.GetOrAdd(key); } @@ -694,10 +578,9 @@ private ISymbolNode GenericLookupFieldHelper( CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunFixupKind fixupKind, FieldDesc fieldArgument, - GenericContext methodContext, - SignatureContext signatureContext) + GenericContext methodContext) { - GenericLookupKey key = new GenericLookupKey(runtimeLookupKind, fixupKind, typeArgument: null, methodArgument: null, fieldArgument: fieldArgument, methodContext, signatureContext); + GenericLookupKey key = new GenericLookupKey(runtimeLookupKind, fixupKind, typeArgument: null, methodArgument: null, fieldArgument: fieldArgument, methodContext); return _genericLookupHelpers.GetOrAdd(key); } @@ -705,31 +588,26 @@ private ISymbolNode GenericLookupMethodHelper( CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind, ReadyToRunFixupKind fixupKind, MethodWithToken methodArgument, - GenericContext methodContext, - SignatureContext signatureContext) + GenericContext methodContext) { - GenericLookupKey key = new GenericLookupKey(runtimeLookupKind, fixupKind, typeArgument: null, methodArgument, fieldArgument: null, methodContext, signatureContext); + GenericLookupKey key = new GenericLookupKey(runtimeLookupKind, fixupKind, typeArgument: null, methodArgument, fieldArgument: null, methodContext); return _genericLookupHelpers.GetOrAdd(key); } private struct PInvokeTargetKey : IEquatable { public readonly MethodWithToken MethodWithToken; - public readonly SignatureContext SignatureContext; public readonly bool IsIndirect; - public PInvokeTargetKey(MethodWithToken methodWithToken, SignatureContext signatureContext, bool isIndirect) + public PInvokeTargetKey(MethodWithToken methodWithToken, bool isIndirect) { MethodWithToken = methodWithToken; - SignatureContext = signatureContext; IsIndirect = isIndirect; } public bool Equals(PInvokeTargetKey other) { - return IsIndirect.Equals(other.IsIndirect) - && MethodWithToken.Equals(other.MethodWithToken) - && SignatureContext.Equals(other.SignatureContext); + return IsIndirect.Equals(other.IsIndirect) && MethodWithToken.Equals(other.MethodWithToken); } public override bool Equals(object obj) @@ -739,22 +617,20 @@ public override bool Equals(object obj) public override int GetHashCode() { - return IsIndirect.GetHashCode() - ^ (MethodWithToken.GetHashCode() * 23) - ^ (SignatureContext.GetHashCode() * 31); + return IsIndirect.GetHashCode() ^ (MethodWithToken.GetHashCode() * 23); } } private NodeCache _pInvokeTargetNodes = new NodeCache(); - public ISymbolNode GetIndirectPInvokeTargetNode(MethodWithToken methodWithToken, SignatureContext signatureContext) + public ISymbolNode GetIndirectPInvokeTargetNode(MethodWithToken methodWithToken) { - return _pInvokeTargetNodes.GetOrAdd(new PInvokeTargetKey(methodWithToken, signatureContext, isIndirect: true)); + return _pInvokeTargetNodes.GetOrAdd(new PInvokeTargetKey(methodWithToken, isIndirect: true)); } - public ISymbolNode GetPInvokeTargetNode(MethodWithToken methodWithToken, SignatureContext signatureContext) + public ISymbolNode GetPInvokeTargetNode(MethodWithToken methodWithToken) { - return _pInvokeTargetNodes.GetOrAdd(new PInvokeTargetKey(methodWithToken, signatureContext, isIndirect: false)); + return _pInvokeTargetNodes.GetOrAdd(new PInvokeTargetKey(methodWithToken, isIndirect: false)); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/TypeAndMethod.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/TypeAndMethod.cs index 12cafccfb81bb..871e5a0ea78bf 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/TypeAndMethod.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/TypeAndMethod.cs @@ -18,16 +18,14 @@ internal struct TypeAndMethod : IEquatable public readonly bool IsUnboxingStub; public readonly bool IsInstantiatingStub; public readonly bool IsPrecodeImportRequired; - public readonly SignatureContext SignatureContext; - public TypeAndMethod(TypeDesc type, MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, bool isPrecodeImportRequired, SignatureContext signatureContext) + public TypeAndMethod(TypeDesc type, MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, bool isPrecodeImportRequired) { Type = type; Method = method; IsUnboxingStub = isUnboxingStub; IsInstantiatingStub = isInstantiatingStub; IsPrecodeImportRequired = isPrecodeImportRequired; - SignatureContext = signatureContext; } public bool Equals(TypeAndMethod other) @@ -36,8 +34,7 @@ public bool Equals(TypeAndMethod other) Method.Equals(other.Method) && IsUnboxingStub == other.IsUnboxingStub && IsInstantiatingStub == other.IsInstantiatingStub && - IsPrecodeImportRequired == other.IsPrecodeImportRequired && - SignatureContext.Equals(other.SignatureContext); + IsPrecodeImportRequired == other.IsPrecodeImportRequired; } public override bool Equals(object obj) @@ -47,12 +44,11 @@ public override bool Equals(object obj) public override int GetHashCode() { - return (Type?.GetHashCode() ?? 0) ^ - unchecked(Method.GetHashCode() * 31) ^ - (IsUnboxingStub ? -0x80000000 : 0) ^ + return (Type?.GetHashCode() ?? 0) ^ + unchecked(Method.GetHashCode() * 31) ^ + (IsUnboxingStub ? -0x80000000 : 0) ^ (IsInstantiatingStub ? 0x40000000 : 0) ^ - (IsPrecodeImportRequired ? 0x20000000 : 0) ^ - (SignatureContext.GetHashCode() * 23); + (IsPrecodeImportRequired ? 0x20000000 : 0); } } } diff --git a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index 23d43df454bd8..c1ffaa651ee40 100644 --- a/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/src/tools/crossgen2/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -227,12 +227,6 @@ public void CompileMethod(IReadyToRunMethodCodeNode methodCodeNodeNeedingCode) } } - private SignatureContext GetSignatureContext() - { - // TODO: this will need changing when compiling multiple input MSIL modules into a single PE executable - return _compilation.NodeFactory.InputModuleContext; - } - private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref CORINFO_LOOKUP_KIND pGenericLookupKind, CorInfoHelpFunc id, ref CORINFO_CONST_LOOKUP pLookup) { switch (id) @@ -244,7 +238,7 @@ private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) return false; - pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.NewHelper, type, GetSignatureContext())); + pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.NewHelper, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_NEWARR_1: @@ -254,7 +248,7 @@ private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) return false; - pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.NewArr1, type, GetSignatureContext())); + pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.NewArr1, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_ISINSTANCEOF: @@ -267,7 +261,7 @@ private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref if (type.IsNullable) type = type.Instantiation[0]; - pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.IsInstanceOf, type, GetSignatureContext())); + pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.IsInstanceOf, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_CHKCAST: @@ -280,7 +274,7 @@ private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref if (type.IsNullable) type = type.Instantiation[0]; - pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.CastClass, type, GetSignatureContext())); + pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.CastClass, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_STATIC_BASE: @@ -289,7 +283,7 @@ private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref if (type.IsCanonicalSubtype(CanonicalFormKind.Any)) return false; - pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.CctorTrigger, type, GetSignatureContext())); + pLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.CctorTrigger, type)); } break; case CorInfoHelpFunc.CORINFO_HELP_READYTORUN_GENERIC_HANDLE: @@ -313,8 +307,7 @@ private bool getReadyToRunHelper(ref CORINFO_RESOLVED_TOKEN pResolvedToken, ref pGenericLookupKind.runtimeLookupKind, helperId, helperArg, - methodContext, - GetSignatureContext()); + methodContext); pLookup = CreateConstLookupToSymbol(helper); } break; @@ -337,8 +330,7 @@ private void getReadyToRunDelegateCtorHelper(ref CORINFO_RESOLVED_TOKEN pTargetM MethodWithToken targetMethod = new MethodWithToken(HandleToObject(pTargetMethod.hMethod), HandleToModuleToken(ref pTargetMethod), constrainedType: null); pLookup.lookupKind.needsRuntimeLookup = false; - pLookup.constLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.DelegateCtor( - delegateTypeDesc, targetMethod, GetSignatureContext())); + pLookup.constLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.DelegateCtor(delegateTypeDesc, targetMethod)); } private ISymbolNode GetHelperFtnUncached(CorInfoHelpFunc ftnNum) @@ -749,7 +741,7 @@ private InfoAccessType constructStringLiteral(CORINFO_MODULE_STRUCT_* module, md EcmaMethod method = (EcmaMethod)methodIL.OwningMethod.GetTypicalMethodDefinition(); ISymbolNode stringObject = _compilation.SymbolNodeFactory.StringLiteral( - new ModuleToken(method.Module, metaTok), GetSignatureContext()); + new ModuleToken(method.Module, metaTok)); ppValue = (void*)ObjectToHandle(stringObject); return InfoAccessType.IAT_PPVALUE; } @@ -1422,7 +1414,7 @@ private void classMustBeLoadedBeforeCodeIsRun(CORINFO_CLASS_STRUCT_* cls) private void classMustBeLoadedBeforeCodeIsRun(TypeDesc type) { - ISymbolNode node = _compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.TypeHandle, type, GetSignatureContext()); + ISymbolNode node = _compilation.SymbolNodeFactory.CreateReadyToRunHelper(ReadyToRunHelperId.TypeHandle, type); ((MethodWithGCInfo)_methodCodeNode).Fixups.Add(node); } @@ -1481,7 +1473,6 @@ private void getCallInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_RESO pResult->codePointerOrStubLookup.constLookup = CreateConstLookupToSymbol( _compilation.SymbolNodeFactory.InterfaceDispatchCell( new MethodWithToken(targetMethod, HandleToModuleToken(ref pResolvedToken, targetMethod), constrainedType: null), - GetSignatureContext(), isUnboxingStub: false, _compilation.NameMangler.GetMangledMethodName(MethodBeingCompiled).ToString())); } @@ -1519,8 +1510,7 @@ private void getCallInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_RESO new MethodWithToken(nonUnboxingMethod, HandleToModuleToken(ref pResolvedToken, nonUnboxingMethod), constrainedType), isUnboxingStub, isInstantiatingStub: useInstantiatingStub, - isPrecodeImportRequired: (flags & CORINFO_CALLINFO_FLAGS.CORINFO_CALLINFO_LDFTN) != 0, - GetSignatureContext())); + isPrecodeImportRequired: (flags & CORINFO_CALLINFO_FLAGS.CORINFO_CALLINFO_LDFTN) != 0)); } break; @@ -1536,8 +1526,7 @@ private void getCallInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_RESO pResult->codePointerOrStubLookup.constLookup = CreateConstLookupToSymbol( _compilation.NodeFactory.DynamicHelperCell( new MethodWithToken(targetMethod, HandleToModuleToken(ref pResolvedToken, targetMethod), constrainedType: null), - useInstantiatingStub, - GetSignatureContext())); + useInstantiatingStub)); Debug.Assert(!pResult->sig.hasTypeArg()); } @@ -1564,15 +1553,13 @@ private void getCallInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_RESO { pResult->instParamLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper( ReadyToRunHelperId.MethodDictionary, - new MethodWithToken(targetMethod, HandleToModuleToken(ref pResolvedToken, targetMethod), constrainedType), - signatureContext: GetSignatureContext())); + new MethodWithToken(targetMethod, HandleToModuleToken(ref pResolvedToken, targetMethod), constrainedType))); } else { pResult->instParamLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.CreateReadyToRunHelper( ReadyToRunHelperId.TypeDictionary, - exactType, - signatureContext: GetSignatureContext())); + exactType)); } } } @@ -1794,8 +1781,7 @@ private void embedGenericHandle(ref CORINFO_RESOLVED_TOKEN pResolvedToken, bool case CorInfoGenericHandleType.CORINFO_HANDLETYPE_CLASS: symbolNode = _compilation.SymbolNodeFactory.CreateReadyToRunHelper( ReadyToRunHelperId.TypeHandle, - HandleToObject(pResolvedToken.hClass), - GetSignatureContext()); + HandleToObject(pResolvedToken.hClass)); break; case CorInfoGenericHandleType.CORINFO_HANDLETYPE_METHOD: @@ -1810,16 +1796,14 @@ private void embedGenericHandle(ref CORINFO_RESOLVED_TOKEN pResolvedToken, bool symbolNode = _compilation.SymbolNodeFactory.CreateReadyToRunHelper( ReadyToRunHelperId.MethodHandle, - new MethodWithToken(md, HandleToModuleToken(ref pResolvedToken), constrainedType: null), - GetSignatureContext()); + new MethodWithToken(md, HandleToModuleToken(ref pResolvedToken), constrainedType: null)); } break; case CorInfoGenericHandleType.CORINFO_HANDLETYPE_FIELD: symbolNode = _compilation.SymbolNodeFactory.CreateReadyToRunHelper( ReadyToRunHelperId.FieldHandle, - HandleToObject(pResolvedToken.hField), - GetSignatureContext()); + HandleToObject(pResolvedToken.hField)); break; default: @@ -1928,7 +1912,7 @@ private void EncodeFieldBaseOffset(FieldDesc field, CORINFO_FIELD_INFO* pResult, // ENCODE_FIELD_OFFSET pResult->offset = 0; pResult->fieldAccessor = CORINFO_FIELD_ACCESSOR.CORINFO_FIELD_INSTANCE_WITH_BASE; - pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldOffset(field, GetSignatureContext())); + pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldOffset(field)); } } else if (pMT.IsValueType) @@ -1948,7 +1932,7 @@ private void EncodeFieldBaseOffset(FieldDesc field, CORINFO_FIELD_INFO* pResult, // ENCODE_FIELD_OFFSET pResult->offset = 0; pResult->fieldAccessor = CORINFO_FIELD_ACCESSOR.CORINFO_FIELD_INSTANCE_WITH_BASE; - pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldOffset(field, GetSignatureContext())); + pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldOffset(field)); } else { @@ -1957,7 +1941,7 @@ private void EncodeFieldBaseOffset(FieldDesc field, CORINFO_FIELD_INFO* pResult, // ENCODE_FIELD_BASE_OFFSET pResult->offset -= (uint)pMT.BaseType.InstanceByteCount.AsInt; pResult->fieldAccessor = CORINFO_FIELD_ACCESSOR.CORINFO_FIELD_INSTANCE_WITH_BASE; - pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldBaseOffset(field.OwningType, GetSignatureContext())); + pResult->fieldLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.FieldBaseOffset(field.OwningType)); } } @@ -2054,12 +2038,12 @@ private void getAddressOfPInvokeTarget(CORINFO_METHOD_STRUCT_* method, ref CORIN if (ecmaMethod.IsSuppressGCTransition()) { - pLookup.addr = (void*)ObjectToHandle(_compilation.SymbolNodeFactory.GetPInvokeTargetNode(methodWithToken, GetSignatureContext())); + pLookup.addr = (void*)ObjectToHandle(_compilation.SymbolNodeFactory.GetPInvokeTargetNode(methodWithToken)); pLookup.accessType = InfoAccessType.IAT_PVALUE; } else { - pLookup.addr = (void*)ObjectToHandle(_compilation.SymbolNodeFactory.GetIndirectPInvokeTargetNode(methodWithToken, GetSignatureContext())); + pLookup.addr = (void*)ObjectToHandle(_compilation.SymbolNodeFactory.GetIndirectPInvokeTargetNode(methodWithToken)); pLookup.accessType = InfoAccessType.IAT_PPVALUE; } }