Remove static variable holding unboxing stubs

src/coreclr/src/tools/Common/JitInterface/CorInfoImpl.cs

@@ -1010,7 +1010,14 @@ private static object ResolveTokenInScope(MethodIL methodIL, object typeOrMethod
  else
  {
  var methodContext = (MethodDesc)typeOrMethodContext;
- Debug.Assert((!methodContext.HasInstantiation && !owningMethod.HasInstantiation) ||
+ // Allow cases where the method's do not have instantiations themselves, if
+ // 1. The method defining the context is generic, but the target method is not
+ // 2. Both methods are not generic
+ // 3. The methods are the same generic
+ // AND
+ // The methods are on the same type
+ Debug.Assert((methodContext.HasInstantiation && !owningMethod.HasInstantiation) ||
+ (!methodContext.HasInstantiation && !owningMethod.HasInstantiation) ||
  methodContext.GetTypicalMethodDefinition() == owningMethod.GetTypicalMethodDefinition() ||
  (owningMethod.Name == "CreateDefaultInstance" && methodContext.Name == "CreateInstance"));
  Debug.Assert(methodContext.OwningType.HasSameTypeDefinition(owningMethod.OwningType));

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelayLoadMethodImport.cs

@@ -21,7 +21,6 @@ public DelayLoadMethodImport(
  ReadyToRunFixupKind fixupKind,
  MethodWithToken method,
  MethodWithGCInfo localMethod,
- bool isUnboxingStub,
  bool isInstantiatingStub)
  : base(
  factory,
@@ -30,7 +29,6 @@ public DelayLoadMethodImport(
  factory.MethodSignature(
  fixupKind,
  method,
- isUnboxingStub,
  isInstantiatingStub))
  {
  _localMethod = localMethod;

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelegateCtorSignature.cs

@@ -44,11 +44,10 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
  SignatureContext innerContext = builder.EmitFixup(factory, ReadyToRunFixupKind.DelegateCtor, _methodToken.Module, factory.SignatureContext);
 
  builder.EmitMethodSignature(
- new MethodWithToken(_targetMethod.Method, _methodToken, constrainedType: null),
+ new MethodWithToken(_targetMethod.Method, _methodToken, constrainedType: null, unboxing: false),
  enforceDefEncoding: false,
  enforceOwningType: false,
  innerContext,
- isUnboxingStub: false,
  isInstantiatingStub: _targetMethod.Method.HasInstantiation);
 
  builder.EmitTypeSignature(_delegateType, innerContext);

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/GenericLookupSignature.cs

@@ -106,12 +106,13 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
  dataBuilder.EmitByte((byte)_fixupKind);
  if (_methodArgument != null)
  {
+ Debug.Assert(_methodArgument.Unboxing == false);
+
  dataBuilder.EmitMethodSignature(
  _methodArgument,
  enforceDefEncoding: false,
  enforceOwningType: false,
  context: innerContext,
- isUnboxingStub: false,
  isInstantiatingStub: true);
  }
  else if (_typeArgument != null)

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstanceEntryPointTableNode.cs

@@ -62,11 +62,10 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
 
  ArraySignatureBuilder signatureBuilder = new ArraySignatureBuilder();
  signatureBuilder.EmitMethodSignature(
- new MethodWithToken(method.Method, moduleToken, constrainedType: null),
+ new MethodWithToken(method.Method, moduleToken, constrainedType: null, unboxing: false),
  enforceDefEncoding: true,
  enforceOwningType: _factory.CompilationModuleGroup.EnforceOwningType(moduleToken.Module),
  factory.SignatureContext,
- isUnboxingStub: false,
  isInstantiatingStub: false);
  byte[] signature = signatureBuilder.ToArray();
  BlobVertex signatureBlob;

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodFixupSignature.cs

@@ -19,19 +19,15 @@ public class MethodFixupSignature : Signature
 
  private readonly MethodWithToken _method;
 
- private readonly bool _isUnboxingStub;
-
  private readonly bool _isInstantiatingStub;
 
  public MethodFixupSignature(
  ReadyToRunFixupKind fixupKind, 
- MethodWithToken method, 
- bool isUnboxingStub,
+ MethodWithToken method,
  bool isInstantiatingStub)
  {
  _fixupKind = fixupKind;
  _method = method;
- _isUnboxingStub = isUnboxingStub;
  _isInstantiatingStub = isInstantiatingStub;
 
  // Ensure types in signature are loadable and resolvable, otherwise we'll fail later while emitting the signature
@@ -45,7 +41,7 @@ public MethodFixupSignature(
 
  public override int ClassCode => 150063499;
 
- public bool IsUnboxingStub => _isUnboxingStub;
+ public bool IsUnboxingStub => _method.Unboxing;
 
  public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
  {
@@ -61,7 +57,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
  // Optimize some of the fixups into a more compact form
  ReadyToRunFixupKind fixupKind = _fixupKind;
  bool optimized = false;
- if (!_isUnboxingStub && !_isInstantiatingStub && _method.ConstrainedType == null &&
+ if (!_method.Unboxing && !_isInstantiatingStub && _method.ConstrainedType == null &&
  fixupKind == ReadyToRunFixupKind.MethodEntry)
  {
  if (!_method.Method.OwningType.HasInstantiation && !_method.Method.OwningType.IsArray)
@@ -85,13 +81,13 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
  {
  if (method.Token.TokenType == CorTokenType.mdtMethodSpec)
  {
- method = new MethodWithToken(method.Method, factory.SignatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType);
+ method = new MethodWithToken(method.Method, factory.SignatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType, unboxing: _method.Unboxing);
  }
  else if (!optimized && (method.Token.TokenType == CorTokenType.mdtMemberRef))
  {
  if (method.Method.OwningType.GetTypeDefinition() is EcmaType)
  {
- method = new MethodWithToken(method.Method, factory.SignatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType);
+ method = new MethodWithToken(method.Method, factory.SignatureContext.GetModuleTokenForMethod(method.Method, throwIfNotFound: false), method.ConstrainedType, unboxing: _method.Unboxing);
  }
  }
  }
@@ -108,7 +104,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
  }
  else
  {
- dataBuilder.EmitMethodSignature(method, enforceDefEncoding: false, enforceOwningType: false, innerContext, _isUnboxingStub, _isInstantiatingStub);
+ dataBuilder.EmitMethodSignature(method, enforceDefEncoding: false, enforceOwningType: false, innerContext, _isInstantiatingStub);
  }
 
  return dataBuilder.ToObjectData();
@@ -119,10 +115,6 @@ public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilde
  sb.Append(nameMangler.CompilationUnitPrefix);
  sb.Append($@"MethodFixupSignature(");
  sb.Append(_fixupKind.ToString());
- if (_isUnboxingStub)
- {
- sb.Append(" [UNBOX]");
- }
  if (_isInstantiatingStub)
  {
  sb.Append(" [INST]");
@@ -138,10 +130,6 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer
  if (result != 0)
  return result;
 
- result = _isUnboxingStub.CompareTo(otherNode._isUnboxingStub);
- if (result != 0)
- return result;
-
  result = _isInstantiatingStub.CompareTo(otherNode._isInstantiatingStub);
  if (result != 0)
  return result;

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/PrecodeMethodImport.cs

@@ -22,14 +22,12 @@ public PrecodeMethodImport(
  ReadyToRunFixupKind fixupKind,
  MethodWithToken method,
  MethodWithGCInfo localMethod,
- bool isUnboxingStub,
  bool isInstantiatingStub) :
  base (
  factory,
  factory.MethodSignature(
  fixupKind,
  method,
- isUnboxingStub,
  isInstantiatingStub)
  )
  {

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/SignatureBuilder.cs

@@ -396,11 +396,10 @@ public void EmitMethodSignature(
  bool enforceDefEncoding,
  bool enforceOwningType,
  SignatureContext context,
- bool isUnboxingStub,
  bool isInstantiatingStub)
  {
  uint flags = 0;
- if (isUnboxingStub)
+ if (method.Unboxing)
  {
  flags |= (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_UnboxingStub;
  }

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs

@@ -224,7 +224,6 @@ private void CreateNodeCaches()
  return new MethodFixupSignature(
  key.FixupKind,
  key.TypeAndMethod.Method,
- key.TypeAndMethod.IsUnboxingStub,
  key.TypeAndMethod.IsInstantiatingStub
  );
  });
@@ -246,7 +245,6 @@ private void CreateNodeCaches()
  MethodSignature(
  ReadyToRunFixupKind.VirtualEntry,
  key.Method,
- isUnboxingStub: key.IsUnboxingStub,
  isInstantiatingStub: key.IsInstantiatingStub));
  });
 
@@ -347,7 +345,6 @@ public Import GetReadyToRunHelperCell(ReadyToRunHelper helperId)
  private IMethodNode CreateMethodEntrypoint(TypeAndMethod key)
  {
  MethodWithToken method = key.Method;
- bool isUnboxingStub = key.IsUnboxingStub;
  bool isInstantiatingStub = key.IsInstantiatingStub;
  bool isPrecodeImportRequired = key.IsPrecodeImportRequired;
  MethodDesc compilableMethod = method.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);
@@ -365,7 +362,6 @@ private IMethodNode CreateMethodEntrypoint(TypeAndMethod key)
  ReadyToRunFixupKind.MethodEntry,
  method,
  methodWithGCInfo,
- isUnboxingStub,
  isInstantiatingStub);
  }
  else
@@ -375,14 +371,13 @@ private IMethodNode CreateMethodEntrypoint(TypeAndMethod key)
  ReadyToRunFixupKind.MethodEntry,
  method,
  methodWithGCInfo,
- isUnboxingStub,
  isInstantiatingStub);
  }
  }
 
- public IMethodNode MethodEntrypoint(MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, bool isPrecodeImportRequired)
+ public IMethodNode MethodEntrypoint(MethodWithToken method, bool isInstantiatingStub, bool isPrecodeImportRequired)
  {
- TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, isPrecodeImportRequired);
+ TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isInstantiatingStub, isPrecodeImportRequired);
  return _importMethods.GetOrAdd(key);
  }
 
@@ -401,7 +396,7 @@ public IEnumerable<MethodWithGCInfo> EnumerateCompiledMethods(EcmaModule moduleT
  EcmaModule module = ((EcmaMethod)method.GetTypicalMethodDefinition()).Module;
  ModuleToken moduleToken = Resolver.GetModuleTokenForMethod(method, throwIfNotFound: true);
 
- IMethodNode methodNodeDebug = MethodEntrypoint(new MethodWithToken(method, moduleToken, constrainedType: null), false, false, false);
+ IMethodNode methodNodeDebug = MethodEntrypoint(new MethodWithToken(method, moduleToken, constrainedType: null, unboxing: false), false, false);
  MethodWithGCInfo methodCodeNodeDebug = methodNodeDebug as MethodWithGCInfo;
  if (methodCodeNodeDebug == null && methodNodeDebug is DelayLoadMethodImport DelayLoadMethodImport)
  {
@@ -453,10 +448,9 @@ public override int GetHashCode()
  public MethodFixupSignature MethodSignature(
  ReadyToRunFixupKind fixupKind,
  MethodWithToken method,
- bool isUnboxingStub,
  bool isInstantiatingStub)
  {
- TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isUnboxingStub, isInstantiatingStub, false);
+ TypeAndMethod key = new TypeAndMethod(method.ConstrainedType, method, isInstantiatingStub, false);
  return _methodSignatures.GetOrAdd(new MethodFixupKey(fixupKind, key));
  }
 

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunSymbolNodeFactory.cs

@@ -110,15 +110,14 @@ private void CreateNodeCaches()
  useInstantiatingStub: false,
  _codegenNodeFactory.MethodSignature(ReadyToRunFixupKind.VirtualEntry,
  cellKey.Method,
-cellKey.IsUnboxingStub, isInstantiatingStub: false),
+ isInstantiatingStub: false),
  cellKey.CallingMethod);
  });
 
  _delegateCtors = new NodeCache<TypeAndMethod, ISymbolNode>(ctorKey =>
  {
  IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint(
  ctorKey.Method,
- isUnboxingStub: false,
  isInstantiatingStub: ctorKey.Method.Method.HasInstantiation,
  isPrecodeImportRequired: false);
 
@@ -159,7 +158,6 @@ private void CreateNodeCaches()
  _codegenNodeFactory.MethodSignature(
  key.IsIndirect ? ReadyToRunFixupKind.IndirectPInvokeTarget : ReadyToRunFixupKind.PInvokeTarget,
  key.MethodWithToken,
- isUnboxingStub: false,
  isInstantiatingStub: false));
  });
  }
@@ -345,20 +343,13 @@ private ISymbolNode CreateTypeHandleHelper(TypeDesc type)
 
  private ISymbolNode CreateMethodHandleHelper(MethodWithToken method)
  {
- bool useUnboxingStub = method.Method.IsUnboxingThunk();
- if (useUnboxingStub)
- {
- method = new MethodWithToken(method.Method.GetUnboxedMethod(), method.Token, method.ConstrainedType);
- }
-
  bool useInstantiatingStub = method.Method.GetCanonMethodTarget(CanonicalFormKind.Specific) != method.Method;
 
  return new PrecodeHelperImport(
  _codegenNodeFactory,
  _codegenNodeFactory.MethodSignature(
  ReadyToRunFixupKind.MethodHandle,
  method,
- isUnboxingStub: useUnboxingStub,
  isInstantiatingStub: useInstantiatingStub));
  }
 
@@ -392,8 +383,7 @@ private ISymbolNode CreateMethodDictionary(MethodWithToken method)
  _codegenNodeFactory,
  _codegenNodeFactory.MethodSignature(
  ReadyToRunFixupKind.MethodDictionary, 
- method, 
- isUnboxingStub: false,
+ method,
  isInstantiatingStub: true));
  }
 
@@ -427,9 +417,9 @@ public ISymbolNode FieldBaseOffset(TypeDesc typeDesc)
 
  private NodeCache<MethodAndCallSite, ISymbolNode> _interfaceDispatchCells = new NodeCache<MethodAndCallSite, ISymbolNode>();
 
- public ISymbolNode InterfaceDispatchCell(MethodWithToken method, bool isUnboxingStub, MethodDesc callingMethod)
+ public ISymbolNode InterfaceDispatchCell(MethodWithToken method, MethodDesc callingMethod)
  {
- MethodAndCallSite cellKey = new MethodAndCallSite(method, isUnboxingStub, callingMethod);
+ MethodAndCallSite cellKey = new MethodAndCallSite(method, callingMethod);
  return _interfaceDispatchCells.GetOrAdd(cellKey);
  }
 
@@ -440,7 +430,6 @@ public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodWithToken method)
  TypeAndMethod ctorKey = new TypeAndMethod(
  delegateType,
  method,
- isUnboxingStub: false,
  isInstantiatingStub: false,
  isPrecodeImportRequired: false);
  return _delegateCtors.GetOrAdd(ctorKey);
@@ -456,19 +445,17 @@ public ISymbolNode CheckTypeLayout(TypeDesc type)
  struct MethodAndCallSite : IEquatable<MethodAndCallSite>
  {
  public readonly MethodWithToken Method;
- public readonly bool IsUnboxingStub;
  public readonly MethodDesc CallingMethod;
 
- public MethodAndCallSite(MethodWithToken method, bool isUnboxingStub, MethodDesc callingMethod)
+ public MethodAndCallSite(MethodWithToken method, MethodDesc callingMethod)
  {
- IsUnboxingStub = isUnboxingStub;
  Method = method;
  CallingMethod = callingMethod;
  }
 
  public bool Equals(MethodAndCallSite other)
  {
- return Method.Equals(other.Method) && IsUnboxingStub == other.IsUnboxingStub && CallingMethod == other.CallingMethod;
+ return Method.Equals(other.Method) && CallingMethod == other.CallingMethod;
  }
 
  public override bool Equals(object obj)
@@ -479,8 +466,7 @@ public override bool Equals(object obj)
  public override int GetHashCode()
  {
  return (CallingMethod != null ? unchecked(199 * CallingMethod.GetHashCode()) : 0)
- ^ unchecked(31 * Method.GetHashCode())
- ^ (IsUnboxingStub ? -0x80000000 : 0);
+ ^ unchecked(31 * Method.GetHashCode());
  }
  }
 

src/coreclr/src/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/TypeAndMethod.cs

@@ -15,15 +15,13 @@ internal struct TypeAndMethod : IEquatable<TypeAndMethod>
  {
  public readonly TypeDesc Type;
  public readonly MethodWithToken Method;
- public readonly bool IsUnboxingStub;
  public readonly bool IsInstantiatingStub;
  public readonly bool IsPrecodeImportRequired;
 
- public TypeAndMethod(TypeDesc type, MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, bool isPrecodeImportRequired)
+ public TypeAndMethod(TypeDesc type, MethodWithToken method, bool isInstantiatingStub, bool isPrecodeImportRequired)
  {
  Type = type;
  Method = method;
- IsUnboxingStub = isUnboxingStub;
  IsInstantiatingStub = isInstantiatingStub;
  IsPrecodeImportRequired = isPrecodeImportRequired;
  }
@@ -32,7 +30,6 @@ public bool Equals(TypeAndMethod other)
  {
  return Type == other.Type &&
  Method.Equals(other.Method) &&
- IsUnboxingStub == other.IsUnboxingStub &&
  IsInstantiatingStub == other.IsInstantiatingStub &&
  IsPrecodeImportRequired == other.IsPrecodeImportRequired;
  }
@@ -46,7 +43,6 @@ public override int GetHashCode()
  {
  return (Type?.GetHashCode() ?? 0) ^
  unchecked(Method.GetHashCode() * 31) ^
- (IsUnboxingStub ? -0x80000000 : 0) ^
  (IsInstantiatingStub ? 0x40000000 : 0) ^
  (IsPrecodeImportRequired ? 0x20000000 : 0);
  }