src/ToolBox/superpmi/superpmi-shared/methodcontext.h

   1 //
   2 // Copyright (c) Microsoft. All rights reserved.
   3 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
   4 //
   5
   6 //----------------------------------------------------------
   7 // MethodContext.h - Primary structure to store all the EE-JIT details required to replay creation of a method
   8 //                   CompileResult contains the stuff generated by a compilation
   9 //----------------------------------------------------------
  10 #ifndef _MethodContext
  11 #define _MethodContext
  12
  13 #include "runtimedetails.h"
  14 #include "compileresult.h"
  15 #include "lightweightmap.h"
  16 #include "errorhandling.h"
  17
  18 #define METHOD_IDENTITY_INFO_SIZE 0x10000 // We assume that the METHOD_IDENTITY_INFO_SIZE will not exceed 64KB
  19
  20 #define MD5_HASH_BYTE_SIZE 16   // MD5 is 128-bit, so we need 16 bytes to store it
  21 #define MD5_HASH_BUFFER_SIZE 33 // MD5 is 128-bit, so we need 32 chars + 1 char to store null-terminator
  22
  23 class MethodContext
  24 {
  25 public:
  26 #pragma pack(push, 1)
  27     struct Agnostic_CORINFO_SIG_INFO
  28     {
  29         DWORD     callConv;
  30         DWORDLONG retTypeClass;
  31         DWORDLONG retTypeSigClass;
  32         DWORD     retType;
  33         DWORD     flags;
  34         DWORD     numArgs;
  35         DWORD     sigInst_classInstCount;
  36         DWORD     sigInst_classInst_Index;
  37         DWORD     sigInst_methInstCount;
  38         DWORD     sigInst_methInst_Index;
  39         DWORDLONG args;
  40         DWORD     pSig_Index;
  41         DWORD     cbSig;
  42         DWORDLONG scope;
  43         DWORD     token;
  44     };
  45     struct Agnostic_CORINFO_METHOD_INFO
  46     {
  47         DWORDLONG                 ftn;
  48         DWORDLONG                 scope;
  49         DWORD                     ILCode_offset;
  50         DWORD                     ILCodeSize;
  51         DWORD                     maxStack;
  52         DWORD                     EHcount;
  53         DWORD                     options;
  54         DWORD                     regionKind;
  55         Agnostic_CORINFO_SIG_INFO args;
  56         Agnostic_CORINFO_SIG_INFO locals;
  57     };
  58     struct Agnostic_CompileMethod
  59     {
  60         Agnostic_CORINFO_METHOD_INFO info;
  61         DWORD                        flags;
  62     };
  63     struct Agnostic_InitClass
  64     {
  65         DWORDLONG field;
  66         DWORDLONG method;
  67         DWORDLONG context;
  68         DWORD     speculative;
  69     };
  70     struct DLDL
  71     {
  72         DWORDLONG A;
  73         DWORDLONG B;
  74     };
  75     struct Agnostic_CanInline
  76     {
  77         DWORD Restrictions;
  78         DWORD result;
  79         DWORD exceptionCode;
  80     };
  81     struct Agnostic_GetClassGClayout
  82     {
  83         DWORD gcPtrs_Index;
  84         DWORD len;
  85         DWORD valCount;
  86     };
  87     struct DLD
  88     {
  89         DWORDLONG A;
  90         DWORD     B;
  91     };
  92     struct Agnostic_CORINFO_RESOLVED_TOKENin
  93     {
  94         DWORDLONG tokenContext;
  95         DWORDLONG tokenScope;
  96         DWORD     token;
  97         DWORD     tokenType;
  98     };
  99     struct Agnostic_CORINFO_RESOLVED_TOKENout
 100     {
 101         DWORDLONG hClass;
 102         DWORDLONG hMethod;
 103         DWORDLONG hField;
 104         DWORD     pTypeSpec_Index;
 105         DWORD     cbTypeSpec;
 106         DWORD     pMethodSpec_Index;
 107         DWORD     cbMethodSpec;
 108     };
 109     struct GetArgTypeValue
 110     {
 111         DWORD     flags;
 112         DWORD     numArgs;
 113         DWORD     sigInst_classInstCount;
 114         DWORD     sigInst_classInst_Index;
 115         DWORD     sigInst_methInstCount;
 116         DWORD     sigInst_methInst_Index;
 117         DWORDLONG scope;
 118         DWORDLONG args;
 119     };
 120     struct GetArgClassValue
 121     {
 122         DWORD     sigInst_classInstCount;
 123         DWORD     sigInst_classInst_Index;
 124         DWORD     sigInst_methInstCount;
 125         DWORD     sigInst_methInst_Index;
 126         DWORDLONG scope;
 127         DWORDLONG args;
 128     };
 129     struct Agnostic_GetBoundaries
 130     {
 131         DWORD cILOffsets;
 132         DWORD pILOffset_offset;
 133         DWORD implicitBoundaries;
 134     };
 135     struct Agnostic_CORINFO_EE_INFO
 136     {
 137         struct Agnostic_InlinedCallFrameInfo
 138         {
 139             DWORD size;
 140             DWORD offsetOfGSCookie;
 141             DWORD offsetOfFrameVptr;
 142             DWORD offsetOfFrameLink;
 143             DWORD offsetOfCallSiteSP;
 144             DWORD offsetOfCalleeSavedFP;
 145             DWORD offsetOfCallTarget;
 146             DWORD offsetOfReturnAddress;
 147         } inlinedCallFrameInfo;
 148         DWORD offsetOfThreadFrame;
 149         DWORD offsetOfGCState;
 150         DWORD offsetOfDelegateInstance;
 151         DWORD offsetOfDelegateFirstTarget;
 152         DWORD offsetOfSecureDelegateIndirectCell;
 153         DWORD offsetOfTransparentProxyRP;
 154         DWORD offsetOfRealProxyServer;
 155         DWORD offsetOfObjArrayData;
 156         DWORD sizeOfReversePInvokeFrame;
 157         DWORD osPageSize;
 158         DWORD maxUncheckedOffsetForNullObject;
 159         DWORD targetAbi;
 160         DWORD osType;
 161         DWORD osMajor;
 162         DWORD osMinor;
 163         DWORD osBuild;
 164     };
 165     struct Agnostic_GetFieldAddress
 166     {
 167         DWORDLONG ppIndirection;
 168         DWORDLONG fieldAddress;
 169         DWORD     fieldValue;
 170     };
 171     struct Agnostic_CORINFO_RESOLVED_TOKEN
 172     {
 173         Agnostic_CORINFO_RESOLVED_TOKENin inValue;
 174
 175         Agnostic_CORINFO_RESOLVED_TOKENout outValue;
 176     };
 177     struct Agnostic_GetFieldInfo
 178     {
 179         Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
 180         DWORDLONG                       callerHandle;
 181         DWORD                           flags;
 182     };
 183     struct Agnostic_CORINFO_HELPER_ARG
 184     {
 185         DWORDLONG constant; // one view of a large union of ptr size
 186         DWORD     argType;
 187     };
 188     struct Agnostic_CORINFO_HELPER_DESC
 189     {
 190         DWORD                       helperNum;
 191         DWORD                       numArgs;
 192         Agnostic_CORINFO_HELPER_ARG args[CORINFO_ACCESS_ALLOWED_MAX_ARGS];
 193     };
 194     struct Agnostic_CORINFO_CONST_LOOKUP
 195     {
 196         DWORD     accessType;
 197         DWORDLONG handle; // actually a union of two pointer sized things
 198     };
 199     struct Agnostic_CORINFO_LOOKUP_KIND
 200     {
 201         DWORD needsRuntimeLookup;
 202         DWORD runtimeLookupKind;
 203         WORD  runtimeLookupFlags;
 204     };
 205     struct Agnostic_CORINFO_RUNTIME_LOOKUP
 206     {
 207         DWORDLONG signature;
 208         DWORD     helper;
 209         DWORD     indirections;
 210         DWORD     testForNull;
 211         DWORD     testForFixup;
 212         DWORDLONG offsets[CORINFO_MAXINDIRECTIONS];
 213         DWORD     indirectFirstOffset;
 214         DWORD     indirectSecondOffset;
 215     };
 216     struct Agnostic_CORINFO_LOOKUP
 217     {
 218         Agnostic_CORINFO_LOOKUP_KIND    lookupKind;
 219         Agnostic_CORINFO_RUNTIME_LOOKUP runtimeLookup; // This and constLookup actually a union, but with different
 220                                                        // layouts.. :-| copy the right one based on lookupKinds value
 221         Agnostic_CORINFO_CONST_LOOKUP constLookup;
 222     };
 223     struct Agnostic_CORINFO_FIELD_INFO
 224     {
 225         DWORD                         fieldAccessor;
 226         DWORD                         fieldFlags;
 227         DWORD                         helper;
 228         DWORD                         offset;
 229         DWORD                         fieldType;
 230         DWORDLONG                     structType;
 231         DWORD                         accessAllowed;
 232         Agnostic_CORINFO_HELPER_DESC  accessCalloutHelper;
 233         Agnostic_CORINFO_CONST_LOOKUP fieldLookup;
 234     };
 235     struct DD
 236     {
 237         DWORD A;
 238         DWORD B;
 239     };
 240     struct DDD
 241     {
 242         DWORD A;
 243         DWORD B;
 244         bool C;
 245     };
 246     struct Agnostic_CanTailCall
 247     {
 248         DWORDLONG callerHnd;
 249         DWORDLONG declaredCalleeHnd;
 250         DWORDLONG exactCalleeHnd;
 251         WORD      fIsTailPrefix;
 252     };
 253     struct Agnostic_Environment
 254     {
 255         DWORD name_index;
 256         ;
 257         DWORD val_index;
 258     };
 259     struct Agnostic_GetCallInfo
 260     {
 261         Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
 262         Agnostic_CORINFO_RESOLVED_TOKEN ConstrainedResolvedToken;
 263         DWORDLONG                       callerHandle;
 264         DWORD                           flags;
 265     };
 266
 267     struct Agnostic_CORINFO_CALL_INFO
 268     {
 269         DWORDLONG                     hMethod;
 270         DWORD                         methodFlags;
 271         DWORD                         classFlags;
 272         Agnostic_CORINFO_SIG_INFO     sig;
 273         DWORD                         verMethodFlags;
 274         Agnostic_CORINFO_SIG_INFO     verSig;
 275         DWORD                         accessAllowed;
 276         Agnostic_CORINFO_HELPER_DESC  callsiteCalloutHelper;
 277         DWORD                         thisTransform;
 278         DWORD                         kind;
 279         DWORD                         nullInstanceCheck;
 280         DWORDLONG                     contextHandle;
 281         DWORD                         exactContextNeedsRuntimeLookup;
 282         Agnostic_CORINFO_LOOKUP       stubLookup; // first view of union.  others are matching or subordinate
 283         Agnostic_CORINFO_CONST_LOOKUP instParamLookup;
 284         DWORD                         secureDelegateInvoke;
 285         DWORD                         exceptionCode;
 286     };
 287     struct Agnostic_GetMethodInfo
 288     {
 289         Agnostic_CORINFO_METHOD_INFO info;
 290         bool                         result;
 291         DWORD                        exceptionCode;
 292     };
 293     struct Agnostic_FindSig
 294     {
 295         DWORDLONG module;
 296         DWORD     sigTOK;
 297         DWORDLONG context;
 298     };
 299     struct PInvokeMarshalingRequiredValue
 300     {
 301         DWORDLONG method;
 302         DWORD     pSig_Index;
 303         DWORD     cbSig;
 304         DWORDLONG scope;
 305     };
 306     struct Agnostic_CORINFO_EH_CLAUSE
 307     {
 308         DWORD Flags;
 309         DWORD TryOffset;
 310         DWORD TryLength;
 311         DWORD HandlerOffset;
 312         DWORD HandlerLength;
 313         DWORD ClassToken; // first view of a two dword union
 314     };
 315     struct Agnostic_GetVars
 316     {
 317         DWORD cVars;
 318         DWORD vars_offset;
 319         DWORD extendOthers;
 320     };
 321     struct Agnostic_CanAccessClassIn
 322     {
 323         Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
 324         DWORDLONG                       callerHandle;
 325     };
 326     struct Agnostic_CanAccessClassOut
 327     {
 328         Agnostic_CORINFO_HELPER_DESC AccessHelper;
 329         DWORD                        result;
 330     };
 331     struct Agnostic_AppendClassName
 332     {
 333         DWORDLONG classHandle;
 334         DWORD     fNamespace;
 335         DWORD     fFullInst;
 336         DWORD     fAssembly;
 337     };
 338     struct Agnostic_CheckMethodModifier
 339     {
 340         DWORDLONG hMethod;
 341         DWORD     modifier;
 342         DWORD     fOptional;
 343     };
 344     struct Agnostic_EmbedGenericHandle
 345     {
 346         Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
 347         DWORD                           fEmbedParent;
 348     };
 349     struct Agnostic_CORINFO_GENERICHANDLE_RESULT
 350     {
 351
 352         Agnostic_CORINFO_LOOKUP lookup;
 353         DWORDLONG               compileTimeHandle;
 354         DWORD                   handleType;
 355     };
 356     struct Agnostic_GetDelegateCtorIn
 357     {
 358         DWORDLONG methHnd;
 359         DWORDLONG clsHnd;
 360         DWORDLONG targetMethodHnd;
 361     };
 362     struct Agnostic_DelegateCtorArgs
 363     {
 364         DWORDLONG pMethod;
 365         DWORDLONG pArg3;
 366         DWORDLONG pArg4;
 367         DWORDLONG pArg5;
 368     };
 369     struct Agnostic_GetDelegateCtorOut
 370     {
 371         Agnostic_DelegateCtorArgs CtorData;
 372         DWORDLONG                 result;
 373     };
 374     struct Agnostic_FindCallSiteSig
 375     {
 376         DWORDLONG module;
 377         DWORD     methTok;
 378         DWORDLONG context;
 379     };
 380     struct Agnostic_GetNewHelper
 381     {
 382         DWORDLONG hClass;
 383         DWORDLONG callerHandle;
 384     };
 385     struct Agnostic_GetCastingHelper
 386     {
 387         DWORDLONG hClass;
 388         DWORD     fThrowing;
 389     };
 390     struct Agnostic_GetClassModuleIdForStatics
 391     {
 392         DWORDLONG Module;
 393         DWORDLONG pIndirection;
 394         DWORDLONG result;
 395     };
 396     struct Agnostic_IsCompatibleDelegate
 397     {
 398         DWORDLONG objCls;
 399         DWORDLONG methodParentCls;
 400         DWORDLONG method;
 401         DWORDLONG delegateCls;
 402     };
 403     struct Agnostic_GetBBProfileData
 404     {
 405         DWORD count;
 406         DWORD profileBuffer_index;
 407         DWORD numRuns;
 408         DWORD result;
 409     };
 410     struct Agnostic_GetProfilingHandle
 411     {
 412         DWORD     bHookFunction;
 413         DWORDLONG ProfilerHandle;
 414         DWORD     bIndirectedHandles;
 415     };
 416     struct Agnostic_GetTailCallCopyArgsThunk
 417     {
 418         Agnostic_CORINFO_SIG_INFO Sig;
 419         DWORD                     flags;
 420     };
 421     struct Agnostic_GetArgClass_Value
 422     {
 423         DWORDLONG result;
 424         DWORD     exceptionCode;
 425     };
 426     struct Agnostic_GetArgType_Value
 427     {
 428         DWORDLONG vcTypeRet;
 429         DWORD     result;
 430         DWORD     exceptionCode;
 431     };
 432
 433     // Agnostic_ConfigIntInfo combines as a single key the name
 434     // and defaultValue of a integer config query.
 435     // Note: nameIndex is treated as a DWORD index to the name string.
 436     struct Agnostic_ConfigIntInfo
 437     {
 438         DWORD nameIndex;
 439         DWORD defaultValue;
 440     };
 441
 442     // SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR
 443     struct Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor
 444     {
 445         DWORD passedInRegisters; // Whether the struct is passable/passed (this includes struct returning) in registers.
 446         DWORD eightByteCount;    // Number of eightbytes for this struct.
 447         DWORD eightByteClassifications[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The eightbytes type
 448                                                                                                // classification.
 449         DWORD eightByteSizes[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The size of the eightbytes (an
 450                                                                                      // eightbyte could include padding.
 451                                                                                      // This represents the no padding
 452                                                                                      // size of the eightbyte).
 453         DWORD eightByteOffsets[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The start offset of the
 454                                                                                        // eightbytes (in bytes).
 455         DWORD result;
 456     };
 457
 458     struct Agnostic_ResolveVirtualMethod
 459     {
 460         DWORDLONG virtualMethod;
 461         DWORDLONG implementingClass;
 462         DWORDLONG ownerType;
 463     };
 464
 465     struct ResolveTokenValue
 466     {
 467         Agnostic_CORINFO_RESOLVED_TOKENout tokenOut;
 468         DWORD                              exceptionCode;
 469     };
 470
 471     struct TryResolveTokenValue
 472     {
 473         Agnostic_CORINFO_RESOLVED_TOKENout tokenOut;
 474         DWORD                              success;
 475     };
 476
 477     struct GetTokenTypeAsHandleValue
 478     {
 479         DWORDLONG hMethod;
 480         DWORDLONG hField;
 481     };
 482
 483     struct GetVarArgsHandleValue
 484     {
 485         DWORD     cbSig;
 486         DWORD     pSig_Index;
 487         DWORDLONG scope;
 488         DWORD     token;
 489     };
 490
 491     struct CanGetVarArgsHandleValue
 492     {
 493         DWORDLONG scope;
 494         DWORD     token;
 495     };
 496
 497     struct GetCookieForPInvokeCalliSigValue
 498     {
 499         DWORD     cbSig;
 500         DWORD     pSig_Index;
 501         DWORDLONG scope;
 502         DWORD     token;
 503     };
 504
 505     struct CanGetCookieForPInvokeCalliSigValue
 506     {
 507         DWORDLONG scope;
 508         DWORD     token;
 509     };
 510
 511     struct GetReadyToRunHelper_TOKENin
 512     {
 513         Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
 514         Agnostic_CORINFO_LOOKUP_KIND    GenericLookupKind;
 515         DWORD                           id;
 516     };
 517
 518     struct GetReadyToRunHelper_TOKENout
 519     {
 520         Agnostic_CORINFO_CONST_LOOKUP Lookup;
 521         bool                          result;
 522     };
 523
 524     struct GetReadyToRunDelegateCtorHelper_TOKENIn
 525     {
 526         Agnostic_CORINFO_RESOLVED_TOKEN TargetMethod;
 527         DWORDLONG                       delegateType;
 528     };
 529
 530 #pragma pack(pop)
 531
 532     MethodContext();
 533
 534 private:
 535     MethodContext(HANDLE hFile);
 536     MethodContext(unsigned char* buff, unsigned int totalLen);
 537
 538     void MethodInitHelper(unsigned char* buff, unsigned int totalLen);
 539     void MethodInitHelperFile(HANDLE hFile);
 540
 541     bool Initialize(int loadedCount, unsigned char* buff, DWORD size);
 542     bool Initialize(int loadedCount, HANDLE hFile);
 543
 544     int dumpMD5HashToBuffer(BYTE* pBuffer, int bufLen, char* buff, int len);
 545
 546 public:
 547     static bool Initialize(int loadedCount, unsigned char* buff, DWORD size, /* OUT */ MethodContext** ppmc);
 548     static bool Initialize(int loadedCount, HANDLE hFile, /* OUT */ MethodContext** ppmc);
 549     ~MethodContext();
 550     void Destroy();
 551
 552     bool Equal(MethodContext* other);
 553     unsigned int saveToFile(HANDLE hFile);
 554     unsigned int calculateFileSize();
 555     unsigned int calculateRawFileSize();
 556     void dumpToConsole(int mcNumber = -1); // if mcNumber is not -1, display the method context number before the dumped
 557                                            // info
 558     int dumpStatToBuffer(char* buff, int len);
 559     static int dumpStatTitleToBuffer(char* buff, int len);
 560     int methodSize;
 561
 562     int dumpMethodIdentityInfoToBuffer(char* buff, int len);
 563     int dumpMethodMD5HashToBuffer(char* buff, int len);
 564
 565     void recGlobalContext(const MethodContext& other);
 566
 567     void recEnvironment();
 568     void dmpEnvironment(DWORD key, const Agnostic_Environment& value);
 569     void repEnvironmentSet();
 570     void repEnvironmentUnset();
 571     int  repEnvironmentGetCount();
 572     int  repGetTestID();
 573
 574     void recCompileMethod(CORINFO_METHOD_INFO* info, unsigned flags);
 575     void dmpCompileMethod(DWORD key, const Agnostic_CompileMethod& value);
 576     void repCompileMethod(CORINFO_METHOD_INFO* info, unsigned* flags);
 577
 578     void recGetMethodClass(CORINFO_METHOD_HANDLE methodHandle, CORINFO_CLASS_HANDLE classHandle);
 579     void dmpGetMethodClass(DWORDLONG key, DWORDLONG value);
 580     CORINFO_CLASS_HANDLE repGetMethodClass(CORINFO_METHOD_HANDLE methodHandle);
 581
 582     void recGetClassAttribs(CORINFO_CLASS_HANDLE classHandle, DWORD attribs);
 583     void dmpGetClassAttribs(DWORDLONG key, DWORD value);
 584     DWORD repGetClassAttribs(CORINFO_CLASS_HANDLE classHandle);
 585
 586     void recGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle, DWORD attribs);
 587     void dmpGetMethodAttribs(DWORDLONG key, DWORD value);
 588     DWORD repGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle);
 589
 590     void recGetVars(CORINFO_METHOD_HANDLE ftn, ULONG32* cVars, ICorDebugInfo::ILVarInfo** vars, bool* extendOthers);
 591     void dmpGetVars(DWORDLONG key, const Agnostic_GetVars& value);
 592     void repGetVars(CORINFO_METHOD_HANDLE ftn, ULONG32* cVars, ICorDebugInfo::ILVarInfo** vars, bool* extendOthers);
 593
 594     void recGetBoundaries(CORINFO_METHOD_HANDLE         ftn,
 595                           unsigned int*                 cILOffsets,
 596                           DWORD**                       pILOffsets,
 597                           ICorDebugInfo::BoundaryTypes* implictBoundaries);
 598     void dmpGetBoundaries(DWORDLONG key, const Agnostic_GetBoundaries& value);
 599     void repGetBoundaries(CORINFO_METHOD_HANDLE         ftn,
 600                           unsigned int*                 cILOffsets,
 601                           DWORD**                       pILOffsets,
 602                           ICorDebugInfo::BoundaryTypes* implictBoundaries);
 603
 604     void recInitClass(CORINFO_FIELD_HANDLE   field,
 605                       CORINFO_METHOD_HANDLE  method,
 606                       CORINFO_CONTEXT_HANDLE context,
 607                       BOOL                   speculative,
 608                       CorInfoInitClassResult result);
 609     void dmpInitClass(const Agnostic_InitClass& key, DWORD value);
 610     CorInfoInitClassResult repInitClass(CORINFO_FIELD_HANDLE   field,
 611                                         CORINFO_METHOD_HANDLE  method,
 612                                         CORINFO_CONTEXT_HANDLE context,
 613                                         BOOL                   speculative);
 614
 615     void recGetMethodName(CORINFO_METHOD_HANDLE ftn, char* methodname, const char** moduleName);
 616     void dmpGetMethodName(DLD key, DD value);
 617     const char* repGetMethodName(CORINFO_METHOD_HANDLE ftn, const char** moduleName);
 618
 619     void recGetJitFlags(CORJIT_FLAGS* jitFlags, DWORD sizeInBytes, DWORD result);
 620     void dmpGetJitFlags(DWORD key, DD value);
 621     DWORD repGetJitFlags(CORJIT_FLAGS* jitFlags, DWORD sizeInBytes);
 622
 623     void recGetJitTimeLogFilename(LPCWSTR tempFileName);
 624     void dmpGetJitTimeLogFilename(DWORD key, DWORD value);
 625     LPCWSTR repGetJitTimeLogFilename();
 626
 627     void recCanInline(CORINFO_METHOD_HANDLE callerHnd,
 628                       CORINFO_METHOD_HANDLE calleeHnd,
 629                       DWORD*                pRestrictions,
 630                       CorInfoInline         response,
 631                       DWORD                 exceptionCode);
 632     void dmpCanInline(DLDL key, const Agnostic_CanInline& value);
 633     CorInfoInline repCanInline(CORINFO_METHOD_HANDLE callerHnd,
 634                                CORINFO_METHOD_HANDLE calleeHnd,
 635                                DWORD*                pRestrictions,
 636                                DWORD*                exceptionCode);
 637
 638     void recResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, DWORD exceptionCode);
 639     void dmpResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const ResolveTokenValue& value);
 640     void repResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, DWORD* exceptionCode);
 641
 642     void recTryResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool success);
 643     void dmpTryResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const TryResolveTokenValue& value);
 644     bool repTryResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken);
 645
 646     void recGetCallInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 647                         CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken,
 648                         CORINFO_METHOD_HANDLE   callerHandle,
 649                         CORINFO_CALLINFO_FLAGS  flags,
 650                         CORINFO_CALL_INFO*      pResult,
 651                         DWORD                   exceptionCode);
 652     void dmpGetCallInfo(const Agnostic_GetCallInfo& key, const Agnostic_CORINFO_CALL_INFO& value);
 653     void repGetCallInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 654                         CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken,
 655                         CORINFO_METHOD_HANDLE   callerHandle,
 656                         CORINFO_CALLINFO_FLAGS  flags,
 657                         CORINFO_CALL_INFO*      pResult,
 658                         DWORD*                  exceptionCode);
 659     void repGetCallInfoFromMethodHandle(CORINFO_METHOD_HANDLE methodHandle, CORINFO_CALL_INFO* pResult);
 660
 661     void recGetIntrinsicID(CORINFO_METHOD_HANDLE method, bool* pMustExpand, CorInfoIntrinsics result);
 662     void dmpGetIntrinsicID(DWORDLONG key, DD value);
 663     CorInfoIntrinsics repGetIntrinsicID(CORINFO_METHOD_HANDLE method, bool* pMustExpand);
 664
 665     void recGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CorInfoUnmanagedCallConv result);
 666     void dmpGetUnmanagedCallConv(DWORDLONG key, DWORD result);
 667     CorInfoUnmanagedCallConv repGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method);
 668
 669     void recIsInstantiationOfVerifiedGeneric(CORINFO_METHOD_HANDLE method, CorInfoInstantiationVerification result);
 670     void dmpIsInstantiationOfVerifiedGeneric(DWORDLONG key, DWORD value);
 671     CorInfoInstantiationVerification repIsInstantiationOfVerifiedGeneric(CORINFO_METHOD_HANDLE method);
 672
 673     void recAsCorInfoType(CORINFO_CLASS_HANDLE cls, CorInfoType result);
 674     void dmpAsCorInfoType(DWORDLONG key, DWORD value);
 675     CorInfoType repAsCorInfoType(CORINFO_CLASS_HANDLE cls);
 676
 677     void recIsValueClass(CORINFO_CLASS_HANDLE cls, BOOL result);
 678     void dmpIsValueClass(DWORDLONG key, DWORD value);
 679     BOOL repIsValueClass(CORINFO_CLASS_HANDLE cls);
 680
 681     void recIsStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls, BOOL result);
 682     void dmpIsStructRequiringStackAllocRetBuf(DWORDLONG key, DWORD value);
 683     BOOL repIsStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cls);
 684
 685     void recGetClassSize(CORINFO_CLASS_HANDLE cls, unsigned result);
 686     void dmpGetClassSize(DWORDLONG key, DWORD val);
 687     unsigned repGetClassSize(CORINFO_CLASS_HANDLE cls);
 688
 689     void recGetClassNumInstanceFields(CORINFO_CLASS_HANDLE cls, unsigned result);
 690     void dmpGetClassNumInstanceFields(DWORDLONG key, DWORD value);
 691     unsigned repGetClassNumInstanceFields(CORINFO_CLASS_HANDLE cls);
 692
 693     void recGetNewArrHelper(CORINFO_CLASS_HANDLE arrayCls, CorInfoHelpFunc result);
 694     void dmpGetNewArrHelper(DWORDLONG key, DWORD value);
 695     CorInfoHelpFunc repGetNewArrHelper(CORINFO_CLASS_HANDLE arrayCls);
 696
 697     void recGetSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd, CorInfoHelpFunc result);
 698     void dmpGetSharedCCtorHelper(DWORDLONG key, DWORD value);
 699     CorInfoHelpFunc repGetSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd);
 700
 701     void recGetSecurityPrologHelper(CORINFO_METHOD_HANDLE ftn, CorInfoHelpFunc result);
 702     void dmpGetSecurityPrologHelper(DWORDLONG key, DWORD value);
 703     CorInfoHelpFunc repGetSecurityPrologHelper(CORINFO_METHOD_HANDLE ftn);
 704
 705     void recGetTypeForBox(CORINFO_CLASS_HANDLE cls, CORINFO_CLASS_HANDLE result);
 706     void dmpGetTypeForBox(DWORDLONG key, DWORDLONG value);
 707     CORINFO_CLASS_HANDLE repGetTypeForBox(CORINFO_CLASS_HANDLE cls);
 708
 709     void recGetBoxHelper(CORINFO_CLASS_HANDLE cls, CorInfoHelpFunc result);
 710     void dmpGetBoxHelper(DWORDLONG key, DWORD value);
 711     CorInfoHelpFunc repGetBoxHelper(CORINFO_CLASS_HANDLE cls);
 712
 713     void recGetBuiltinClass(CorInfoClassId classId, CORINFO_CLASS_HANDLE result);
 714     void dmpGetBuiltinClass(DWORD key, DWORDLONG value);
 715     CORINFO_CLASS_HANDLE repGetBuiltinClass(CorInfoClassId classId);
 716
 717     void recGetTypeForPrimitiveValueClass(CORINFO_CLASS_HANDLE cls, CorInfoType result);
 718     void dmpGetTypeForPrimitiveValueClass(DWORDLONG key, DWORD value);
 719     CorInfoType repGetTypeForPrimitiveValueClass(CORINFO_CLASS_HANDLE cls);
 720
 721     void recGetParentType(CORINFO_CLASS_HANDLE cls, CORINFO_CLASS_HANDLE result);
 722     void dmpGetParentType(DWORDLONG key, DWORDLONG value);
 723     CORINFO_CLASS_HANDLE repGetParentType(CORINFO_CLASS_HANDLE cls);
 724
 725     void recIsSDArray(CORINFO_CLASS_HANDLE cls, BOOL result);
 726     void dmpIsSDArray(DWORDLONG key, DWORD value);
 727     BOOL repIsSDArray(CORINFO_CLASS_HANDLE cls);
 728
 729     void recIsInSIMDModule(CORINFO_CLASS_HANDLE cls, BOOL result);
 730     void dmpIsInSIMDModule(DWORDLONG key, DWORD value);
 731     BOOL repIsInSIMDModule(CORINFO_CLASS_HANDLE cls);
 732
 733     void recGetFieldClass(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE result);
 734     void dmpGetFieldClass(DWORDLONG key, DWORDLONG value);
 735     CORINFO_CLASS_HANDLE repGetFieldClass(CORINFO_FIELD_HANDLE field);
 736
 737     void recGetFieldOffset(CORINFO_FIELD_HANDLE field, unsigned result);
 738     void dmpGetFieldOffset(DWORDLONG key, DWORD value);
 739     unsigned repGetFieldOffset(CORINFO_FIELD_HANDLE field);
 740
 741     void recGetLazyStringLiteralHelper(CORINFO_MODULE_HANDLE handle, CorInfoHelpFunc result);
 742     void dmpGetLazyStringLiteralHelper(DWORDLONG key, DWORD value);
 743     CorInfoHelpFunc repGetLazyStringLiteralHelper(CORINFO_MODULE_HANDLE handle);
 744
 745     void recGetUnBoxHelper(CORINFO_CLASS_HANDLE cls, CorInfoHelpFunc result);
 746     void dmpGetUnBoxHelper(DWORDLONG key, DWORD value);
 747     CorInfoHelpFunc repGetUnBoxHelper(CORINFO_CLASS_HANDLE cls);
 748
 749     void recGetReadyToRunHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 750                                 CORINFO_LOOKUP_KIND*    pGenericLookupKind,
 751                                 CorInfoHelpFunc         id,
 752                                 CORINFO_CONST_LOOKUP*   pLookup,
 753                                 bool                    result);
 754     void dmpGetReadyToRunHelper(GetReadyToRunHelper_TOKENin key, GetReadyToRunHelper_TOKENout value);
 755     bool repGetReadyToRunHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 756                                 CORINFO_LOOKUP_KIND*    pGenericLookupKind,
 757                                 CorInfoHelpFunc         id,
 758                                 CORINFO_CONST_LOOKUP*   pLookup);
 759
 760     void recGetReadyToRunDelegateCtorHelper(CORINFO_RESOLVED_TOKEN* pTargetMethod,
 761                                             CORINFO_CLASS_HANDLE    delegateType,
 762                                             CORINFO_LOOKUP*         pLookup);
 763     void dmpGetReadyToRunDelegateCtorHelper(GetReadyToRunDelegateCtorHelper_TOKENIn key,
 764                                             Agnostic_CORINFO_LOOKUP                 pLookup);
 765     void repGetReadyToRunDelegateCtorHelper(CORINFO_RESOLVED_TOKEN* pTargetMethod,
 766                                             CORINFO_CLASS_HANDLE    delegateType,
 767                                             CORINFO_LOOKUP*         pLookup);
 768
 769     void recGetHelperFtn(CorInfoHelpFunc ftnNum, void** ppIndirection, void* result);
 770     void dmpGetHelperFtn(DWORD key, DLDL value);
 771     void* repGetHelperFtn(CorInfoHelpFunc ftnNum, void** ppIndirection);
 772     bool fndGetHelperFtn(void* functionAddress, CorInfoHelpFunc* pResult);
 773
 774     void recGetJustMyCodeHandle(CORINFO_METHOD_HANDLE         method,
 775                                 CORINFO_JUST_MY_CODE_HANDLE** ppIndirection,
 776                                 CORINFO_JUST_MY_CODE_HANDLE   result);
 777     void dmpGetJustMyCodeHandle(DWORDLONG key, DLDL value);
 778     CORINFO_JUST_MY_CODE_HANDLE repGetJustMyCodeHandle(CORINFO_METHOD_HANDLE         method,
 779                                                        CORINFO_JUST_MY_CODE_HANDLE** ppIndirection);
 780
 781     void recGetFunctionEntryPoint(CORINFO_METHOD_HANDLE ftn,
 782                                   CORINFO_CONST_LOOKUP* pResult,
 783                                   CORINFO_ACCESS_FLAGS  accessFlags);
 784     void dmpGetFunctionEntryPoint(DLD key, DLD value);
 785     void repGetFunctionEntryPoint(CORINFO_METHOD_HANDLE ftn,
 786                                   CORINFO_CONST_LOOKUP* pResult,
 787                                   CORINFO_ACCESS_FLAGS  accessFlags);
 788     bool fndGetFunctionEntryPoint(DLD value, CORINFO_METHOD_HANDLE* pResult);
 789
 790     void recConstructStringLiteral(CORINFO_MODULE_HANDLE module, mdToken metaTok, void* ppValue, InfoAccessType result);
 791     void dmpConstructStringLiteral(DLD key, DLD value);
 792     InfoAccessType repConstructStringLiteral(CORINFO_MODULE_HANDLE module, mdToken metaTok, void** ppValue);
 793
 794     void recEmptyStringLiteral(void** ppValue, InfoAccessType result);
 795     void dmpEmptyStringLiteral(DWORD key, DLD value);
 796     InfoAccessType repEmptyStringLiteral(void** ppValue);
 797
 798     void recGetArgType(CORINFO_SIG_INFO*       sig,
 799                        CORINFO_ARG_LIST_HANDLE args,
 800                        CORINFO_CLASS_HANDLE*   vcTypeRet,
 801                        CorInfoTypeWithMod      result,
 802                        DWORD                   exception);
 803     void dmpGetArgType(const GetArgTypeValue& key, const Agnostic_GetArgType_Value& value);
 804     CorInfoTypeWithMod repGetArgType(CORINFO_SIG_INFO*       sig,
 805                                      CORINFO_ARG_LIST_HANDLE args,
 806                                      CORINFO_CLASS_HANDLE*   vcTypeRet,
 807                                      DWORD*                  exception);
 808
 809     void recGetArgNext(CORINFO_ARG_LIST_HANDLE args, CORINFO_ARG_LIST_HANDLE result);
 810     void dmpGetArgNext(DWORDLONG key, DWORDLONG value);
 811     CORINFO_ARG_LIST_HANDLE repGetArgNext(CORINFO_ARG_LIST_HANDLE args);
 812
 813     void recGetMethodSig(CORINFO_METHOD_HANDLE ftn, CORINFO_SIG_INFO* sig, CORINFO_CLASS_HANDLE memberParent);
 814     void dmpGetMethodSig(DLDL key, const Agnostic_CORINFO_SIG_INFO& value);
 815     void repGetMethodSig(CORINFO_METHOD_HANDLE ftn, CORINFO_SIG_INFO* sig, CORINFO_CLASS_HANDLE memberParent);
 816
 817     void recGetArgClass(CORINFO_SIG_INFO*       sig,
 818                         CORINFO_ARG_LIST_HANDLE args,
 819                         CORINFO_CLASS_HANDLE    result,
 820                         DWORD                   exceptionCode);
 821     void dmpGetArgClass(const GetArgClassValue& key, const Agnostic_GetArgClass_Value& value);
 822     CORINFO_CLASS_HANDLE repGetArgClass(CORINFO_SIG_INFO* sig, CORINFO_ARG_LIST_HANDLE args, DWORD* exceptionCode);
 823
 824     void recGetHFAType(CORINFO_CLASS_HANDLE clsHnd, CorInfoType result);
 825     void dmpGetHFAType(DWORDLONG key, DWORD value);
 826     CorInfoType repGetHFAType(CORINFO_CLASS_HANDLE clsHnd);
 827
 828     void recGetMethodInfo(CORINFO_METHOD_HANDLE ftn, CORINFO_METHOD_INFO* info, bool result, DWORD exceptionCode);
 829     void dmpGetMethodInfo(DWORDLONG key, const Agnostic_GetMethodInfo& value);
 830     bool repGetMethodInfo(CORINFO_METHOD_HANDLE ftn, CORINFO_METHOD_INFO* info, DWORD* exceptionCode);
 831
 832     void recGetNewHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 833                          CORINFO_METHOD_HANDLE   callerHandle,
 834                          CorInfoHelpFunc         result);
 835     void dmpGetNewHelper(const Agnostic_GetNewHelper& key, DWORD value);
 836     CorInfoHelpFunc repGetNewHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle);
 837
 838     void recEmbedGenericHandle(CORINFO_RESOLVED_TOKEN*       pResolvedToken,
 839                                BOOL                          fEmbedParent,
 840                                CORINFO_GENERICHANDLE_RESULT* pResult);
 841     void dmpEmbedGenericHandle(const Agnostic_EmbedGenericHandle&           key,
 842                                const Agnostic_CORINFO_GENERICHANDLE_RESULT& value);
 843     void repEmbedGenericHandle(CORINFO_RESOLVED_TOKEN*       pResolvedToken,
 844                                BOOL                          fEmbedParent,
 845                                CORINFO_GENERICHANDLE_RESULT* pResult);
 846
 847     void recGetEHinfo(CORINFO_METHOD_HANDLE ftn, unsigned EHnumber, CORINFO_EH_CLAUSE* clause);
 848     void dmpGetEHinfo(DLD key, const Agnostic_CORINFO_EH_CLAUSE& value);
 849     void repGetEHinfo(CORINFO_METHOD_HANDLE ftn, unsigned EHnumber, CORINFO_EH_CLAUSE* clause);
 850
 851     void recGetMethodVTableOffset(CORINFO_METHOD_HANDLE method,
 852                                   unsigned*             offsetOfIndirection,
 853                                   unsigned*             offsetAfterIndirection,
 854                                   bool*                 isRelative);
 855     void dmpGetMethodVTableOffset(DWORDLONG key, DDD value);
 856     void repGetMethodVTableOffset(CORINFO_METHOD_HANDLE method,
 857                                   unsigned*             offsetOfIndirection,
 858                                   unsigned*             offsetAfterIndirection,
 859                                   bool*                 isRelative);
 860
 861     void recResolveVirtualMethod(CORINFO_METHOD_HANDLE  virtMethod,
 862                                  CORINFO_CLASS_HANDLE   implClass,
 863                                  CORINFO_CONTEXT_HANDLE ownerType,
 864                                  CORINFO_METHOD_HANDLE  result);
 865     void dmpResolveVirtualMethod(const Agnostic_ResolveVirtualMethod& key, DWORDLONG value);
 866     CORINFO_METHOD_HANDLE repResolveVirtualMethod(CORINFO_METHOD_HANDLE  virtMethod,
 867                                                   CORINFO_CLASS_HANDLE   implClass,
 868                                                   CORINFO_CONTEXT_HANDLE ownerType);
 869
 870     void recGetTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_CLASS_HANDLE result);
 871     void dmpGetTokenTypeAsHandle(const GetTokenTypeAsHandleValue& key, DWORDLONG value);
 872     CORINFO_CLASS_HANDLE repGetTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken);
 873
 874     void recGetFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 875                          CORINFO_METHOD_HANDLE   callerHandle,
 876                          CORINFO_ACCESS_FLAGS    flags,
 877                          CORINFO_FIELD_INFO*     pResult);
 878     void dmpGetFieldInfo(const Agnostic_GetFieldInfo& key, const Agnostic_CORINFO_FIELD_INFO& value);
 879     void repGetFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 880                          CORINFO_METHOD_HANDLE   callerHandle,
 881                          CORINFO_ACCESS_FLAGS    flags,
 882                          CORINFO_FIELD_INFO*     pResult);
 883
 884     void recEmbedMethodHandle(CORINFO_METHOD_HANDLE handle, void** ppIndirection, CORINFO_METHOD_HANDLE result);
 885     void dmpEmbedMethodHandle(DWORDLONG key, DLDL value);
 886     CORINFO_METHOD_HANDLE repEmbedMethodHandle(CORINFO_METHOD_HANDLE handle, void** ppIndirection);
 887
 888     void recGetFieldAddress(CORINFO_FIELD_HANDLE field, void** ppIndirection, void* result, CorInfoType cit);
 889     void dmpGetFieldAddress(DWORDLONG key, const Agnostic_GetFieldAddress& value);
 890     void* repGetFieldAddress(CORINFO_FIELD_HANDLE field, void** ppIndirection);
 891
 892     void recGetClassGClayout(CORINFO_CLASS_HANDLE cls, BYTE* gcPtrs, unsigned len, unsigned result);
 893     void dmpGetClassGClayout(DWORDLONG key, const Agnostic_GetClassGClayout& value);
 894     unsigned repGetClassGClayout(CORINFO_CLASS_HANDLE cls, BYTE* gcPtrs);
 895
 896     void recGetClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, BOOL fDoubleAlignHint, unsigned result);
 897     void dmpGetClassAlignmentRequirement(DLD key, DWORD value);
 898     unsigned repGetClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, BOOL fDoubleAlignHint);
 899
 900     void recCanAccessClass(CORINFO_RESOLVED_TOKEN*      pResolvedToken,
 901                            CORINFO_METHOD_HANDLE        callerHandle,
 902                            CORINFO_HELPER_DESC*         pAccessHelper,
 903                            CorInfoIsAccessAllowedResult result);
 904     void dmpCanAccessClass(const Agnostic_CanAccessClassIn& key, const Agnostic_CanAccessClassOut& value);
 905     CorInfoIsAccessAllowedResult repCanAccessClass(CORINFO_RESOLVED_TOKEN* pResolvedToken,
 906                                                    CORINFO_METHOD_HANDLE   callerHandle,
 907                                                    CORINFO_HELPER_DESC*    pAccessHelper);
 908
 909     void recGetCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fThrowing, CorInfoHelpFunc result);
 910     void dmpGetCastingHelper(const Agnostic_GetCastingHelper& key, DWORD value);
 911     CorInfoHelpFunc repGetCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fThrowing);
 912
 913     void recEmbedModuleHandle(CORINFO_MODULE_HANDLE handle, void** ppIndirection, CORINFO_MODULE_HANDLE result);
 914     void dmpEmbedModuleHandle(DWORDLONG key, DLDL value);
 915     CORINFO_MODULE_HANDLE repEmbedModuleHandle(CORINFO_MODULE_HANDLE handle, void** ppIndirection);
 916
 917     void recEmbedClassHandle(CORINFO_CLASS_HANDLE handle, void** ppIndirection, CORINFO_CLASS_HANDLE result);
 918     void dmpEmbedClassHandle(DWORDLONG key, DLDL value);
 919     CORINFO_CLASS_HANDLE repEmbedClassHandle(CORINFO_CLASS_HANDLE handle, void** ppIndirection);
 920
 921     void recPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig, BOOL result);
 922     void dmpPInvokeMarshalingRequired(const PInvokeMarshalingRequiredValue& key, DWORD value);
 923     BOOL repPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig);
 924
 925     void recFindSig(CORINFO_MODULE_HANDLE  module,
 926                     unsigned               sigTOK,
 927                     CORINFO_CONTEXT_HANDLE context,
 928                     CORINFO_SIG_INFO*      sig);
 929     void dmpFindSig(const Agnostic_FindSig& key, const Agnostic_CORINFO_SIG_INFO& value);
 930     void repFindSig(CORINFO_MODULE_HANDLE  module,
 931                     unsigned               sigTOK,
 932                     CORINFO_CONTEXT_HANDLE context,
 933                     CORINFO_SIG_INFO*      sig);
 934
 935     void recGetEEInfo(CORINFO_EE_INFO* pEEInfoOut);
 936     void dmpGetEEInfo(DWORD key, const Agnostic_CORINFO_EE_INFO& value);
 937     void repGetEEInfo(CORINFO_EE_INFO* pEEInfoOut);
 938
 939     void recGetGSCookie(GSCookie* pCookieVal, GSCookie** ppCookieVal);
 940     void dmpGetGSCookie(DWORD key, DLDL value);
 941     void repGetGSCookie(GSCookie* pCookieVal, GSCookie** ppCookieVal);
 942
 943     void recGetClassModuleIdForStatics(CORINFO_CLASS_HANDLE   cls,
 944                                        CORINFO_MODULE_HANDLE* pModule,
 945                                        void**                 ppIndirection,
 946                                        size_t                 result);
 947     void dmpGetClassModuleIdForStatics(DWORDLONG key, const Agnostic_GetClassModuleIdForStatics& value);
 948     size_t repGetClassModuleIdForStatics(CORINFO_CLASS_HANDLE   cls,
 949                                          CORINFO_MODULE_HANDLE* pModule,
 950                                          void**                 ppIndirection);
 951
 952     void recGetThreadTLSIndex(void** ppIndirection, DWORD result);
 953     void dmpGetThreadTLSIndex(DWORD key, DLD value);
 954     DWORD repGetThreadTLSIndex(void** ppIndirection);
 955
 956     void recGetInlinedCallFrameVptr(void** ppIndirection, const void* result);
 957     void dmpGetInlinedCallFrameVptr(DWORD key, DLDL value);
 958     const void* repGetInlinedCallFrameVptr(void** ppIndirection);
 959
 960     void recGetAddrOfCaptureThreadGlobal(void** ppIndirection, LONG* result);
 961     void dmpGetAddrOfCaptureThreadGlobal(DWORD key, DLDL value);
 962     LONG* repGetAddrOfCaptureThreadGlobal(void** ppIndirection);
 963
 964     void recGetClassDomainID(CORINFO_CLASS_HANDLE cls, void** ppIndirection, unsigned result);
 965     void dmpGetClassDomainID(DWORDLONG key, DLD value);
 966     unsigned repGetClassDomainID(CORINFO_CLASS_HANDLE cls, void** ppIndirection);
 967
 968     void recGetLocationOfThisType(CORINFO_METHOD_HANDLE context, CORINFO_LOOKUP_KIND* result);
 969     void dmpGetLocationOfThisType(DWORDLONG key, const Agnostic_CORINFO_LOOKUP_KIND& value);
 970     CORINFO_LOOKUP_KIND repGetLocationOfThisType(CORINFO_METHOD_HANDLE context);
 971
 972     void recGetDelegateCtor(CORINFO_METHOD_HANDLE methHnd,
 973                             CORINFO_CLASS_HANDLE  clsHnd,
 974                             CORINFO_METHOD_HANDLE targetMethodHnd,
 975                             DelegateCtorArgs*     pCtorData,
 976                             CORINFO_METHOD_HANDLE result);
 977     void dmpGetDelegateCtor(const Agnostic_GetDelegateCtorIn& key, const Agnostic_GetDelegateCtorOut& value);
 978     CORINFO_METHOD_HANDLE repGetDelegateCtor(CORINFO_METHOD_HANDLE methHnd,
 979                                              CORINFO_CLASS_HANDLE  clsHnd,
 980                                              CORINFO_METHOD_HANDLE targetMethodHnd,
 981                                              DelegateCtorArgs*     pCtorData);
 982
 983     void recGetFunctionFixedEntryPoint(CORINFO_METHOD_HANDLE ftn, CORINFO_CONST_LOOKUP* pResult);
 984     void dmpGetFunctionFixedEntryPoint(DWORDLONG key, const Agnostic_CORINFO_CONST_LOOKUP& value);
 985     void repGetFunctionFixedEntryPoint(CORINFO_METHOD_HANDLE ftn, CORINFO_CONST_LOOKUP* pResult);
 986
 987     void recGetFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num, CORINFO_FIELD_HANDLE result);
 988     void dmpGetFieldInClass(DLD key, DWORDLONG value);
 989     CORINFO_FIELD_HANDLE repGetFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num);
 990
 991     void recGetFieldType(CORINFO_FIELD_HANDLE  field,
 992                          CORINFO_CLASS_HANDLE* structType,
 993                          CORINFO_CLASS_HANDLE  memberParent,
 994                          CorInfoType           result);
 995     void dmpGetFieldType(DLDL key, DLD value);
 996     CorInfoType repGetFieldType(CORINFO_FIELD_HANDLE  field,
 997                                 CORINFO_CLASS_HANDLE* structType,
 998                                 CORINFO_CLASS_HANDLE  memberParent);
 999
1000     void recGetFieldName(CORINFO_FIELD_HANDLE ftn, const char** moduleName, const char* result);
1001     void dmpGetFieldName(DWORDLONG key, DD value);
1002     const char* repGetFieldName(CORINFO_FIELD_HANDLE ftn, const char** moduleName);
1003
1004     void recCanInlineTypeCheckWithObjectVTable(CORINFO_CLASS_HANDLE cls, BOOL result);
1005     void dmpCanInlineTypeCheckWithObjectVTable(DWORDLONG key, DWORD value);
1006     BOOL repCanInlineTypeCheckWithObjectVTable(CORINFO_CLASS_HANDLE cls);
1007
1008     void recSatisfiesMethodConstraints(CORINFO_CLASS_HANDLE parent, CORINFO_METHOD_HANDLE method, BOOL result);
1009     void dmpSatisfiesMethodConstraints(DLDL key, DWORD value);
1010     BOOL repSatisfiesMethodConstraints(CORINFO_CLASS_HANDLE parent, CORINFO_METHOD_HANDLE method);
1011
1012     void recInitConstraintsForVerification(CORINFO_METHOD_HANDLE method,
1013                                            BOOL*                 pfHasCircularClassConstraints,
1014                                            BOOL*                 pfHasCircularMethodConstraint);
1015     void dmpInitConstraintsForVerification(DWORDLONG key, DD value);
1016     void repInitConstraintsForVerification(CORINFO_METHOD_HANDLE method,
1017                                            BOOL*                 pfHasCircularClassConstraints,
1018                                            BOOL*                 pfHasCircularMethodConstraint);
1019
1020     void recIsValidStringRef(CORINFO_MODULE_HANDLE module, unsigned metaTOK, BOOL result);
1021     void dmpIsValidStringRef(DLD key, DWORD value);
1022     BOOL repIsValidStringRef(CORINFO_MODULE_HANDLE module, unsigned metaTOK);
1023
1024     void recGetHelperName(CorInfoHelpFunc funcNum, const char* result);
1025     void dmpGetHelperName(DWORD key, DWORD value);
1026     const char* repGetHelperName(CorInfoHelpFunc funcNum);
1027
1028     void recCanCast(CORINFO_CLASS_HANDLE child, CORINFO_CLASS_HANDLE parent, BOOL result);
1029     void dmpCanCast(DLDL key, DWORD value);
1030     BOOL repCanCast(CORINFO_CLASS_HANDLE child, CORINFO_CLASS_HANDLE parent);
1031
1032     void recGetChildType(CORINFO_CLASS_HANDLE clsHnd, CORINFO_CLASS_HANDLE* clsRet, CorInfoType result);
1033     void dmpGetChildType(DWORDLONG key, DLD value);
1034     CorInfoType repGetChildType(CORINFO_CLASS_HANDLE clsHnd, CORINFO_CLASS_HANDLE* clsRet);
1035
1036     void recGetArrayInitializationData(CORINFO_FIELD_HANDLE field, DWORD size, void* result);
1037     void dmpGetArrayInitializationData(DLD key, DWORDLONG value);
1038     void* repGetArrayInitializationData(CORINFO_FIELD_HANDLE field, DWORD size);
1039
1040     void recFilterException(struct _EXCEPTION_POINTERS* pExceptionPointers, int result);
1041     void dmpFilterException(DWORD key, DWORD value);
1042     int repFilterException(struct _EXCEPTION_POINTERS* pExceptionPointers);
1043
1044     void recHandleException(struct _EXCEPTION_POINTERS* pExceptionPointers);
1045     void dmpHandleException(DWORD key, DWORD value);
1046
1047     void recGetAddressOfPInvokeFixup(CORINFO_METHOD_HANDLE method, void** ppIndirection, void* result);
1048     void dmpGetAddressOfPInvokeFixup(DWORDLONG key, DLDL value);
1049     void* repGetAddressOfPInvokeFixup(CORINFO_METHOD_HANDLE method, void** ppIndirection);
1050
1051     void recGetAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method, CORINFO_CONST_LOOKUP* pLookup);
1052     void dmpGetAddressOfPInvokeTarget(DWORDLONG key, DLD value);
1053     void repGetAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method, CORINFO_CONST_LOOKUP* pLookup);
1054
1055     void recSatisfiesClassConstraints(CORINFO_CLASS_HANDLE cls, BOOL result);
1056     void dmpSatisfiesClassConstraints(DWORDLONG key, DWORD value);
1057     BOOL repSatisfiesClassConstraints(CORINFO_CLASS_HANDLE cls);
1058
1059     void recGetMethodHash(CORINFO_METHOD_HANDLE ftn, unsigned result);
1060     void dmpGetMethodHash(DWORDLONG key, DWORD value);
1061     unsigned repGetMethodHash(CORINFO_METHOD_HANDLE ftn);
1062
1063     void recCanTailCall(CORINFO_METHOD_HANDLE callerHnd,
1064                         CORINFO_METHOD_HANDLE declaredCalleeHnd,
1065                         CORINFO_METHOD_HANDLE exactCalleeHnd,
1066                         bool                  fIsTailPrefix,
1067                         bool                  result);
1068     void dmpCanTailCall(const Agnostic_CanTailCall& key, DWORD value);
1069     bool repCanTailCall(CORINFO_METHOD_HANDLE callerHnd,
1070                         CORINFO_METHOD_HANDLE declaredCalleeHnd,
1071                         CORINFO_METHOD_HANDLE exactCalleeHnd,
1072                         bool                  fIsTailPrefix);
1073
1074     void recIsCompatibleDelegate(CORINFO_CLASS_HANDLE  objCls,
1075                                  CORINFO_CLASS_HANDLE  methodParentCls,
1076                                  CORINFO_METHOD_HANDLE method,
1077                                  CORINFO_CLASS_HANDLE  delegateCls,
1078                                  BOOL*                 pfIsOpenDelegate,
1079                                  BOOL                  result);
1080     void dmpIsCompatibleDelegate(const Agnostic_IsCompatibleDelegate& key, DD value);
1081     BOOL repIsCompatibleDelegate(CORINFO_CLASS_HANDLE  objCls,
1082                                  CORINFO_CLASS_HANDLE  methodParentCls,
1083                                  CORINFO_METHOD_HANDLE method,
1084                                  CORINFO_CLASS_HANDLE  delegateCls,
1085                                  BOOL*                 pfIsOpenDelegate);
1086
1087     void recIsDelegateCreationAllowed(CORINFO_CLASS_HANDLE delegateHnd, CORINFO_METHOD_HANDLE calleeHnd, BOOL result);
1088     void dmpIsDelegateCreationAllowed(DLDL key, DWORD value);
1089     BOOL repIsDelegateCreationAllowed(CORINFO_CLASS_HANDLE delegateHnd, CORINFO_METHOD_HANDLE calleeHnd);
1090
1091     void recCanSkipMethodVerification(CORINFO_METHOD_HANDLE            ftnHandle,
1092                                       BOOL                             skip,
1093                                       CorInfoCanSkipVerificationResult result);
1094     void dmpCanSkipMethodVerification(DLD key, DWORD value);
1095     CorInfoCanSkipVerificationResult repCanSkipMethodVerification(CORINFO_METHOD_HANDLE ftnHandle, BOOL skip);
1096
1097     void recFindCallSiteSig(CORINFO_MODULE_HANDLE  module,
1098                             unsigned               methTOK,
1099                             CORINFO_CONTEXT_HANDLE context,
1100                             CORINFO_SIG_INFO*      sig);
1101     void dmpFindCallSiteSig(const Agnostic_FindCallSiteSig& key, const Agnostic_CORINFO_SIG_INFO& value);
1102     void repFindCallSiteSig(CORINFO_MODULE_HANDLE  module,
1103                             unsigned               methTOK,
1104                             CORINFO_CONTEXT_HANDLE context,
1105                             CORINFO_SIG_INFO*      sig);
1106
1107     void recShouldEnforceCallvirtRestriction(CORINFO_MODULE_HANDLE scope, BOOL result);
1108     void dmpShouldEnforceCallvirtRestriction(DWORDLONG key, DWORD value);
1109     BOOL repShouldEnforceCallvirtRestriction(CORINFO_MODULE_HANDLE scope);
1110
1111     void recGetMethodSync(CORINFO_METHOD_HANDLE ftn, void** ppIndirection, void* result);
1112     void dmpGetMethodSync(DWORDLONG key, DLDL value);
1113     void* repGetMethodSync(CORINFO_METHOD_HANDLE ftn, void** ppIndirection);
1114
1115     void recGetVarArgsHandle(CORINFO_SIG_INFO* pSig, void** ppIndirection, CORINFO_VARARGS_HANDLE result);
1116     void dmpGetVarArgsHandle(const GetVarArgsHandleValue& key, DLDL value);
1117     CORINFO_VARARGS_HANDLE repGetVarArgsHandle(CORINFO_SIG_INFO* pSig, void** ppIndirection);
1118
1119     void recCanGetVarArgsHandle(CORINFO_SIG_INFO* pSig, bool result);
1120     void dmpCanGetVarArgsHandle(const CanGetVarArgsHandleValue& key, DWORD value);
1121     bool repCanGetVarArgsHandle(CORINFO_SIG_INFO* pSig);
1122
1123     void recGetFieldThreadLocalStoreID(CORINFO_FIELD_HANDLE field, void** ppIndirection, DWORD result);
1124     void dmpGetFieldThreadLocalStoreID(DWORDLONG key, DLD value);
1125     DWORD repGetFieldThreadLocalStoreID(CORINFO_FIELD_HANDLE field, void** ppIndirection);
1126
1127     void recGetBBProfileData(CORINFO_METHOD_HANDLE        ftnHnd,
1128                              ULONG*                       count,
1129                              ICorJitInfo::ProfileBuffer** profileBuffer,
1130                              ULONG*                       numRuns,
1131                              HRESULT                      result);
1132     void dmpGetBBProfileData(DWORDLONG key, const Agnostic_GetBBProfileData& value);
1133     HRESULT repGetBBProfileData(CORINFO_METHOD_HANDLE        ftnHnd,
1134                                 ULONG*                       count,
1135                                 ICorJitInfo::ProfileBuffer** profileBuffer,
1136                                 ULONG*                       numRuns);
1137
1138     void recMergeClasses(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2, CORINFO_CLASS_HANDLE result);
1139     void dmpMergeClasses(DLDL key, DWORDLONG value);
1140     CORINFO_CLASS_HANDLE repMergeClasses(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2);
1141
1142     void recGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig, void** ppIndirection, LPVOID result);
1143     void dmpGetCookieForPInvokeCalliSig(const GetCookieForPInvokeCalliSigValue& key, DLDL value);
1144     LPVOID repGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig, void** ppIndirection);
1145
1146     void recCanGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig, bool result);
1147     void dmpCanGetCookieForPInvokeCalliSig(const CanGetCookieForPInvokeCalliSigValue& key, DWORD value);
1148     bool repCanGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig);
1149
1150     void recCanAccessFamily(CORINFO_METHOD_HANDLE hCaller, CORINFO_CLASS_HANDLE hInstanceType, BOOL result);
1151     void dmpCanAccessFamily(DLDL key, DWORD value);
1152     BOOL repCanAccessFamily(CORINFO_METHOD_HANDLE hCaller, CORINFO_CLASS_HANDLE hInstanceType);
1153
1154     void recErrorList(const char* error);
1155     void dmpErrorList(DWORD key, DWORD value);
1156
1157     void recGetProfilingHandle(BOOL* pbHookFunction, void** pProfilerHandle, BOOL* pbIndirectedHandles);
1158     void dmpGetProfilingHandle(DWORD key, const Agnostic_GetProfilingHandle& value);
1159     void repGetProfilingHandle(BOOL* pbHookFunction, void** pProfilerHandle, BOOL* pbIndirectedHandles);
1160
1161     void recEmbedFieldHandle(CORINFO_FIELD_HANDLE handle, void** ppIndirection, CORINFO_FIELD_HANDLE result);
1162     void dmpEmbedFieldHandle(DWORDLONG key, DLDL value);
1163     CORINFO_FIELD_HANDLE repEmbedFieldHandle(CORINFO_FIELD_HANDLE handle, void** ppIndirection);
1164
1165     void recAreTypesEquivalent(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2, BOOL result);
1166     void dmpAreTypesEquivalent(DLDL key, DWORD value);
1167     BOOL repAreTypesEquivalent(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2);
1168
1169     void recFindNameOfToken(
1170         CORINFO_MODULE_HANDLE module, mdToken metaTOK, char* szFQName, size_t FQNameCapacity, size_t result);
1171     void dmpFindNameOfToken(DLD key, DLD value);
1172     size_t repFindNameOfToken(CORINFO_MODULE_HANDLE module, mdToken metaTOK, char* szFQName, size_t FQNameCapacity);
1173
1174     void recGetSystemVAmd64PassStructInRegisterDescriptor(
1175         CORINFO_CLASS_HANDLE                                 structHnd,
1176         SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr,
1177         bool                                                 result);
1178     void dmpGetSystemVAmd64PassStructInRegisterDescriptor(
1179         DWORDLONG key, const Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor& value);
1180     bool repGetSystemVAmd64PassStructInRegisterDescriptor(
1181         CORINFO_CLASS_HANDLE structHnd, SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr);
1182
1183     void recGetRelocTypeHint(void* target, WORD result);
1184     void dmpGetRelocTypeHint(DWORDLONG key, DWORD value);
1185     WORD repGetRelocTypeHint(void* target);
1186
1187     void recIsWriteBarrierHelperRequired(CORINFO_FIELD_HANDLE field, bool result);
1188     void dmpIsWriteBarrierHelperRequired(DWORDLONG key, DWORD value);
1189     bool repIsWriteBarrierHelperRequired(CORINFO_FIELD_HANDLE field);
1190
1191     void recIsValidToken(CORINFO_MODULE_HANDLE module, unsigned metaTOK, BOOL result);
1192     void dmpIsValidToken(DLD key, DWORD value);
1193     BOOL repIsValidToken(CORINFO_MODULE_HANDLE module, unsigned metaTOK);
1194
1195     void recGetClassName(CORINFO_CLASS_HANDLE cls, const char* result);
1196     void dmpGetClassName(DWORDLONG key, DWORD value);
1197     const char* repGetClassName(CORINFO_CLASS_HANDLE cls);
1198
1199     void recAppendClassName(
1200         CORINFO_CLASS_HANDLE cls, BOOL fNamespace, BOOL fFullInst, BOOL fAssembly, const WCHAR* result);
1201     void dmpAppendClassName(const Agnostic_AppendClassName& key, DWORD value);
1202     const WCHAR* repAppendClassName(CORINFO_CLASS_HANDLE cls, BOOL fNamespace, BOOL fFullInst, BOOL fAssembly);
1203
1204     void recGetTailCallCopyArgsThunk(CORINFO_SIG_INFO* pSig, CorInfoHelperTailCallSpecialHandling flags, void* result);
1205     void dmpGetTailCallCopyArgsThunk(const Agnostic_GetTailCallCopyArgsThunk& key, DWORDLONG value);
1206     void* repGetTailCallCopyArgsThunk(CORINFO_SIG_INFO* pSig, CorInfoHelperTailCallSpecialHandling flags);
1207
1208     void recGetMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod, mdMethodDef result);
1209     void dmpGetMethodDefFromMethod(DWORDLONG key, DWORD value);
1210     mdMethodDef repGetMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod);
1211
1212     void recCheckMethodModifier(CORINFO_METHOD_HANDLE hMethod, LPCSTR modifier, BOOL fOptional, BOOL result);
1213     void dmpCheckMethodModifier(const Agnostic_CheckMethodModifier& key, DWORD value);
1214     BOOL repCheckMethodModifier(CORINFO_METHOD_HANDLE hMethod, LPCSTR modifier, BOOL fOptional);
1215
1216     void recGetPInvokeUnmanagedTarget(CORINFO_METHOD_HANDLE method, void** ppIndirection, void* result);
1217     void dmpGetPInvokeUnmanagedTarget(DWORDLONG key, DLDL value);
1218     void* repGetPInvokeUnmanagedTarget(CORINFO_METHOD_HANDLE method, void** ppIndirection);
1219
1220     void recGetArrayRank(CORINFO_CLASS_HANDLE cls, unsigned result);
1221     void dmpGetArrayRank(DWORDLONG key, DWORD value);
1222     unsigned repGetArrayRank(CORINFO_CLASS_HANDLE cls);
1223
1224     void recIsFieldStatic(CORINFO_FIELD_HANDLE fhld, bool result);
1225     void dmpIsFieldStatic(DWORDLONG key, DWORD value);
1226     bool repIsFieldStatic(CORINFO_FIELD_HANDLE fhld);
1227
1228     void recGetIntConfigValue(const wchar_t* name, int defaultValue, int result);
1229     void dmpGetIntConfigValue(const Agnostic_ConfigIntInfo& key, int value);
1230     int repGetIntConfigValue(const wchar_t* name, int defaultValue);
1231
1232     void recGetStringConfigValue(const wchar_t* name, const wchar_t* result);
1233     void dmpGetStringConfigValue(DWORD nameIndex, DWORD result);
1234     const wchar_t* repGetStringConfigValue(const wchar_t* name);
1235
1236     bool wasEnviromentChanged();
1237     static DenseLightWeightMap<Agnostic_Environment>* prevEnviroment;
1238
1239     CompileResult* cr;
1240     CompileResult* originalCR;
1241     int            index;
1242
1243 private:
1244 #define LWM(map, key, value) LightWeightMap<key, value>* map;
1245 #define DENSELWM(map, value) DenseLightWeightMap<value>* map;
1246 #include "lwmlist.h"
1247 };
1248
1249 // ********************* Please keep this up-to-date to ease adding more ***************
1250 // Highest packet number: 160
1251 // *************************************************************************************
1252 enum mcPackets
1253 {
1254     Packet_AppendClassName            = 149, // Added 8/6/2014 - needed for SIMD
1255     Packet_AreTypesEquivalent         = 1,
1256     Packet_AsCorInfoType              = 2,
1257     Packet_CanAccessClass             = 3,
1258     Packet_CanAccessFamily            = 4,
1259     Packet_CanCast                    = 5,
1260     Retired8                          = 6,
1261     Packet_GetLazyStringLiteralHelper = 147, // Added 12/20/2013 - as a replacement for CanEmbedModuleHandleForHelper
1262     Packet_CanGetCookieForPInvokeCalliSig                = 7,
1263     Packet_CanGetVarArgsHandle                           = 8,
1264     Packet_CanInline                                     = 9,
1265     Packet_CanInlineTypeCheckWithObjectVTable            = 10,
1266     Packet_CanSkipMethodVerification                     = 11,
1267     Packet_CanTailCall                                   = 12,
1268     Retired4                                             = 13,
1269     Packet_CheckMethodModifier                           = 142, // retired as 13 on 2013/07/04
1270     Retired3                                             = 14,
1271     Retired5                                             = 141, // retired as 14 on 2013/07/03
1272     Packet_CompileMethod                                 = 143, // retired as 141 on 2013/07/09
1273     Packet_ConstructStringLiteral                        = 15,
1274     Packet_EmbedClassHandle                              = 16,
1275     Packet_EmbedFieldHandle                              = 17,
1276     Packet_EmbedGenericHandle                            = 18,
1277     Packet_EmbedMethodHandle                             = 19,
1278     Packet_EmbedModuleHandle                             = 20,
1279     Packet_EmptyStringLiteral                            = 21,
1280     Packet_Environment                                   = 136, // Added 4/3/2013
1281     Packet_ErrorList                                     = 22,
1282     Packet_FilterException                               = 134,
1283     Packet_FindCallSiteSig                               = 23,
1284     Retired7                                             = 24,
1285     Packet_FindNameOfToken                               = 145, // Added 7/19/2013 - adjusted members to proper types
1286     Packet_GetSystemVAmd64PassStructInRegisterDescriptor = 156, // Added 2/17/2016
1287     Packet_FindSig                                       = 25,
1288     Packet_GetAddressOfPInvokeFixup                      = 26,
1289     Packet_GetAddressOfPInvokeTarget                     = 153, // Added 2/3/2016
1290     Packet_GetAddrOfCaptureThreadGlobal                  = 27,
1291     Retired1                                             = 28,
1292     Packet_GetArgClass                                   = 139, // retired as 28 on 2013/07/03
1293     Packet_GetHFAType                                    = 159,
1294     Packet_GetArgNext                                    = 29,
1295     Retired2                                             = 30,
1296     Packet_GetArgType                                    = 140, // retired as 30 on 2013/07/03
1297     Packet_GetArrayInitializationData                    = 31,
1298     Packet_GetArrayRank                                  = 32,
1299     Packet_GetBBProfileData                              = 33,
1300     Packet_GetBoundaries                                 = 34,
1301     Packet_GetBoxHelper                                  = 35,
1302     Packet_GetBuiltinClass                               = 36,
1303     Packet_GetCallInfo                                   = 37,
1304     Packet_GetCastingHelper                              = 38,
1305     Packet_GetChildType                                  = 39,
1306     Packet_GetClassAlignmentRequirement                  = 40,
1307     Packet_GetClassAttribs                               = 41,
1308     Packet_GetClassDomainID                              = 42,
1309     Packet_GetClassGClayout                              = 43,
1310     Packet_GetClassModuleIdForStatics                    = 44,
1311     Packet_GetClassName                                  = 45,
1312     Packet_GetClassNumInstanceFields                     = 46,
1313     Packet_GetClassSize                                  = 47,
1314     Packet_GetIntConfigValue                             = 151, // Added 2/12/2015
1315     Packet_GetStringConfigValue                          = 152, // Added 2/12/2015
1316     Packet_GetCookieForPInvokeCalliSig                   = 48,
1317     Packet_GetDelegateCtor                               = 49,
1318     Packet_GetEEInfo                                     = 50,
1319     Packet_GetEHinfo                                     = 51,
1320     Packet_GetFieldAddress                               = 52,
1321     Packet_GetFieldClass                                 = 53,
1322     Packet_GetFieldInClass                               = 54,
1323     Packet_GetFieldInfo                                  = 55,
1324     Packet_GetFieldName                                  = 56,
1325     Packet_GetFieldOffset                                = 57,
1326     Packet_GetFieldThreadLocalStoreID                    = 58,
1327     Packet_GetFieldType                                  = 59,
1328     Packet_GetFunctionEntryPoint                         = 60,
1329     Packet_GetFunctionFixedEntryPoint                    = 61,
1330     Packet_GetGSCookie                                   = 62,
1331     Packet_GetHelperFtn                                  = 63,
1332     Packet_GetHelperName                                 = 64,
1333     Packet_GetInlinedCallFrameVptr                       = 65,
1334     Packet_GetIntrinsicID                                = 66,
1335     Packet_GetJitFlags                                   = 154, // Added 2/3/2016
1336     Packet_GetJitTimeLogFilename                         = 67,
1337     Packet_GetJustMyCodeHandle                           = 68,
1338     Packet_GetLocationOfThisType                         = 69,
1339     Packet_GetMethodAttribs                              = 70,
1340     Packet_GetMethodClass                                = 71,
1341     Packet_GetMethodDefFromMethod                        = 72,
1342     Packet_GetMethodHash                                 = 73,
1343     Packet_GetMethodInfo                                 = 74,
1344     Packet_GetMethodName                                 = 75,
1345     Packet_GetMethodSig                                  = 76,
1346     Packet_GetMethodSync                                 = 77,
1347     Packet_GetMethodVTableOffset                         = 78,
1348     Packet_GetNewArrHelper                               = 79,
1349     Packet_GetNewHelper                                  = 80,
1350     Packet_GetParentType                                 = 81,
1351     Packet_GetPInvokeUnmanagedTarget                     = 82,
1352     Packet_GetProfilingHandle                            = 83,
1353     Packet_GetRelocTypeHint                              = 84,
1354     Packet_GetSecurityPrologHelper                       = 85,
1355     Packet_GetSharedCCtorHelper                          = 86,
1356     Packet_GetTailCallCopyArgsThunk                      = 87,
1357     Packet_GetThreadTLSIndex                             = 88,
1358     Packet_GetTokenTypeAsHandle                          = 89,
1359     Packet_GetTypeForBox                                 = 90,
1360     Packet_GetTypeForPrimitiveValueClass                 = 91,
1361     Packet_GetUnBoxHelper                                = 92,
1362     Packet_GetReadyToRunHelper                           = 150, // Added 10/10/2014
1363     Packet_GetReadyToRunDelegateCtorHelper               = 157, // Added 3/30/2016
1364     Packet_GetUnmanagedCallConv                          = 94,
1365     Packet_GetVarArgsHandle                              = 95,
1366     Packet_GetVars                                       = 96,
1367     Packet_HandleException                               = 135,
1368     Packet_InitClass                                     = 97,
1369     Packet_InitConstraintsForVerification                = 98,
1370     Packet_IsCompatibleDelegate                          = 99,
1371     Packet_IsDelegateCreationAllowed                     = 155,
1372     Packet_IsFieldStatic                                 = 137, // Added 4/9/2013 - needed for 4.5.1
1373     Packet_IsInSIMDModule                                = 148, // Added 6/18/2014 - SIMD support
1374     Packet_IsInstantiationOfVerifiedGeneric              = 100,
1375     Packet_IsSDArray                                     = 101,
1376     Packet_IsStructRequiringStackAllocRetBuf             = 102,
1377     Packet_IsValidStringRef                              = 103,
1378     Retired6                                             = 104,
1379     Packet_IsValidToken                                  = 144, // Added 7/19/2013 - adjusted members to proper types
1380     Packet_IsValueClass                                  = 105,
1381     Packet_IsWriteBarrierHelperRequired                  = 106,
1382     Packet_MergeClasses                                  = 107,
1383     Packet_PInvokeMarshalingRequired                     = 108,
1384     Packet_ResolveToken                                  = 109,
1385     Packet_ResolveVirtualMethod                          = 160, // Added 2/13/17
1386     Packet_TryResolveToken                               = 158, // Added 4/26/2016
1387     Packet_SatisfiesClassConstraints                     = 110,
1388     Packet_SatisfiesMethodConstraints                    = 111,
1389     Packet_ShouldEnforceCallvirtRestriction              = 112,
1390
1391     PacketCR_AddressMap                        = 113,
1392     PacketCR_AllocBBProfileBuffer              = 131,
1393     PacketCR_AllocGCInfo                       = 114,
1394     PacketCR_AllocMem                          = 115,
1395     PacketCR_AllocUnwindInfo                   = 132,
1396     PacketCR_AssertLog                         = 138, // Added 6/10/2013 - added to nicely support ilgen
1397     PacketCR_CallLog                           = 116,
1398     PacketCR_ClassMustBeLoadedBeforeCodeIsRun  = 117,
1399     PacketCR_CompileMethod                     = 118,
1400     PacketCR_MessageLog                        = 119,
1401     PacketCR_MethodMustBeLoadedBeforeCodeIsRun = 120,
1402     PacketCR_ProcessName                       = 121,
1403     PacketCR_RecordRelocation                  = 122,
1404     PacketCR_ReportFatalError                  = 123,
1405     PacketCR_ReportInliningDecision            = 124,
1406     PacketCR_ReportTailCallDecision            = 125,
1407     PacketCR_ReserveUnwindInfo                 = 133,
1408     PacketCR_SetBoundaries                     = 126,
1409     PacketCR_SetEHcount                        = 127,
1410     PacketCR_SetEHinfo                         = 128,
1411     PacketCR_SetMethodAttribs                  = 129,
1412     PacketCR_SetVars                           = 130,
1413     PacketCR_RecordCallSite                    = 146, // Added 10/28/2013 - to support indirect calls
1414 };
1415
1416 #endif