src/zap/zapinfo.h

   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 // ZapInfo.h
   6 //
   7
   8 //
   9 // JIT-EE interface for zapping
  10 //
  11 // ======================================================================================
  12
  13 #ifndef __ZAPINFO_H__
  14 #define __ZAPINFO_H__
  15
  16 #include "zapcode.h"
  17
  18 class ZapInfo;
  19 struct InlineContext;
  20
  21 // The compiled code often implicitly needs fixups for various subtle reasons.
  22 // We only emit explict fixups while compiling the method, while collecting
  23 // implicit fixups in the LoadTable. At the end of compiling, we expect
  24 // many of the LoadTable entries to be subsumed by the explicit entries
  25 // and will not need to be emitted.
  26 // This is also used to detect duplicate explicit fixups for the same type.
  27
  28 template <typename HandleType>
  29 class LoadTable
  30 {
  31 private:
  32     ZapImage            *m_pModule;
  33
  34     struct LoadEntry
  35     {
  36         HandleType              handle;
  37         int                     order;      // -1 = fixed
  38     };
  39
  40     static int __cdecl LoadEntryCmp(const void* a_, const void* b_)
  41     {
  42         return ((LoadEntry*)a_)->order - ((LoadEntry*)b_)->order;
  43     }
  44
  45     class LoadEntryTraits : public NoRemoveSHashTraits< DefaultSHashTraits<LoadEntry> >
  46     {
  47     public:
  48         typedef typename NoRemoveSHashTraits<DefaultSHashTraits<LoadEntry> >::count_t count_t;
  49         typedef typename NoRemoveSHashTraits<DefaultSHashTraits<LoadEntry> >::element_t element_t;
  50         typedef HandleType key_t;
  51
  52         static key_t GetKey(element_t e)
  53         {
  54             LIMITED_METHOD_CONTRACT;
  55             return e.handle;
  56         }
  57         static BOOL Equals(key_t k1, key_t k2)
  58         {
  59             LIMITED_METHOD_CONTRACT;
  60             return k1 == k2;
  61         }
  62         static count_t Hash(key_t k)
  63         {
  64             LIMITED_METHOD_CONTRACT;
  65             return (count_t)(size_t)k;
  66         }
  67
  68         static const element_t Null() { LIMITED_METHOD_CONTRACT; LoadEntry e; e.handle = NULL; e.order = 0; return e; }
  69         static bool IsNull(const element_t &e) { LIMITED_METHOD_CONTRACT; return (e.handle == NULL); }
  70     };
  71
  72     typedef SHash<LoadEntryTraits> LoadEntryHashTable;
  73
  74     LoadEntryHashTable      m_entries;
  75
  76 public:
  77     LoadTable(ZapImage *pModule)
  78       : m_pModule(pModule)
  79     {
  80     }
  81
  82     // fixed=TRUE if the caller can guarantee that type will be fixed up because
  83     // of some implicit fixup. In this case, we track 'handle' only to avoid
  84     // duplicates and will not actually emit an explicit fixup for 'handle'
  85     //
  86     // fixed=FALSE if the caller needs an explicit fixup. We will emit an
  87     // explicit fixup for 'handle' if there are no other implicit fixups.
  88
  89     void Load(HandleType handle, BOOL fixed)
  90     {
  91         CONTRACTL
  92         {
  93             THROWS;
  94             GC_NOTRIGGER;
  95         }
  96         CONTRACTL_END;
  97
  98         const LoadEntry *result = m_entries.LookupPtr(handle);
  99
 100         if (result != NULL)
 101         {
 102             if (fixed)
 103                 ((LoadEntry*)result)->order = -1;
 104             return;
 105         }
 106
 107         LoadEntry   newEntry;
 108
 109         newEntry.handle = handle;
 110         newEntry.order = fixed ? -1 : m_entries.GetCount();
 111
 112         m_entries.Add(newEntry);
 113     }
 114
 115     void EmitLoadFixups(CORINFO_METHOD_HANDLE currentMethodHandle, ZapInfo * pZapInfo);
 116 };
 117
 118 // Declare some specializations of EmitLoadFixups().
 119 template<> void LoadTable<CORINFO_CLASS_HANDLE>::EmitLoadFixups(CORINFO_METHOD_HANDLE currentMethodHandle, ZapInfo * pZapInfo);
 120 template<> void LoadTable<CORINFO_METHOD_HANDLE>::EmitLoadFixups(CORINFO_METHOD_HANDLE currentMethodHandle, ZapInfo * pZapInfo);
 121
 122
 123 class ZapInfo
 124     : public ICorJitInfo
 125 {
 126     friend class ZapImage;
 127
 128     // Owning ZapImage
 129     ZapImage * m_pImage;
 130
 131     Zapper * m_zapper;
 132     ICorDynamicInfo * m_pEEJitInfo;
 133     ICorCompileInfo * m_pEECompileInfo;
 134
 135     // Current method being compiled; it is non-nil only for
 136     // method defs whose IL is in this module and (for generic code)
 137     // have <object> instantiation. It is also nil for IL_STUBs.
 138     mdMethodDef                 m_currentMethodToken;
 139     CORINFO_METHOD_HANDLE       m_currentMethodHandle;
 140     CORINFO_METHOD_INFO         m_currentMethodInfo;
 141
 142     // m_currentMethodModule==m_hModule except for generic types/methods
 143     // defined in another assembly but instantiated in the current assembly.
 144     CORINFO_MODULE_HANDLE       m_currentMethodModule;
 145
 146     unsigned                    m_currentMethodProfilingDataFlags;
 147
 148     // Debug information reported by the JIT compiler for the current method
 149     ICorDebugInfo::NativeVarInfo *m_pNativeVarInfo;
 150     ULONG32                     m_iNativeVarInfo;
 151     ICorDebugInfo::OffsetMapping *m_pOffsetMapping;
 152     ULONG32                     m_iOffsetMapping;
 153
 154     BYTE *                      m_pGCInfo;
 155     SIZE_T                      m_cbGCInfo;
 156
 157
 158     ZapBlobWithRelocs *         m_pCode;
 159     ZapBlobWithRelocs *         m_pColdCode;
 160     ZapBlobWithRelocs *         m_pROData;
 161
 162 #ifdef WIN64EXCEPTIONS
 163     // Unwind info of the main method body. It will get merged with GC info.
 164     BYTE *                      m_pMainUnwindInfo;
 165     ULONG                       m_cbMainUnwindInfo;
 166
 167     ZapUnwindInfo *             m_pUnwindInfo;
 168     ZapUnwindInfo *             m_pUnwindInfoFragments;
 169 #if defined(_TARGET_AMD64_)
 170     ZapUnwindInfo *             m_pChainedColdUnwindInfo;
 171 #endif
 172 #endif // WIN64EXCEPTIONS
 173
 174     ZapExceptionInfo *          m_pExceptionInfo;
 175
 176     ZapBlobWithRelocs *         m_pProfileData;
 177
 178     ZapImport *                 m_pProfilingHandle;
 179
 180     struct CodeRelocation : ZapReloc
 181     {
 182         ZapBlobWithRelocs * m_pNode;
 183     };
 184
 185     SArray<CodeRelocation>   m_CodeRelocations;
 186
 187     static int __cdecl CompareCodeRelocation(const void * a, const void * b);
 188
 189     struct ImportEntry
 190     {
 191         ZapImport * pImport;
 192         bool fConditional; // Conditional imports are emitted only if they are actually referenced by the code.
 193     };
 194
 195     class ImportTraits : public NoRemoveSHashTraits< DefaultSHashTraits<ImportEntry> >
 196     {
 197     public:
 198         typedef ZapImport * key_t;
 199
 200         static key_t GetKey(element_t e)
 201         {
 202             LIMITED_METHOD_CONTRACT;
 203             return e.pImport;
 204         }
 205         static BOOL Equals(key_t k1, key_t k2)
 206         {
 207             LIMITED_METHOD_CONTRACT;
 208             return k1 == k2;
 209         }
 210         static count_t Hash(key_t k)
 211         {
 212             LIMITED_METHOD_CONTRACT;
 213             return (count_t)(size_t)k;
 214         }
 215
 216         static const element_t Null() { LIMITED_METHOD_CONTRACT; ImportEntry e; e.pImport = NULL; return e; }
 217         static bool IsNull(const element_t &e) { LIMITED_METHOD_CONTRACT; return e.pImport == NULL; }
 218     };
 219
 220     SHash<ImportTraits>         m_ImportSet;
 221     SArray<ZapImport *>         m_Imports;
 222
 223     InlineSString<128>          m_currentMethodName;
 224
 225     // Cache to reduce the number of entries in CORCOMPILE_LOAD_TABLE if it
 226     // is implied by some other fixup type
 227     LoadTable<CORINFO_CLASS_HANDLE>  m_ClassLoadTable;
 228     LoadTable<CORINFO_METHOD_HANDLE> m_MethodLoadTable;
 229
 230     CORJIT_FLAGS m_jitFlags;
 231
 232     void InitMethodName();
 233
 234     CORJIT_FLAGS ComputeJitFlags(CORINFO_METHOD_HANDLE handle);
 235
 236     ZapDebugInfo * EmitDebugInfo();
 237     ZapGCInfo * EmitGCInfo();
 238     ZapImport ** EmitFixupList();
 239
 240     void PublishCompiledMethod();
 241
 242     void EmitCodeRelocations();
 243
 244     void ProcessReferences();
 245
 246     BOOL CurrentMethodHasProfileData();
 247
 248     void embedGenericSignature(CORINFO_LOOKUP * pLookup);
 249
 250     PVOID embedDirectCall(CORINFO_METHOD_HANDLE ftn,
 251                           CORINFO_ACCESS_FLAGS accessFlags,
 252                           BOOL fAllowThunk);
 253
 254 public:
 255     ZapInfo(ZapImage * pImage, mdMethodDef md, CORINFO_METHOD_HANDLE handle, CORINFO_MODULE_HANDLE module, unsigned methodProfilingDataFlags);
 256     ~ZapInfo();
 257
 258 #ifdef ALLOW_SXS_JIT_NGEN
 259     void ResetForJitRetry();
 260 #endif // ALLOW_SXS_JIT_NGEN
 261
 262     void CompileMethod();
 263
 264     void AppendImport(ZapImport * pImport);
 265     void AppendConditionalImport(ZapImport * pImport);
 266
 267     ULONG GetNumFixups();
 268
 269     // ICorJitInfo
 270
 271     IEEMemoryManager* getMemoryManager();
 272
 273     virtual void allocMem (
 274             ULONG               hotCodeSize,    /* IN */
 275             ULONG               coldCodeSize,   /* IN */
 276             ULONG               roDataSize,     /* IN */
 277             ULONG               xcptnsCount,    /* IN */
 278             CorJitAllocMemFlag  flag,           /* IN */
 279             void **             hotCodeBlock,   /* OUT */
 280             void **             coldCodeBlock,  /* OUT */
 281             void **             roDataBlock     /* OUT */
 282             );
 283
 284     void    reserveUnwindInfo(
 285             BOOL isFunclet,               /* IN */
 286             BOOL isColdCode,              /* IN */
 287             ULONG unwindSize              /* IN */
 288             );
 289
 290     void    allocUnwindInfo (
 291             BYTE * pHotCode,              /* IN */
 292             BYTE * pColdCode,             /* IN */
 293             ULONG  startOffset,           /* IN */
 294             ULONG  endOffset,             /* IN */
 295             ULONG  unwindSize,            /* IN */
 296             BYTE * pUnwindBlock,          /* IN */
 297             CorJitFuncKind funcKind       /* IN */
 298             );
 299
 300     void * allocGCInfo(size_t size);
 301     void yieldExecution();
 302     void setEHcount(unsigned cEH);
 303     void setEHinfo(unsigned EHnumber, const CORINFO_EH_CLAUSE *clause);
 304
 305     int  canHandleException(struct _EXCEPTION_POINTERS *pExceptionPointers);
 306     BOOL logMsg(unsigned level,  const char *fmt, va_list args);
 307     int  doAssert(const char* szFile, int iLine, const char* szExpr);
 308     void reportFatalError(CorJitResult result);
 309
 310     HRESULT allocBBProfileBuffer (
 311             ULONG cBlock,
 312             ICorJitInfo::ProfileBuffer ** ppBlock);
 313
 314     HRESULT getBBProfileData (
 315             CORINFO_METHOD_HANDLE ftnHnd,
 316             ULONG * size,
 317             ICorJitInfo::ProfileBuffer ** profileBuffer,
 318             ULONG * numRuns);
 319
 320     DWORD getJitFlags(CORJIT_FLAGS* jitFlags, DWORD sizeInBytes);
 321
 322     bool runWithErrorTrap(void (*function)(void*), void* param);
 323
 324     // ICorDynamicInfo
 325
 326     DWORD getThreadTLSIndex(void **ppIndirection);
 327     const void * getInlinedCallFrameVptr(void **ppIndirection);
 328     LONG * getAddrOfCaptureThreadGlobal(void **ppIndirection);
 329
 330     // get slow lazy string literal helper to use (CORINFO_HELP_STRCNS*).
 331     // Returns CORINFO_HELP_UNDEF if lazy string literal helper cannot be used.
 332     CorInfoHelpFunc getLazyStringLiteralHelper(CORINFO_MODULE_HANDLE handle);
 333
 334     CORINFO_MODULE_HANDLE
 335       embedModuleHandle(CORINFO_MODULE_HANDLE handle,
 336                         void **ppIndirection);
 337     CORINFO_CLASS_HANDLE
 338       embedClassHandle(CORINFO_CLASS_HANDLE handle,
 339                        void **ppIndirection);
 340     CORINFO_FIELD_HANDLE
 341       embedFieldHandle(CORINFO_FIELD_HANDLE handle,
 342                        void **ppIndirection);
 343     CORINFO_METHOD_HANDLE
 344       embedMethodHandle(CORINFO_METHOD_HANDLE handle,
 345                         void **ppIndirection);
 346     void
 347       embedGenericHandle(CORINFO_RESOLVED_TOKEN * pResolvedToken,
 348                          BOOL                     fEmbedParent,
 349                          CORINFO_GENERICHANDLE_RESULT *pResult);
 350
 351     CORINFO_LOOKUP_KIND
 352         getLocationOfThisType(CORINFO_METHOD_HANDLE context);
 353
 354
 355
 356     void * getHelperFtn (CorInfoHelpFunc   ftnNum,
 357                                   void**            ppIndirection);
 358
 359     void* getTailCallCopyArgsThunk (
 360                       CORINFO_SIG_INFO       *pSig,
 361                       CorInfoHelperTailCallSpecialHandling flags);
 362
 363     void getFunctionEntryPoint(
 364                       CORINFO_METHOD_HANDLE   ftn,                 /* IN  */
 365                       CORINFO_CONST_LOOKUP *  pResult,             /* OUT */
 366                       CORINFO_ACCESS_FLAGS    accessFlags = CORINFO_ACCESS_ANY);
 367
 368     void getFunctionFixedEntryPoint(
 369                       CORINFO_METHOD_HANDLE   ftn,
 370                       CORINFO_CONST_LOOKUP *  pResult);
 371
 372
 373     void * getMethodSync(CORINFO_METHOD_HANDLE ftn,
 374                          void **ppIndirection);
 375     void * getPInvokeUnmanagedTarget(CORINFO_METHOD_HANDLE method,
 376                                      void **ppIndirection);
 377     void * getAddressOfPInvokeFixup(CORINFO_METHOD_HANDLE method,
 378                                     void **ppIndirection);
 379     void getAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method,
 380                                    CORINFO_CONST_LOOKUP *pLookup);
 381     CORINFO_JUST_MY_CODE_HANDLE getJustMyCodeHandle(
 382                         CORINFO_METHOD_HANDLE method,
 383                         CORINFO_JUST_MY_CODE_HANDLE **ppIndirection);
 384
 385     ZapImport * GetProfilingHandleImport();
 386
 387     void GetProfilingHandle(
 388                     BOOL                      *pbHookFunction,
 389                     void                     **pProfilerHandle,
 390                     BOOL                      *pbIndirectedHandles
 391                     );
 392
 393     void getCallInfo(
 394                         // Token info
 395                         CORINFO_RESOLVED_TOKEN * pResolvedToken,
 396                         //Generics info
 397                         CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken,
 398                         //Security info
 399                         CORINFO_METHOD_HANDLE   callerHandle,
 400                         //Jit info
 401                         CORINFO_CALLINFO_FLAGS  flags,
 402                         //out params
 403                         CORINFO_CALL_INFO       *pResult);
 404
 405     BOOL canAccessFamily(CORINFO_METHOD_HANDLE hCaller,
 406                                    CORINFO_CLASS_HANDLE hInstanceType);
 407
 408
 409     BOOL isRIDClassDomainID(CORINFO_CLASS_HANDLE cls);
 410
 411     unsigned getClassDomainID(CORINFO_CLASS_HANDLE cls,
 412                                         void **ppIndirection);
 413
 414     void * getFieldAddress(CORINFO_FIELD_HANDLE field,
 415                                     void **ppIndirection);
 416     DWORD getFieldThreadLocalStoreID (CORINFO_FIELD_HANDLE field,
 417                                                 void **ppIndirection);
 418     CORINFO_VARARGS_HANDLE getVarArgsHandle(CORINFO_SIG_INFO *sig,
 419                                                       void **ppIndirection);
 420     bool canGetVarArgsHandle(CORINFO_SIG_INFO *sig);
 421
 422     InfoAccessType constructStringLiteral(CORINFO_MODULE_HANDLE module,
 423                                             unsigned metaTok, void **ppIndirection);
 424
 425     InfoAccessType emptyStringLiteral(void **ppIndirection);
 426
 427     void setOverride(ICorDynamicInfo *pOverride, CORINFO_METHOD_HANDLE currentMethod);
 428
 429     void addActiveDependency(CORINFO_MODULE_HANDLE moduleFrom, CORINFO_MODULE_HANDLE moduleTo);
 430
 431     void recordCallSite(ULONG instrOffset, CORINFO_SIG_INFO *callSig, CORINFO_METHOD_HANDLE methodHandle);
 432
 433     // Relocations
 434
 435     void recordRelocation(void *location, void *target,
 436                                     WORD fRelocType, WORD slotNum, INT32 addlDelta);
 437
 438     WORD getRelocTypeHint(void * target);
 439
 440     void getModuleNativeEntryPointRange(void** pStart, void** pEnd);
 441
 442     DWORD getExpectedTargetArchitecture();
 443
 444     // ICorJitInfo delegate ctor optimization
 445     CORINFO_METHOD_HANDLE GetDelegateCtor(
 446                             CORINFO_METHOD_HANDLE   methHnd,
 447                             CORINFO_CLASS_HANDLE    clsHnd,
 448                             CORINFO_METHOD_HANDLE   targetMethodHnd,
 449                             DelegateCtorArgs *      pCtorData);
 450
 451     void MethodCompileComplete(
 452                 CORINFO_METHOD_HANDLE methHnd);
 453
 454     // ICorStaticInfo
 455
 456     void getEEInfo(CORINFO_EE_INFO *pEEInfoOut);
 457
 458     LPCWSTR getJitTimeLogFilename();
 459
 460     // ICorArgInfo
 461
 462     CORINFO_ARG_LIST_HANDLE getArgNext(CORINFO_ARG_LIST_HANDLE args);
 463     CorInfoTypeWithMod getArgType(CORINFO_SIG_INFO* sig,
 464                                      CORINFO_ARG_LIST_HANDLE args,
 465                                      CORINFO_CLASS_HANDLE *vcTypeRet);
 466     CORINFO_CLASS_HANDLE getArgClass(CORINFO_SIG_INFO* sig,
 467                                                CORINFO_ARG_LIST_HANDLE args);
 468     CorInfoType getHFAType(CORINFO_CLASS_HANDLE hClass);
 469
 470     // ICorDebugInfo
 471
 472     void getBoundaries(CORINFO_METHOD_HANDLE ftn, unsigned int *cILOffsets,
 473                        DWORD **pILOffsets, ICorDebugInfo::BoundaryTypes *implicitBoundaries);
 474     void setBoundaries(CORINFO_METHOD_HANDLE ftn, ULONG32 cMap,
 475                        ICorDebugInfo::OffsetMapping *pMap);
 476     void getVars(CORINFO_METHOD_HANDLE ftn, ULONG32 *cVars,
 477                  ICorDebugInfo::ILVarInfo **vars, bool *extendOthers);
 478     void setVars(CORINFO_METHOD_HANDLE ftn, ULONG32 cVars,
 479                  ICorDebugInfo::NativeVarInfo*vars);
 480     void * allocateArray(ULONG cBytes);
 481     void freeArray(void *array);
 482
 483     // ICorFieldInfo
 484
 485     const char* getFieldName(CORINFO_FIELD_HANDLE ftn, const char **moduleName);
 486     CORINFO_CLASS_HANDLE getFieldClass(CORINFO_FIELD_HANDLE field);
 487
 488     CorInfoType getFieldType(CORINFO_FIELD_HANDLE field,
 489                                        CORINFO_CLASS_HANDLE *structType,
 490                                        CORINFO_CLASS_HANDLE memberParent);
 491
 492     unsigned getFieldOffset(CORINFO_FIELD_HANDLE field);
 493
 494     bool isWriteBarrierHelperRequired(
 495                         CORINFO_FIELD_HANDLE    field);
 496
 497     void getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
 498                        CORINFO_METHOD_HANDLE  callerHandle,
 499                        CORINFO_ACCESS_FLAGS   flags,
 500                        CORINFO_FIELD_INFO    *pResult);
 501
 502     bool isFieldStatic(CORINFO_FIELD_HANDLE fldHnd);
 503
 504     // ICorClassInfo
 505
 506     CorInfoType asCorInfoType(CORINFO_CLASS_HANDLE cls);
 507     const char* getClassName(CORINFO_CLASS_HANDLE cls);
 508     const char* getClassNameFromMetadata(CORINFO_CLASS_HANDLE cls, const char** namespaceName);
 509     CORINFO_CLASS_HANDLE getTypeInstantiationArgument(CORINFO_CLASS_HANDLE cls, unsigned index);
 510     const char* getHelperName(CorInfoHelpFunc ftnNum);
 511     int appendClassName(__deref_inout_ecount(*pnBufLen) WCHAR** ppBuf, int* pnBufLen,
 512                                   CORINFO_CLASS_HANDLE    cls,
 513                                   BOOL fNamespace,
 514                                   BOOL fFullInst,
 515                                   BOOL fAssembly);
 516     BOOL isValueClass(CORINFO_CLASS_HANDLE clsHnd);
 517     BOOL canInlineTypeCheckWithObjectVTable(CORINFO_CLASS_HANDLE clsHnd);
 518     DWORD getClassAttribs(CORINFO_CLASS_HANDLE cls);
 519     BOOL isStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls);
 520     CORINFO_MODULE_HANDLE getClassModule(CORINFO_CLASS_HANDLE cls);
 521     CORINFO_ASSEMBLY_HANDLE getModuleAssembly(CORINFO_MODULE_HANDLE mod);
 522     const char* getAssemblyName(CORINFO_ASSEMBLY_HANDLE assem);
 523     void* LongLifetimeMalloc(size_t sz);
 524     void LongLifetimeFree(void* obj);
 525     size_t getClassModuleIdForStatics(CORINFO_CLASS_HANDLE cls, CORINFO_MODULE_HANDLE *pModule, void **ppIndirection);
 526
 527     unsigned getClassSize(CORINFO_CLASS_HANDLE cls);
 528     unsigned getClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, BOOL fDoubleAlignHint);
 529
 530     CORINFO_FIELD_HANDLE getFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num);
 531
 532     mdMethodDef getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod);
 533     BOOL checkMethodModifier(CORINFO_METHOD_HANDLE hMethod, LPCSTR modifier, BOOL fOptional);
 534
 535     unsigned getClassGClayout(CORINFO_CLASS_HANDLE cls, BYTE *gcPtrs);
 536
 537     bool getSystemVAmd64PassStructInRegisterDescriptor(
 538         /*IN*/  CORINFO_CLASS_HANDLE _structHnd,
 539         /*OUT*/ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr);
 540
 541     unsigned getClassNumInstanceFields(CORINFO_CLASS_HANDLE cls);
 542
 543     CorInfoHelpFunc getNewHelper(CORINFO_RESOLVED_TOKEN * pResolvedToken, CORINFO_METHOD_HANDLE callerHandle);
 544     CorInfoHelpFunc getCastingHelper(CORINFO_RESOLVED_TOKEN * pResolvedToken, bool fThrowing);
 545     CorInfoHelpFunc getNewArrHelper(CORINFO_CLASS_HANDLE arrayCls);
 546     CorInfoHelpFunc getSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd);
 547     CorInfoHelpFunc getSecurityPrologHelper(CORINFO_METHOD_HANDLE ftn);
 548     CORINFO_CLASS_HANDLE getTypeForBox(CORINFO_CLASS_HANDLE  cls);
 549     CorInfoHelpFunc getBoxHelper(CORINFO_CLASS_HANDLE cls);
 550     CorInfoHelpFunc getUnBoxHelper(CORINFO_CLASS_HANDLE cls);
 551
 552     bool getReadyToRunHelper(
 553             CORINFO_RESOLVED_TOKEN *        pResolvedToken,
 554             CORINFO_LOOKUP_KIND *           pGenericLookupKind,
 555             CorInfoHelpFunc                 id,
 556             CORINFO_CONST_LOOKUP *          pLookup
 557             );
 558
 559     void getReadyToRunDelegateCtorHelper(
 560             CORINFO_RESOLVED_TOKEN * pTargetMethod,
 561             CORINFO_CLASS_HANDLE     delegateType,
 562             CORINFO_LOOKUP *   pLookup
 563             );
 564
 565     CorInfoInitClassResult initClass(
 566             CORINFO_FIELD_HANDLE    field,
 567             CORINFO_METHOD_HANDLE   method,
 568             CORINFO_CONTEXT_HANDLE  context,
 569             BOOL                    speculative = FALSE);
 570
 571     void classMustBeLoadedBeforeCodeIsRun(CORINFO_CLASS_HANDLE cls);
 572     void methodMustBeLoadedBeforeCodeIsRun(CORINFO_METHOD_HANDLE meth);
 573     CORINFO_METHOD_HANDLE mapMethodDeclToMethodImpl(CORINFO_METHOD_HANDLE methHnd);
 574     CORINFO_CLASS_HANDLE getBuiltinClass(CorInfoClassId classId);
 575     CorInfoType getTypeForPrimitiveValueClass(CORINFO_CLASS_HANDLE cls);
 576     CorInfoType getTypeForPrimitiveNumericClass(CORINFO_CLASS_HANDLE cls);
 577     BOOL canCast(CORINFO_CLASS_HANDLE child, CORINFO_CLASS_HANDLE parent);
 578     BOOL areTypesEquivalent(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2);
 579     TypeCompareState compareTypesForCast(CORINFO_CLASS_HANDLE fromClass, CORINFO_CLASS_HANDLE toClass);
 580     TypeCompareState compareTypesForEquality(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2);
 581
 582     CORINFO_CLASS_HANDLE mergeClasses(CORINFO_CLASS_HANDLE cls1,
 583                                 CORINFO_CLASS_HANDLE cls2);
 584     BOOL shouldEnforceCallvirtRestriction(CORINFO_MODULE_HANDLE scope);
 585     CORINFO_CLASS_HANDLE getParentType(CORINFO_CLASS_HANDLE  cls);
 586     CorInfoType getChildType (CORINFO_CLASS_HANDLE       clsHnd,
 587                               CORINFO_CLASS_HANDLE       *clsRet);
 588     BOOL satisfiesClassConstraints(CORINFO_CLASS_HANDLE cls);
 589
 590     BOOL     isSDArray   (CORINFO_CLASS_HANDLE  cls);
 591     unsigned getArrayRank(CORINFO_CLASS_HANDLE  cls);
 592     void * getArrayInitializationData(CORINFO_FIELD_HANDLE field, DWORD size);
 593     CorInfoIsAccessAllowedResult canAccessClass(CORINFO_RESOLVED_TOKEN * pResolvedToken,
 594                                                 CORINFO_METHOD_HANDLE   callerHandle,
 595                                                 CORINFO_HELPER_DESC    *throwHelper);
 596
 597     // ICorModuleInfo
 598
 599     void resolveToken(CORINFO_RESOLVED_TOKEN * pResolvedToken);
 600     bool tryResolveToken(CORINFO_RESOLVED_TOKEN * pResolvedToken);
 601
 602     void findSig(CORINFO_MODULE_HANDLE module, unsigned sigTOK,
 603                  CORINFO_CONTEXT_HANDLE context,
 604                  CORINFO_SIG_INFO *sig);
 605     void findCallSiteSig(CORINFO_MODULE_HANDLE module,
 606                                    unsigned methTOK,
 607                                    CORINFO_CONTEXT_HANDLE context,
 608                                    CORINFO_SIG_INFO *sig);
 609     CORINFO_CLASS_HANDLE getTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN * pResolvedToken);
 610     size_t findNameOfToken(CORINFO_MODULE_HANDLE module,
 611                            unsigned metaTOK,
 612                            __out_ecount (FQNameCapacity) char * szFQName,
 613                            size_t FQNameCapacity);
 614     CorInfoCanSkipVerificationResult canSkipVerification (CORINFO_MODULE_HANDLE module);
 615     BOOL isValidToken(CORINFO_MODULE_HANDLE module,
 616                       unsigned metaTOK);
 617     BOOL isValidStringRef(CORINFO_MODULE_HANDLE module,
 618                           unsigned metaTOK);
 619
 620
 621     // ICorMethodInfo
 622
 623     const char* getMethodName(CORINFO_METHOD_HANDLE ftn,
 624                                         const char **moduleName);
 625     const char* getMethodNameFromMetadata(CORINFO_METHOD_HANDLE ftn,
 626                                           const char **className,
 627                                           const char **namespaceName);
 628
 629     unsigned getMethodHash(CORINFO_METHOD_HANDLE ftn);
 630     DWORD getMethodAttribs(CORINFO_METHOD_HANDLE ftn);
 631     void setMethodAttribs(CORINFO_METHOD_HANDLE ftn, CorInfoMethodRuntimeFlags attribs);
 632
 633     void getMethodSig(CORINFO_METHOD_HANDLE ftn, CORINFO_SIG_INFO *sig, CORINFO_CLASS_HANDLE memberParent);
 634
 635     bool getMethodInfo(CORINFO_METHOD_HANDLE ftn,
 636                        CORINFO_METHOD_INFO* info);
 637
 638     CorInfoInline canInline(CORINFO_METHOD_HANDLE caller,
 639                             CORINFO_METHOD_HANDLE callee,
 640                             DWORD*                pRestrictions);
 641
 642     void reportInliningDecision (CORINFO_METHOD_HANDLE inlinerHnd,
 643                                  CORINFO_METHOD_HANDLE inlineeHnd,
 644                                  CorInfoInline inlineResult,
 645                                  const char * reason);
 646
 647     CorInfoInstantiationVerification isInstantiationOfVerifiedGeneric(
 648             CORINFO_METHOD_HANDLE   method);
 649
 650     void initConstraintsForVerification(CORINFO_METHOD_HANDLE method,
 651                                         BOOL *pfHasCircularClassConstraints,
 652                                         BOOL *pfHasCircularMethodConstraints);
 653
 654     bool canTailCall(CORINFO_METHOD_HANDLE caller,
 655                      CORINFO_METHOD_HANDLE declaredCallee,
 656                      CORINFO_METHOD_HANDLE exactCallee,
 657                      bool fIsTailPrefix);
 658
 659     void reportTailCallDecision (CORINFO_METHOD_HANDLE callerHnd,
 660                                  CORINFO_METHOD_HANDLE calleeHnd,
 661                                  bool fIsTailPrefix,
 662                                  CorInfoTailCall tailCallResult,
 663                                  const char * reason);
 664
 665     CorInfoCanSkipVerificationResult canSkipMethodVerification (
 666             CORINFO_METHOD_HANDLE   callerHnd);
 667
 668     void getEHinfo(CORINFO_METHOD_HANDLE ftn,
 669                              unsigned EHnumber, CORINFO_EH_CLAUSE* clause);
 670     CORINFO_CLASS_HANDLE getMethodClass(CORINFO_METHOD_HANDLE method);
 671     CORINFO_MODULE_HANDLE getMethodModule(CORINFO_METHOD_HANDLE method);
 672
 673     void getMethodVTableOffset(CORINFO_METHOD_HANDLE method,
 674                                unsigned * pOffsetOfIndirection,
 675                                unsigned * pOffsetAfterIndirection,
 676                                bool * isRelative);
 677
 678     CORINFO_METHOD_HANDLE resolveVirtualMethod(
 679         CORINFO_METHOD_HANDLE virtualMethod,
 680         CORINFO_CLASS_HANDLE implementingClass,
 681         CORINFO_CONTEXT_HANDLE ownerType);
 682
 683     CORINFO_METHOD_HANDLE getUnboxedEntry(
 684         CORINFO_METHOD_HANDLE ftn,
 685         bool* requiresInstMethodTableArg);
 686
 687     CORINFO_CLASS_HANDLE getDefaultEqualityComparerClass(
 688         CORINFO_CLASS_HANDLE elemType);
 689
 690     void expandRawHandleIntrinsic(
 691         CORINFO_RESOLVED_TOKEN *        pResolvedToken,
 692         CORINFO_GENERICHANDLE_RESULT *  pResult);
 693
 694     CorInfoIntrinsics getIntrinsicID(CORINFO_METHOD_HANDLE method,
 695                                      bool * pMustExpand = NULL);
 696     bool isInSIMDModule(CORINFO_CLASS_HANDLE classHnd);
 697     CorInfoUnmanagedCallConv getUnmanagedCallConv(CORINFO_METHOD_HANDLE method);
 698     BOOL pInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* sig);
 699     LPVOID GetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig,
 700                                        void ** ppIndirecton);
 701     bool canGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig);
 702     BOOL satisfiesMethodConstraints(CORINFO_CLASS_HANDLE parent,
 703                                               CORINFO_METHOD_HANDLE method);
 704
 705     BOOL isCompatibleDelegate(CORINFO_CLASS_HANDLE objCls,
 706                               CORINFO_CLASS_HANDLE methodParentCls,
 707                               CORINFO_METHOD_HANDLE method,
 708                               CORINFO_CLASS_HANDLE delegateCls,
 709                               BOOL* pfIsOpenDelegate);
 710
 711     void getGSCookie(GSCookie * pCookieVal,
 712                      GSCookie** ppCookieVal);
 713     // ICorErrorInfo
 714
 715     HRESULT GetErrorHRESULT(struct _EXCEPTION_POINTERS *pExceptionPointers);
 716     ULONG GetErrorMessage(__in_ecount(bufferLength) LPWSTR buffer, ULONG bufferLength);
 717     int FilterException(struct _EXCEPTION_POINTERS *pExceptionPointers);
 718     void HandleException(struct _EXCEPTION_POINTERS *pExceptionPointers);
 719     void ThrowExceptionForJitResult(HRESULT result);
 720     void ThrowExceptionForHelper(const CORINFO_HELPER_DESC * throwHelper);
 721 };
 722
 723 #endif // __ZAPINFO_H__