src/jit/ICorJitInfo_API_wrapper.hpp

   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 #define API_ENTER(name) wrapComp->CLR_API_Enter(API_##name);
   6 #define API_LEAVE(name) wrapComp->CLR_API_Leave(API_##name);
   7
   8 /**********************************************************************************/
   9 // clang-format off
  10 /**********************************************************************************/
  11 //
  12 // ICorMethodInfo
  13 //
  14
  15 DWORD WrapICorJitInfo::getMethodAttribs(CORINFO_METHOD_HANDLE ftn /* IN */)
  16 {
  17     API_ENTER(getMethodAttribs)
  18     DWORD temp = wrapHnd->getMethodAttribs(ftn);
  19     API_LEAVE(getMethodAttribs)
  20     return temp;
  21 }
  22
  23 void WrapICorJitInfo::setMethodAttribs(CORINFO_METHOD_HANDLE ftn,/* IN */
  24                                        CorInfoMethodRuntimeFlags attribs/* IN */)
  25 {
  26     API_ENTER(setMethodAttribs);
  27     wrapHnd->setMethodAttribs(ftn, attribs);
  28     API_LEAVE(setMethodAttribs);
  29 }
  30
  31 void WrapICorJitInfo::getMethodSig(CORINFO_METHOD_HANDLE      ftn,        /* IN  */
  32                                    CORINFO_SIG_INFO          *sig,        /* OUT */
  33                                    CORINFO_CLASS_HANDLE      memberParent/* IN */)
  34 {
  35     API_ENTER(getMethodSig);
  36     wrapHnd->getMethodSig(ftn, sig, memberParent);
  37     API_LEAVE(getMethodSig);
  38 }
  39
  40 bool WrapICorJitInfo::getMethodInfo(
  41             CORINFO_METHOD_HANDLE   ftn,            /* IN  */
  42             CORINFO_METHOD_INFO*    info            /* OUT */)
  43 {
  44     API_ENTER(getMethodInfo);
  45     bool temp = wrapHnd->getMethodInfo(ftn, info);
  46     API_LEAVE(getMethodInfo);
  47     return temp;
  48 }
  49
  50 CorInfoInline WrapICorJitInfo::canInline(
  51             CORINFO_METHOD_HANDLE       callerHnd,                  /* IN  */
  52             CORINFO_METHOD_HANDLE       calleeHnd,                  /* IN  */
  53             DWORD*                      pRestrictions               /* OUT */)
  54 {
  55     API_ENTER(canInline);
  56     CorInfoInline temp = wrapHnd->canInline(callerHnd, calleeHnd, pRestrictions);
  57     API_LEAVE(canInline);
  58     return temp;
  59 }
  60
  61 void WrapICorJitInfo::reportInliningDecision(CORINFO_METHOD_HANDLE inlinerHnd,
  62                                                 CORINFO_METHOD_HANDLE inlineeHnd,
  63                                                 CorInfoInline inlineResult,
  64                                                 const char * reason)
  65 {
  66     API_ENTER(reportInliningDecision);
  67     wrapHnd->reportInliningDecision(inlinerHnd, inlineeHnd, inlineResult, reason);
  68     API_LEAVE(reportInliningDecision);
  69 }
  70
  71 bool WrapICorJitInfo::canTailCall(
  72             CORINFO_METHOD_HANDLE   callerHnd,          /* IN */
  73             CORINFO_METHOD_HANDLE   declaredCalleeHnd,  /* IN */
  74             CORINFO_METHOD_HANDLE   exactCalleeHnd,     /* IN */
  75             bool fIsTailPrefix                          /* IN */)
  76 {
  77     API_ENTER(canTailCall);
  78     bool temp = wrapHnd->canTailCall(callerHnd, declaredCalleeHnd, exactCalleeHnd, fIsTailPrefix);
  79     API_LEAVE(canTailCall);
  80     return temp;
  81 }
  82
  83 void WrapICorJitInfo::reportTailCallDecision(CORINFO_METHOD_HANDLE callerHnd,
  84                                                    CORINFO_METHOD_HANDLE calleeHnd,
  85                                                    bool fIsTailPrefix,
  86                                                    CorInfoTailCall tailCallResult,
  87                                                    const char * reason)
  88 {
  89     API_ENTER(reportTailCallDecision);
  90     wrapHnd->reportTailCallDecision(callerHnd, calleeHnd, fIsTailPrefix, tailCallResult, reason);
  91     API_LEAVE(reportTailCallDecision);
  92 }
  93
  94 void WrapICorJitInfo::getEHinfo(
  95             CORINFO_METHOD_HANDLE ftn,              /* IN  */
  96             unsigned          EHnumber,             /* IN */
  97             CORINFO_EH_CLAUSE* clause               /* OUT */)
  98 {
  99     API_ENTER(getEHinfo);
 100     wrapHnd->getEHinfo(ftn, EHnumber, clause);
 101     API_LEAVE(getEHinfo);
 102 }
 103
 104 CORINFO_CLASS_HANDLE WrapICorJitInfo::getMethodClass(
 105             CORINFO_METHOD_HANDLE       method)
 106 {
 107     API_ENTER(getMethodClass);
 108     CORINFO_CLASS_HANDLE temp = wrapHnd->getMethodClass(method);
 109     API_LEAVE(getMethodClass);
 110     return temp;
 111 }
 112
 113 CORINFO_MODULE_HANDLE WrapICorJitInfo::getMethodModule(
 114             CORINFO_METHOD_HANDLE       method)
 115 {
 116     API_ENTER(getMethodModule);
 117     CORINFO_MODULE_HANDLE temp = wrapHnd->getMethodModule(method);
 118     API_LEAVE(getMethodModule);
 119     return temp;
 120 }
 121
 122 void WrapICorJitInfo::getMethodVTableOffset(
 123             CORINFO_METHOD_HANDLE       method,                 /* IN */
 124             unsigned*                   offsetOfIndirection,    /* OUT */
 125             unsigned*                   offsetAfterIndirection, /* OUT */
 126             bool*                       isRelative              /* OUT */)
 127 {
 128     API_ENTER(getMethodVTableOffset);
 129     wrapHnd->getMethodVTableOffset(method, offsetOfIndirection, offsetAfterIndirection, isRelative);
 130     API_LEAVE(getMethodVTableOffset);
 131 }
 132
 133 CorInfoIntrinsics WrapICorJitInfo::getIntrinsicID(
 134             CORINFO_METHOD_HANDLE       method,
 135             bool*                       pMustExpand             /* OUT */)
 136 {
 137     API_ENTER(getIntrinsicID);
 138     CorInfoIntrinsics temp = wrapHnd->getIntrinsicID(method, pMustExpand);
 139     API_LEAVE(getIntrinsicID);
 140     return temp;
 141 }
 142
 143 bool WrapICorJitInfo::isInSIMDModule(CORINFO_CLASS_HANDLE classHnd)
 144 {
 145     API_ENTER(isInSIMDModule);
 146     bool temp = wrapHnd->isInSIMDModule(classHnd);
 147     API_LEAVE(isInSIMDModule);
 148     return temp;
 149 }
 150
 151 CorInfoUnmanagedCallConv WrapICorJitInfo::getUnmanagedCallConv(
 152             CORINFO_METHOD_HANDLE       method)
 153 {
 154     API_ENTER(getUnmanagedCallConv);
 155     CorInfoUnmanagedCallConv temp = wrapHnd->getUnmanagedCallConv(method);
 156     API_LEAVE(getUnmanagedCallConv);
 157     return temp;
 158 }
 159
 160 BOOL WrapICorJitInfo::pInvokeMarshalingRequired(
 161             CORINFO_METHOD_HANDLE       method,
 162             CORINFO_SIG_INFO*           callSiteSig)
 163 {
 164     API_ENTER(pInvokeMarshalingRequired);
 165     BOOL temp = wrapHnd->pInvokeMarshalingRequired(method, callSiteSig);
 166     API_LEAVE(pInvokeMarshalingRequired);
 167     return temp;
 168 }
 169
 170 BOOL WrapICorJitInfo::satisfiesMethodConstraints(
 171             CORINFO_CLASS_HANDLE        parent, // the exact parent of the method
 172             CORINFO_METHOD_HANDLE       method)
 173 {
 174     API_ENTER(satisfiesMethodConstraints);
 175     BOOL temp = wrapHnd->satisfiesMethodConstraints(parent, method);
 176     API_LEAVE(satisfiesMethodConstraints);
 177     return temp;
 178 }
 179
 180 BOOL WrapICorJitInfo::isCompatibleDelegate(
 181             CORINFO_CLASS_HANDLE        objCls,
 182             CORINFO_CLASS_HANDLE        methodParentCls,
 183             CORINFO_METHOD_HANDLE       method,
 184             CORINFO_CLASS_HANDLE        delegateCls,
 185             BOOL                        *pfIsOpenDelegate)
 186 {
 187     API_ENTER(isCompatibleDelegate);
 188     BOOL temp = wrapHnd->isCompatibleDelegate(objCls, methodParentCls, method, delegateCls, pfIsOpenDelegate);
 189     API_LEAVE(isCompatibleDelegate);
 190     return temp;
 191 }
 192
 193 CorInfoInstantiationVerification WrapICorJitInfo::isInstantiationOfVerifiedGeneric(
 194             CORINFO_METHOD_HANDLE   method /* IN  */)
 195 {
 196     API_ENTER(isInstantiationOfVerifiedGeneric);
 197     CorInfoInstantiationVerification temp = wrapHnd->isInstantiationOfVerifiedGeneric(method);
 198     API_LEAVE(isInstantiationOfVerifiedGeneric);
 199     return temp;
 200 }
 201
 202 void WrapICorJitInfo::initConstraintsForVerification(
 203             CORINFO_METHOD_HANDLE   method, /* IN */
 204             BOOL *pfHasCircularClassConstraints, /* OUT */
 205             BOOL *pfHasCircularMethodConstraint /* OUT */)
 206 {
 207     API_ENTER(initConstraintsForVerification);
 208     wrapHnd->initConstraintsForVerification(method, pfHasCircularClassConstraints, pfHasCircularMethodConstraint);
 209     API_LEAVE(initConstraintsForVerification);
 210 }
 211
 212 CorInfoCanSkipVerificationResult WrapICorJitInfo::canSkipMethodVerification(
 213             CORINFO_METHOD_HANDLE       ftnHandle)
 214 {
 215     API_ENTER(canSkipMethodVerification);
 216     CorInfoCanSkipVerificationResult temp = wrapHnd->canSkipMethodVerification(ftnHandle);
 217     API_LEAVE(canSkipMethodVerification);
 218     return temp;
 219 }
 220
 221 void WrapICorJitInfo::methodMustBeLoadedBeforeCodeIsRun(
 222             CORINFO_METHOD_HANDLE       method)
 223 {
 224     API_ENTER(methodMustBeLoadedBeforeCodeIsRun);
 225     wrapHnd->methodMustBeLoadedBeforeCodeIsRun(method);
 226     API_LEAVE(methodMustBeLoadedBeforeCodeIsRun);
 227 }
 228
 229 CORINFO_METHOD_HANDLE WrapICorJitInfo::mapMethodDeclToMethodImpl(
 230             CORINFO_METHOD_HANDLE       method)
 231 {
 232     API_ENTER(mapMethodDeclToMethodImpl);
 233     CORINFO_METHOD_HANDLE temp = wrapHnd->mapMethodDeclToMethodImpl(method);
 234     API_LEAVE(mapMethodDeclToMethodImpl);
 235     return temp;
 236 }
 237
 238 void WrapICorJitInfo::getGSCookie(
 239             GSCookie * pCookieVal,
 240             GSCookie ** ppCookieVal             )
 241 {
 242     API_ENTER(getGSCookie);
 243     wrapHnd->getGSCookie(pCookieVal, ppCookieVal);
 244     API_LEAVE(getGSCookie);
 245 }
 246
 247 /**********************************************************************************/
 248 //
 249 // ICorModuleInfo
 250 //
 251 /**********************************************************************************/
 252
 253 void WrapICorJitInfo::resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken)
 254 {
 255     API_ENTER(resolveToken);
 256     wrapHnd->resolveToken(pResolvedToken);
 257     API_LEAVE(resolveToken);
 258 }
 259
 260 bool WrapICorJitInfo::tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken)
 261 {
 262     API_ENTER(tryResolveToken);
 263     bool success = wrapHnd->tryResolveToken(pResolvedToken);
 264     API_LEAVE(tryResolveToken);
 265     return success;
 266 }
 267
 268 void WrapICorJitInfo::findSig(
 269             CORINFO_MODULE_HANDLE       module,
 270             unsigned                    sigTOK,
 271             CORINFO_CONTEXT_HANDLE      context,
 272             CORINFO_SIG_INFO           *sig     )
 273 {
 274     API_ENTER(findSig);
 275     wrapHnd->findSig(module, sigTOK, context, sig);
 276     API_LEAVE(findSig);
 277 }
 278
 279 void WrapICorJitInfo::findCallSiteSig(
 280             CORINFO_MODULE_HANDLE       module,     /* IN */
 281             unsigned                    methTOK,    /* IN */
 282             CORINFO_CONTEXT_HANDLE      context,    /* IN */
 283             CORINFO_SIG_INFO           *sig         /* OUT */)
 284 {
 285     API_ENTER(findCallSiteSig);
 286     wrapHnd->findCallSiteSig(module, methTOK, context, sig);
 287     API_LEAVE(findCallSiteSig);
 288 }
 289
 290 CORINFO_CLASS_HANDLE WrapICorJitInfo::getTokenTypeAsHandle(
 291             CORINFO_RESOLVED_TOKEN *    pResolvedToken /* IN  */)
 292 {
 293     API_ENTER(getTokenTypeAsHandle);
 294     CORINFO_CLASS_HANDLE temp = wrapHnd->getTokenTypeAsHandle(pResolvedToken);
 295     API_LEAVE(getTokenTypeAsHandle);
 296     return temp;
 297 }
 298
 299 CorInfoCanSkipVerificationResult WrapICorJitInfo::canSkipVerification(
 300             CORINFO_MODULE_HANDLE       module     /* IN  */)
 301 {
 302     API_ENTER(canSkipVerification);
 303     CorInfoCanSkipVerificationResult temp = wrapHnd->canSkipVerification(module);
 304     API_LEAVE(canSkipVerification);
 305     return temp;
 306 }
 307
 308 BOOL WrapICorJitInfo::isValidToken(
 309             CORINFO_MODULE_HANDLE       module,     /* IN  */
 310             unsigned                    metaTOK     /* IN  */)
 311 {
 312     API_ENTER(isValidToken);
 313     BOOL result = wrapHnd->isValidToken(module, metaTOK);
 314     API_LEAVE(isValidToken);
 315     return result;
 316 }
 317
 318 BOOL WrapICorJitInfo::isValidStringRef(
 319             CORINFO_MODULE_HANDLE       module,     /* IN  */
 320             unsigned                    metaTOK     /* IN  */)
 321 {
 322     API_ENTER(isValidStringRef);
 323     BOOL temp = wrapHnd->isValidStringRef(module, metaTOK);
 324     API_LEAVE(isValidStringRef);
 325     return temp;
 326 }
 327
 328 BOOL WrapICorJitInfo::shouldEnforceCallvirtRestriction(
 329             CORINFO_MODULE_HANDLE   scope)
 330 {
 331     API_ENTER(shouldEnforceCallvirtRestriction);
 332     BOOL temp = wrapHnd->shouldEnforceCallvirtRestriction(scope);
 333     API_LEAVE(shouldEnforceCallvirtRestriction);
 334     return temp;
 335 }
 336
 337 /**********************************************************************************/
 338 //
 339 // ICorClassInfo
 340 //
 341 /**********************************************************************************/
 342
 343 CorInfoType WrapICorJitInfo::asCorInfoType(CORINFO_CLASS_HANDLE    cls)
 344 {
 345     API_ENTER(asCorInfoType);
 346     CorInfoType temp = wrapHnd->asCorInfoType(cls);
 347     API_LEAVE(asCorInfoType);
 348     return temp;
 349 }
 350
 351 const char* WrapICorJitInfo::getClassName(CORINFO_CLASS_HANDLE    cls)
 352 {
 353     API_ENTER(getClassName);
 354     const char* result = wrapHnd->getClassName(cls);
 355     API_LEAVE(getClassName);
 356     return result;
 357 }
 358
 359 const char* WrapICorJitInfo::getClassNameFromMetadata(CORINFO_CLASS_HANDLE cls, const char** namespaceName)
 360 {
 361     API_ENTER(getClassNameFromMetadata);
 362     const char* result = wrapHnd->getClassNameFromMetadata(cls, namespaceName);
 363     API_LEAVE(getClassNameFromMetadata);
 364     return result;
 365 }
 366
 367 CORINFO_CLASS_HANDLE WrapICorJitInfo::getTypeInstantiationArgument(CORINFO_CLASS_HANDLE cls, unsigned index)
 368 {
 369     API_ENTER(getTypeInstantiationArgument);
 370     CORINFO_CLASS_HANDLE result = wrapHnd->getTypeInstantiationArgument(cls, index);
 371     API_LEAVE(getTypeInstantiationArgument);
 372     return result;
 373 }
 374
 375 int WrapICorJitInfo::appendClassName(
 376             __deref_inout_ecount(*pnBufLen) WCHAR** ppBuf,
 377             int* pnBufLen,
 378             CORINFO_CLASS_HANDLE    cls,
 379             BOOL fNamespace,
 380             BOOL fFullInst,
 381             BOOL fAssembly)
 382 {
 383     API_ENTER(appendClassName);
 384     WCHAR* pBuf = *ppBuf;
 385     int nLen = wrapHnd->appendClassName(ppBuf, pnBufLen, cls, fNamespace, fFullInst, fAssembly);
 386     API_LEAVE(appendClassName);
 387     return nLen;
 388 }
 389
 390 BOOL WrapICorJitInfo::isValueClass(CORINFO_CLASS_HANDLE cls)
 391 {
 392     API_ENTER(isValueClass);
 393     BOOL temp = wrapHnd->isValueClass(cls);
 394     API_LEAVE(isValueClass);
 395     return temp;
 396 }
 397
 398 BOOL WrapICorJitInfo::canInlineTypeCheckWithObjectVTable(CORINFO_CLASS_HANDLE cls)
 399 {
 400     API_ENTER(canInlineTypeCheckWithObjectVTable);
 401     BOOL temp = wrapHnd->canInlineTypeCheckWithObjectVTable(cls);
 402     API_LEAVE(canInlineTypeCheckWithObjectVTable);
 403     return temp;
 404 }
 405
 406 DWORD WrapICorJitInfo::getClassAttribs(
 407             CORINFO_CLASS_HANDLE    cls)
 408 {
 409     API_ENTER(getClassAttribs);
 410     DWORD temp = wrapHnd->getClassAttribs(cls);
 411     API_LEAVE(getClassAttribs);
 412     return temp;
 413 }
 414
 415 BOOL WrapICorJitInfo::isStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls)
 416 {
 417     API_ENTER(isStructRequiringStackAllocRetBuf);
 418     BOOL temp = wrapHnd->isStructRequiringStackAllocRetBuf(cls);
 419     API_LEAVE(isStructRequiringStackAllocRetBuf);
 420     return temp;
 421 }
 422
 423 CORINFO_MODULE_HANDLE WrapICorJitInfo::getClassModule(
 424             CORINFO_CLASS_HANDLE    cls)
 425 {
 426     API_ENTER(getClassModule);
 427     CORINFO_MODULE_HANDLE result = wrapHnd->getClassModule(cls);
 428     API_LEAVE(getClassModule);
 429     return result;
 430 }
 431
 432 CORINFO_ASSEMBLY_HANDLE WrapICorJitInfo::getModuleAssembly(
 433             CORINFO_MODULE_HANDLE   mod)
 434 {
 435     API_ENTER(getModuleAssembly);
 436     CORINFO_ASSEMBLY_HANDLE result = wrapHnd->getModuleAssembly(mod);
 437     API_LEAVE(getModuleAssembly);
 438     return result;
 439 }
 440
 441 const char* WrapICorJitInfo::getAssemblyName(
 442             CORINFO_ASSEMBLY_HANDLE assem)
 443 {
 444     API_ENTER(getAssemblyName);
 445     const char* result = wrapHnd->getAssemblyName(assem);
 446     API_LEAVE(getAssemblyName);
 447     return result;
 448 }
 449
 450 void* WrapICorJitInfo::LongLifetimeMalloc(size_t sz)
 451 {
 452     API_ENTER(LongLifetimeMalloc);
 453     void* result = wrapHnd->LongLifetimeMalloc(sz);
 454     API_LEAVE(LongLifetimeMalloc);
 455     return result;
 456 }
 457
 458 void WrapICorJitInfo::LongLifetimeFree(void* obj)
 459 {
 460     API_ENTER(LongLifetimeFree);
 461     wrapHnd->LongLifetimeFree(obj);
 462     API_LEAVE(LongLifetimeFree);
 463 }
 464
 465 size_t WrapICorJitInfo::getClassModuleIdForStatics(
 466         CORINFO_CLASS_HANDLE    cls,
 467         CORINFO_MODULE_HANDLE *pModule,
 468         void **ppIndirection)
 469 {
 470     API_ENTER(getClassModuleIdForStatics);
 471     size_t temp = wrapHnd->getClassModuleIdForStatics(cls, pModule, ppIndirection);
 472     API_LEAVE(getClassModuleIdForStatics);
 473     return temp;
 474 }
 475
 476 unsigned WrapICorJitInfo::getClassSize(CORINFO_CLASS_HANDLE        cls)
 477 {
 478     API_ENTER(getClassSize);
 479     unsigned temp = wrapHnd->getClassSize(cls);
 480     API_LEAVE(getClassSize);
 481     return temp;
 482 }
 483
 484 unsigned WrapICorJitInfo::getClassAlignmentRequirement(
 485             CORINFO_CLASS_HANDLE        cls,
 486             BOOL                        fDoubleAlignHint)
 487 {
 488     API_ENTER(getClassAlignmentRequirement);
 489     unsigned temp = wrapHnd->getClassAlignmentRequirement(cls, fDoubleAlignHint);
 490     API_LEAVE(getClassAlignmentRequirement);
 491     return temp;
 492 }
 493
 494 unsigned WrapICorJitInfo::getClassGClayout(
 495             CORINFO_CLASS_HANDLE        cls,        /* IN */
 496             BYTE                       *gcPtrs      /* OUT */)
 497 {
 498     API_ENTER(getClassGClayout);
 499     unsigned temp = wrapHnd->getClassGClayout(cls, gcPtrs);
 500     API_LEAVE(getClassGClayout);
 501     return temp;
 502 }
 503
 504 unsigned WrapICorJitInfo::getClassNumInstanceFields(
 505             CORINFO_CLASS_HANDLE        cls        /* IN */)
 506 {
 507     API_ENTER(getClassNumInstanceFields);
 508     unsigned temp = wrapHnd->getClassNumInstanceFields(cls);
 509     API_LEAVE(getClassNumInstanceFields);
 510     return temp;
 511 }
 512
 513 CORINFO_FIELD_HANDLE WrapICorJitInfo::getFieldInClass(
 514             CORINFO_CLASS_HANDLE clsHnd,
 515             INT num)
 516 {
 517     API_ENTER(getFieldInClass);
 518     CORINFO_FIELD_HANDLE temp = wrapHnd->getFieldInClass(clsHnd, num);
 519     API_LEAVE(getFieldInClass);
 520     return temp;
 521 }
 522
 523 BOOL WrapICorJitInfo::checkMethodModifier(
 524             CORINFO_METHOD_HANDLE hMethod,
 525             LPCSTR modifier,
 526             BOOL fOptional)
 527 {
 528     API_ENTER(checkMethodModifier);
 529     BOOL result = wrapHnd->checkMethodModifier(hMethod, modifier, fOptional);
 530     API_LEAVE(checkMethodModifier);
 531     return result;
 532 }
 533
 534 CorInfoHelpFunc WrapICorJitInfo::getNewHelper(
 535             CORINFO_RESOLVED_TOKEN * pResolvedToken,
 536             CORINFO_METHOD_HANDLE    callerHandle)
 537 {
 538     API_ENTER(getNewHelper);
 539     CorInfoHelpFunc temp = wrapHnd->getNewHelper(pResolvedToken, callerHandle);
 540     API_LEAVE(getNewHelper);
 541     return temp;
 542 }
 543
 544 CorInfoHelpFunc WrapICorJitInfo::getNewArrHelper(
 545             CORINFO_CLASS_HANDLE        arrayCls)
 546 {
 547     API_ENTER(getNewArrHelper);
 548     CorInfoHelpFunc temp = wrapHnd->getNewArrHelper(arrayCls);
 549     API_LEAVE(getNewArrHelper);
 550     return temp;
 551 }
 552
 553 CorInfoHelpFunc WrapICorJitInfo::getCastingHelper(
 554             CORINFO_RESOLVED_TOKEN * pResolvedToken,
 555             bool fThrowing)
 556 {
 557     API_ENTER(getCastingHelper);
 558     CorInfoHelpFunc temp = wrapHnd->getCastingHelper(pResolvedToken, fThrowing);
 559     API_LEAVE(getCastingHelper);
 560     return temp;
 561 }
 562
 563 CorInfoHelpFunc WrapICorJitInfo::getSharedCCtorHelper(
 564             CORINFO_CLASS_HANDLE clsHnd)
 565 {
 566     API_ENTER(getSharedCCtorHelper);
 567     CorInfoHelpFunc temp = wrapHnd->getSharedCCtorHelper(clsHnd);
 568     API_LEAVE(getSharedCCtorHelper);
 569     return temp;
 570 }
 571
 572 CorInfoHelpFunc WrapICorJitInfo::getSecurityPrologHelper(
 573             CORINFO_METHOD_HANDLE   ftn)
 574 {
 575     API_ENTER(getSecurityPrologHelper);
 576     CorInfoHelpFunc temp = wrapHnd->getSecurityPrologHelper(ftn);
 577     API_LEAVE(getSecurityPrologHelper);
 578     return temp;
 579 }
 580
 581 CORINFO_CLASS_HANDLE  WrapICorJitInfo::getTypeForBox(
 582             CORINFO_CLASS_HANDLE        cls)
 583 {
 584     API_ENTER(getTypeForBox);
 585     CORINFO_CLASS_HANDLE temp = wrapHnd->getTypeForBox(cls);
 586     API_LEAVE(getTypeForBox);
 587     return temp;
 588 }
 589
 590 CorInfoHelpFunc WrapICorJitInfo::getBoxHelper(
 591             CORINFO_CLASS_HANDLE        cls)
 592 {
 593     API_ENTER(getBoxHelper);
 594     CorInfoHelpFunc temp = wrapHnd->getBoxHelper(cls);
 595     API_LEAVE(getBoxHelper);
 596     return temp;
 597 }
 598
 599 CorInfoHelpFunc WrapICorJitInfo::getUnBoxHelper(
 600             CORINFO_CLASS_HANDLE        cls)
 601 {
 602     API_ENTER(getUnBoxHelper);
 603     CorInfoHelpFunc temp = wrapHnd->getUnBoxHelper(cls);
 604     API_LEAVE(getUnBoxHelper);
 605     return temp;
 606 }
 607
 608 bool WrapICorJitInfo::getReadyToRunHelper(
 609             CORINFO_RESOLVED_TOKEN * pResolvedToken,
 610             CORINFO_LOOKUP_KIND *    pGenericLookupKind,
 611             CorInfoHelpFunc          id,
 612             CORINFO_CONST_LOOKUP *   pLookup)
 613 {
 614     API_ENTER(getReadyToRunHelper);
 615     bool result = wrapHnd->getReadyToRunHelper(pResolvedToken, pGenericLookupKind, id, pLookup);
 616     API_LEAVE(getReadyToRunHelper);
 617     return result;
 618 }
 619
 620 void WrapICorJitInfo::getReadyToRunDelegateCtorHelper(
 621     CORINFO_RESOLVED_TOKEN * pTargetMethod,
 622     CORINFO_CLASS_HANDLE     delegateType,
 623     CORINFO_LOOKUP *   pLookup)
 624 {
 625     API_ENTER(getReadyToRunDelegateCtorHelper);
 626     wrapHnd->getReadyToRunDelegateCtorHelper(pTargetMethod, delegateType, pLookup);
 627     API_LEAVE(getReadyToRunDelegateCtorHelper);
 628 }
 629
 630 const char* WrapICorJitInfo::getHelperName(
 631             CorInfoHelpFunc funcNum)
 632 {
 633     API_ENTER(getHelperName);
 634     const char* temp = wrapHnd->getHelperName(funcNum);
 635     API_LEAVE(getHelperName);
 636     return temp;
 637 }
 638
 639 CorInfoInitClassResult WrapICorJitInfo::initClass(
 640             CORINFO_FIELD_HANDLE    field,
 641
 642             CORINFO_METHOD_HANDLE   method,
 643             CORINFO_CONTEXT_HANDLE  context,
 644             BOOL                    speculative)
 645 {
 646     API_ENTER(initClass);
 647     CorInfoInitClassResult temp = wrapHnd->initClass(field, method, context, speculative);
 648     API_LEAVE(initClass);
 649     return temp;
 650 }
 651
 652 void WrapICorJitInfo::classMustBeLoadedBeforeCodeIsRun(
 653             CORINFO_CLASS_HANDLE        cls)
 654 {
 655     API_ENTER(classMustBeLoadedBeforeCodeIsRun);
 656     wrapHnd->classMustBeLoadedBeforeCodeIsRun(cls);
 657     API_LEAVE(classMustBeLoadedBeforeCodeIsRun);
 658 }
 659
 660 CORINFO_CLASS_HANDLE WrapICorJitInfo::getBuiltinClass(
 661             CorInfoClassId              classId)
 662 {
 663     API_ENTER(getBuiltinClass);
 664     CORINFO_CLASS_HANDLE temp = wrapHnd->getBuiltinClass(classId);
 665     API_LEAVE(getBuiltinClass);
 666     return temp;
 667 }
 668
 669 CorInfoType WrapICorJitInfo::getTypeForPrimitiveValueClass(
 670             CORINFO_CLASS_HANDLE        cls)
 671 {
 672     API_ENTER(getTypeForPrimitiveValueClass);
 673     CorInfoType temp = wrapHnd->getTypeForPrimitiveValueClass(cls);
 674     API_LEAVE(getTypeForPrimitiveValueClass);
 675     return temp;
 676 }
 677
 678 CorInfoType WrapICorJitInfo::getTypeForPrimitiveNumericClass(
 679             CORINFO_CLASS_HANDLE        cls)
 680 {
 681     API_ENTER(getTypeForPrimitiveNumericClass);
 682     CorInfoType temp = wrapHnd->getTypeForPrimitiveNumericClass(cls);
 683     API_LEAVE(getTypeForPrimitiveNumericClass);
 684     return temp;
 685 }
 686
 687 BOOL WrapICorJitInfo::canCast(
 688             CORINFO_CLASS_HANDLE        child,
 689             CORINFO_CLASS_HANDLE        parent  )
 690 {
 691     API_ENTER(canCast);
 692     BOOL temp = wrapHnd->canCast(child, parent);
 693     API_LEAVE(canCast);
 694     return temp;
 695 }
 696
 697 BOOL WrapICorJitInfo::areTypesEquivalent(
 698             CORINFO_CLASS_HANDLE        cls1,
 699             CORINFO_CLASS_HANDLE        cls2)
 700 {
 701     API_ENTER(areTypesEquivalent);
 702     BOOL temp = wrapHnd->areTypesEquivalent(cls1, cls2);
 703     API_LEAVE(areTypesEquivalent);
 704     return temp;
 705 }
 706
 707 CORINFO_CLASS_HANDLE WrapICorJitInfo::mergeClasses(
 708             CORINFO_CLASS_HANDLE        cls1,
 709             CORINFO_CLASS_HANDLE        cls2)
 710 {
 711     API_ENTER(mergeClasses);
 712     CORINFO_CLASS_HANDLE temp = wrapHnd->mergeClasses(cls1, cls2);
 713     API_LEAVE(mergeClasses);
 714     return temp;
 715 }
 716
 717 CORINFO_CLASS_HANDLE WrapICorJitInfo::getParentType(
 718             CORINFO_CLASS_HANDLE        cls)
 719 {
 720     API_ENTER(getParentType);
 721     CORINFO_CLASS_HANDLE temp = wrapHnd->getParentType(cls);
 722     API_LEAVE(getParentType);
 723     return temp;
 724 }
 725
 726 CorInfoType WrapICorJitInfo::getChildType(
 727             CORINFO_CLASS_HANDLE       clsHnd,
 728             CORINFO_CLASS_HANDLE       *clsRet)
 729 {
 730     API_ENTER(getChildType);
 731     CorInfoType temp = wrapHnd->getChildType(clsHnd, clsRet);
 732     API_LEAVE(getChildType);
 733     return temp;
 734 }
 735
 736 BOOL WrapICorJitInfo::satisfiesClassConstraints(
 737             CORINFO_CLASS_HANDLE cls)
 738 {
 739     API_ENTER(satisfiesClassConstraints);
 740     BOOL temp = wrapHnd->satisfiesClassConstraints(cls);
 741     API_LEAVE(satisfiesClassConstraints);
 742     return temp;
 743
 744 }
 745
 746 BOOL WrapICorJitInfo::isSDArray(
 747             CORINFO_CLASS_HANDLE        cls)
 748 {
 749     API_ENTER(isSDArray);
 750     BOOL temp = wrapHnd->isSDArray(cls);
 751     API_LEAVE(isSDArray);
 752     return temp;
 753 }
 754
 755 unsigned WrapICorJitInfo::getArrayRank(
 756         CORINFO_CLASS_HANDLE        cls)
 757 {
 758     API_ENTER(getArrayRank);
 759     unsigned result = wrapHnd->getArrayRank(cls);
 760     API_LEAVE(getArrayRank);
 761     return result;
 762 }
 763
 764 void * WrapICorJitInfo::getArrayInitializationData(
 765         CORINFO_FIELD_HANDLE        field,
 766         DWORD                       size)
 767 {
 768     API_ENTER(getArrayInitializationData);
 769     void *temp = wrapHnd->getArrayInitializationData(field, size);
 770     API_LEAVE(getArrayInitializationData);
 771     return temp;
 772 }
 773
 774 CorInfoIsAccessAllowedResult WrapICorJitInfo::canAccessClass(
 775                     CORINFO_RESOLVED_TOKEN * pResolvedToken,
 776                     CORINFO_METHOD_HANDLE   callerHandle,
 777                     CORINFO_HELPER_DESC    *pAccessHelper)
 778 {
 779     API_ENTER(canAccessClass);
 780     CorInfoIsAccessAllowedResult temp = wrapHnd->canAccessClass(pResolvedToken, callerHandle, pAccessHelper);
 781     API_LEAVE(canAccessClass);
 782     return temp;
 783 }
 784
 785 /**********************************************************************************/
 786 //
 787 // ICorFieldInfo
 788 //
 789 /**********************************************************************************/
 790
 791 const char* WrapICorJitInfo::getFieldName(
 792                     CORINFO_FIELD_HANDLE        ftn,        /* IN */
 793                     const char                **moduleName  /* OUT */)
 794 {
 795     API_ENTER(getFieldName);
 796     const char* temp = wrapHnd->getFieldName(ftn, moduleName);
 797     API_LEAVE(getFieldName);
 798     return temp;
 799 }
 800
 801 CORINFO_CLASS_HANDLE WrapICorJitInfo::getFieldClass(
 802                     CORINFO_FIELD_HANDLE    field)
 803 {
 804     API_ENTER(getFieldClass);
 805     CORINFO_CLASS_HANDLE temp = wrapHnd->getFieldClass(field);
 806     API_LEAVE(getFieldClass);
 807     return temp;
 808 }
 809
 810 CorInfoType WrapICorJitInfo::getFieldType(
 811                         CORINFO_FIELD_HANDLE    field,
 812                         CORINFO_CLASS_HANDLE   *structType,
 813                         CORINFO_CLASS_HANDLE    memberParent/* IN */)
 814 {
 815     API_ENTER(getFieldType);
 816     CorInfoType temp = wrapHnd->getFieldType(field, structType, memberParent);
 817     API_LEAVE(getFieldType);
 818     return temp;
 819 }
 820
 821 unsigned WrapICorJitInfo::getFieldOffset(
 822                     CORINFO_FIELD_HANDLE    field)
 823 {
 824     API_ENTER(getFieldOffset);
 825     unsigned temp = wrapHnd->getFieldOffset(field);
 826     API_LEAVE(getFieldOffset);
 827     return temp;
 828 }
 829
 830 bool WrapICorJitInfo::isWriteBarrierHelperRequired(
 831                     CORINFO_FIELD_HANDLE    field)
 832 {
 833     API_ENTER(isWriteBarrierHelperRequired);
 834     bool result = wrapHnd->isWriteBarrierHelperRequired(field);
 835     API_LEAVE(isWriteBarrierHelperRequired);
 836     return result;
 837 }
 838
 839 void WrapICorJitInfo::getFieldInfo(CORINFO_RESOLVED_TOKEN * pResolvedToken,
 840                             CORINFO_METHOD_HANDLE  callerHandle,
 841                             CORINFO_ACCESS_FLAGS   flags,
 842                             CORINFO_FIELD_INFO    *pResult)
 843 {
 844     API_ENTER(getFieldInfo);
 845     wrapHnd->getFieldInfo(pResolvedToken, callerHandle, flags, pResult);
 846     API_LEAVE(getFieldInfo);
 847 }
 848
 849 bool WrapICorJitInfo::isFieldStatic(CORINFO_FIELD_HANDLE fldHnd)
 850 {
 851     API_ENTER(isFieldStatic);
 852     bool result = wrapHnd->isFieldStatic(fldHnd);
 853     API_LEAVE(isFieldStatic);
 854     return result;
 855 }
 856
 857 /*********************************************************************************/
 858 //
 859 // ICorDebugInfo
 860 //
 861 /*********************************************************************************/
 862
 863 void WrapICorJitInfo::getBoundaries(
 864             CORINFO_METHOD_HANDLE   ftn,
 865             unsigned int           *cILOffsets,
 866             DWORD                 **pILOffsets,
 867
 868             ICorDebugInfo::BoundaryTypes *implictBoundaries)
 869 {
 870     API_ENTER(getBoundaries);
 871     wrapHnd->getBoundaries(ftn, cILOffsets, pILOffsets, implictBoundaries);
 872     API_LEAVE(getBoundaries);
 873 }
 874
 875 void WrapICorJitInfo::setBoundaries(
 876             CORINFO_METHOD_HANDLE   ftn,
 877             ULONG32                 cMap,
 878             ICorDebugInfo::OffsetMapping *pMap)
 879 {
 880     API_ENTER(setBoundaries);
 881     wrapHnd->setBoundaries(ftn, cMap, pMap);
 882     API_LEAVE(setBoundaries);
 883 }
 884
 885 void WrapICorJitInfo::getVars(
 886         CORINFO_METHOD_HANDLE           ftn,
 887         ULONG32                        *cVars,
 888         ICorDebugInfo::ILVarInfo       **vars,
 889         bool                           *extendOthers)
 890
 891 {
 892     API_ENTER(getVars);
 893     wrapHnd->getVars(ftn, cVars, vars, extendOthers);
 894     API_LEAVE(getVars);
 895 }
 896
 897 void WrapICorJitInfo::setVars(
 898         CORINFO_METHOD_HANDLE           ftn,
 899         ULONG32                         cVars,
 900         ICorDebugInfo::NativeVarInfo   *vars)
 901
 902 {
 903     API_ENTER(setVars);
 904     wrapHnd->setVars(ftn, cVars, vars);
 905     API_LEAVE(setVars);
 906 }
 907
 908 void * WrapICorJitInfo::allocateArray(
 909                     ULONG              cBytes)
 910 {
 911     API_ENTER(allocateArray);
 912     void *temp = wrapHnd->allocateArray(cBytes);
 913     API_LEAVE(allocateArray);
 914     return temp;
 915 }
 916
 917 void WrapICorJitInfo::freeArray(
 918         void               *array)
 919 {
 920     API_ENTER(freeArray);
 921     wrapHnd->freeArray(array);
 922     API_LEAVE(freeArray);
 923 }
 924
 925 /*********************************************************************************/
 926 //
 927 // ICorArgInfo
 928 //
 929 /*********************************************************************************/
 930
 931 CORINFO_ARG_LIST_HANDLE WrapICorJitInfo::getArgNext(
 932         CORINFO_ARG_LIST_HANDLE     args            /* IN */)
 933 {
 934     API_ENTER(getArgNext);
 935     CORINFO_ARG_LIST_HANDLE temp = wrapHnd->getArgNext(args);
 936     API_LEAVE(getArgNext);
 937     return temp;
 938 }
 939
 940 CorInfoTypeWithMod WrapICorJitInfo::getArgType(
 941         CORINFO_SIG_INFO*           sig,            /* IN */
 942         CORINFO_ARG_LIST_HANDLE     args,           /* IN */
 943         CORINFO_CLASS_HANDLE       *vcTypeRet       /* OUT */)
 944 {
 945     API_ENTER(getArgType);
 946     CorInfoTypeWithMod temp = wrapHnd->getArgType(sig, args, vcTypeRet);
 947     API_LEAVE(getArgType);
 948     return temp;
 949 }
 950
 951 CORINFO_CLASS_HANDLE WrapICorJitInfo::getArgClass(
 952         CORINFO_SIG_INFO*           sig,            /* IN */
 953         CORINFO_ARG_LIST_HANDLE     args            /* IN */)
 954 {
 955     API_ENTER(getArgClass);
 956     CORINFO_CLASS_HANDLE temp = wrapHnd->getArgClass(sig, args);
 957     API_LEAVE(getArgClass);
 958     return temp;
 959 }
 960
 961 CorInfoType WrapICorJitInfo::getHFAType(
 962         CORINFO_CLASS_HANDLE hClass)
 963 {
 964     API_ENTER(getHFAType);
 965     CorInfoType temp = wrapHnd->getHFAType(hClass);
 966     API_LEAVE(getHFAType);
 967     return temp;
 968 }
 969
 970 HRESULT WrapICorJitInfo::GetErrorHRESULT(
 971         struct _EXCEPTION_POINTERS *pExceptionPointers)
 972 {
 973     API_ENTER(GetErrorHRESULT);
 974     HRESULT temp = wrapHnd->GetErrorHRESULT(pExceptionPointers);
 975     API_LEAVE(GetErrorHRESULT);
 976     return temp;
 977 }
 978
 979 ULONG WrapICorJitInfo::GetErrorMessage(
 980         __inout_ecount(bufferLength) LPWSTR buffer,
 981         ULONG bufferLength)
 982 {
 983     API_ENTER(GetErrorMessage);
 984     ULONG temp = wrapHnd->GetErrorMessage(buffer, bufferLength);
 985     API_LEAVE(GetErrorMessage);
 986     return temp;
 987 }
 988
 989 int WrapICorJitInfo::FilterException(
 990         struct _EXCEPTION_POINTERS *pExceptionPointers)
 991 {
 992     API_ENTER(FilterException);
 993     int temp = wrapHnd->FilterException(pExceptionPointers);
 994     API_LEAVE(FilterException);
 995     return temp;
 996 }
 997
 998 void WrapICorJitInfo::HandleException(
 999         struct _EXCEPTION_POINTERS *pExceptionPointers)
1000 {
1001     API_ENTER(HandleException);
1002     wrapHnd->HandleException(pExceptionPointers);
1003     API_LEAVE(HandleException);
1004 }
1005
1006 void WrapICorJitInfo::ThrowExceptionForJitResult(
1007         HRESULT result)
1008 {
1009     API_ENTER(ThrowExceptionForJitResult);
1010     wrapHnd->ThrowExceptionForJitResult(result);
1011     API_LEAVE(ThrowExceptionForJitResult);
1012 }
1013
1014 void WrapICorJitInfo::ThrowExceptionForHelper(
1015         const CORINFO_HELPER_DESC * throwHelper)
1016 {
1017     API_ENTER(ThrowExceptionForHelper);
1018     wrapHnd->ThrowExceptionForHelper(throwHelper);
1019     API_LEAVE(ThrowExceptionForHelper);
1020 }
1021
1022 void WrapICorJitInfo::getEEInfo(
1023             CORINFO_EE_INFO            *pEEInfoOut)
1024 {
1025     API_ENTER(getEEInfo);
1026     wrapHnd->getEEInfo(pEEInfoOut);
1027     API_LEAVE(getEEInfo);
1028 }
1029
1030 LPCWSTR WrapICorJitInfo::getJitTimeLogFilename()
1031 {
1032     API_ENTER(getJitTimeLogFilename);
1033     LPCWSTR temp = wrapHnd->getJitTimeLogFilename();
1034     API_LEAVE(getJitTimeLogFilename);
1035     return temp;
1036 }
1037
1038 mdMethodDef WrapICorJitInfo::getMethodDefFromMethod(
1039         CORINFO_METHOD_HANDLE hMethod)
1040 {
1041     API_ENTER(getMethodDefFromMethod);
1042     mdMethodDef result = wrapHnd->getMethodDefFromMethod(hMethod);
1043     API_LEAVE(getMethodDefFromMethod);
1044     return result;
1045 }
1046
1047 const char* WrapICorJitInfo::getMethodName(
1048         CORINFO_METHOD_HANDLE       ftn,        /* IN */
1049         const char                **moduleName  /* OUT */)
1050 {
1051     API_ENTER(getMethodName);
1052     const char* temp = wrapHnd->getMethodName(ftn, moduleName);
1053     API_LEAVE(getMethodName);
1054     return temp;
1055 }
1056
1057 const char* WrapICorJitInfo::getMethodNameFromMetadata(
1058         CORINFO_METHOD_HANDLE       ftn,           /* IN */
1059         const char                **className,     /* OUT */
1060         const char                **namespaceName  /* OUT */)
1061 {
1062     API_ENTER(getMethodNameFromMetadata);
1063     const char* temp = wrapHnd->getMethodNameFromMetaData(ftn, moduleName, namespaceName);
1064     API_LEAVE(getMethodNameFromMetadata);
1065     return temp;
1066 }
1067
1068 unsigned WrapICorJitInfo::getMethodHash(
1069         CORINFO_METHOD_HANDLE       ftn         /* IN */)
1070 {
1071     API_ENTER(getMethodHash);
1072     unsigned temp = wrapHnd->getMethodHash(ftn);
1073     API_LEAVE(getMethodHash);
1074     return temp;
1075 }
1076
1077 size_t WrapICorJitInfo::findNameOfToken(
1078         CORINFO_MODULE_HANDLE       module,     /* IN  */
1079         mdToken                     metaTOK,     /* IN  */
1080         __out_ecount(FQNameCapacity) char * szFQName, /* OUT */
1081         size_t FQNameCapacity  /* IN */)
1082 {
1083     API_ENTER(findNameOfToken);
1084     size_t result = wrapHnd->findNameOfToken(module, metaTOK, szFQName, FQNameCapacity);
1085     API_LEAVE(findNameOfToken);
1086     return result;
1087 }
1088
1089 bool WrapICorJitInfo::getSystemVAmd64PassStructInRegisterDescriptor(
1090         /* IN */    CORINFO_CLASS_HANDLE        structHnd,
1091         /* OUT */   SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr)
1092 {
1093     API_ENTER(getSystemVAmd64PassStructInRegisterDescriptor);
1094     bool result = wrapHnd->getSystemVAmd64PassStructInRegisterDescriptor(structHnd, structPassInRegDescPtr);
1095     API_LEAVE(getSystemVAmd64PassStructInRegisterDescriptor);
1096     return result;
1097 }
1098
1099 DWORD WrapICorJitInfo::getThreadTLSIndex(
1100                 void                  **ppIndirection)
1101 {
1102     API_ENTER(getThreadTLSIndex);
1103     DWORD temp = wrapHnd->getThreadTLSIndex(ppIndirection);
1104     API_LEAVE(getThreadTLSIndex);
1105     return temp;
1106 }
1107
1108 const void * WrapICorJitInfo::getInlinedCallFrameVptr(
1109                 void                  **ppIndirection)
1110 {
1111     API_ENTER(getInlinedCallFrameVptr);
1112     const void* temp = wrapHnd->getInlinedCallFrameVptr(ppIndirection);
1113     API_LEAVE(getInlinedCallFrameVptr);
1114     return temp;
1115 }
1116
1117 LONG * WrapICorJitInfo::getAddrOfCaptureThreadGlobal(
1118                 void                  **ppIndirection)
1119 {
1120     API_ENTER(getAddrOfCaptureThreadGlobal);
1121     LONG * temp = wrapHnd->getAddrOfCaptureThreadGlobal(ppIndirection);
1122     API_LEAVE(getAddrOfCaptureThreadGlobal);
1123     return temp;
1124 }
1125
1126 void* WrapICorJitInfo::getHelperFtn(
1127                 CorInfoHelpFunc         ftnNum,
1128                 void                  **ppIndirection)
1129 {
1130     API_ENTER(getHelperFtn);
1131     void *temp = wrapHnd->getHelperFtn(ftnNum, ppIndirection);
1132     API_LEAVE(getHelperFtn);
1133     return temp;
1134 }
1135
1136 void WrapICorJitInfo::getFunctionEntryPoint(
1137                             CORINFO_METHOD_HANDLE   ftn,                 /* IN  */
1138                             CORINFO_CONST_LOOKUP *  pResult,             /* OUT */
1139                             CORINFO_ACCESS_FLAGS    accessFlags)
1140 {
1141     API_ENTER(getFunctionEntryPoint);
1142     wrapHnd->getFunctionEntryPoint(ftn, pResult, accessFlags);
1143     API_LEAVE(getFunctionEntryPoint);
1144 }
1145
1146 void WrapICorJitInfo::getFunctionFixedEntryPoint(
1147                             CORINFO_METHOD_HANDLE   ftn,
1148                             CORINFO_CONST_LOOKUP *  pResult)
1149 {
1150     API_ENTER(getFunctionFixedEntryPoint);
1151     wrapHnd->getFunctionFixedEntryPoint(ftn, pResult);
1152     API_LEAVE(getFunctionFixedEntryPoint);
1153 }
1154
1155 void* WrapICorJitInfo::getMethodSync(
1156                 CORINFO_METHOD_HANDLE               ftn,
1157                 void                  **ppIndirection)
1158 {
1159     API_ENTER(getMethodSync);
1160     void *temp = wrapHnd->getMethodSync(ftn, ppIndirection);
1161     API_LEAVE(getMethodSync);
1162     return temp;
1163 }
1164
1165
1166 CorInfoHelpFunc WrapICorJitInfo::getLazyStringLiteralHelper(
1167     CORINFO_MODULE_HANDLE   handle)
1168 {
1169     API_ENTER(getLazyStringLiteralHelper);
1170     CorInfoHelpFunc temp = wrapHnd->getLazyStringLiteralHelper(handle);
1171     API_LEAVE(getLazyStringLiteralHelper);
1172     return temp;
1173 }
1174
1175 CORINFO_MODULE_HANDLE WrapICorJitInfo::embedModuleHandle(
1176                 CORINFO_MODULE_HANDLE   handle,
1177                 void                  **ppIndirection)
1178 {
1179     API_ENTER(embedModuleHandle);
1180     CORINFO_MODULE_HANDLE temp = wrapHnd->embedModuleHandle(handle, ppIndirection);
1181     API_LEAVE(embedModuleHandle);
1182     return temp;
1183 }
1184
1185 CORINFO_CLASS_HANDLE WrapICorJitInfo::embedClassHandle(
1186                 CORINFO_CLASS_HANDLE    handle,
1187                 void                  **ppIndirection)
1188 {
1189     API_ENTER(embedClassHandle);
1190     CORINFO_CLASS_HANDLE temp = wrapHnd->embedClassHandle(handle, ppIndirection);
1191     API_LEAVE(embedClassHandle);
1192     return temp;
1193 }
1194
1195 CORINFO_METHOD_HANDLE WrapICorJitInfo::embedMethodHandle(
1196                 CORINFO_METHOD_HANDLE   handle,
1197                 void                  **ppIndirection)
1198 {
1199     API_ENTER(embedMethodHandle);
1200     CORINFO_METHOD_HANDLE temp = wrapHnd->embedMethodHandle(handle, ppIndirection);
1201     API_LEAVE(embedMethodHandle);
1202     return temp;
1203 }
1204
1205 CORINFO_FIELD_HANDLE WrapICorJitInfo::embedFieldHandle(
1206                 CORINFO_FIELD_HANDLE    handle,
1207                 void                  **ppIndirection)
1208 {
1209     API_ENTER(embedFieldHandle);
1210     CORINFO_FIELD_HANDLE temp = wrapHnd->embedFieldHandle(handle, ppIndirection);
1211     API_LEAVE(embedFieldHandle);
1212     return temp;
1213 }
1214
1215 void WrapICorJitInfo::embedGenericHandle(
1216                     CORINFO_RESOLVED_TOKEN *        pResolvedToken,
1217                     BOOL                            fEmbedParent,
1218                     CORINFO_GENERICHANDLE_RESULT *  pResult)
1219 {
1220     API_ENTER(embedGenericHandle);
1221     wrapHnd->embedGenericHandle(pResolvedToken, fEmbedParent, pResult);
1222     API_LEAVE(embedGenericHandle);
1223 }
1224
1225 CORINFO_LOOKUP_KIND WrapICorJitInfo::getLocationOfThisType(
1226                 CORINFO_METHOD_HANDLE context)
1227 {
1228     API_ENTER(getLocationOfThisType);
1229     CORINFO_LOOKUP_KIND temp = wrapHnd->getLocationOfThisType(context);
1230     API_LEAVE(getLocationOfThisType);
1231     return temp;
1232 }
1233
1234 void* WrapICorJitInfo::getPInvokeUnmanagedTarget(
1235                 CORINFO_METHOD_HANDLE   method,
1236                 void                  **ppIndirection)
1237 {
1238     API_ENTER(getPInvokeUnmanagedTarget);
1239     void *result = wrapHnd->getPInvokeUnmanagedTarget(method, ppIndirection);
1240     API_LEAVE(getPInvokeUnmanagedTarget);
1241     return result;
1242 }
1243
1244 void* WrapICorJitInfo::getAddressOfPInvokeFixup(
1245                 CORINFO_METHOD_HANDLE   method,
1246                 void                  **ppIndirection)
1247 {
1248     API_ENTER(getAddressOfPInvokeFixup);
1249     void *temp = wrapHnd->getAddressOfPInvokeFixup(method, ppIndirection);
1250     API_LEAVE(getAddressOfPInvokeFixup);
1251     return temp;
1252 }
1253
1254 void WrapICorJitInfo::getAddressOfPInvokeTarget(
1255                 CORINFO_METHOD_HANDLE   method,
1256                 CORINFO_CONST_LOOKUP   *pLookup)
1257 {
1258     API_ENTER(getAddressOfPInvokeTarget);
1259     wrapHnd->getAddressOfPInvokeTarget(method, pLookup);
1260     API_LEAVE(getAddressOfPInvokeTarget);
1261 }
1262
1263 LPVOID WrapICorJitInfo::GetCookieForPInvokeCalliSig(
1264         CORINFO_SIG_INFO* szMetaSig,
1265         void           ** ppIndirection)
1266 {
1267     API_ENTER(GetCookieForPInvokeCalliSig);
1268     LPVOID temp = wrapHnd->GetCookieForPInvokeCalliSig(szMetaSig, ppIndirection);
1269     API_LEAVE(GetCookieForPInvokeCalliSig);
1270     return temp;
1271 }
1272
1273 bool WrapICorJitInfo::canGetCookieForPInvokeCalliSig(
1274                 CORINFO_SIG_INFO* szMetaSig)
1275 {
1276     API_ENTER(canGetCookieForPInvokeCalliSig);
1277     bool temp = wrapHnd->canGetCookieForPInvokeCalliSig(szMetaSig);
1278     API_LEAVE(canGetCookieForPInvokeCalliSig);
1279     return temp;
1280 }
1281
1282 CORINFO_JUST_MY_CODE_HANDLE WrapICorJitInfo::getJustMyCodeHandle(
1283                 CORINFO_METHOD_HANDLE       method,
1284                 CORINFO_JUST_MY_CODE_HANDLE**ppIndirection)
1285 {
1286     API_ENTER(getJustMyCodeHandle);
1287     CORINFO_JUST_MY_CODE_HANDLE temp = wrapHnd->getJustMyCodeHandle(method, ppIndirection);
1288     API_LEAVE(getJustMyCodeHandle);
1289     return temp;
1290 }
1291
1292 void WrapICorJitInfo::GetProfilingHandle(
1293                     BOOL                      *pbHookFunction,
1294                     void                     **pProfilerHandle,
1295                     BOOL                      *pbIndirectedHandles)
1296 {
1297     API_ENTER(GetProfilingHandle);
1298     wrapHnd->GetProfilingHandle(pbHookFunction, pProfilerHandle, pbIndirectedHandles);
1299     API_LEAVE(GetProfilingHandle);
1300 }
1301
1302 void WrapICorJitInfo::getCallInfo(
1303                     CORINFO_RESOLVED_TOKEN * pResolvedToken,
1304                     CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken,
1305                     CORINFO_METHOD_HANDLE   callerHandle,
1306                     CORINFO_CALLINFO_FLAGS  flags,
1307                     CORINFO_CALL_INFO       *pResult)
1308 {
1309     API_ENTER(getCallInfo);
1310     wrapHnd->getCallInfo(pResolvedToken, pConstrainedResolvedToken, callerHandle, flags, pResult);
1311     API_LEAVE(getCallInfo);
1312 }
1313
1314 BOOL WrapICorJitInfo::canAccessFamily(CORINFO_METHOD_HANDLE hCaller,
1315                                         CORINFO_CLASS_HANDLE hInstanceType)
1316 {
1317     API_ENTER(canAccessFamily);
1318     BOOL temp = wrapHnd->canAccessFamily(hCaller, hInstanceType);
1319     API_LEAVE(canAccessFamily);
1320     return temp;
1321 }
1322
1323 BOOL WrapICorJitInfo::isRIDClassDomainID(CORINFO_CLASS_HANDLE cls)
1324 {
1325     API_ENTER(isRIDClassDomainID);
1326     BOOL result = wrapHnd->isRIDClassDomainID(cls);
1327     API_LEAVE(isRIDClassDomainID);
1328     return result;
1329 }
1330
1331 unsigned WrapICorJitInfo::getClassDomainID(
1332                 CORINFO_CLASS_HANDLE    cls,
1333                 void                  **ppIndirection)
1334 {
1335     API_ENTER(getClassDomainID);
1336     unsigned temp = wrapHnd->getClassDomainID(cls, ppIndirection);
1337     API_LEAVE(getClassDomainID);
1338     return temp;
1339 }
1340
1341 void* WrapICorJitInfo::getFieldAddress(
1342                 CORINFO_FIELD_HANDLE    field,
1343                 void                  **ppIndirection)
1344 {
1345     API_ENTER(getFieldAddress);
1346     void *temp = wrapHnd->getFieldAddress(field, ppIndirection);
1347     API_LEAVE(getFieldAddress);
1348     return temp;
1349 }
1350
1351 CORINFO_VARARGS_HANDLE WrapICorJitInfo::getVarArgsHandle(
1352                 CORINFO_SIG_INFO       *pSig,
1353                 void                  **ppIndirection)
1354 {
1355     API_ENTER(getVarArgsHandle);
1356     CORINFO_VARARGS_HANDLE temp = wrapHnd->getVarArgsHandle(pSig, ppIndirection);
1357     API_LEAVE(getVarArgsHandle);
1358     return temp;
1359 }
1360
1361 bool WrapICorJitInfo::canGetVarArgsHandle(
1362                 CORINFO_SIG_INFO       *pSig)
1363 {
1364     API_ENTER(canGetVarArgsHandle);
1365     bool temp = wrapHnd->canGetVarArgsHandle(pSig);
1366     API_LEAVE(canGetVarArgsHandle);
1367     return temp;
1368 }
1369
1370 InfoAccessType WrapICorJitInfo::constructStringLiteral(
1371                 CORINFO_MODULE_HANDLE   module,
1372                 mdToken                 metaTok,
1373                 void                  **ppValue)
1374 {
1375     API_ENTER(constructStringLiteral);
1376     InfoAccessType temp = wrapHnd->constructStringLiteral(module, metaTok, ppValue);
1377     API_LEAVE(constructStringLiteral);
1378     return temp;
1379 }
1380
1381 InfoAccessType WrapICorJitInfo::emptyStringLiteral(void **ppValue)
1382 {
1383     API_ENTER(emptyStringLiteral);
1384     InfoAccessType temp = wrapHnd->emptyStringLiteral(ppValue);
1385     API_LEAVE(emptyStringLiteral);
1386     return temp;
1387 }
1388
1389 DWORD WrapICorJitInfo::getFieldThreadLocalStoreID(
1390                 CORINFO_FIELD_HANDLE    field,
1391                 void                  **ppIndirection)
1392 {
1393     API_ENTER(getFieldThreadLocalStoreID);
1394     DWORD temp = wrapHnd->getFieldThreadLocalStoreID(field, ppIndirection);
1395     API_LEAVE(getFieldThreadLocalStoreID);
1396     return temp;
1397 }
1398
1399 void WrapICorJitInfo::setOverride(
1400             ICorDynamicInfo             *pOverride,
1401             CORINFO_METHOD_HANDLE       currentMethod)
1402 {
1403     API_ENTER(setOverride);
1404     wrapHnd->setOverride(pOverride, currentMethod);
1405     API_LEAVE(setOverride);
1406 }
1407
1408 void WrapICorJitInfo::addActiveDependency(
1409             CORINFO_MODULE_HANDLE       moduleFrom,
1410             CORINFO_MODULE_HANDLE       moduleTo)
1411 {
1412     API_ENTER(addActiveDependency);
1413     wrapHnd->addActiveDependency(moduleFrom, moduleTo);
1414     API_LEAVE(addActiveDependency);
1415 }
1416
1417 CORINFO_METHOD_HANDLE WrapICorJitInfo::GetDelegateCtor(
1418         CORINFO_METHOD_HANDLE  methHnd,
1419         CORINFO_CLASS_HANDLE   clsHnd,
1420         CORINFO_METHOD_HANDLE  targetMethodHnd,
1421         DelegateCtorArgs *     pCtorData)
1422 {
1423     API_ENTER(GetDelegateCtor);
1424     CORINFO_METHOD_HANDLE temp = wrapHnd->GetDelegateCtor(methHnd, clsHnd, targetMethodHnd, pCtorData);
1425     API_LEAVE(GetDelegateCtor);
1426     return temp;
1427 }
1428
1429 void WrapICorJitInfo::MethodCompileComplete(
1430             CORINFO_METHOD_HANDLE methHnd)
1431 {
1432     API_ENTER(MethodCompileComplete);
1433     wrapHnd->MethodCompileComplete(methHnd);
1434     API_LEAVE(MethodCompileComplete);
1435 }
1436
1437 void* WrapICorJitInfo::getTailCallCopyArgsThunk(
1438                 CORINFO_SIG_INFO       *pSig,
1439                 CorInfoHelperTailCallSpecialHandling flags)
1440 {
1441     API_ENTER(getTailCallCopyArgsThunk);
1442     void *result = wrapHnd->getTailCallCopyArgsThunk(pSig, flags);
1443     API_LEAVE(getTailCallCopyArgsThunk);
1444     return result;
1445 }
1446
1447 /*********************************************************************************/
1448 //
1449 // ICorJitInfo
1450 //
1451 /*********************************************************************************/
1452
1453 DWORD WrapICorJitInfo::getJitFlags(CORJIT_FLAGS *jitFlags, DWORD sizeInBytes)
1454 {
1455     API_ENTER(getJitFlags);
1456     DWORD result = wrapHnd->getJitFlags(jitFlags, sizeInBytes);
1457     API_LEAVE(getJitFlags);
1458     return result;
1459 }
1460
1461 bool WrapICorJitInfo::runWithErrorTrap(void(*function)(void*), void *param)
1462 {
1463     return wrapHnd->runWithErrorTrap(function, param);
1464 }
1465
1466 IEEMemoryManager* WrapICorJitInfo::getMemoryManager()
1467 {
1468     API_ENTER(getMemoryManager);
1469     IEEMemoryManager * temp = wrapHnd->getMemoryManager();
1470     API_LEAVE(getMemoryManager);
1471     return temp;
1472 }
1473
1474 void WrapICorJitInfo::allocMem(
1475         ULONG               hotCodeSize,    /* IN */
1476         ULONG               coldCodeSize,   /* IN */
1477         ULONG               roDataSize,     /* IN */
1478         ULONG               xcptnsCount,    /* IN */
1479         CorJitAllocMemFlag  flag,           /* IN */
1480         void **             hotCodeBlock,   /* OUT */
1481         void **             coldCodeBlock,  /* OUT */
1482         void **             roDataBlock     /* OUT */)
1483 {
1484     API_ENTER(allocMem);
1485     wrapHnd->allocMem(hotCodeSize, coldCodeSize, roDataSize, xcptnsCount, flag, hotCodeBlock, coldCodeBlock, roDataBlock);
1486     API_LEAVE(allocMem);
1487 }
1488
1489 void WrapICorJitInfo::reserveUnwindInfo(
1490         BOOL                isFunclet,             /* IN */
1491         BOOL                isColdCode,            /* IN */
1492         ULONG               unwindSize             /* IN */)
1493 {
1494     API_ENTER(reserveUnwindInfo);
1495     wrapHnd->reserveUnwindInfo(isFunclet, isColdCode, unwindSize);
1496     API_LEAVE(reserveUnwindInfo);
1497 }
1498
1499 void WrapICorJitInfo::allocUnwindInfo(
1500         BYTE *              pHotCode,              /* IN */
1501         BYTE *              pColdCode,             /* IN */
1502         ULONG               startOffset,           /* IN */
1503         ULONG               endOffset,             /* IN */
1504         ULONG               unwindSize,            /* IN */
1505         BYTE *              pUnwindBlock,          /* IN */
1506         CorJitFuncKind      funcKind               /* IN */)
1507 {
1508     API_ENTER(allocUnwindInfo);
1509     wrapHnd->allocUnwindInfo(pHotCode, pColdCode, startOffset, endOffset, unwindSize, pUnwindBlock, funcKind);
1510     API_LEAVE(allocUnwindInfo);
1511 }
1512
1513 void *WrapICorJitInfo::allocGCInfo(size_t size /* IN */)
1514 {
1515     API_ENTER(allocGCInfo);
1516     void *temp = wrapHnd->allocGCInfo(size);
1517     API_LEAVE(allocGCInfo);
1518     return temp;
1519 }
1520
1521 void WrapICorJitInfo::yieldExecution()
1522 {
1523     API_ENTER(yieldExecution); //Nothing to record
1524     wrapHnd->yieldExecution();
1525     API_LEAVE(yieldExecution); //Nothing to recor)
1526 }
1527
1528 void WrapICorJitInfo::setEHcount(unsigned cEH /* IN */)
1529 {
1530     API_ENTER(setEHcount);
1531     wrapHnd->setEHcount(cEH);
1532     API_LEAVE(setEHcount);
1533 }
1534
1535 void WrapICorJitInfo::setEHinfo(
1536         unsigned EHnumber, /* IN  */
1537         const CORINFO_EH_CLAUSE *clause /* IN */)
1538 {
1539     API_ENTER(setEHinfo);
1540     wrapHnd->setEHinfo(EHnumber, clause);
1541     API_LEAVE(setEHinfo);
1542 }
1543
1544 BOOL WrapICorJitInfo::logMsg(unsigned level, const char* fmt, va_list args)
1545 {
1546     API_ENTER(logMsg);
1547     BOOL result = wrapHnd->logMsg(level, fmt, args);
1548     API_LEAVE(logMsg);
1549     return result;
1550 }
1551
1552 int WrapICorJitInfo::doAssert(const char* szFile, int iLine, const char* szExpr)
1553 {
1554     API_ENTER(doAssert);
1555     int result = wrapHnd->doAssert(szFile, iLine, szExpr);
1556     API_LEAVE(doAssert);
1557     return result;
1558 }
1559
1560 void WrapICorJitInfo::reportFatalError(CorJitResult result)
1561 {
1562     API_ENTER(reportFatalError);
1563     wrapHnd->reportFatalError(result);
1564     API_LEAVE(reportFatalError);
1565 }
1566
1567 HRESULT WrapICorJitInfo::allocBBProfileBuffer(
1568         ULONG count,
1569         ProfileBuffer **profileBuffer)
1570 {
1571     API_ENTER(allocBBProfileBuffer);
1572     HRESULT result = wrapHnd->allocBBProfileBuffer(count, profileBuffer);
1573     API_LEAVE(allocBBProfileBuffer);
1574     return result;
1575 }
1576
1577 HRESULT WrapICorJitInfo::getBBProfileData(
1578         CORINFO_METHOD_HANDLE ftnHnd,
1579         ULONG *count,
1580         ProfileBuffer **profileBuffer,
1581         ULONG *numRuns)
1582 {
1583     API_ENTER(getBBProfileData);
1584     HRESULT temp = wrapHnd->getBBProfileData(ftnHnd, count, profileBuffer, numRuns);
1585     API_LEAVE(getBBProfileData);
1586     return temp;
1587 }
1588
1589 void WrapICorJitInfo::recordCallSite(
1590     ULONG                 instrOffset,  /* IN */
1591     CORINFO_SIG_INFO *    callSig,      /* IN */
1592     CORINFO_METHOD_HANDLE methodHandle  /* IN */)
1593 {
1594     API_ENTER(recordCallSite);
1595     wrapHnd->recordCallSite(instrOffset, callSig, methodHandle);
1596     API_LEAVE(recordCallSite);
1597 }
1598
1599 void WrapICorJitInfo::recordRelocation(
1600         void *location, /* IN  */
1601         void *target, /* IN  */
1602         WORD fRelocType, /* IN  */
1603         WORD slotNum, /* IN  */
1604         INT32 addlDelta /* IN  */)
1605 {
1606     API_ENTER(recordRelocation);
1607     wrapHnd->recordRelocation(location, target, fRelocType, slotNum, addlDelta);
1608     API_LEAVE(recordRelocation);
1609 }
1610
1611 WORD WrapICorJitInfo::getRelocTypeHint(void *target)
1612 {
1613     API_ENTER(getRelocTypeHint);
1614     WORD result = wrapHnd->getRelocTypeHint(target);
1615     API_LEAVE(getRelocTypeHint);
1616     return result;
1617 }
1618
1619 void WrapICorJitInfo::getModuleNativeEntryPointRange(
1620             void **pStart, /* OUT */
1621             void **pEnd    /* OUT */)
1622 {
1623     API_ENTER(getModuleNativeEntryPointRange);
1624     wrapHnd->getModuleNativeEntryPointRange(pStart, pEnd);
1625     API_LEAVE(getModuleNativeEntryPointRange);
1626 }
1627
1628 DWORD WrapICorJitInfo::getExpectedTargetArchitecture()
1629 {
1630     API_ENTER(getExpectedTargetArchitecture);
1631     DWORD result = wrapHnd->getExpectedTargetArchitecture();
1632     API_LEAVE(getExpectedTargetArchitecture);
1633     return result;
1634 }
1635
1636 CORINFO_METHOD_HANDLE WrapICorJitInfo::resolveVirtualMethod(
1637     CORINFO_METHOD_HANDLE       virtualMethod,          /* IN */
1638     CORINFO_CLASS_HANDLE        implementingClass,      /* IN */
1639     CORINFO_CONTEXT_HANDLE      ownerType = NULL        /* IN */
1640 )
1641 {
1642     API_ENTER(resolveVirtualMethod);
1643     CORINFO_METHOD_HANDLE result = wrapHnd->resolveVirtualMethod(virtualMethod, implementingClass, ownerType);
1644     API_LEAVE(resolveVirtualMethod);
1645     return result;
1646 }
1647
1648 CORINFO_METHOD_HANDLE WrapICorJitInfo::getUnboxedEntry(
1649     CORINFO_METHOD_HANDLE       ftn,          /* IN */
1650     bool* requiresInstMethodTableArg          /* OUT */
1651 )
1652 {
1653     API_ENTER(getUnboxedEntry);
1654     CORINFO_METHOD_HANDLE result = wrapHnd->getUnboxedEntry(ftn, requiresInstMethodTableArg);
1655     API_LEAVE(getUnboxedEntry);
1656     return result;
1657 }
1658
1659 CORINFO_CLASS_HANDLE WrapICorJitInfo::getDefaultEqualityComparerClass(
1660     CORINFO_CLASS_HANDLE elemType)
1661 {
1662     API_ENTER(getDefaultEqualityComparerClass);
1663     CORINFO_CLASS_HANDLE result = wrapHnd->getDefaultEqualityComparerClass(elemType);
1664     API_LEAVE(getDefaultEqualityComparerClass);
1665     return result;
1666 }
1667
1668
1669 void WrapICorJitInfo::expandRawHandleIntrinsic(
1670     CORINFO_RESOLVED_TOKEN *        pResolvedToken,
1671     CORINFO_GENERICHANDLE_RESULT *  pResult)
1672 {
1673     API_ENTER(expandRawHandleIntrinsic);
1674     wrapHnd->expandRawHandleIntrinsic(pResolvedToken, pResult);
1675     API_LEAVE(expandRawHandleIntrinsic);
1676 }
1677
1678 /**********************************************************************************/
1679 // clang-format on
1680 /**********************************************************************************/