Collapse the recent ILStub generation patterns into a helper (#115673)

Author: AaronRobinsonMSFT

src/coreclr/vm/asyncthunks.cpp

@@ -53,34 +53,8 @@ bool MethodDesc::TryGenerateAsyncThunk(DynamicResolver** resolver, COR_ILMETHOD_
     ilResolver->SetStubTargetMethodDesc(pAsyncOtherVariant);
 
     // Generate all IL associated data for JIT
-    {
-        UINT maxStack;
-        size_t cbCode = sl.Link(&maxStack);
-        DWORD cbSig = sl.GetLocalSigSize();
-
-        COR_ILMETHOD_DECODER* pILHeader = ilResolver->AllocGeneratedIL(cbCode, cbSig, maxStack);
-        BYTE* pbBuffer = (BYTE*)pILHeader->Code;
-        BYTE* pbLocalSig = (BYTE*)pILHeader->LocalVarSig;
-        _ASSERTE(cbSig == pILHeader->cbLocalVarSig);
-
-        size_t numEH = sl.GetNumEHClauses();
-        if (numEH > 0)
-        {
-            sl.WriteEHClauses(ilResolver->AllocEHSect(numEH));
-        }
-
-        sl.GenerateCode(pbBuffer, cbCode);
-        sl.GetLocalSig(pbLocalSig, cbSig);
-
-        // Store the token lookup map
-        ilResolver->SetTokenLookupMap(sl.GetTokenLookupMap());
-        ilResolver->SetJitFlags(CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB));
-
-        *resolver = (DynamicResolver*)ilResolver;
-        *methodILDecoder = pILHeader;
-    }
-
-    ilResolver.SuppressRelease();
+    *methodILDecoder = ilResolver->FinalizeILStub(&sl);
+    *resolver = ilResolver.Extract();
     return true;
 }
 
@@ -564,7 +538,7 @@ void MethodDesc::EmitAsyncMethodThunk(MethodDesc* pAsyncOtherVariant, MetaSig& m
         getIsCompletedToken = GetTokenForGenericTypeMethodCallWithAsyncReturnType(pCode, mdIsCompleted);
         getResultToken = GetTokenForGenericTypeMethodCallWithAsyncReturnType(pCode, mdGetResult);
     }
-    else 
+    else
     {
         getAwaiterToken = pCode->GetToken(mdGetAwaiter);
         getIsCompletedToken = pCode->GetToken(mdIsCompleted);

src/coreclr/vm/dllimport.cpp

@@ -6483,27 +6483,8 @@ bool GenerateCopyConstructorHelper(MethodDesc* ftn, DynamicResolver** ppResolver
     pCode->EmitRET();
 
     // Generate all IL associated data for JIT
-    {
-        UINT maxStack;
-        size_t cbCode = sl.Link(&maxStack);
-        DWORD cbSig = sl.GetLocalSigSize();
-
-        COR_ILMETHOD_DECODER* pILHeader = ilResolver->AllocGeneratedIL(cbCode, cbSig, maxStack);
-        BYTE* pbBuffer = (BYTE*)pILHeader->Code;
-        BYTE* pbLocalSig = (BYTE*)pILHeader->LocalVarSig;
-        _ASSERTE(cbSig == pILHeader->cbLocalVarSig);
-        sl.GenerateCode(pbBuffer, cbCode);
-        sl.GetLocalSig(pbLocalSig, cbSig);
-
-        // Store the token lookup map
-        ilResolver->SetTokenLookupMap(sl.GetTokenLookupMap());
-        ilResolver->SetJitFlags(CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB));
-
-        *ppResolver = (DynamicResolver*)ilResolver;
-        *ppHeader = pILHeader;
-    }
-
-    ilResolver.SuppressRelease();
+    *ppHeader = ilResolver->FinalizeILStub(&sl);
+    *ppResolver = ilResolver.Extract();
     return true;
 }
 

src/coreclr/vm/ilstubcache.cpp

@@ -97,33 +97,9 @@ MethodDesc* ILStubCache::CreateAndLinkNewILStubMethodDesc(LoaderAllocator* pAllo
 
     pResolver->SetStubMethodDesc(pStubMD);
 
-
-    {
-        UINT   maxStack;
-        size_t cbCode = pStubLinker->Link(&maxStack);
-        DWORD cbSig = pStubLinker->GetLocalSigSize();
-
-        COR_ILMETHOD_DECODER * pILHeader = pResolver->AllocGeneratedIL(cbCode, cbSig, maxStack);
-        BYTE * pbBuffer   = (BYTE *)pILHeader->Code;
-        BYTE * pbLocalSig = (BYTE *)pILHeader->LocalVarSig;
-        _ASSERTE(cbSig == pILHeader->cbLocalVarSig);
-
-        size_t numEH = pStubLinker->GetNumEHClauses();
-        if (numEH > 0)
-        {
-            pStubLinker->WriteEHClauses(pResolver->AllocEHSect(numEH));
-        }
-
-        pStubLinker->GenerateCode(pbBuffer, cbCode);
-        pStubLinker->GetLocalSig(pbLocalSig, cbSig);
-
-        pResolver->SetJitFlags(CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB));
-    }
-
-    pResolver->SetTokenLookupMap(pStubLinker->GetTokenLookupMap());
+    pResolver->FinalizeILStub(pStubLinker);
 
     RETURN pStubMD;
-
 }
 
 

src/coreclr/vm/ilstubresolver.cpp

@@ -282,74 +282,101 @@ void ILStubResolver::GetEHInfo(unsigned EHnumber, CORINFO_EH_CLAUSE* clause)
     clause->FilterOffset = ehInfo->GetFilterOffset();
 }
 
-void ILStubResolver::SetStubMethodDesc(MethodDesc* pStubMD)
+//---------------------------------------------------------------------------------------
+//
+ILStubResolver::ILStubResolver() :
+    m_pCompileTimeState(dac_cast<PTR_CompileTimeState>(ILNotYetGenerated)),
+    m_pStubMD(dac_cast<PTR_MethodDesc>(nullptr)),
+    m_pStubTargetMD(dac_cast<PTR_MethodDesc>(nullptr)),
+    m_jitFlags(),
+    m_loaderHeap(dac_cast<PTR_LoaderHeap>(nullptr))
 {
     LIMITED_METHOD_CONTRACT;
-    m_pStubMD = PTR_MethodDesc(pStubMD);
 }
 
-void ILStubResolver::SetStubTargetMethodDesc(MethodDesc* pStubTargetMD)
+bool ILStubResolver::IsCompiled()
 {
     LIMITED_METHOD_CONTRACT;
-    m_pStubTargetMD = PTR_MethodDesc(pStubTargetMD);
+    return (dac_cast<TADDR>(m_pCompileTimeState) == ILGeneratedAndFreed);
 }
 
-
-//---------------------------------------------------------------------------------------
-//
-void
-ILStubResolver::SetStubTargetMethodSig(
-    PCCOR_SIGNATURE pStubTargetMethodSig,
-    DWORD           cbStubTargetSigLength)
+bool ILStubResolver::IsILGenerated()
 {
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(m_pCompileTimeState));
-    }
-    CONTRACTL_END;
+    LIMITED_METHOD_CONTRACT;
+    return (dac_cast<TADDR>(m_pCompileTimeState) != ILNotYetGenerated);
+}
 
-    NewArrayHolder<BYTE> pNewSig = new BYTE[cbStubTargetSigLength];
+MethodDesc* ILStubResolver::GetStubMethodDesc()
+{
+    LIMITED_METHOD_CONTRACT;
+    return m_pStubMD;
+}
 
-    memcpyNoGCRefs((void *)pNewSig, pStubTargetMethodSig, cbStubTargetSigLength);
+MethodDesc* ILStubResolver::GetStubTargetMethodDesc()
+{
+    LIMITED_METHOD_CONTRACT;
+    return m_pStubTargetMD;
+}
 
-    m_pCompileTimeState->m_StubTargetMethodSig = SigPointer(pNewSig, cbStubTargetSigLength);
-    pNewSig.SuppressRelease();
+COR_ILMETHOD_DECODER* ILStubResolver::GetILHeader()
+{
+    LIMITED_METHOD_CONTRACT;
+    _ASSERTE(m_pCompileTimeState != NULL);
+    return &m_pCompileTimeState->m_ILHeader;
 }
 
-//---------------------------------------------------------------------------------------
-//
-MethodDesc *
-ILStubResolver::GetStubTargetMethodDesc()
+#ifndef DACCESS_COMPILE
+void ILStubResolver::SetLoaderHeap(PTR_LoaderHeap pLoaderHeap)
 {
     LIMITED_METHOD_CONTRACT;
-    return m_pStubTargetMD;
+    m_loaderHeap = pLoaderHeap;
 }
 
-MethodDesc* ILStubResolver::GetStubMethodDesc()
+void ILStubResolver::SetTokenLookupMap(TokenLookupMap* pMap)
+{
+    STANDARD_VM_CONTRACT;
+    _ASSERTE(m_pCompileTimeState != NULL);
+
+    // run copy ctor
+    new (&m_pCompileTimeState->m_tokenLookupMap) TokenLookupMap(pMap);
+}
+
+void ILStubResolver::SetJitFlags(CORJIT_FLAGS jitFlags)
 {
     LIMITED_METHOD_CONTRACT;
-    return m_pStubMD;
+    m_jitFlags = jitFlags;
 }
 
-ILStubResolver::ILStubResolver() :
-    m_pCompileTimeState(dac_cast<PTR_CompileTimeState>(ILNotYetGenerated)),
-    m_pStubMD(dac_cast<PTR_MethodDesc>(nullptr)),
-    m_pStubTargetMD(dac_cast<PTR_MethodDesc>(nullptr)),
-    m_jitFlags(),
-    m_loaderHeap(dac_cast<PTR_LoaderHeap>(nullptr))
+void ILStubResolver::SetStubMethodDesc(MethodDesc* pStubMD)
 {
     LIMITED_METHOD_CONTRACT;
+    m_pStubMD = PTR_MethodDesc(pStubMD);
+}
 
+void ILStubResolver::SetStubTargetMethodDesc(MethodDesc* pStubTargetMD)
+{
+    LIMITED_METHOD_CONTRACT;
+    m_pStubTargetMD = PTR_MethodDesc(pStubTargetMD);
 }
 
-void ILStubResolver::SetLoaderHeap(PTR_LoaderHeap pLoaderHeap)
+void ILStubResolver::SetStubTargetMethodSig(
+    PCCOR_SIGNATURE pStubTargetMethodSig,
+    DWORD           cbStubTargetSigLength)
 {
-    m_loaderHeap = pLoaderHeap;
+    STANDARD_VM_CONTRACT;
+    _ASSERTE(m_pCompileTimeState != NULL);
+
+    NewArrayHolder<BYTE> pNewSig = new BYTE[cbStubTargetSigLength];
+
+    memcpyNoGCRefs((void *)pNewSig, pStubTargetMethodSig, cbStubTargetSigLength);
+
+    m_pCompileTimeState->m_StubTargetMethodSig = SigPointer(pNewSig, cbStubTargetSigLength);
+    pNewSig.SuppressRelease();
 }
 
 static COR_ILMETHOD_DECODER CreateILHeader(size_t cbCode, UINT maxStack, BYTE* pNewILCodeBuffer, BYTE* pNewLocalSig, DWORD cbLocalSig)
 {
+    LIMITED_METHOD_CONTRACT;
     COR_ILMETHOD_DECODER ilHeader{};
     ilHeader.CodeSize = (DWORD)cbCode;
     ilHeader.MaxStack = maxStack;
@@ -359,17 +386,13 @@ static COR_ILMETHOD_DECODER CreateILHeader(size_t cbCode, UINT maxStack, BYTE* p
     return ilHeader;
 }
 
-//---------------------------------------------------------------------------------------
-//
-COR_ILMETHOD_DECODER *
-ILStubResolver::AllocGeneratedIL(
+COR_ILMETHOD_DECODER* ILStubResolver::AllocGeneratedIL(
     size_t cbCode,
     DWORD  cbLocalSig,
     UINT   maxStack)
 {
     STANDARD_VM_CONTRACT;
 
-#if !defined(DACCESS_COMPILE)
     _ASSERTE(0 != cbCode);
 
     // Perform a single allocation for all needed memory
@@ -410,27 +433,37 @@ ILStubResolver::AllocGeneratedIL(
     newMemory.SuppressRelease();
     return pILHeader;
 
-#else  // DACCESS_COMPILE
-    DacNotImpl();
-    return NULL;
-
-#endif // DACCESS_COMPILE
 } // ILStubResolver::AllocGeneratedIL
 
-//---------------------------------------------------------------------------------------
-//
-COR_ILMETHOD_DECODER* ILStubResolver::GetILHeader()
+COR_ILMETHOD_DECODER* ILStubResolver::FinalizeILStub(ILStubLinker* sl)
 {
-    CONTRACTL
+    STANDARD_VM_CONTRACT;
+    _ASSERTE(!IsILGenerated());
+    _ASSERTE(sl != NULL);
+
+    UINT maxStack;
+    size_t cbCode = sl->Link(&maxStack);
+    DWORD cbSig = sl->GetLocalSigSize();
+
+    COR_ILMETHOD_DECODER* pILHeader = AllocGeneratedIL(cbCode, cbSig, maxStack);
+    BYTE* pbBuffer = (BYTE*)pILHeader->Code;
+    BYTE* pbLocalSig = (BYTE*)pILHeader->LocalVarSig;
+    _ASSERTE(cbSig == pILHeader->cbLocalVarSig);
+
+    size_t numEH = sl->GetNumEHClauses();
+    if (numEH > 0)
     {
-        MODE_ANY;
-        THROWS;
-        GC_NOTRIGGER;
-        PRECONDITION(CheckPointer(m_pCompileTimeState));
+        sl->WriteEHClauses(AllocEHSect(numEH));
     }
-    CONTRACTL_END;
 
-    return &m_pCompileTimeState->m_ILHeader;
+    sl->GenerateCode(pbBuffer, cbCode);
+    sl->GetLocalSig(pbLocalSig, cbSig);
+
+    // Store the token lookup map
+    SetTokenLookupMap(sl->GetTokenLookupMap());
+    SetJitFlags(CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB));
+
+    return pILHeader;
 }
 
 COR_ILMETHOD_SECT_EH* ILStubResolver::AllocEHSect(size_t nClauses)
@@ -448,6 +481,7 @@ COR_ILMETHOD_SECT_EH* ILStubResolver::AllocEHSect(size_t nClauses)
     m_pCompileTimeState->m_ILHeader.EH = m_pCompileTimeState->m_pEHSect;
     return m_pCompileTimeState->m_pEHSect;
 }
+#endif // !DACCESS_COMPILE
 
 bool ILStubResolver::UseLoaderHeap()
 {
@@ -506,40 +540,6 @@ ILStubResolver::ClearCompileTimeState(CompileTimeStatePtrSpecialValues newState)
     InterlockedExchangeT(&m_pCompileTimeState, dac_cast<PTR_CompileTimeState>((TADDR)newState));
 } // ILStubResolver::ClearCompileTimeState
 
-//---------------------------------------------------------------------------------------
-//
-void
-ILStubResolver::SetTokenLookupMap(
-    TokenLookupMap * pMap)
-{
-    CONTRACTL
-    {
-        STANDARD_VM_CHECK;
-        PRECONDITION(CheckPointer(m_pCompileTimeState));
-    }
-    CONTRACTL_END;
-
-    // run copy ctor
-    new (&m_pCompileTimeState->m_tokenLookupMap) TokenLookupMap(pMap);
-}
-
-bool ILStubResolver::IsCompiled()
-{
-    LIMITED_METHOD_CONTRACT;
-    return (dac_cast<TADDR>(m_pCompileTimeState) == ILGeneratedAndFreed);
-}
-
-bool ILStubResolver::IsILGenerated()
-{
-    return (dac_cast<TADDR>(m_pCompileTimeState) != ILNotYetGenerated);
-}
-
-void ILStubResolver::SetJitFlags(CORJIT_FLAGS jitFlags)
-{
-    LIMITED_METHOD_CONTRACT;
-    m_jitFlags = jitFlags;
-}
-
 // static
 void ILStubResolver::StubGenFailed(ILStubResolver* pResolver)
 {
@@ -558,4 +558,4 @@ void ILStubResolver::StubGenFailed(ILStubResolver* pResolver)
     }
 
     pResolver->ClearCompileTimeState(ILNotYetGenerated);
-}
+}