src/vm/ilstubresolver.cpp

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4 //
   5 // File: ILStubResolver.cpp
   6 //
   7
   8 //
   9
  10
  11 #include "common.h"
  12
  13 #include "field.h"
  14
  15 // returns pointer to IL code
  16 BYTE* ILStubResolver::GetCodeInfo(unsigned* pCodeSize, unsigned* pStackSize, CorInfoOptions* pOptions, unsigned* pEHSize)
  17 {
  18     CONTRACT(BYTE*)
  19     {
  20         STANDARD_VM_CHECK;
  21         PRECONDITION(CheckPointer(pCodeSize));
  22         PRECONDITION(CheckPointer(pStackSize));
  23         PRECONDITION(CheckPointer(pOptions));
  24         PRECONDITION(CheckPointer(pEHSize));
  25         PRECONDITION(CheckPointer(m_pCompileTimeState));
  26         POSTCONDITION(CheckPointer(RETVAL));
  27     }
  28     CONTRACT_END;
  29
  30 #ifndef DACCESS_COMPILE
  31     CORINFO_METHOD_INFO methodInfo;
  32     getMethodInfoILMethodHeaderHelper(&m_pCompileTimeState->m_ILHeader, &methodInfo);
  33
  34     *pCodeSize = methodInfo.ILCodeSize;
  35     *pStackSize = methodInfo.maxStack;
  36     *pOptions = methodInfo.options;
  37     *pEHSize = methodInfo.EHcount;
  38
  39     RETURN methodInfo.ILCode;
  40 #else // DACCESS_COMPILE
  41     DacNotImpl();
  42     RETURN NULL;
  43 #endif // DACCESS_COMPILE
  44 }
  45
  46 // static
  47 LPCUTF8 ILStubResolver::GetStubClassName(MethodDesc* pMD)
  48 {
  49     CONTRACTL
  50     {
  51         MODE_ANY;
  52         GC_NOTRIGGER;
  53         NOTHROW;
  54         SUPPORTS_DAC;
  55         PRECONDITION(pMD->IsILStub());
  56     }
  57     CONTRACTL_END;
  58
  59     return "ILStubClass";
  60 }
  61
  62 LPCUTF8 ILStubResolver::GetStubMethodName()
  63 {
  64     CONTRACTL
  65     {
  66         MODE_ANY;
  67         GC_NOTRIGGER;
  68         NOTHROW;
  69     }
  70     CONTRACTL_END;
  71
  72     switch (m_type)
  73     {
  74         case CLRToNativeInteropStub: return "IL_STUB_PInvoke";
  75         case CLRToCOMInteropStub:    return "IL_STUB_CLRtoCOM";
  76         case CLRToWinRTInteropStub:  return "IL_STUB_CLRtoWinRT";
  77         case NativeToCLRInteropStub: return "IL_STUB_ReversePInvoke";
  78         case COMToCLRInteropStub:    return "IL_STUB_COMtoCLR";
  79         case WinRTToCLRInteropStub:  return "IL_STUB_WinRTtoCLR";
  80 #ifdef FEATURE_ARRAYSTUB_AS_IL
  81         case ArrayOpStub:            return "IL_STUB_Array";
  82 #endif
  83 #ifdef FEATURE_MULTICASTSTUB_AS_IL
  84         case MulticastDelegateStub:  return "IL_STUB_MulticastDelegate_Invoke";
  85 #endif
  86 #ifdef FEATURE_INSTANTIATINGSTUB_AS_IL
  87         case UnboxingILStub:         return "IL_STUB_UnboxingStub";
  88         case InstantiatingStub:      return "IL_STUB_InstantiatingStub";
  89 #endif
  90         case WrapperDelegateStub:    return "IL_STUB_WrapperDelegate_Invoke";
  91         default:
  92             UNREACHABLE_MSG("Unknown stub type");
  93     }
  94 }
  95
  96 void ILStubResolver::GetJitContext(SecurityControlFlags* pSecurityControlFlags,
  97                                    TypeHandle* pTypeOwner)
  98 {
  99     CONTRACTL
 100     {
 101         STANDARD_VM_CHECK;
 102         PRECONDITION(CheckPointer(pSecurityControlFlags));
 103         PRECONDITION(CheckPointer(pTypeOwner));
 104     }
 105     CONTRACTL_END;
 106
 107     *pSecurityControlFlags = DynamicResolver::SkipVisibilityChecks;
 108     *pTypeOwner = TypeHandle();
 109 }
 110
 111 ChunkAllocator* ILStubResolver::GetJitMetaHeap()
 112 {
 113     LIMITED_METHOD_CONTRACT;
 114     _ASSERTE(FALSE);
 115     return NULL;
 116 }
 117
 118 SigPointer
 119 ILStubResolver::GetLocalSig()
 120 {
 121     STANDARD_VM_CONTRACT;
 122
 123     return SigPointer(
 124         m_pCompileTimeState->m_ILHeader.LocalVarSig,
 125         m_pCompileTimeState->m_ILHeader.cbLocalVarSig);
 126 }
 127
 128 OBJECTHANDLE ILStubResolver::ConstructStringLiteral(mdToken token)
 129 {
 130     STANDARD_VM_CONTRACT;
 131     _ASSERTE(FALSE);
 132     return NULL;
 133 }
 134
 135 BOOL ILStubResolver::IsValidStringRef(mdToken metaTok)
 136 {
 137     STANDARD_VM_CONTRACT;
 138     _ASSERTE(FALSE);
 139     return FALSE;
 140 }
 141
 142 void ILStubResolver::ResolveToken(mdToken token, TypeHandle * pTH, MethodDesc ** ppMD, FieldDesc ** ppFD)
 143 {
 144     STANDARD_VM_CONTRACT;
 145
 146     *pTH = NULL;
 147     *ppMD = NULL;
 148     *ppFD = NULL;
 149
 150     switch (TypeFromToken(token))
 151     {
 152     case mdtMethodDef:
 153         {
 154             MethodDesc* pMD = m_pCompileTimeState->m_tokenLookupMap.LookupMethodDef(token);
 155             _ASSERTE(pMD);
 156             *ppMD = pMD;
 157             *pTH = TypeHandle(pMD->GetMethodTable());
 158         }
 159         break;
 160
 161     case mdtTypeDef:
 162         {
 163             TypeHandle typeHnd = m_pCompileTimeState->m_tokenLookupMap.LookupTypeDef(token);
 164             _ASSERTE(!typeHnd.IsNull());
 165             *pTH = typeHnd;
 166         }
 167         break;
 168
 169     case mdtFieldDef:
 170         {
 171             FieldDesc* pFD = m_pCompileTimeState->m_tokenLookupMap.LookupFieldDef(token);
 172             _ASSERTE(pFD);
 173             *ppFD = pFD;
 174             *pTH = TypeHandle(pFD->GetEnclosingMethodTable());
 175         }
 176         break;
 177
 178     default:
 179         UNREACHABLE_MSG("unexpected metadata token type");
 180     }
 181 }
 182
 183 //---------------------------------------------------------------------------------------
 184 //
 185 SigPointer
 186 ILStubResolver::ResolveSignature(
 187     mdToken token)
 188 {
 189     STANDARD_VM_CONTRACT;
 190     CONSISTENCY_CHECK_MSG(token == TOKEN_ILSTUB_TARGET_SIG, "IL stubs do not support any other signature tokens!");
 191
 192     return m_pCompileTimeState->m_StubTargetMethodSig;
 193 }
 194
 195 //---------------------------------------------------------------------------------------
 196 //
 197 SigPointer
 198 ILStubResolver::ResolveSignatureForVarArg(
 199     mdToken token)
 200 {
 201     STANDARD_VM_CONTRACT;
 202     _ASSERTE(FALSE);
 203     return SigPointer();
 204 }
 205
 206 //---------------------------------------------------------------------------------------
 207 //
 208 void ILStubResolver::GetEHInfo(unsigned EHnumber, CORINFO_EH_CLAUSE* clause)
 209 {
 210     CONTRACTL
 211     {
 212         STANDARD_VM_CHECK;
 213         PRECONDITION(CheckPointer(m_pCompileTimeState));
 214         PRECONDITION(CheckPointer(m_pCompileTimeState->m_ILHeader.EH));
 215         PRECONDITION(EHnumber < m_pCompileTimeState->m_ILHeader.EH->EHCount());
 216     }
 217     CONTRACTL_END;
 218
 219     COR_ILMETHOD_SECT_EH_CLAUSE_FAT ehClause;
 220     const COR_ILMETHOD_SECT_EH_CLAUSE_FAT* ehInfo;
 221     ehInfo = (COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)m_pCompileTimeState->m_ILHeader.EH->EHClause(EHnumber, &ehClause);
 222     clause->Flags = (CORINFO_EH_CLAUSE_FLAGS)ehInfo->GetFlags();
 223     clause->TryOffset = ehInfo->GetTryOffset();
 224     clause->TryLength = ehInfo->GetTryLength();
 225     clause->HandlerOffset = ehInfo->GetHandlerOffset();
 226     clause->HandlerLength = ehInfo->GetHandlerLength();
 227     clause->ClassToken = ehInfo->GetClassToken();
 228     clause->FilterOffset = ehInfo->GetFilterOffset();
 229 }
 230
 231 bool ILStubResolver::IsNativeToCLRInteropStub()
 232 {
 233     return (m_type == NativeToCLRInteropStub);
 234 }
 235
 236 bool ILStubResolver::IsCLRToNativeInteropStub()
 237 {
 238     return (m_type == CLRToNativeInteropStub);
 239 }
 240
 241 void ILStubResolver::SetStubType(ILStubType stubType)
 242 {
 243     LIMITED_METHOD_CONTRACT;
 244     m_type = stubType;
 245 }
 246
 247 void ILStubResolver::SetStubMethodDesc(MethodDesc* pStubMD)
 248 {
 249     LIMITED_METHOD_CONTRACT;
 250     m_pStubMD = PTR_MethodDesc(pStubMD);
 251 }
 252
 253 void ILStubResolver::SetStubTargetMethodDesc(MethodDesc* pStubTargetMD)
 254 {
 255     LIMITED_METHOD_CONTRACT;
 256     m_pStubTargetMD = PTR_MethodDesc(pStubTargetMD);
 257 }
 258
 259
 260 //---------------------------------------------------------------------------------------
 261 //
 262 void
 263 ILStubResolver::SetStubTargetMethodSig(
 264     PCCOR_SIGNATURE pStubTargetMethodSig,
 265     DWORD           cbStubTargetSigLength)
 266 {
 267     CONTRACTL
 268     {
 269         STANDARD_VM_CHECK;
 270         PRECONDITION(CheckPointer(m_pCompileTimeState));
 271     }
 272     CONTRACTL_END;
 273
 274     NewArrayHolder<BYTE> pNewSig = new BYTE[cbStubTargetSigLength];
 275
 276     memcpyNoGCRefs((void *)pNewSig, pStubTargetMethodSig, cbStubTargetSigLength);
 277
 278     m_pCompileTimeState->m_StubTargetMethodSig = SigPointer(pNewSig, cbStubTargetSigLength);
 279     pNewSig.SuppressRelease();
 280 }
 281
 282 //---------------------------------------------------------------------------------------
 283 //
 284 MethodDesc *
 285 ILStubResolver::GetStubTargetMethodDesc()
 286 {
 287     LIMITED_METHOD_CONTRACT;
 288     return m_pStubTargetMD;
 289 }
 290
 291 MethodDesc* ILStubResolver::GetStubMethodDesc()
 292 {
 293     LIMITED_METHOD_CONTRACT;
 294     return m_pStubMD;
 295 }
 296
 297 ILStubResolver::ILStubResolver() :
 298     m_pCompileTimeState(dac_cast<PTR_CompileTimeState>(ILNotYetGenerated)),
 299     m_pStubMD(dac_cast<PTR_MethodDesc>(nullptr)),
 300     m_pStubTargetMD(dac_cast<PTR_MethodDesc>(nullptr)),
 301     m_type(Unassigned),
 302     m_jitFlags()
 303 {
 304     LIMITED_METHOD_CONTRACT;
 305
 306 }
 307
 308 //---------------------------------------------------------------------------------------
 309 //
 310 COR_ILMETHOD_DECODER *
 311 ILStubResolver::AllocGeneratedIL(
 312     size_t cbCode,
 313     DWORD  cbLocalSig,
 314     UINT   maxStack)
 315 {
 316     STANDARD_VM_CONTRACT;
 317
 318 #if !defined(DACCESS_COMPILE)
 319     _ASSERTE(0 != cbCode);
 320
 321     NewArrayHolder<BYTE>             pNewILCodeBuffer        = NULL;
 322     NewArrayHolder<BYTE>             pNewLocalSig            = NULL;
 323     NewArrayHolder<CompileTimeState> pNewCompileTimeState    = NULL;
 324
 325     pNewCompileTimeState = (CompileTimeState *)new BYTE[sizeof(CompileTimeState)];
 326     memset(pNewCompileTimeState, 0, sizeof(CompileTimeState));
 327
 328     pNewILCodeBuffer = new BYTE[cbCode];
 329
 330     if (0 != cbLocalSig)
 331     {
 332         pNewLocalSig = new BYTE[cbLocalSig];
 333     }
 334
 335     COR_ILMETHOD_DECODER* pILHeader = &pNewCompileTimeState->m_ILHeader;
 336
 337     pILHeader->Flags         = 0;
 338     pILHeader->CodeSize      = (DWORD)cbCode;
 339     pILHeader->MaxStack      = maxStack;
 340     pILHeader->EH            = 0;
 341     pILHeader->Sect          = 0;
 342     pILHeader->Code          = pNewILCodeBuffer;
 343     pILHeader->LocalVarSig   = pNewLocalSig;
 344     pILHeader->cbLocalVarSig = cbLocalSig;
 345
 346 #ifdef _DEBUG
 347     LPVOID pPrevCompileTimeState =
 348 #endif // _DEBUG
 349     FastInterlockExchangePointer(&m_pCompileTimeState, pNewCompileTimeState.GetValue());
 350     CONSISTENCY_CHECK(ILNotYetGenerated == (UINT_PTR)pPrevCompileTimeState);
 351
 352     pNewLocalSig.SuppressRelease();
 353     pNewILCodeBuffer.SuppressRelease();
 354     pNewCompileTimeState.SuppressRelease();
 355
 356     return pILHeader;
 357
 358 #else  // DACCESS_COMPILE
 359     DacNotImpl();
 360     return NULL;
 361
 362 #endif // DACCESS_COMPILE
 363 } // ILStubResolver::AllocGeneratedIL
 364
 365 //---------------------------------------------------------------------------------------
 366 //
 367 COR_ILMETHOD_DECODER* ILStubResolver::GetILHeader()
 368 {
 369     CONTRACTL
 370     {
 371         MODE_ANY;
 372         THROWS;
 373         GC_NOTRIGGER;
 374         PRECONDITION(CheckPointer(m_pCompileTimeState));
 375     }
 376     CONTRACTL_END;
 377
 378     return &m_pCompileTimeState->m_ILHeader;
 379 }
 380
 381 COR_ILMETHOD_SECT_EH* ILStubResolver::AllocEHSect(size_t nClauses)
 382 {
 383     STANDARD_VM_CONTRACT;
 384
 385     if (nClauses >= 1)
 386     {
 387         size_t cbSize = sizeof(COR_ILMETHOD_SECT_EH)
 388                         - sizeof(IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT)
 389                         + (nClauses * sizeof(IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT));
 390         m_pCompileTimeState->m_pEHSect = (COR_ILMETHOD_SECT_EH*) new BYTE[cbSize];
 391         CONSISTENCY_CHECK(NULL == m_pCompileTimeState->m_ILHeader.EH);
 392         m_pCompileTimeState->m_ILHeader.EH = m_pCompileTimeState->m_pEHSect;
 393         return m_pCompileTimeState->m_pEHSect;
 394     }
 395     else
 396     {
 397         return NULL;
 398     }
 399 }
 400
 401 void ILStubResolver::FreeCompileTimeState()
 402 {
 403     CONTRACTL
 404     {
 405         NOTHROW;
 406         GC_NOTRIGGER;
 407         MODE_ANY;
 408     }
 409     CONTRACTL_END;
 410
 411     if ((ILNotYetGenerated == dac_cast<TADDR>(m_pCompileTimeState)) ||
 412         (ILGeneratedAndFreed == dac_cast<TADDR>(m_pCompileTimeState)))
 413     {
 414         return;
 415     }
 416
 417     ClearCompileTimeState(ILGeneratedAndFreed);
 418 }
 419
 420 //---------------------------------------------------------------------------------------
 421 //
 422 void
 423 ILStubResolver::ClearCompileTimeState(CompileTimeStatePtrSpecialValues newState)
 424 {
 425     CONTRACTL
 426     {
 427         NOTHROW;
 428         GC_NOTRIGGER;
 429         MODE_ANY;
 430     }
 431     CONTRACTL_END;
 432
 433     //
 434     // See allocations in AllocGeneratedIL and SetStubTargetMethodSig
 435     //
 436
 437     COR_ILMETHOD_DECODER * pILHeader = &m_pCompileTimeState->m_ILHeader;
 438
 439     CONSISTENCY_CHECK(NULL != pILHeader->Code);
 440     delete[] pILHeader->Code;
 441
 442     if (NULL != pILHeader->LocalVarSig)
 443     {
 444         delete[] pILHeader->LocalVarSig;
 445     }
 446
 447     if (!m_pCompileTimeState->m_StubTargetMethodSig.IsNull())
 448     {
 449         delete[] m_pCompileTimeState->m_StubTargetMethodSig.GetPtr();
 450     }
 451
 452     if (NULL != m_pCompileTimeState->m_pEHSect)
 453     {
 454         delete[] m_pCompileTimeState->m_pEHSect;
 455     }
 456
 457     delete m_pCompileTimeState;
 458
 459     FastInterlockExchangePointer(&m_pCompileTimeState, dac_cast<PTR_CompileTimeState>((TADDR)newState));
 460 } // ILStubResolver::ClearCompileTimeState
 461
 462 //---------------------------------------------------------------------------------------
 463 //
 464 void
 465 ILStubResolver::SetTokenLookupMap(
 466     TokenLookupMap * pMap)
 467 {
 468     CONTRACTL
 469     {
 470         STANDARD_VM_CHECK;
 471         PRECONDITION(CheckPointer(m_pCompileTimeState));
 472     }
 473     CONTRACTL_END;
 474
 475     // run copy ctor
 476     new (&m_pCompileTimeState->m_tokenLookupMap) TokenLookupMap(pMap);
 477 }
 478
 479 bool ILStubResolver::IsCompiled()
 480 {
 481     LIMITED_METHOD_CONTRACT;
 482     return (dac_cast<TADDR>(m_pCompileTimeState) == ILGeneratedAndFreed);
 483 }
 484
 485 bool ILStubResolver::IsILGenerated()
 486 {
 487     return (dac_cast<TADDR>(m_pCompileTimeState) != ILNotYetGenerated);
 488 }
 489
 490 void ILStubResolver::SetJitFlags(CORJIT_FLAGS jitFlags)
 491 {
 492     LIMITED_METHOD_CONTRACT;
 493     m_jitFlags = jitFlags;
 494 }
 495
 496 CORJIT_FLAGS ILStubResolver::GetJitFlags()
 497 {
 498     LIMITED_METHOD_CONTRACT;
 499     return m_jitFlags;
 500 }
 501
 502 // static
 503 void ILStubResolver::StubGenFailed(ILStubResolver* pResolver)
 504 {
 505     CONTRACTL
 506     {
 507         NOTHROW;
 508         GC_NOTRIGGER;
 509         MODE_ANY;
 510     }
 511     CONTRACTL_END;
 512
 513     if ((ILNotYetGenerated == dac_cast<TADDR>(pResolver->m_pCompileTimeState)) ||
 514         (ILGeneratedAndFreed == dac_cast<TADDR>(pResolver->m_pCompileTimeState)))
 515     {
 516         return;
 517     }
 518
 519     pResolver->ClearCompileTimeState(ILNotYetGenerated);
 520 }