diff options
author | dotnet-bot <dotnet-bot@microsoft.com> | 2015-01-30 14:14:42 -0800 |
---|---|---|
committer | dotnet-bot <dotnet-bot@microsoft.com> | 2015-01-30 14:14:42 -0800 |
commit | ef1e2ab328087c61a6878c1e84f4fc5d710aebce (patch) | |
tree | dee1bbb89e9d722e16b0d1485e3cdd1b6c8e2cfa /src/vm/ilstubresolver.cpp | |
download | coreclr-ef1e2ab328087c61a6878c1e84f4fc5d710aebce.tar.gz coreclr-ef1e2ab328087c61a6878c1e84f4fc5d710aebce.tar.bz2 coreclr-ef1e2ab328087c61a6878c1e84f4fc5d710aebce.zip |
Initial commit to populate CoreCLR repo
[tfs-changeset: 1407945]
Diffstat (limited to 'src/vm/ilstubresolver.cpp')
-rw-r--r-- | src/vm/ilstubresolver.cpp | 521 |
1 files changed, 521 insertions, 0 deletions
diff --git a/src/vm/ilstubresolver.cpp b/src/vm/ilstubresolver.cpp new file mode 100644 index 0000000000..5c717d7805 --- /dev/null +++ b/src/vm/ilstubresolver.cpp @@ -0,0 +1,521 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// +// +// File: ILStubResolver.cpp +// + +// + + +#include "common.h" + +#include "field.h" + +// returns pointer to IL code +BYTE* ILStubResolver::GetCodeInfo(unsigned* pCodeSize, unsigned* pStackSize, CorInfoOptions* pOptions, unsigned* pEHSize) +{ + CONTRACT(BYTE*) + { + STANDARD_VM_CHECK; + PRECONDITION(CheckPointer(pCodeSize)); + PRECONDITION(CheckPointer(pStackSize)); + PRECONDITION(CheckPointer(pOptions)); + PRECONDITION(CheckPointer(pEHSize)); + PRECONDITION(CheckPointer(m_pCompileTimeState)); + POSTCONDITION(CheckPointer(RETVAL)); + } + CONTRACT_END; + +#ifndef DACCESS_COMPILE + CORINFO_METHOD_INFO methodInfo; + getMethodInfoILMethodHeaderHelper(&m_pCompileTimeState->m_ILHeader, &methodInfo); + + *pCodeSize = methodInfo.ILCodeSize; + *pStackSize = methodInfo.maxStack; + *pOptions = methodInfo.options; + *pEHSize = methodInfo.EHcount; + + RETURN methodInfo.ILCode; +#else // DACCESS_COMPILE + DacNotImpl(); + RETURN NULL; +#endif // DACCESS_COMPILE +} + +// static +LPCUTF8 ILStubResolver::GetStubClassName(MethodDesc* pMD) +{ + CONTRACTL + { + MODE_ANY; + GC_NOTRIGGER; + NOTHROW; + SUPPORTS_DAC; + PRECONDITION(pMD->IsILStub()); + } + CONTRACTL_END; + + if (pMD->GetDomain()->IsSharedDomain()) + { + return "DomainNeutralILStubClass"; + } + else + { + return "DomainBoundILStubClass"; + } +} + +LPCUTF8 ILStubResolver::GetStubMethodName() +{ + CONTRACTL + { + MODE_ANY; + GC_NOTRIGGER; + NOTHROW; + } + CONTRACTL_END; + + switch (m_type) + { + case CLRToNativeInteropStub: return "IL_STUB_PInvoke"; + case CLRToCOMInteropStub: return "IL_STUB_CLRtoCOM"; + case CLRToWinRTInteropStub: return "IL_STUB_CLRtoWinRT"; + case NativeToCLRInteropStub: return "IL_STUB_ReversePInvoke"; + case COMToCLRInteropStub: return "IL_STUB_COMtoCLR"; + case WinRTToCLRInteropStub: return "IL_STUB_WinRTtoCLR"; +#ifdef FEATURE_ARRAYSTUB_AS_IL + case ArrayOpStub: return "IL_STUB_Array"; +#endif +#ifdef FEATURE_STUBS_AS_IL + case MulticastDelegateStub: return "IL_STUB_MulticastDelegate_Invoke"; + case UnboxingILStub: return "IL_STUB_UnboxingStub"; + case InstantiatingStub: return "IL_STUB_InstantiatingStub"; +#endif + default: + UNREACHABLE_MSG("Unknown stub type"); + } +} + +void ILStubResolver::GetJitContext(SecurityControlFlags* pSecurityControlFlags, + TypeHandle* pTypeOwner) +{ + CONTRACTL + { + STANDARD_VM_CHECK; + PRECONDITION(CheckPointer(pSecurityControlFlags)); + PRECONDITION(CheckPointer(pTypeOwner)); + } + CONTRACTL_END; + + *pSecurityControlFlags = DynamicResolver::SkipVisibilityChecks; + *pTypeOwner = TypeHandle(); +} + +ChunkAllocator* ILStubResolver::GetJitMetaHeap() +{ + LIMITED_METHOD_CONTRACT; + _ASSERTE(FALSE); + return NULL; +} + +SigPointer +ILStubResolver::GetLocalSig() +{ + STANDARD_VM_CONTRACT; + + return SigPointer( + m_pCompileTimeState->m_ILHeader.LocalVarSig, + m_pCompileTimeState->m_ILHeader.cbLocalVarSig); +} + +OBJECTHANDLE ILStubResolver::ConstructStringLiteral(mdToken token) +{ + STANDARD_VM_CONTRACT; + _ASSERTE(FALSE); + return NULL; +} + +BOOL ILStubResolver::IsValidStringRef(mdToken metaTok) +{ + STANDARD_VM_CONTRACT; + _ASSERTE(FALSE); + return FALSE; +} + +void ILStubResolver::ResolveToken(mdToken token, TypeHandle * pTH, MethodDesc ** ppMD, FieldDesc ** ppFD) +{ + STANDARD_VM_CONTRACT; + + *pTH = NULL; + *ppMD = NULL; + *ppFD = NULL; + + switch (TypeFromToken(token)) + { + case mdtMethodDef: + { + MethodDesc* pMD = m_pCompileTimeState->m_tokenLookupMap.LookupMethodDef(token); + _ASSERTE(pMD); + *ppMD = pMD; + *pTH = TypeHandle(pMD->GetMethodTable()); + } + break; + + case mdtTypeDef: + { + TypeHandle typeHnd = m_pCompileTimeState->m_tokenLookupMap.LookupTypeDef(token); + _ASSERTE(!typeHnd.IsNull()); + *pTH = typeHnd; + } + break; + + case mdtFieldDef: + { + FieldDesc* pFD = m_pCompileTimeState->m_tokenLookupMap.LookupFieldDef(token); + _ASSERTE(pFD); + *ppFD = pFD; + *pTH = TypeHandle(pFD->GetEnclosingMethodTable()); + } + break; + + default: + UNREACHABLE_MSG("unexpected metadata token type"); + } +} + +//--------------------------------------------------------------------------------------- +// +SigPointer +ILStubResolver::ResolveSignature( + mdToken token) +{ + STANDARD_VM_CONTRACT; + CONSISTENCY_CHECK_MSG(token == TOKEN_ILSTUB_TARGET_SIG, "IL stubs do not support any other signature tokens!"); + + return m_pCompileTimeState->m_StubTargetMethodSig; +} + +//--------------------------------------------------------------------------------------- +// +SigPointer +ILStubResolver::ResolveSignatureForVarArg( + mdToken token) +{ + STANDARD_VM_CONTRACT; + _ASSERTE(FALSE); + return SigPointer(); +} + +//--------------------------------------------------------------------------------------- +// +void ILStubResolver::GetEHInfo(unsigned EHnumber, CORINFO_EH_CLAUSE* clause) +{ + CONTRACTL + { + STANDARD_VM_CHECK; + PRECONDITION(CheckPointer(m_pCompileTimeState)); + PRECONDITION(CheckPointer(m_pCompileTimeState->m_ILHeader.EH)); + PRECONDITION(EHnumber < m_pCompileTimeState->m_ILHeader.EH->EHCount()); + } + CONTRACTL_END; + + COR_ILMETHOD_SECT_EH_CLAUSE_FAT ehClause; + const COR_ILMETHOD_SECT_EH_CLAUSE_FAT* ehInfo; + ehInfo = (COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)m_pCompileTimeState->m_ILHeader.EH->EHClause(EHnumber, &ehClause); + clause->Flags = (CORINFO_EH_CLAUSE_FLAGS)ehInfo->GetFlags(); + clause->TryOffset = ehInfo->GetTryOffset(); + clause->TryLength = ehInfo->GetTryLength(); + clause->HandlerOffset = ehInfo->GetHandlerOffset(); + clause->HandlerLength = ehInfo->GetHandlerLength(); + clause->ClassToken = ehInfo->GetClassToken(); + clause->FilterOffset = ehInfo->GetFilterOffset(); +} + +bool ILStubResolver::IsNativeToCLRInteropStub() +{ + return (m_type == NativeToCLRInteropStub); +} + +void ILStubResolver::SetStubType(ILStubType stubType) +{ + LIMITED_METHOD_CONTRACT; + m_type = stubType; +} + +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::SetStubTargetMethodSig( + PCCOR_SIGNATURE pStubTargetMethodSig, + DWORD cbStubTargetSigLength) +{ + CONTRACTL + { + STANDARD_VM_CHECK; + PRECONDITION(CheckPointer(m_pCompileTimeState)); + } + CONTRACTL_END; + + NewHolder<BYTE> pNewSig = new BYTE[cbStubTargetSigLength]; + + memcpyNoGCRefs((void *)pNewSig, pStubTargetMethodSig, cbStubTargetSigLength); + + m_pCompileTimeState->m_StubTargetMethodSig = SigPointer(pNewSig, cbStubTargetSigLength); + pNewSig.SuppressRelease(); +} + +//--------------------------------------------------------------------------------------- +// +MethodDesc * +ILStubResolver::GetStubTargetMethodDesc() +{ + LIMITED_METHOD_CONTRACT; + return m_pStubTargetMD; +} + +MethodDesc* ILStubResolver::GetStubMethodDesc() +{ + LIMITED_METHOD_CONTRACT; + return m_pStubMD; +} + +ILStubResolver::ILStubResolver() : + m_pCompileTimeState(dac_cast<PTR_CompileTimeState>(ILNotYetGenerated)), + m_pStubMD(dac_cast<PTR_MethodDesc>(NULL)), + m_pStubTargetMD(dac_cast<PTR_MethodDesc>(NULL)), + m_type(Unassigned), + m_dwJitFlags(0) +{ + LIMITED_METHOD_CONTRACT; + +} + +//--------------------------------------------------------------------------------------- +// +COR_ILMETHOD_DECODER * +ILStubResolver::AllocGeneratedIL( + size_t cbCode, + DWORD cbLocalSig, + UINT maxStack) +{ + STANDARD_VM_CONTRACT; + +#if !defined(DACCESS_COMPILE) + _ASSERTE(0 != cbCode); + + NewHolder<BYTE> pNewILCodeBuffer = NULL; + NewHolder<BYTE> pNewLocalSig = NULL; + NewHolder<CompileTimeState> pNewCompileTimeState = NULL; + + pNewCompileTimeState = (CompileTimeState *)new BYTE[sizeof(CompileTimeState)]; + memset(pNewCompileTimeState, 0, sizeof(CompileTimeState)); + + pNewILCodeBuffer = new BYTE[cbCode]; + + if (0 != cbLocalSig) + { + pNewLocalSig = new BYTE[cbLocalSig]; + } + + COR_ILMETHOD_DECODER* pILHeader = &pNewCompileTimeState->m_ILHeader; + + pILHeader->Flags = 0; + pILHeader->CodeSize = (DWORD)cbCode; + pILHeader->MaxStack = maxStack; + pILHeader->EH = 0; + pILHeader->Sect = 0; + pILHeader->Code = pNewILCodeBuffer; + pILHeader->LocalVarSig = pNewLocalSig; + pILHeader->cbLocalVarSig = cbLocalSig; + +#ifdef _DEBUG + LPVOID pPrevCompileTimeState = +#endif // _DEBUG + FastInterlockExchangePointer(&m_pCompileTimeState, pNewCompileTimeState.GetValue()); + CONSISTENCY_CHECK(ILNotYetGenerated == (UINT_PTR)pPrevCompileTimeState); + + pNewLocalSig.SuppressRelease(); + pNewILCodeBuffer.SuppressRelease(); + pNewCompileTimeState.SuppressRelease(); + + return pILHeader; + +#else // DACCESS_COMPILE + DacNotImpl(); + return NULL; + +#endif // DACCESS_COMPILE +} // ILStubResolver::AllocGeneratedIL + +//--------------------------------------------------------------------------------------- +// +COR_ILMETHOD_DECODER* ILStubResolver::GetILHeader() +{ + CONTRACTL + { + MODE_ANY; + THROWS; + GC_NOTRIGGER; + PRECONDITION(CheckPointer(m_pCompileTimeState)); + } + CONTRACTL_END; + + return &m_pCompileTimeState->m_ILHeader; +} + +COR_ILMETHOD_SECT_EH* ILStubResolver::AllocEHSect(size_t nClauses) +{ + STANDARD_VM_CONTRACT; + + if (nClauses >= 1) + { + size_t cbSize = sizeof(COR_ILMETHOD_SECT_EH) + - sizeof(IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT) + + (nClauses * sizeof(IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT)); + m_pCompileTimeState->m_pEHSect = (COR_ILMETHOD_SECT_EH*) new BYTE[cbSize]; + CONSISTENCY_CHECK(NULL == m_pCompileTimeState->m_ILHeader.EH); + m_pCompileTimeState->m_ILHeader.EH = m_pCompileTimeState->m_pEHSect; + return m_pCompileTimeState->m_pEHSect; + } + else + { + return NULL; + } +} + + +void ILStubResolver::FreeCompileTimeState() +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + MODE_ANY; + } + CONTRACTL_END; + + if ((ILNotYetGenerated == dac_cast<TADDR>(m_pCompileTimeState)) || + (ILGeneratedAndFreed == dac_cast<TADDR>(m_pCompileTimeState))) + { + return; + } + + ClearCompileTimeState(ILGeneratedAndFreed); +} + +//--------------------------------------------------------------------------------------- +// +void +ILStubResolver::ClearCompileTimeState(CompileTimeStatePtrSpecialValues newState) +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + MODE_ANY; + } + CONTRACTL_END; + + // + // See allocations in AllocGeneratedIL and SetStubTargetMethodSig + // + + COR_ILMETHOD_DECODER * pILHeader = &m_pCompileTimeState->m_ILHeader; + + CONSISTENCY_CHECK(NULL != pILHeader->Code); + delete[] pILHeader->Code; + + if (NULL != pILHeader->LocalVarSig) + { + delete[] pILHeader->LocalVarSig; + } + + if (!m_pCompileTimeState->m_StubTargetMethodSig.IsNull()) + { + delete[] m_pCompileTimeState->m_StubTargetMethodSig.GetPtr(); + } + + if (NULL != m_pCompileTimeState->m_pEHSect) + { + delete[] m_pCompileTimeState->m_pEHSect; + } + + delete m_pCompileTimeState; + + FastInterlockExchangePointer(&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(DWORD dwFlags) +{ + LIMITED_METHOD_CONTRACT; + m_dwJitFlags = dwFlags; +} + +DWORD ILStubResolver::GetJitFlags() +{ + LIMITED_METHOD_CONTRACT; + return m_dwJitFlags; +} + +// static +void ILStubResolver::StubGenFailed(ILStubResolver* pResolver) +{ + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + MODE_ANY; + } + CONTRACTL_END; + + if ((ILNotYetGenerated == dac_cast<TADDR>(pResolver->m_pCompileTimeState)) || + (ILGeneratedAndFreed == dac_cast<TADDR>(pResolver->m_pCompileTimeState))) + { + return; + } + + pResolver->ClearCompileTimeState(ILNotYetGenerated); +} |