Fix two Crossgen2 codegen bugs found via SVM testing

1. Delegate cctor helper JIT interface method was missing support
for type constraint.

2. Methods wrapped in instantiation / unboxing stubs shouldn't
claim they have a generic dictionary slot in their GC refmap.

Thanks

Tomas

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

@@ -88,12 +88,12 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
                 }
                 else
                 {
-                    bool isUnboxingStub = false;
-                    if (methodNode is DelayLoadHelperImport methodImport)
+                    bool isStub = false;
+                    if (methodNode is Import methodImport && methodImport.Signature is MethodFixupSignature methodSignature)
                     {
-                        isUnboxingStub = ((MethodFixupSignature)methodImport.ImportSignature.Target).IsUnboxingStub;
+                        isStub = methodSignature.IsUnboxingStub || methodSignature.IsInstantiatingStub;
                     }
-                    builder.GetCallRefMap(methodNode.Method, isUnboxingStub);
+                    builder.GetCallRefMap(methodNode.Method, isStub);
                 }
                 if (methodIndex >= nextMethodIndex)
                 {

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

@@ -19,6 +19,8 @@ public class Import : EmbeddedObjectNode, ISymbolDefinitionNode, ISortableSymbol
 
         internal readonly MethodDesc CallingMethod;
 
+        public Signature Signature => ImportSignature.Target;
+
         public Import(ImportSectionNode tableNode, Signature importSignature, MethodDesc callingMethod = null)
         {
             Table = tableNode;

src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs

@@ -940,7 +940,23 @@ private void getReadyToRunDelegateCtorHelper(ref CORINFO_RESOLVED_TOKEN pTargetM
             TypeDesc delegateTypeDesc = HandleToObject(delegateType);
             MethodDesc targetMethodDesc = HandleToObject(pTargetMethod.hMethod);
             Debug.Assert(!targetMethodDesc.IsUnboxingThunk());
-            MethodWithToken targetMethod = new MethodWithToken(targetMethodDesc, HandleToModuleToken(ref pTargetMethod), constrainedType: null, unboxing: false, context: entityFromContext(pTargetMethod.tokenContext));
+
+            var typeOrMethodContext = (pTargetMethod.tokenContext == contextFromMethodBeingCompiled()) ?
+                MethodBeingCompiled : HandleToObject((void*)pTargetMethod.tokenContext);
+
+            TypeDesc constrainedType = null;
+            if (targetConstraint != 0)
+            {
+                MethodIL methodIL = _compilation.GetMethodIL(MethodBeingCompiled);
+                constrainedType = (TypeDesc)ResolveTokenInScope(methodIL, typeOrMethodContext, targetConstraint);
+            }
+
+            MethodWithToken targetMethod = new MethodWithToken(
+                targetMethodDesc,
+                HandleToModuleToken(ref pTargetMethod),
+                constrainedType: constrainedType,
+                unboxing: false,
+                context: typeOrMethodContext);
 
             pLookup.lookupKind.needsRuntimeLookup = false;
             pLookup.constLookup = CreateConstLookupToSymbol(_compilation.SymbolNodeFactory.DelegateCtor(delegateTypeDesc, targetMethod));
@@ -2179,7 +2195,9 @@ private void ceeInfoGetCallInfo(
                 // class and not requesting the instantiating stub makes the runtime transform the
                 // owning type to its canonical equivalent that would need different codegen
                 // (supplying the instantiation argument).
-                if (!resolvedConstraint && !originalMethod.IsSharedByGenericInstantiations)
+                if (!resolvedConstraint &&
+                    !originalMethod.IsSharedByGenericInstantiations &&
+                    targetMethod.IsSharedByGenericInstantiations)
                 {
                     useInstantiatingStub = true;
                 }