text: // Licensed to the .NET Foundation under one or more agreements.
  // The .NET Foundation licenses this file to you under the MIT license.
  // See the LICENSE file in the project root for more information.
  // ===========================================================================
  // File: CEELOAD.H
  //
  
  //
  // CEELOAD.H defines the class use to represent the PE file
  // ===========================================================================
  
  #ifndef CEELOAD_H_
  #define CEELOAD_H_
  
  #include "common.h"
  #ifdef FEATURE_FUSION
  #include <fusion.h>
  #endif
  #include "vars.hpp" // for LPCUTF8
  #include "hash.h"
  #include "clsload.hpp"
  #include "cgensys.h"
  #include "corsym.h"
  #include "typehandle.h"
  #include "arraylist.h"
  #include "pefile.h"
  #include "typehash.h"
  #include "contractimpl.h"
  #include "bitmask.h"
  #include "instmethhash.h"
  #include "eetwain.h"    // For EnumGCRefs (we should probably move that somewhere else, but can't
                          // find anything better (modulo common or vars.hpp)
  #include "classloadlevel.h"
  #include "precode.h"
  #include "corbbtprof.h"
  #include "ilstubcache.h"
  #include "classhash.h"
  
  #ifdef FEATURE_PREJIT
  #include "corcompile.h"
  #include "dataimage.h"
  #include <gcinfodecoder.h>
  #endif // FEATURE_PREJIT
  
  #ifdef FEATURE_COMINTEROP
  #include "winrttypenameconverter.h"
  #endif // FEATURE_COMINTEROP
  
  #ifdef FEATURE_READYTORUN
  #include "readytoruninfo.h"
  #endif
  
  class PELoader;
  class Stub;
  class MethodDesc;
  class FieldDesc;
  class Crst;
  class IAssemblySecurityDescriptor;
  class ClassConverter;
  class RefClassWriter;
  class ReflectionModule;
  class EEStringData;
  class MethodDescChunk;
  class SigTypeContext;
  class Assembly;
  class BaseDomain;
  class AppDomain;
  class CompilationDomain;
  class DomainModule;
  struct DomainLocalModule;
  class SystemDomain;
  class Module;
  class SString;
  class Pending;
  class MethodTable;
  class AppDomain;
  class DynamicMethodTable;
  struct CerPrepInfo;
  class ModuleSecurityDescriptor;
  #ifdef FEATURE_PREJIT
  class CerNgenRootTable;
  struct MethodContextElement;
  class TypeHandleList;
  class ProfileEmitter;
  class ReJitManager;
  class TrackingMap;
  class PersistentInlineTrackingMap;
  
  // Hash table parameter of available classes (name -> module/class) hash
  #define AVAILABLE_CLASSES_HASH_BUCKETS 1024
  #define AVAILABLE_CLASSES_HASH_BUCKETS_COLLECTIBLE 128
  #define PARAMTYPES_HASH_BUCKETS 23
  #define PARAMMETHODS_HASH_BUCKETS 11
  #define METHOD_STUBS_HASH_BUCKETS 11
  #define GUID_TO_TYPE_HASH_BUCKETS 16
  
  
  typedef DPTR(PersistentInlineTrackingMap) PTR_PersistentInlineTrackingMap;
  
  extern VerboseLevel g_CorCompileVerboseLevel;
  #endif  // FEATURE_PREJIT
  
  //
  // LookupMaps are used to implement RID maps
  // It is a linked list of nodes, each handling a successive (and consecutive)
  // range of RIDs.
  //
  // LookupMapBase is non-type safe implementation of the worker methods. LookupMap is type 
  // safe wrapper around it.
  //
  
  typedef DPTR(struct LookupMapBase) PTR_LookupMapBase;
  
  #ifdef FEATURE_PREJIT
  
  //
  // LookupMap cold entry compression support
  //
  // A lookup map (the cold section) is notionally an array of pointer values indexed by rid. The pointers are
  // generally to data structures such as MethodTables or MethodDescs. When we compress such a table (at ngen
  // time) we wish to avoid direct pointers, since these would need to be fixed up due to image base
  // relocations. Instead we store RVAs (Relative Virtual Addresses). Unlike regular RVAs our base address is
  // the map address itself (as opposed to the module base). We do this purely out of convenience since
  // LookupMaps don't store the module base address.
  //
  // It turns out that very often the value pointers (and hence the value RVAs) are related to each other:
  // adjacent map entries often point to data structures that were allocated next to or close to each other. The
  // compression algorithm takes advantage of this fact: instead of storing value RVAs we store the deltas
  // between RVAs. So the nth value in the table is composed of the addition of the deltas from the preceding (n
  // - 1) entries. Since the deltas are often small (especially when we take structure alignment into account
  // and realize that we can discard the lower 2 or 3 bits of the delta) we can store them in a compressed
  // manner by discarding the insignificant leading zero bits in each value.
  //
  // So now we imagine our compressed table to be a sequence of entries, each entry being a variably sized delta
  // from the previous entry. As a result we need some means to encode how large each delta in the table is. We
  // could use a fixed size field (a 5-bit length field would be able to encode any length between 1 and 32
  // bits, say). This is troublesome since although most entry values are close in value there are a few
  // (usually a minority) that require much larger deltas (hot/cold data splitting based on profiling can cause
  // this for instance). For most tables this would force us to use a large fixed-size length field for every
  // entry, just to deal with the relatively uncommon worst case (5 bits would be enough, but many entry deltas
  // can be encoded in 2 or 3 bits).
  //
  // Instead we utilize a compromise: we store all delta lengths with a small number of bits
  // (kLookupMapLengthBits below). Instead of encoding the length directly this value indexes a per-map table of
  // possible delta encoding lengths. During ngen we calculate the optimal value for each entry in this encoding
  // length table. The advantage here is that it lets us encode both best case and worst case delta lengths with
  // a fixed size but small field. The disadvantage is that some deltas will be encoded with more bits than they
  // strictly need.
  //
  // This still leaves the problem of runtime lookup performance. Touches to the cold section of a LookupMap
  // aren't all that critical (after all the data is meant to be cold), but looking up the last entry of a map
  // with 22 thousand entries (roughly what the MethodDefToDesc map in mscorlib is sized at at the time of
  // writing) is still likely to so inefficient as to be noticeable. Remember that the issue is that we have to
  // decode all predecessor entries in order to compute the value of a given entry in the table.
  //
  // To address this we introduce an index to each compressed map. The index contains an entry for each
  // kLookupMapIndexStride'th entry in the compressed map. The index entry consists of the RVA of the
  // corresponding table value and the bit offset into the compressed map at which the data for the next entry
  // commences. Thus we can use the index to find a value within kLookupMapIndexStride entries of our target and
  // then proceed to decode only the last few compressed entries to finish the job. This reduces the lookup to a
  // constant time operation once more (given a reasonable value for kLookupMapIndexStride).
  //
  // The main areas in which this algorithm can be tuned are the number of bits used as an index into the
  // encoding lengths table (kLookupMapLengthBits) and the frequency with which entries are bookmarked in the
  // index (kLookupMapIndexStride). The current values have been set based on looking at models of mscorlib,
  // PresentationCore and PresentationFramework built from the actual ridmap data in their ngen images and
  // methodically trying different values in order to maximize compression or balance size versus likely runtime
  // performance. An alternative strategy was considered using direct (non-length prefix) encoding of the
  // deltas with a couple of variantions on probability-based variable length encoding (completely unbalanced
  // tree and completely balanced tree with pessimally encoded worst case escapes). But these were found to
  // yield best case results similar to the above but with more complex processing required at ngen (optimal
  // results for these algorithms are achieved when you have enough resources to build a probability map of your
  // entire data).
  //
  // Note that not all lookup tables are suitable for compression. In fact we compress only TypeDefToMethodTable
  // and MethodDefToDesc tables. For one thing this optimization only brings benefits to larger tables. But more
  // importantly we cannot mutate compressed entries (for obvious reasons). Many of the lookup maps are only
  // partially populated at ngen time or otherwise might be updated at runtime and thus are not candidates.
  //
  // In the threshhold timeframe (predicted to be .Net 4.5.3 at the time of writing), we added profiler support
  // for adding new types to NGEN images. Historically we could always do this for jitted images, but one of the
  // blockers for NGEN were the compressed RID maps. We worked around that by supporting multi-node maps in which
  // the first node is compressed, but all future nodes are uncompressed. The NGENed portion will all land in the
  // compressed node, while the new profiler added data will land in the uncompressed portion. Note this could 
  // probably be leveraged for other dynamic scenarios such as a limited form of EnC, but nothing further has
  // been implemented at this time.
  //
  
  // Some useful constants used when compressing tables.
  enum {
      kLookupMapLengthBits    = 2,                            // Bits used to encode an index into a table of possible value lengths
      kLookupMapLengthEntries = 1 << kLookupMapLengthBits,    // Number of entries in the encoding table above
      kLookupMapIndexStride   = 0x10,                         // The range of table entries covered by one index entry (power of two for faster hash lookup)
      kBitsPerRVA             = sizeof(DWORD) * 8,            // Bits in an (uncompressed) table value RVA (RVAs
                                                              // currently still 32-bit even on 64-bit platforms)
  #ifdef _WIN64
      kFlagBits               = 3,                            // Number of bits at the bottom of a value
                                                              // pointer that may be used for flags
  #else // _WIN64
      kFlagBits               = 2,
  #endif // _WIN64
  
  };
  
  #endif // FEATURE_PREJIT
  
  struct LookupMapBase
  {
      DPTR(LookupMapBase) pNext;
  
      ArrayDPTR(TADDR)    pTable;
  
      // Number of elements in this node (only RIDs less than this value can be present in this node)
      DWORD               dwCount;
  
      // Set of flags that the map supports writing on top of the data value
      TADDR               supportedFlags;
  
  #ifdef FEATURE_PREJIT
      struct  HotItem
      {
          DWORD   rid;
          TADDR   value;
          static int __cdecl Cmp(const void* a_, const void* b_);
      };
      DWORD               dwNumHotItems;
      ArrayDPTR(HotItem)  hotItemList;
      PTR_TADDR FindHotItemValuePtr(DWORD rid);
  
      //
      // Compressed map support
      //
      PTR_CBYTE           pIndex;             // Bookmark for every kLookupMapIndexStride'th entry in the table
      DWORD               cIndexEntryBits;    // Number of bits in every index entry
      DWORD               cbTable;            // Number of bytes of compressed table data at pTable
      DWORD               cbIndex;            // Number of bytes of index data at pIndex
      BYTE                rgEncodingLengths[kLookupMapLengthEntries]; // Table of delta encoding lengths for
                                                                      // compressed values
  
      // Returns true if this map instance is compressed (this can only happen at runtime when running against
      // an ngen image). Currently and for the forseeable future only TypeDefToMethodTable and MethodDefToDesc
      // tables can be compressed.
      bool MapIsCompressed()
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return pIndex != NULL;
      }
  
  protected:
      // Internal routine used to iterate though one entry in the compressed table.
      INT32 GetNextCompressedEntry(BitStreamReader *pTableStream, INT32 iLastValue);
  
  public:
      // Public method used to retrieve the full value (non-RVA) of a compressed table entry.
      TADDR GetValueFromCompressedMap(DWORD rid);
  
  #ifndef DACCESS_COMPILE
      void CreateHotItemList(DataImage *image, CorProfileData *profileData, int table, BOOL fSkipNullEntries = FALSE);
      void Save(DataImage *image, DataImage::ItemKind kind, CorProfileData *profileData, int table, BOOL fCopyValues = FALSE);
      void SaveUncompressedMap(DataImage *image, DataImage::ItemKind kind, BOOL fCopyValues = FALSE);
      void ConvertSavedMapToUncompressed(DataImage *image, DataImage::ItemKind kind);
      void Fixup(DataImage *image, BOOL fFixupEntries = TRUE);
  #endif // !DACCESS_COMPILE
  
  #ifdef _DEBUG
      void    CheckConsistentHotItemList();
  #endif
  
  #endif // FEATURE_PREJIT
  
  #ifdef DACCESS_COMPILE
      void EnumMemoryRegions(CLRDataEnumMemoryFlags flags,
                             bool enumThis);
      void ListEnumMemoryRegions(CLRDataEnumMemoryFlags flags);
  #endif // DACCESS_COMPILE
  
      PTR_TADDR GetIndexPtr(DWORD index)
      {
          LIMITED_METHOD_DAC_CONTRACT;
  #ifdef FEATURE_PREJIT
          _ASSERTE(!MapIsCompressed());
  #endif // FEATURE_PREJIT
          _ASSERTE(index < dwCount);
          return dac_cast<PTR_TADDR>(pTable) + index;
      }
  
      PTR_TADDR GetElementPtr(DWORD rid);
      PTR_TADDR GrowMap(Module * pModule, DWORD rid);
  
      // Get number of RIDs that this table can store
      DWORD GetSize();
  
  #ifdef _DEBUG
      void DebugGetRidMapOccupancy(DWORD *pdwOccupied, DWORD *pdwSize);
  #endif
  };
  
  #define NO_MAP_FLAGS ((TADDR)0)
  
  template <typename TYPE>
  struct LookupMap : LookupMapBase
  {
      static TYPE GetValueAt(PTR_TADDR pValue, TADDR* pFlags, TADDR supportedFlags);
      static void SetValueAt(PTR_TADDR pValue, TYPE value, TADDR flags);
  
      TYPE GetElement(DWORD rid, TADDR* pFlags);
      void SetElement(DWORD rid, TYPE value, TADDR flags);
      BOOL TrySetElement(DWORD rid, TYPE value, TADDR flags);
      void AddElement(Module * pModule, DWORD rid, TYPE value, TADDR flags);
      void EnsureElementCanBeStored(Module * pModule, DWORD rid);
      DWORD Find(TYPE value, TADDR* flags);
  
  
  public:
  
      //
      // Retrieve the value associated with a rid
      //
      TYPE GetElement(DWORD rid)
      {
          WRAPPER_NO_CONTRACT;
          SUPPORTS_DAC;
  
          return GetElement(rid, NULL);
      }
  
      TYPE GetElementAndFlags(DWORD rid, TADDR* pFlags)
      {
          WRAPPER_NO_CONTRACT;
          SUPPORTS_DAC;
  
          _ASSERTE(pFlags != NULL);
  
          return GetElement(rid, pFlags);
      }
  
      //
      // Stores an association in a map that has been previously grown to
      // the required size. Will never throw or fail.
      //
      void SetElement(DWORD rid, TYPE value)
      {
          WRAPPER_NO_CONTRACT;
          SUPPORTS_DAC;
  
          SetElement(rid, value, 0);
      }
  
      void SetElementWithFlags(DWORD rid, TYPE value, TADDR flags)
      {
          WRAPPER_NO_CONTRACT;
          SUPPORTS_DAC;
  
          // Validate flags: that they are in the predefined range and that the range does not collide with value
          _ASSERTE((flags & supportedFlags) == flags);
          _ASSERTE((dac_cast<TADDR>(value) & supportedFlags) == 0);
  
          SetElement(rid, value, flags);
      }
  
      void AddFlag(DWORD rid, TADDR flag)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE((flag & supportedFlags) == flag);
          _ASSERTE(!MapIsCompressed());
          _ASSERTE(dwNumHotItems == 0);
  
          PTR_TADDR pElement = GetElementPtr(rid);
          _ASSERTE(pElement);
  
          if (!pElement)
          {
              return;
          }
  
          TADDR existingFlags;
          TYPE existingValue = GetValueAt(pElement, &existingFlags, supportedFlags);
          SetValueAt(pElement, existingValue, existingFlags | flag);
      }
  
      //
      // Try to store an association in a map. Will never throw or fail.
      //
      BOOL TrySetElement(DWORD rid, TYPE value)
      {
          WRAPPER_NO_CONTRACT;
  
          return TrySetElement(rid, value, 0);
      }
  
      BOOL TrySetElementWithFlags(DWORD rid, TYPE value, TADDR flags)
      {
          WRAPPER_NO_CONTRACT;
  
          // Validate flags: that they are in the predefined range and that the range does not collide with value
          _ASSERTE((flags & supportedFlags) == flags);
          _ASSERTE((dac_cast<TADDR>(value) & supportedFlags) == 0);
  
          return TrySetElement(rid, value, flags);
      }
      
      //
      // Stores an association in a map. Grows the map as necessary.
      //
      void AddElement(Module * pModule, DWORD rid, TYPE value)
      {
          WRAPPER_NO_CONTRACT;
  
          AddElement(pModule, rid, value, 0);
      }
  
      void AddElementWithFlags(Module * pModule, DWORD rid, TYPE value, TADDR flags)
      {
          WRAPPER_NO_CONTRACT;
  
          // Validate flags: that they are in the predefined range and that the range does not collide with value
          _ASSERTE((flags & supportedFlags) == flags);
          _ASSERTE((dac_cast<TADDR>(value) & supportedFlags) == 0);
  
          AddElement(pModule, rid, value, flags);
      }
  
      //
      // Find the given value in the table and return its RID
      //
      DWORD Find(TYPE value)
      {
          WRAPPER_NO_CONTRACT;
  
          return Find(value, NULL);
      }
  
      DWORD FindWithFlags(TYPE value, TADDR flags)
      {
          WRAPPER_NO_CONTRACT;
  
          // Validate flags: that they are in the predefined range and that the range does not collide with value
          _ASSERTE((flags & supportedFlags) == flags);
          _ASSERTE((dac_cast<TADDR>(value) & supportedFlags) == 0);
  
          return Find(value, &flags);
      }
  
      class Iterator
      {
      public:
          Iterator(LookupMap* map);
  
          BOOL Next();
  
          TYPE GetElement()
          {
              WRAPPER_NO_CONTRACT;
              SUPPORTS_DAC;
  
              return GetElement(NULL);
          }
          
          TYPE GetElementAndFlags(TADDR* pFlags)
          {
              WRAPPER_NO_CONTRACT;
              SUPPORTS_DAC;
  
              return GetElement(pFlags);
          }
  
      private:
          TYPE GetElement(TADDR* pFlags);
          
          LookupMap* m_map;
          DWORD m_index;
  #ifdef FEATURE_PREJIT
          // Support for iterating compressed maps.
          INT32 m_currentEntry;           // RVA of current entry value
          BitStreamReader m_tableStream;  // Our current context in the compressed bit stream
  #endif // FEATURE_PREJIT
      };
  };
  
  // Place holder types for RID maps that store cross-module references
  
  class TypeRef { };
  typedef DPTR(class TypeRef) PTR_TypeRef;
  
  class MemberRef { };
  typedef DPTR(class MemberRef) PTR_MemberRef;
  
  
  // flag used to mark member ref pointers to field descriptors in the member ref cache
  #define IS_FIELD_MEMBER_REF ((TADDR)0x00000002)
  
  
  //
  // NGen image layout information that we need to quickly access at runtime
  //
  typedef DPTR(struct NGenLayoutInfo) PTR_NGenLayoutInfo;
  struct NGenLayoutInfo
  {
      // One range for each hot, unprofiled, cold code sections
      MemoryRange             m_CodeSections[3];
  
      // Pointer to the RUNTIME_FUNCTION table for hot, unprofiled, and cold code sections.
      PTR_RUNTIME_FUNCTION    m_pRuntimeFunctions[3];
  
      // Number of RUNTIME_FUNCTIONs for hot, unprofiled, and cold code sections.
      DWORD                   m_nRuntimeFunctions[3];
  
      // A parallel arrays of MethodDesc RVAs for hot and unprofiled methods. Both of the array are parallel for m_pRuntimeFunctions
      // The first array is for hot methods. The second array is for unprofiled methods.
      PTR_DWORD               m_MethodDescs[2];
  
      // Lookup table to speed up RUNTIME_FUNCTION lookup.
      // The first array is for hot methods. The second array is for unprofiled methods.
      // Number of elements is m_UnwindInfoLookupTableEntryCount + 1.
      // Last element of the lookup table is a sentinal entry that's good to cover the rest of the code section.
      // Values are indices into m_pRuntimeFunctions array.
      PTR_DWORD               m_UnwindInfoLookupTable[2];
  
      // Count of lookup entries in m_UnwindInfoLookupTable
      DWORD                   m_UnwindInfoLookupTableEntryCount[2];
  
      // Map for matching the cold code with hot code. Index is relative position of RUNTIME_FUNCTION within the section.
      PTR_CORCOMPILE_COLD_METHOD_ENTRY m_ColdCodeMap;
  
      // One range for each hot, cold, write, hot writeable, and cold writeable precode sections
      MemoryRange             m_Precodes[4];
  
      MemoryRange             m_JumpStubs;
      MemoryRange             m_StubLinkStubs;
      MemoryRange             m_VirtualMethodThunks;
      MemoryRange             m_ExternalMethodThunks;
      MemoryRange             m_ExceptionInfoLookupTable;
  
      PCODE                   m_pPrestubJumpStub;
  #ifdef HAS_FIXUP_PRECODE
      PCODE                   m_pPrecodeFixupJumpStub;
  #endif
      PCODE                   m_pVirtualImportFixupJumpStub;
      PCODE                   m_pExternalMethodFixupJumpStub;
      DWORD                   m_rvaFilterPersonalityRoutine;
  };
  
  //
  // VASigCookies are allocated to encapsulate a varargs call signature.
  // A reference to the cookie is embedded in the code stream.  Cookies
  // are shared amongst call sites with identical signatures in the same
  // module
  //
  
  typedef DPTR(struct VASigCookie) PTR_VASigCookie;
  typedef DPTR(PTR_VASigCookie) PTR_PTR_VASigCookie;
  struct VASigCookie
  {
      // The JIT wants knows that the size of the arguments comes first
      // so please keep this field first
      unsigned        sizeOfArgs;             // size of argument list
      Volatile<PCODE> pNDirectILStub;         // will be use if target is NDirect (tag == 0)
      PTR_Module      pModule;
      Signature       signature;
  };
  
  //
  // VASigCookies are allocated in VASigCookieBlocks to amortize
  // allocation cost and allow proper bookkeeping.
  //
  
  struct VASigCookieBlock
  {
      enum {
  #ifdef _DEBUG
          kVASigCookieBlockSize = 2
  #else // !_DEBUG
          kVASigCookieBlockSize = 20
  #endif // !_DEBUG
      };
  
      VASigCookieBlock    *m_Next;
      UINT                 m_numcookies;
      VASigCookie          m_cookies[kVASigCookieBlockSize];
  };
  
  // This lookup table persists the information about boxed statics into the ngen'ed image
  // which allows one to the type static initialization without touching expensive EEClasses. Note
  // that since the persisted info is stored at ngen time as opposed to class layout time,
  // in jitted scenarios we would still touch EEClasses. This imples that the variables which store
  // this info in the EEClasses are still present.
  
  // We used this table to store more data require to run cctors in the past (it explains the name),
  // but we are only using it for boxed statics now. Boxed statics are rare. The complexity may not
  // be worth the gains. We should consider removing this cache and avoid the complexity.
  
  typedef DPTR(struct ClassCtorInfoEntry) PTR_ClassCtorInfoEntry;
  struct ClassCtorInfoEntry
  {
      DWORD firstBoxedStaticOffset;
      DWORD firstBoxedStaticMTIndex;
      WORD numBoxedStatics;
      WORD hasFixedAddressVTStatics; // This is WORD avoid padding in the datastructure. It is really bool.
  };
  
  #define MODULE_CTOR_ELEMENTS 256
  struct ModuleCtorInfo
  {
      DWORD                   numElements;
      DWORD                   numLastAllocated;
      DWORD                   numElementsHot;
      DPTR(PTR_MethodTable)   ppMT;           // size is numElements
      PTR_ClassCtorInfoEntry  cctorInfoHot;   // size is numElementsHot
      PTR_ClassCtorInfoEntry  cctorInfoCold;  // size is numElements-numElementsHot
  
      PTR_DWORD               hotHashOffsets;  // Indices to the start of each "hash region" in the hot part of the ppMT array. 
      PTR_DWORD               coldHashOffsets; // Indices to the start of each "hash region" in the cold part of the ppMT array. 
      DWORD                   numHotHashes;
      DWORD                   numColdHashes;
  
      ArrayDPTR(FixupPointer<PTR_MethodTable>) ppHotGCStaticsMTs;            // hot table
      ArrayDPTR(FixupPointer<PTR_MethodTable>) ppColdGCStaticsMTs;           // cold table
  
      DWORD                   numHotGCStaticsMTs;
      DWORD                   numColdGCStaticsMTs;
  
  #ifdef DACCESS_COMPILE
      void EnumMemoryRegions(CLRDataEnumMemoryFlags flags);
  #endif
  
      typedef enum {HOT, COLD} REGION;
      FORCEINLINE DWORD GenerateHash(PTR_MethodTable pMT, REGION region)
      {
          SUPPORTS_DAC;
  
          DWORD tmp1  = pMT->GetTypeDefRid();
          DWORD tmp2  = pMT->GetNumVirtuals();
          DWORD tmp3  = pMT->GetNumInterfaces();
  
          tmp1        = (tmp1 << 7) + (tmp1 << 0); // 10000001
          tmp2        = (tmp2 << 6) + (tmp2 << 1); // 01000010
          tmp3        = (tmp3 << 4) + (tmp3 << 3); // 00011000
  
          tmp1       ^= (tmp1 >> 4);               // 10001001 0001
          tmp2       ^= (tmp2 >> 4);               // 01000110 0010   
          tmp3       ^= (tmp3 >> 4);               // 00011001 1000
  
          DWORD hashVal = tmp1 + tmp2 + tmp3;
  
          if (region == HOT)
              hashVal     &= (numHotHashes - 1);   // numHotHashes is required to be a power of two
          else
              hashVal     &= (numColdHashes - 1);  // numColdHashes is required to be a power of two
  
          return hashVal;
      };
  
      ArrayDPTR(FixupPointer<PTR_MethodTable>) GetGCStaticMTs(DWORD index);
  
  #ifdef FEATURE_PREJIT
  
      void AddElement(MethodTable *pMethodTable);
      void Save(DataImage *image, CorProfileData *profileData);
      void Fixup(DataImage *image);
  
      class ClassCtorInfoEntryArraySort : public CQuickSort<DWORD>
      {
      private:
          PTR_MethodTable *m_pBase1;
  
      public:
          //Constructor
          ClassCtorInfoEntryArraySort(DWORD *base, PTR_MethodTable *base1, int count)
            : CQuickSort<DWORD>(base, count)
          {
              WRAPPER_NO_CONTRACT;
  
              m_pBase1 = base1;
          }
          
          //Returns -1,0,or 1 if first's nativeStartOffset is less than, equal to, or greater than second's
          FORCEINLINE int Compare(DWORD *first, DWORD *second)
          {
              LIMITED_METHOD_CONTRACT;
          
              if (*first < *second)
                  return -1;
              else if (*first == *second)
                  return 0;
              else
                  return 1;
          }
          
          // Swap is overwriten so that we can sort both the MethodTable pointer
          // array and the ClassCtorInfoEntry array in parrallel.
          FORCEINLINE void Swap(SSIZE_T iFirst, SSIZE_T iSecond)
          {
              LIMITED_METHOD_CONTRACT;
  
              DWORD sTemp;
              PTR_MethodTable sTemp1;
  
              if (iFirst == iSecond) return;
  
              sTemp = m_pBase[iFirst];
              m_pBase[iFirst] = m_pBase[iSecond];
              m_pBase[iSecond] = sTemp;
  
              sTemp1 = m_pBase1[iFirst];
              m_pBase1[iFirst] = m_pBase1[iSecond];
              m_pBase1[iSecond] = sTemp1;
          }
      };
  #endif // FEATURE_PREJIT
  };
  
  
  
  #ifdef FEATURE_PREJIT
  
  // For IBC Profiling we collect signature blobs for instantiated types.
  // For such instantiated types and methods we create our own ibc token
  // 
  // For instantiated types, there also may be no corresponding type token 
  // or method token for the instantiated types or method in our module.
  // For these cases we create our own ibc token definition that is used
  // to refer to these external types and methods.  We have to handle 
  // external nested types and namespaces and method signatures.
  //
  //    ParamTypeSpec               = 4,    // Instantiated Type Signature
  //    ParamMethodSpec             = 5,    // Instantiated Method Signature
  //    ExternalNamespaceDef        = 6,    // External Namespace Token Definition 
  //    ExternalTypeDef             = 7,    // External Type Token Definition
  //    ExternalSignatureDef        = 8,    // External Signature Definition
  //    ExternalMethodDef           = 9,    // External Method Token Definition
  //
  // typedef DPTR(class ProfilingBlobEntry) PTR_ProfilingBlobEntry;
  class ProfilingBlobEntry
  {
  public:
      virtual ~ProfilingBlobEntry() { LIMITED_METHOD_CONTRACT; };
      virtual bool              IsEqual(const ProfilingBlobEntry *  other) const = 0;  // Pure Virtual
      virtual size_t            Hash()        const                              = 0;
      virtual BlobType          kind()        const                              = 0;
      virtual size_t            varSize()     const                              = 0;
      virtual void              newToken()                                       = 0;
      mdToken                   token()       const { LIMITED_METHOD_CONTRACT; return m_token; }
  
  protected:
      mdToken                   m_token;
  };
  
  class TypeSpecBlobEntry : public ProfilingBlobEntry
  {
  public:
      TypeSpecBlobEntry(DWORD _cbSig, PCCOR_SIGNATURE _pSig);
      
      virtual ~TypeSpecBlobEntry()                  { LIMITED_METHOD_CONTRACT;  delete [] m_pSig; }
      virtual BlobType          kind()        const { LIMITED_METHOD_CONTRACT;  return ParamTypeSpec; }
      virtual size_t            varSize()     const { LIMITED_METHOD_CONTRACT;  return sizeof(COR_SIGNATURE) * m_cbSig; }
      virtual void              newToken()          { LIMITED_METHOD_CONTRACT;  m_token = ++s_lastTypeSpecToken; }
      DWORD                     flags()       const { LIMITED_METHOD_CONTRACT;  return m_flags; }
      DWORD                     cbSig()       const { LIMITED_METHOD_CONTRACT;  return m_cbSig; }
      PCCOR_SIGNATURE           pSig()        const { LIMITED_METHOD_CONTRACT;  return m_pSig;  }
      void                      orFlag(DWORD flag)  { LIMITED_METHOD_CONTRACT;  m_flags |= flag; }
      static size_t             HashInit()          { LIMITED_METHOD_CONTRACT;  return 156437; }    
  
      virtual bool              IsEqual(const ProfilingBlobEntry *  other) const;
      virtual size_t            Hash()        const;
  
      static const TypeSpecBlobEntry *  FindOrAdd(PTR_Module      pModule, 
                                                  DWORD           _cbSig, 
                                                  PCCOR_SIGNATURE _pSig);
  
  private:
      DWORD                     m_flags;
      DWORD                     m_cbSig;
      PCCOR_SIGNATURE           m_pSig;
      
      static idTypeSpec         s_lastTypeSpecToken;   
  };
  
  class MethodSpecBlobEntry : public ProfilingBlobEntry
  {
  public:
      MethodSpecBlobEntry(DWORD _cbSig, PCCOR_SIGNATURE _pSig);
      
      virtual ~MethodSpecBlobEntry()                { LIMITED_METHOD_CONTRACT;  delete [] m_pSig; }
      virtual BlobType          kind()        const { LIMITED_METHOD_CONTRACT;  return ParamMethodSpec; }
      virtual size_t            varSize()     const { LIMITED_METHOD_CONTRACT;  return sizeof(COR_SIGNATURE) * m_cbSig; }
      virtual void              newToken()          { LIMITED_METHOD_CONTRACT;  m_token = ++s_lastMethodSpecToken; }
      DWORD                     flags()       const { LIMITED_METHOD_CONTRACT;  return m_flags; }
      DWORD                     cbSig()       const { LIMITED_METHOD_CONTRACT;  return m_cbSig; }
      PCCOR_SIGNATURE           pSig()        const { LIMITED_METHOD_CONTRACT;  return m_pSig;  }
      void                      orFlag(DWORD flag)  { LIMITED_METHOD_CONTRACT;  m_flags |= flag; }
      static size_t             HashInit()          { LIMITED_METHOD_CONTRACT;  return 187751; }    
      
      virtual bool              IsEqual(const ProfilingBlobEntry *  other) const;
      virtual size_t            Hash()        const;
      
      static const MethodSpecBlobEntry *  FindOrAdd(PTR_Module      pModule, 
                                                    DWORD           _cbSig, 
                                                    PCCOR_SIGNATURE _pSig);
  
  private:
      DWORD                     m_flags;
      DWORD                     m_cbSig;
      PCCOR_SIGNATURE           m_pSig;
      
      static idTypeSpec  s_lastMethodSpecToken;   
  };
  
  class ExternalNamespaceBlobEntry : public ProfilingBlobEntry
  {
  public:
      ExternalNamespaceBlobEntry(LPCSTR _pName);
      
      virtual ~ExternalNamespaceBlobEntry()         { LIMITED_METHOD_CONTRACT;  delete [] m_pName; }
      virtual BlobType          kind()        const { LIMITED_METHOD_CONTRACT;  return ExternalNamespaceDef; }
      virtual size_t            varSize()     const { LIMITED_METHOD_CONTRACT;  return sizeof(CHAR) * m_cbName; }
      virtual void              newToken()          { LIMITED_METHOD_CONTRACT;  m_token = ++s_lastExternalNamespaceToken; }
      DWORD                     cbName()      const { LIMITED_METHOD_CONTRACT;  return m_cbName; }
      LPCSTR                    pName()       const { LIMITED_METHOD_CONTRACT;  return m_pName;  }
      static size_t             HashInit()          { LIMITED_METHOD_CONTRACT;  return 225307; }    
      
      virtual bool              IsEqual(const ProfilingBlobEntry *  other) const;
      virtual size_t            Hash()        const;
  
      static const ExternalNamespaceBlobEntry *  FindOrAdd(PTR_Module pModule, LPCSTR _pName);
  
  private:
      DWORD                     m_cbName;
      LPCSTR                    m_pName;
      
      static idExternalNamespace s_lastExternalNamespaceToken;   
  };
  
  class ExternalTypeBlobEntry : public ProfilingBlobEntry
  {
  public:
      ExternalTypeBlobEntry(mdToken _assemblyRef,  mdToken _nestedClass,
                            mdToken _nameSpace,    LPCSTR  _pName);
  
      virtual ~ExternalTypeBlobEntry()              { LIMITED_METHOD_CONTRACT;  delete [] m_pName; }
      virtual BlobType          kind()        const { LIMITED_METHOD_CONTRACT;  return ExternalTypeDef; }
      virtual size_t            varSize()     const { LIMITED_METHOD_CONTRACT;  return sizeof(CHAR) * m_cbName; }
      virtual void              newToken()          { LIMITED_METHOD_CONTRACT;  m_token = ++s_lastExternalTypeToken; }
      mdToken                   assemblyRef() const { LIMITED_METHOD_CONTRACT;  return m_assemblyRef; }
      mdToken                   nestedClass() const { LIMITED_METHOD_CONTRACT;  return m_nestedClass; }
      mdToken                   nameSpace()   const { LIMITED_METHOD_CONTRACT;  return m_nameSpace; }
      DWORD                     cbName()      const { LIMITED_METHOD_CONTRACT;  return m_cbName; }
      LPCSTR                    pName()       const { LIMITED_METHOD_CONTRACT;  return m_pName;  }
      static size_t             HashInit()          { LIMITED_METHOD_CONTRACT;  return 270371; }    
  
      virtual bool              IsEqual(const ProfilingBlobEntry *  other) const;
      virtual size_t            Hash()        const;
  
      static const ExternalTypeBlobEntry *  FindOrAdd(PTR_Module pModule, 
                                                      mdToken    _assemblyRef, 
                                                      mdToken    _nestedClass,
                                                      mdToken    _nameSpace, 
                                                      LPCSTR     _pName);
  
  private:
      mdToken                   m_assemblyRef;
      mdToken                   m_nestedClass;
      mdToken                   m_nameSpace;
      DWORD                     m_cbName;
      LPCSTR                    m_pName;
      
      static idExternalType     s_lastExternalTypeToken;
  };
  
  class ExternalSignatureBlobEntry : public ProfilingBlobEntry
  {
  public:
      ExternalSignatureBlobEntry(DWORD _cbSig, PCCOR_SIGNATURE _pSig);
  
      virtual ~ExternalSignatureBlobEntry()         { LIMITED_METHOD_CONTRACT;  delete [] m_pSig; }
      virtual BlobType          kind()        const { LIMITED_METHOD_CONTRACT;  return ExternalSignatureDef; }
      virtual size_t            varSize()     const { LIMITED_METHOD_CONTRACT;  return sizeof(COR_SIGNATURE) * m_cbSig; }
      virtual void              newToken()          { LIMITED_METHOD_CONTRACT;  m_token = ++s_lastExternalSignatureToken; }
      DWORD                     cbSig()       const { LIMITED_METHOD_CONTRACT;  return m_cbSig; }
      PCCOR_SIGNATURE           pSig()        const { LIMITED_METHOD_CONTRACT;  return m_pSig;  }
      static size_t             HashInit()          { LIMITED_METHOD_CONTRACT;  return 324449; }    
      
      virtual bool              IsEqual(const ProfilingBlobEntry *  other) const;
      virtual size_t            Hash()        const;
  
      static const ExternalSignatureBlobEntry *  FindOrAdd(PTR_Module      pModule, 
                                                           DWORD           _cbSig, 
                                                           PCCOR_SIGNATURE _pSig);
  
  private:
      DWORD                     m_cbSig;
      PCCOR_SIGNATURE           m_pSig;
      
      static idExternalSignature s_lastExternalSignatureToken;   
  };
  
  class ExternalMethodBlobEntry : public ProfilingBlobEntry
  {
  public:
      ExternalMethodBlobEntry(mdToken _nestedClass, mdToken _signature, LPCSTR _pName);
      
      virtual ~ExternalMethodBlobEntry()            { LIMITED_METHOD_CONTRACT;  delete [] m_pName; }
      virtual BlobType          kind()        const { LIMITED_METHOD_CONTRACT;  return ExternalMethodDef; }
      virtual size_t            varSize()     const { LIMITED_METHOD_CONTRACT;  return sizeof(CHAR) * m_cbName; }
      virtual void              newToken()          { LIMITED_METHOD_CONTRACT;  m_token = ++s_lastExternalMethodToken; }
      mdToken                   nestedClass() const { LIMITED_METHOD_CONTRACT;  return m_nestedClass; }
      mdToken                   signature()   const { LIMITED_METHOD_CONTRACT;  return m_signature; }
      DWORD                     cbName()      const { LIMITED_METHOD_CONTRACT;  return m_cbName; }
      LPCSTR                    pName()       const { LIMITED_METHOD_CONTRACT;  return m_pName;  }
      static size_t             HashInit()          { LIMITED_METHOD_CONTRACT;  return 389357; }    
      
      virtual bool              IsEqual(const ProfilingBlobEntry *  other) const;
      virtual size_t            Hash()        const;
  
      static const ExternalMethodBlobEntry *  FindOrAdd(PTR_Module pModule, 
                                                        mdToken    _nestedClass,
                                                        mdToken    _signature, 
                                                        LPCSTR     _pName);
  
  private:
      mdToken                   m_nestedClass;
      mdToken                   m_signature;
      DWORD                     m_cbName;
      LPCSTR                    m_pName;
      
      static idExternalMethod   s_lastExternalMethodToken;   
  };
  
  struct IbcNameHandle
  {
      mdToken  tkIbcNameSpace; 
      mdToken  tkIbcNestedClass;
  
      LPCSTR   szName; 
      LPCSTR   szNamespace;
      mdToken  tkEnclosingClass;
  };
  
  //
  // Hashtable of ProfilingBlobEntry *
  //
  class ProfilingBlobTraits : public NoRemoveSHashTraits<DefaultSHashTraits<ProfilingBlobEntry *> >
  {
  public:
      typedef ProfilingBlobEntry *  key_t;
  
      static key_t GetKey(element_t e)
      {
          LIMITED_METHOD_CONTRACT;
          return e;
      }
      static BOOL Equals(key_t k1, key_t k2)
      {
          LIMITED_METHOD_CONTRACT;
          return k1->IsEqual(k2);
      }
      static count_t Hash(key_t k)
      {
          LIMITED_METHOD_CONTRACT;
          return (count_t) k->Hash();
      }
      static const element_t Null() 
      { 
          LIMITED_METHOD_CONTRACT; 
          return NULL; 
      }
  
      static bool IsNull(const element_t &e) 
      { 
          LIMITED_METHOD_CONTRACT; 
          return (e == NULL);
      }
  };
  
  typedef SHash<ProfilingBlobTraits> ProfilingBlobTable;
  typedef DPTR(ProfilingBlobTable) PTR_ProfilingBlobTable;
  
  
  #define METHODTABLE_RESTORE_REASON() \
      RESTORE_REASON_FUNC(CanNotPreRestoreHardBindToParentMethodTable) \
      RESTORE_REASON_FUNC(CanNotPreRestoreHardBindToCanonicalMethodTable) \
      RESTORE_REASON_FUNC(CrossModuleNonCanonicalMethodTable) \
      RESTORE_REASON_FUNC(CanNotHardBindToInstanceMethodTableChain) \
      RESTORE_REASON_FUNC(GenericsDictionaryNeedsRestore) \
      RESTORE_REASON_FUNC(InterfaceIsGeneric) \
      RESTORE_REASON_FUNC(CrossModuleGenericsStatics) \
      RESTORE_REASON_FUNC(ComImportStructDependenciesNeedRestore) \
      RESTORE_REASON_FUNC(CrossAssembly) \
      RESTORE_REASON_FUNC(ArrayElement) \
      RESTORE_REASON_FUNC(ProfilingEnabled)
  
  #undef RESTORE_REASON_FUNC
  #define RESTORE_REASON_FUNC(s) s ,
  typedef enum
  {
  
      METHODTABLE_RESTORE_REASON()
  
      TotalMethodTables
  } MethodTableRestoreReason;
  #undef RESTORE_REASON_FUNC
  
  class NgenStats
  {
  public:
      NgenStats()
      {
          LIMITED_METHOD_CONTRACT;
          memset (MethodTableRestoreNumReasons, 0, sizeof(DWORD)*(TotalMethodTables+1));
      }
  
      DWORD MethodTableRestoreNumReasons[TotalMethodTables + 1];
  };
  #endif // FEATURE_PREJIT
  
  //
  // A Module is the primary unit of code packaging in the runtime.  It
  // corresponds mostly to an OS executable image, although other kinds
  // of modules exist.
  //
  class UMEntryThunk;
  
  // Hashtable of absolute addresses of IL blobs for dynamics, keyed by token
  
   struct  DynamicILBlobEntry
  {
      mdToken     m_methodToken;
      TADDR       m_il;
  };
  
  class DynamicILBlobTraits : public NoRemoveSHashTraits<DefaultSHashTraits<DynamicILBlobEntry> >
  {
  public:
      typedef mdToken key_t;
  
      static key_t GetKey(element_t e)
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
          return e.m_methodToken;
      }
      static BOOL Equals(key_t k1, key_t k2)
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
          return k1 == k2;
      }
      static count_t Hash(key_t k)
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
          return (count_t)(size_t)k;
      }
      static const element_t Null() 
      { 
          LIMITED_METHOD_CONTRACT; 
          SUPPORTS_DAC;
          DynamicILBlobEntry e; 
          e.m_il = TADDR(0);
          e.m_methodToken = 0; 
          return e; 
      }
      static bool IsNull(const element_t &e) 
      { 
          LIMITED_METHOD_CONTRACT; 
          SUPPORTS_DAC;
          return e.m_methodToken == 0;
      }
  };
  
  typedef SHash<DynamicILBlobTraits> DynamicILBlobTable;
  typedef DPTR(DynamicILBlobTable) PTR_DynamicILBlobTable;
  
  
  // declare an array type of COR_IL_MAP entries
  typedef ArrayDPTR(COR_IL_MAP) ARRAY_PTR_COR_IL_MAP;
  
  //---------------------------------------------------------------------------------------
  //
  // A profiler may instrument a method by changing the IL.  This is typically done when the profiler receives
  // a JITCompilationStarted notification.  The profiler also has the option to provide the runtime with 
  // a mapping between original IL offsets and instrumented IL offsets.  This struct is a simple container
  // for storing the mapping information.  We store the mapping information on the Module class, where it can
  // be accessed by the debugger from out-of-process.
  //
  
  class InstrumentedILOffsetMapping
  {
  public:
      InstrumentedILOffsetMapping();
  
      // Check whether there is any mapping information stored in this object.
      BOOL IsNull();
  
  #if !defined(DACCESS_COMPILE)
      // Release the memory used by the array of COR_IL_MAPs.
      void Clear();
  
      void SetMappingInfo(SIZE_T cMap, COR_IL_MAP * rgMap);
  #endif // !DACCESS_COMPILE
  
      SIZE_T               GetCount()   const;
      ARRAY_PTR_COR_IL_MAP GetOffsets() const;
  
  private:
      SIZE_T               m_cMap;        // the number of elements in m_rgMap
      ARRAY_PTR_COR_IL_MAP m_rgMap;       // an array of COR_IL_MAPs
  };
  
  //---------------------------------------------------------------------------------------
  //
  // Hash table entry for storing InstrumentedILOffsetMapping.  This is keyed by the MethodDef token.
  //
  
  struct ILOffsetMappingEntry
  {
      ILOffsetMappingEntry()
      {
          LIMITED_METHOD_DAC_CONTRACT;
  
          m_methodToken = mdMethodDefNil; 
          // No need to initialize m_mapping.  The default ctor of InstrumentedILOffsetMapping does the job.
      }
  
      ILOffsetMappingEntry(mdMethodDef token, InstrumentedILOffsetMapping mapping)
      {
          LIMITED_METHOD_DAC_CONTRACT;
  
          m_methodToken = token;
          m_mapping     = mapping;
      }
  
      mdMethodDef                 m_methodToken;
      InstrumentedILOffsetMapping m_mapping;
  };
  
  //---------------------------------------------------------------------------------------
  //
  // This class is used to create the hash table for the instrumented IL offset mapping.
  // It encapsulates the desired behaviour of the templated hash table and implements 
  // the various functions needed by the hash table.
  //
  
  class ILOffsetMappingTraits : public NoRemoveSHashTraits<DefaultSHashTraits<ILOffsetMappingEntry> >
  {
  public:
      typedef mdMethodDef key_t;
  
      static key_t GetKey(element_t e)
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return e.m_methodToken;
      }
      static BOOL Equals(key_t k1, key_t k2)
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return (k1 == k2);
      }
      static count_t Hash(key_t k)
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return (count_t)(size_t)k;
      }
      static const element_t Null() 
      { 
          LIMITED_METHOD_DAC_CONTRACT; 
          ILOffsetMappingEntry e; 
          return e; 
      }
      static bool IsNull(const element_t &e) { LIMITED_METHOD_DAC_CONTRACT; return e.m_methodToken == mdMethodDefNil; }
  };
  
  // ESymbolFormat specified the format used by a symbol stream
  typedef enum 
  {
      eSymbolFormatNone,      /* symbol format to use not yet determined */
      eSymbolFormatPDB,       /* PDB format from diasymreader.dll - only safe for trusted scenarios */
      eSymbolFormatILDB       /* ILDB format from ildbsymbols.dll */
  }ESymbolFormat;
  
  
  // Hash table of profiler-provided instrumented IL offset mapping, keyed by the MethodDef token
  typedef SHash<ILOffsetMappingTraits> ILOffsetMappingTable;
  typedef DPTR(ILOffsetMappingTable) PTR_ILOffsetMappingTable;
  
  
  #ifdef FEATURE_COMINTEROP
  
  //---------------------------------------------------------------------------------------
  //
  // The type of each entry in the Guid to MT hash
  //
  typedef DPTR(GUID) PTR_GUID;
  typedef DPTR(struct GuidToMethodTableEntry) PTR_GuidToMethodTableEntry;
  struct GuidToMethodTableEntry
  {
      PTR_GUID        m_Guid;
      PTR_MethodTable m_pMT;
  };
  
  //---------------------------------------------------------------------------------------
  //
  // The hash type itself
  //
  typedef DPTR(class GuidToMethodTableHashTable) PTR_GuidToMethodTableHashTable;
  class GuidToMethodTableHashTable : public NgenHashTable<GuidToMethodTableHashTable, GuidToMethodTableEntry, 4>
  {
  public:
      typedef NgenHashTable<GuidToMethodTableHashTable, GuidToMethodTableEntry, 4> Base_t;
      friend class Base_t;
  
  #ifndef DACCESS_COMPILE
  
  private:
      GuidToMethodTableHashTable(Module *pModule, LoaderHeap *pHeap, DWORD cInitialBuckets)
          : Base_t(pModule, pHeap, cInitialBuckets)
      { LIMITED_METHOD_CONTRACT; }
  
  public:
      static GuidToMethodTableHashTable* Create(Module* pModule, DWORD cInitialBuckets, AllocMemTracker *pamTracker);
  
      GuidToMethodTableEntry * InsertValue(PTR_GUID pGuid, PTR_MethodTable pMT, BOOL bReplaceIfFound, AllocMemTracker *pamTracker);
  
  #endif // !DACCESS_COMPILE
  
  public:
      typedef Base_t::LookupContext LookupContext;
  
      PTR_MethodTable GetValue(const GUID * pGuid, LookupContext *pContext);
      GuidToMethodTableEntry * FindItem(const GUID * pGuid, LookupContext *pContext);
  
  private:
      BOOL CompareKeys(PTR_GuidToMethodTableEntry pEntry, const GUID * pGuid);
      static DWORD Hash(const GUID * pGuid);
  
  public:
      // An iterator for the table
      struct Iterator
      {
      public:
          Iterator() : m_pTable(NULL), m_fIterating(false)
          { LIMITED_METHOD_DAC_CONTRACT; }
          Iterator(GuidToMethodTableHashTable * pTable) : m_pTable(pTable), m_fIterating(false)
          { LIMITED_METHOD_DAC_CONTRACT; }
  
      private:
          friend class GuidToMethodTableHashTable;
  
          GuidToMethodTableHashTable * m_pTable;
          BaseIterator              m_sIterator;
          bool                      m_fIterating;
      };
  
      BOOL FindNext(Iterator *it, GuidToMethodTableEntry **ppEntry);
      DWORD GetCount();
  
  #ifdef DACCESS_COMPILE
      // do not save this in mini-/heap-dumps
      void EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
      { SUPPORTS_DAC; }
      void EnumMemoryRegionsForEntry(GuidToMethodTableEntry *pEntry, CLRDataEnumMemoryFlags flags)
      { SUPPORTS_DAC; }
  #endif // DACCESS_COMPILE
  
  #if defined(FEATURE_PREJIT) && !defined(DACCESS_COMPILE)
  
  public:
      void Save(DataImage *pImage, CorProfileData *pProfileData);
      void Fixup(DataImage *pImage);
  
  private:
      // We save all entries
      bool ShouldSave(DataImage *pImage, GuidToMethodTableEntry *pEntry)
      { LIMITED_METHOD_CONTRACT; return true; }
  
      bool IsHotEntry(GuidToMethodTableEntry *pEntry, CorProfileData *pProfileData)
      { LIMITED_METHOD_CONTRACT; return false; }
  
      bool SaveEntry(DataImage *pImage, CorProfileData *pProfileData, 
                          GuidToMethodTableEntry *pOldEntry, GuidToMethodTableEntry *pNewEntry, 
                          EntryMappingTable *pMap);
  
      void FixupEntry(DataImage *pImage, GuidToMethodTableEntry *pEntry, void *pFixupBase, DWORD cbFixupOffset);
      
  #endif // FEATURE_PREJIT && !DACCESS_COMPILE
  
  };
  
  #endif // FEATURE_COMINTEROP
  
  
  //Hash for MemberRef to Desc tables (fieldDesc or MethodDesc)
  typedef DPTR(struct MemberRefToDescHashEntry) PTR_MemberRefToDescHashEntry;
  
  struct MemberRefToDescHashEntry
  {
      TADDR m_value;
  };
  
  typedef DPTR(class MemberRefToDescHashTable) PTR_MemberRefToDescHashTable;
  
  #define MEMBERREF_MAP_INITIAL_SIZE 10
  
  class MemberRefToDescHashTable: public NgenHashTable<MemberRefToDescHashTable, MemberRefToDescHashEntry, 2>
  {
  	friend class NgenHashTable<MemberRefToDescHashTable, MemberRefToDescHashEntry, 2>;
  #ifndef DACCESS_COMPILE
  
  private:
      MemberRefToDescHashTable(Module *pModule, LoaderHeap *pHeap, DWORD cInitialBuckets):
         NgenHashTable<MemberRefToDescHashTable, MemberRefToDescHashEntry, 2>(pModule, pHeap, cInitialBuckets) 
      { LIMITED_METHOD_CONTRACT; }
  
  public:
  
      static MemberRefToDescHashTable* Create(Module *pModule, DWORD cInitialBuckets, AllocMemTracker *pamTracker);
  
      MemberRefToDescHashEntry* Insert(mdMemberRef token, MethodDesc *value);
      MemberRefToDescHashEntry* Insert(mdMemberRef token , FieldDesc *value);
  #endif //!DACCESS_COMPILE
  
  public:
      typedef NgenHashTable<MemberRefToDescHashTable, MemberRefToDescHashEntry, 2>::LookupContext LookupContext;
  
      PTR_MemberRef GetValue(mdMemberRef token, BOOL *pfIsMethod);
  
  #ifdef DACCESS_COMPILE
  
      void EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
      {
          WRAPPER_NO_CONTRACT;
          BaseEnumMemoryRegions(flags);
      }
  
      void EnumMemoryRegionsForEntry(MemberRefToDescHashEntry *pEntry, CLRDataEnumMemoryFlags flags)
      { SUPPORTS_DAC; }
  
  #endif
  
  #if defined(FEATURE_PREJIT) && !defined(DACCESS_COMPILE)
  
      void Fixup(DataImage *pImage)
      {
          WRAPPER_NO_CONTRACT;
          BaseFixup(pImage);
      }
  
      void Save(DataImage *pImage, CorProfileData *pProfileData);
  
  
  private:
      bool ShouldSave(DataImage *pImage, MemberRefToDescHashEntry *pEntry)
      {
          return IsHotEntry(pEntry, NULL);
      }
  
      bool IsHotEntry(MemberRefToDescHashEntry *pEntry, CorProfileData *pProfileData) // yes according to IBC data
      {
  		LIMITED_METHOD_CONTRACT;
  
          _ASSERTE(pEntry != NULL);
  		// Low order bit of data field indicates a hot entry.
  		return (pEntry->m_value & 0x1) != 0;
  
      }
  
  
      bool SaveEntry(DataImage *pImage, CorProfileData *pProfileData, 
                          MemberRefToDescHashEntry *pOldEntry, MemberRefToDescHashEntry *pNewEntry, 
                          EntryMappingTable *pMap)
      {
          //The entries are mutable
          return FALSE;
      }
  
      void FixupEntry(DataImage *pImage, MemberRefToDescHashEntry *pEntry, void *pFixupBase, DWORD cbFixupOffset);
  
  #endif
  };
  
  #ifdef FEATURE_READYTORUN
  typedef DPTR(class ReadyToRunInfo)      PTR_ReadyToRunInfo;
  #endif
  
  struct ThreadLocalModule;
  
  // A code:Module represents a DLL or EXE file loaded from the disk. It could either be a IL module or a
  // Native code (NGEN module). A module live in a code:Assembly
  // 
  // Some important fields are
  //    * code:Module.m_file - this points at a code:PEFile that understands the layout of a PE file. The most
  //        important part is getting at the code:Module (see file:..\inc\corhdr.h#ManagedHeader) from there
  //        you can get at the Meta-data and IL)
  //    * code:Module.m_pAvailableClasses - this is a table that lets you look up the types (the code:EEClass)
  //        for all the types in the module
  //        
  // See file:..\inc\corhdr.h#ManagedHeader for more on the layout of managed exectuable files. 
  
  class Module
  {
  #ifdef DACCESS_COMPILE
      friend class ClrDataAccess;
      friend class NativeImageDumper;
  #endif
  
      friend class DataImage;
  
      VPTR_BASE_CONCRETE_VTABLE_CLASS(Module)
  
  private:
      PTR_CUTF8               m_pSimpleName; // Cached simple name for better performance and easier diagnostics
  
      PTR_PEFile              m_file;
  
      MethodDesc              *m_pDllMain;
  
      enum {
          // These are the values set in m_dwTransientFlags.
          // Note that none of these flags survive a prejit save/restore.
  
          MODULE_IS_TENURED           = 0x00000001,   // Set once we know for sure the Module will not be freed until the appdomain itself exits
          M_CER_ROOT_TABLE_ON_HEAP    = 0x00000002,   // Set when m_pCerNgenRootTable is allocated from heap (at ngen time)
          CLASSES_FREED               = 0x00000004,
          IS_EDIT_AND_CONTINUE        = 0x00000008,   // is EnC Enabled for this module
  
          IS_PROFILER_NOTIFIED        = 0x00000010,
          IS_ETW_NOTIFIED             = 0x00000020,
  
          //
          // Note: the order of these must match the order defined in
          // cordbpriv.h for DebuggerAssemblyControlFlags. The three
          // values below should match the values defined in
          // DebuggerAssemblyControlFlags when shifted right
          // DEBUGGER_INFO_SHIFT bits.
          //
          DEBUGGER_USER_OVERRIDE_PRIV = 0x00000400,
          DEBUGGER_ALLOW_JIT_OPTS_PRIV= 0x00000800,
          DEBUGGER_TRACK_JIT_INFO_PRIV= 0x00001000,
          DEBUGGER_ENC_ENABLED_PRIV   = 0x00002000,   // this is what was attempted to be set.  IS_EDIT_AND_CONTINUE is actual result.
          DEBUGGER_PDBS_COPIED        = 0x00004000,
          DEBUGGER_IGNORE_PDBS        = 0x00008000,
          DEBUGGER_INFO_MASK_PRIV     = 0x0000Fc00,
          DEBUGGER_INFO_SHIFT_PRIV    = 10,
  
          // Used to indicate that this module has had it's IJW fixups properly installed.
          IS_IJW_FIXED_UP             = 0x00080000,
          IS_BEING_UNLOADED           = 0x00100000,
  
          // Used to indicate that the module is loaded sufficiently for generic candidate instantiations to work
          MODULE_READY_FOR_TYPELOAD  = 0x00200000,
  
          // Used during NGen only
          TYPESPECS_TRIAGED           = 0x40000000,
          MODULE_SAVED                = 0x80000000,
      };
  
      enum {
          // These are the values set in m_dwPersistedFlags.  These will survive
          // a prejit save/restore
          // unused                   = 0x00000001,
          COMPUTED_GLOBAL_CLASS       = 0x00000002,
  
          // This flag applies to assembly, but it is stored so it can be cached in ngen image
          COMPUTED_STRING_INTERNING   = 0x00000004,
          NO_STRING_INTERNING         = 0x00000008,
  
          // This flag applies to assembly, but it is stored so it can be cached in ngen image
          COMPUTED_WRAP_EXCEPTIONS    = 0x00000010,
          WRAP_EXCEPTIONS             = 0x00000020,
  
          // This flag applies to assembly, but it is stored so it can be cached in ngen image
          COMPUTED_RELIABILITY_CONTRACT=0x00000040,
  
          // This flag applies to assembly, but is also stored here so that it can be cached in ngen image
          COLLECTIBLE_MODULE          = 0x00000080,
  
          // Caches metadata version
          COMPUTED_IS_PRE_V4_ASSEMBLY = 0x00000100,
          IS_PRE_V4_ASSEMBLY          = 0x00000200,
  
          //If attribute value has been cached before
          DEFAULT_DLL_IMPORT_SEARCH_PATHS_IS_CACHED   = 0x00000400,
  
          //If module has default dll import search paths attribute
          DEFAULT_DLL_IMPORT_SEARCH_PATHS_STATUS      = 0x00000800,
  
          //If attribute value has been cached before
          NEUTRAL_RESOURCES_LANGUAGE_IS_CACHED = 0x00001000,
  
          //If m_MethodDefToPropertyInfoMap has been generated
          COMPUTED_METHODDEF_TO_PROPERTYINFO_MAP = 0x00002000,
  
          // Low level system assembly. Used by preferred zap module computation.
          LOW_LEVEL_SYSTEM_ASSEMBLY_BY_NAME = 0x00004000,
      };
  
      Volatile<DWORD>          m_dwTransientFlags;
      Volatile<DWORD>          m_dwPersistedFlags;
  
      // Linked list of VASig cookie blocks: protected by m_pStubListCrst
      VASigCookieBlock        *m_pVASigCookieBlock;
  
      PTR_Assembly            m_pAssembly;
      mdFile                  m_moduleRef;
  
      CrstExplicitInit        m_Crst;
      CrstExplicitInit        m_FixupCrst;
  
      // Debugging symbols reader interface. This will only be
      // initialized if needed, either by the debugging subsystem or for
      // an exception.
      ISymUnmanagedReader *   m_pISymUnmanagedReader;
  
      // The reader lock is used to serialize all creation of symbol readers.
      // It does NOT seralize all access to the readers since we freely give
      // out references to the reader outside this class.  Instead, once a
      // reader object is created, it is entirely read-only and so thread-safe.
      CrstExplicitInit        m_ISymUnmanagedReaderCrst;
  
      // Storage for the in-memory symbol stream if any
      // Debugger may retrieve this from out-of-process.
      PTR_CGrowableStream     m_pIStreamSym;
  
      // Format the above stream is in (if any)
      ESymbolFormat           m_symbolFormat;
  
      // Active dependencies
      ArrayList               m_activeDependencies;
  
      SynchronizedBitMask     m_unconditionalDependencies;
      ULONG                   m_dwNumberOfActivations;
  
      // For protecting additions to the heap
      CrstExplicitInit        m_LookupTableCrst;
  
      #define TYPE_DEF_MAP_ALL_FLAGS                    ((TADDR)0x00000001)
          #define ZAPPED_TYPE_NEEDS_NO_RESTORE          ((TADDR)0x00000001)
  
      #define TYPE_REF_MAP_ALL_FLAGS                    NO_MAP_FLAGS
          // For type ref map, 0x1 cannot be used as a flag: reserved for FIXUP_POINTER_INDIRECTION bit
          // For type ref map, 0x2 cannot be used as a flag: reserved for TypeHandle to signify TypeDesc
  
      #define METHOD_DEF_MAP_ALL_FLAGS                  NO_MAP_FLAGS
  
      #define FIELD_DEF_MAP_ALL_FLAGS                   NO_MAP_FLAGS
  
      #define MEMBER_REF_MAP_ALL_FLAGS                  ((TADDR)0x00000003)
  	// For member ref hash table, 0x1 is reserved for IsHot bit
          #define IS_FIELD_MEMBER_REF                   ((TADDR)0x00000002)      // denotes that target is a FieldDesc
  
      #define GENERIC_PARAM_MAP_ALL_FLAGS               NO_MAP_FLAGS
  
      #define GENERIC_TYPE_DEF_MAP_ALL_FLAGS            ((TADDR)0x00000001)
          #define ZAPPED_GENERIC_TYPE_NEEDS_NO_RESTORE  ((TADDR)0x00000001)
  
      #define FILE_REF_MAP_ALL_FLAGS                    NO_MAP_FLAGS
          // For file ref map, 0x1 cannot be used as a flag: reserved for FIXUP_POINTER_INDIRECTION bit
  
      #define MANIFEST_MODULE_MAP_ALL_FLAGS             NO_MAP_FLAGS
          // For manifest module map, 0x1 cannot be used as a flag: reserved for FIXUP_POINTER_INDIRECTION bit
  
      #define PROPERTY_INFO_MAP_ALL_FLAGS               NO_MAP_FLAGS
  
      // Linear mapping from TypeDef token to MethodTable *
      // For generic types, IsGenericTypeDefinition() is true i.e. instantiation at formals
      LookupMap<PTR_MethodTable>      m_TypeDefToMethodTableMap;
  
      // Linear mapping from TypeRef token to TypeHandle *
      LookupMap<PTR_TypeRef>          m_TypeRefToMethodTableMap;
  
      // Linear mapping from MethodDef token to MethodDesc *
      // For generic methods, IsGenericTypeDefinition() is true i.e. instantiation at formals
      LookupMap<PTR_MethodDesc>       m_MethodDefToDescMap;
  
      // Linear mapping from FieldDef token to FieldDesc*
      LookupMap<PTR_FieldDesc>        m_FieldDefToDescMap;
  
      // mapping from MemberRef token to MethodDesc*, FieldDesc*
      PTR_MemberRefToDescHashTable        m_pMemberRefToDescHashTable;
  
      // Linear mapping from GenericParam token to TypeVarTypeDesc*
      LookupMap<PTR_TypeVarTypeDesc>  m_GenericParamToDescMap;
  
      // Linear mapping from TypeDef token to the MethodTable * for its canonical generic instantiation
      // If the type is not generic, the entry is guaranteed to be NULL.  This means we are paying extra
      // space in order to use the LookupMap infrastructure, but what it buys us is IBC support and
      // a compressed format for NGen that makes up for it.
      LookupMap<PTR_MethodTable>      m_GenericTypeDefToCanonMethodTableMap;
  
      // Mapping from File token to Module *
      LookupMap<PTR_Module>           m_FileReferencesMap;
  
      // Mapping of AssemblyRef token to Module *
      LookupMap<PTR_Module>           m_ManifestModuleReferencesMap;
  
      // Mapping from MethodDef token to pointer-sized value encoding property information
      LookupMap<SIZE_T>           m_MethodDefToPropertyInfoMap;
  
      // IL stub cache with fabricated MethodTable parented by this module.
      ILStubCache                *m_pILStubCache;
  
      ULONG m_DefaultDllImportSearchPathsAttributeValue;
  
       LPCUTF8 m_pszCultureName;
       ULONG m_CultureNameLength;
       INT16 m_FallbackLocation;
  
  #ifdef PROFILING_SUPPORTED_DATA 
       // a wrapper for the underlying PEFile metadata emitter which validates that the metadata edits being
       // made are supported modifications to the type system
       VolatilePtr<IMetaDataEmit> m_pValidatedEmitter;
  #endif
  
  public:
      LookupMap<PTR_MethodTable>::Iterator EnumerateTypeDefs()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
  
          return LookupMap<PTR_MethodTable>::Iterator(&m_TypeDefToMethodTableMap);
      }
  
      // Hash of available types by name
      PTR_EEClassHashTable    m_pAvailableClasses;
  
      // Hashtable of generic type instances
      PTR_EETypeHashTable     m_pAvailableParamTypes;
  
      // For protecting additions to m_pInstMethodHashTable
      CrstExplicitInit        m_InstMethodHashTableCrst;
  
      // Hashtable of instantiated methods and per-instantiation static methods
      PTR_InstMethodHashTable m_pInstMethodHashTable;
  
  #ifdef FEATURE_PREJIT
      // Mapping from tokens to IL marshaling stubs (NGEN only).
      PTR_StubMethodHashTable m_pStubMethodHashTable;
  #endif // FEATURE_PREJIT
  
      // This is used by the Debugger. We need to store a dword
      // for a count of JMC functions. This is a count, not a pointer.
      // We'll pass the address of this field
      // off to the jit, which will include it in probes injected for
      // debuggable code.
      // This means we need the dword at the time a function is jitted.
      // The Debugger has its own module structure, but those aren't created
      // if a debugger isn't attached.
      // We put it here instead of in the debugger's module because:
      // 1) we need a module structure that's around even when the debugger
      // isn't attached... so we use the EE's module.
      // 2) Needs to be here for ngen
      DWORD                   m_dwDebuggerJMCProbeCount;
  
      // We can skip the JMC probes if we know that a module has no JMC stuff
      // inside. So keep a strict count of all functions inside us.
      bool HasAnyJMCFunctions();
      void IncJMCFuncCount();
      void DecJMCFuncCount();
  
      // Get and set the default JMC status of this module.
      bool GetJMCStatus();
      void SetJMCStatus(bool fStatus);
  
      // If this is a dynamic module, eagerly serialize the metadata so that it is available for DAC.
      // This is a nop for non-dynamic modules.
      void UpdateDynamicMetadataIfNeeded();
  
  #ifdef _DEBUG
      //
      // We call these methods to seal/unseal the
      // lists: m_pAvailableClasses and m_pAvailableParamTypes 
      // 
      // When they are sealed ClassLoader::PublishType cannot 
      // add new generic types or methods
      //   
      void SealGenericTypesAndMethods();
      void UnsealGenericTypesAndMethods();
  #endif
  
  private:
      // Set the given bit on m_dwTransientFlags. Return true if we won the race to set the bit.
      BOOL SetTransientFlagInterlocked(DWORD dwFlag);
  
      // Invoke fusion hooks into host to fetch PDBs
      void FetchPdbsFromHost();
  
      // Cannoically-cased hashtable of the available class names for
      // case insensitive lookup.  Contains pointers into
      // m_pAvailableClasses.
      PTR_EEClassHashTable    m_pAvailableClassesCaseIns;
  
      // Pointer to binder, if we have one
      friend class MscorlibBinder;
      PTR_MscorlibBinder      m_pBinder;
  
  public:
      BOOL IsCollectible()
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return (m_dwPersistedFlags & COLLECTIBLE_MODULE) != 0;
      }
  
  #ifdef FEATURE_PREJIT
  
  private:
      PTR_NGenLayoutInfo      m_pNGenLayoutInfo;
  #ifdef FEATURE_READYTORUN
      PTR_ReadyToRunInfo      m_pReadyToRunInfo;
  #endif
  
      PTR_ProfilingBlobTable  m_pProfilingBlobTable;   // While performing IBC instrumenting this hashtable is populated with the External defs
      CorProfileData *        m_pProfileData;          // While ngen-ing with IBC optimizations this contains a link to the IBC data for the assembly
      SString *               m_pIBCErrorNameString;   // Used when reporting IBC type loading errors
  
      // Profile information
      BOOL                            m_nativeImageProfiling;
      CORCOMPILE_METHOD_PROFILE_LIST *m_methodProfileList;
  
  #if defined(FEATURE_COMINTEROP)
          public:
  
          #ifndef DACCESS_COMPILE
              BOOL CanCacheWinRTTypeByGuid(MethodTable *pMT);
              void CacheWinRTTypeByGuid(PTR_MethodTable pMT, PTR_GuidInfo pgi = NULL);
          #endif // !DACCESS_COMPILE
  
              PTR_MethodTable LookupTypeByGuid(const GUID & guid);
              void GetCachedWinRTTypes(SArray<PTR_MethodTable> * pTypes, SArray<GUID> * pGuids);
  
          private:
              PTR_GuidToMethodTableHashTable m_pGuidToTypeHash;   // A map from GUID to Type, for the "WinRT-interesting" types
  
  #endif // defined(FEATURE_COMINTEROP)
  
  #endif // FEATURE_PREJIT
  
      // Module wide static fields information
      ModuleCtorInfo          m_ModuleCtorInfo;
  
  #ifdef FEATURE_PREJIT
      struct TokenProfileData
      {
          static TokenProfileData *CreateNoThrow(void);
  
          TokenProfileData()
              // We need a critical section that can be entered in both preemptive and cooperative modes.
              // Hopefully this restriction can be removed in the future.
              : crst(CrstSaveModuleProfileData, CRST_UNSAFE_ANYMODE)
          {
              WRAPPER_NO_CONTRACT;
          }
  
          ~TokenProfileData()
          {
              WRAPPER_NO_CONTRACT;
          }
  
          Crst crst;
  
          struct Formats
          {
              CQuickArray<CORBBTPROF_TOKEN_INFO>   tokenArray;
              RidBitmap                   tokenBitmaps[CORBBTPROF_TOKEN_MAX_NUM_FLAGS];
          } m_formats[SectionFormatCount];
  
      } *m_tokenProfileData;
  
      // Stats for prejit log
      NgenStats                *m_pNgenStats;
  #endif // FEATURE_PREJIT
  
  #ifdef FEATURE_MIXEDMODE 
      // LoaderHeap for storing thunks
      PTR_LoaderHeap           m_pThunkHeap;
  
      // Self-initializing accessor for thunk heap
      LoaderHeap              *GetThunkHeap();
      // Self-initializing accessor for domain-independent thunk heap
      LoaderHeap              *GetDllThunkHeap();
  
  
  public:
      UMEntryThunk*            GetADThunkTable();
      void                     SetADThunkTable(UMEntryThunk* pTable);
  
  protected:
      // Domain that the IJW fixups were applied in
      ADID                    m_DomainIdOfIJWFixups;
  
  public:
      ADID                    GetDomainIdOfIJWFixups()
      {
          LIMITED_METHOD_CONTRACT;
          _ASSERT(m_DomainIdOfIJWFixups != ADID());
          return m_DomainIdOfIJWFixups;
      }
  
      void                     SetDomainIdOfIJWFixups(ADID id)
      {
          LIMITED_METHOD_CONTRACT;
          _ASSERT(id != ADID());
          m_DomainIdOfIJWFixups = id;
      }
  
  #endif // FEATURE_MIXEDMODE
  
  protected:
  
      void CreateDomainThunks();
  
  protected:
      void DoInit(AllocMemTracker *pamTracker, LPCWSTR szName);
  
  protected:
  #ifndef DACCESS_COMPILE
      virtual void Initialize(AllocMemTracker *pamTracker, LPCWSTR szName = NULL);
  #ifdef FEATURE_PREJIT 
      void InitializeNativeImage(AllocMemTracker* pamTracker);
  #endif
  #endif
  
      void AllocateMaps();
  
  #ifdef _DEBUG
      void DebugLogRidMapOccupancy();
  #endif // _DEBUG
  
      static HRESULT VerifyFile(PEFile *file, BOOL fZap);
  
   public:
      static Module *Create(Assembly *pAssembly, mdFile kFile, PEFile *pFile, AllocMemTracker *pamTracker);
  
   protected:
      Module(Assembly *pAssembly, mdFile moduleRef, PEFile *file);
  
  
   public:
  #ifndef DACCESS_COMPILE
      virtual void Destruct();
  #ifdef  FEATURE_PREJIT
      void DeleteNativeCodeRanges();
  #endif
  #endif
  
      PTR_LoaderAllocator GetLoaderAllocator();
  
      PTR_PEFile GetFile() const { LIMITED_METHOD_DAC_CONTRACT; return m_file; }
  
      static size_t GetFileOffset() { LIMITED_METHOD_CONTRACT; return offsetof(Module, m_file); }
  
      BOOL IsManifest();
  
      void ApplyMetaData();
  
  #ifdef FEATURE_MIXEDMODE
      void FixupVTables();
  #endif 
  
      void FreeClassTables();
  
  #ifdef DACCESS_COMPILE
      virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags,
                                     bool enumThis);
  #endif // DACCESS_COMPILE
  
      ReflectionModule *GetReflectionModule() const
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
  
          _ASSERTE(IsReflection());
          return dac_cast<PTR_ReflectionModule>(this);
      }
  
      PTR_Assembly GetAssembly() const;
  
      int GetClassLoaderIndex()
      {
          LIMITED_METHOD_CONTRACT;
  
          return RidFromToken(m_moduleRef);
      }
  
      MethodTable *GetGlobalMethodTable();
      bool         NeedsGlobalMethodTable();
  
      // Only for non-manifest modules
      DomainModule *GetDomainModule(AppDomain *pDomain);
      DomainModule *FindDomainModule(AppDomain *pDomain);
  
      // This works for manifest modules too
      DomainFile *GetDomainFile(AppDomain *pDomain);
      DomainFile *FindDomainFile(AppDomain *pDomain);
  
      // Operates on assembly of module
      DomainAssembly *GetDomainAssembly(AppDomain *pDomain);
      DomainAssembly *FindDomainAssembly(AppDomain *pDomain);
  
      // Versions which rely on the current AppDomain (N/A for DAC builds)
  #ifndef DACCESS_COMPILE
      DomainModule * GetDomainModule()         { WRAPPER_NO_CONTRACT; return GetDomainModule(GetAppDomain()); }
      DomainFile * GetDomainFile()             { WRAPPER_NO_CONTRACT; return GetDomainFile(GetAppDomain()); }
      DomainAssembly * GetDomainAssembly()     { WRAPPER_NO_CONTRACT; return GetDomainAssembly(GetAppDomain()); }
  #endif
  
      void SetDomainFile(DomainFile *pDomainFile);
  
      OBJECTREF GetExposedObject();
  
      ClassLoader *GetClassLoader();
      PTR_BaseDomain GetDomain();
      ReJitManager * GetReJitManager();
      IAssemblySecurityDescriptor* GetSecurityDescriptor();
  
      mdFile GetModuleRef()
      {
          LIMITED_METHOD_CONTRACT;
  
          return m_moduleRef;
      }
  
  
      BOOL IsResource() const { WRAPPER_NO_CONTRACT; SUPPORTS_DAC; return GetFile()->IsResource(); }
      BOOL IsPEFile() const { WRAPPER_NO_CONTRACT; return !GetFile()->IsDynamic(); }
      BOOL IsReflection() const { WRAPPER_NO_CONTRACT; SUPPORTS_DAC; return GetFile()->IsDynamic(); }
      BOOL IsIbcOptimized() const { WRAPPER_NO_CONTRACT; return GetFile()->IsIbcOptimized(); }
      // Returns true iff the debugger can see this module.
      BOOL IsVisibleToDebugger();
  
  
      BOOL IsEditAndContinueEnabled() 
      { 
          LIMITED_METHOD_CONTRACT; 
          SUPPORTS_DAC;
          // We are seeing cases where this flag is set for a module that is not an EditAndContinueModule.  This should
          // never happen unless the module is EditAndContinueCapable, in which case we would have created an EditAndContinueModule
          // not a Module.  
          //_ASSERTE((m_dwTransientFlags & IS_EDIT_AND_CONTINUE) == 0 || IsEditAndContinueCapable());
          return (IsEditAndContinueCapable()) && ((m_dwTransientFlags & IS_EDIT_AND_CONTINUE) != 0); 
      }
  
      BOOL IsEditAndContinueCapable();
      
      BOOL IsIStream() { LIMITED_METHOD_CONTRACT; return GetFile()->IsIStream(); }
  
      BOOL IsSystem() { WRAPPER_NO_CONTRACT; SUPPORTS_DAC; return m_file->IsSystem(); }
  
      static BOOL IsEditAndContinueCapable(Assembly *pAssembly, PEFile *file);
  
      void EnableEditAndContinue()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
          // _ASSERTE(IsEditAndContinueCapable());
          LOG((LF_ENC, LL_INFO100, "EnableEditAndContinue: this:0x%x, %s\n", this, GetDebugName()));
          m_dwTransientFlags |= IS_EDIT_AND_CONTINUE;
      }
  
      void DisableEditAndContinue()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
          // don't _ASSERTE(IsEditAndContinueCapable());
          LOG((LF_ENC, LL_INFO100, "DisableEditAndContinue: this:0x%x, %s\n", this, GetDebugName()));
          m_dwTransientFlags = m_dwTransientFlags.Load() & (~IS_EDIT_AND_CONTINUE);
      }
  
      BOOL IsTenured()
      {
          LIMITED_METHOD_CONTRACT;
          return m_dwTransientFlags & MODULE_IS_TENURED;
      }
  
  #ifndef DACCESS_COMPILE
      VOID SetIsTenured()
      {
          LIMITED_METHOD_CONTRACT;
          FastInterlockOr(&m_dwTransientFlags, MODULE_IS_TENURED);
      }
  
      // CAUTION: This should only be used as backout code if an assembly is unsuccessfully
      //          added to the shared domain assembly map.
      VOID UnsetIsTenured()
      {
          LIMITED_METHOD_CONTRACT;
          FastInterlockAnd(&m_dwTransientFlags, ~MODULE_IS_TENURED);
      }
  #endif // !DACCESS_COMPILE
  
  
      // This means the module has been sufficiently fixed up/security checked
      // that type loads can occur in domains. This is not sufficient to indicate
      // that domain-specific types can be loaded when applied to domain-neutral modules
      BOOL IsReadyForTypeLoad()
      {
          LIMITED_METHOD_CONTRACT;
          return m_dwTransientFlags & MODULE_READY_FOR_TYPELOAD;
      }
  
  #ifndef DACCESS_COMPILE
      VOID SetIsReadyForTypeLoad()
      {
          LIMITED_METHOD_CONTRACT;
          FastInterlockOr(&m_dwTransientFlags, MODULE_READY_FOR_TYPELOAD);
      }
  #endif
  
      BOOL IsLowLevelSystemAssemblyByName()
      {
          LIMITED_METHOD_CONTRACT;
          // The flag is set during initialization, so we can skip the memory barrier
          return m_dwPersistedFlags.LoadWithoutBarrier() & LOW_LEVEL_SYSTEM_ASSEMBLY_BY_NAME;
      }
  
      BOOL IsIntrospectionOnly();
  
  #ifndef DACCESS_COMMPILE
      VOID EnsureActive();
      VOID EnsureAllocated();    
      VOID EnsureLibraryLoaded();
  #endif
  
      CHECK CheckActivated();
      ULONG GetNumberOfActivations();
      ULONG IncrementNumberOfActivations();
  
      IMDInternalImport *GetMDImport() const
      {
          WRAPPER_NO_CONTRACT;
          SUPPORTS_DAC;
  
  #ifdef DACCESS_COMPILE
          if (IsReflection())
          {
              return DacGetMDImport(GetReflectionModule(), true);
          }
  #endif // DACCESS_COMPILE
          return m_file->GetPersistentMDImport();
      }
  
  #ifndef DACCESS_COMPILE
      IMetaDataEmit *GetEmitter()
      {
          WRAPPER_NO_CONTRACT;
  
          return m_file->GetEmitter();
      }
  
  #if defined(PROFILING_SUPPORTED) && !defined(CROSSGEN_COMPILE) 
      IMetaDataEmit *GetValidatedEmitter();
  #endif
  
      IMetaDataImport2 *GetRWImporter()
      {
          WRAPPER_NO_CONTRACT;
  
          return m_file->GetRWImporter();
      }
  
      IMetaDataAssemblyImport *GetAssemblyImporter()
      {
          WRAPPER_NO_CONTRACT;
  
          return m_file->GetAssemblyImporter();
      }
  
      HRESULT GetReadablePublicMetaDataInterface(DWORD dwOpenFlags, REFIID riid, LPVOID * ppvInterface);
  #endif // !DACCESS_COMPILE
  
      BOOL IsWindowsRuntimeModule();
  
      BOOL IsInCurrentVersionBubble();
  
      LPCWSTR GetPathForErrorMessages();
  
  
  #ifdef FEATURE_ISYM_READER
      // Gets an up-to-date symbol reader for this module, lazily creating it if necessary
      // The caller must call Release
      ISymUnmanagedReader *GetISymUnmanagedReader(void);
      ISymUnmanagedReader *GetISymUnmanagedReaderNoThrow(void);
  #endif // FEATURE_ISYM_READER
  
      // Save a copy of the provided debugging symbols in the InMemorySymbolStream.
      // These are used by code:Module::GetInMemorySymbolStream and code:Module.GetISymUnmanagedReader
      // This can only be called during module creation, before anyone may have tried to create a reader.
      void SetSymbolBytes(LPCBYTE pSyms, DWORD cbSyms);
  
      // Does the current configuration permit reading of symbols for this module?
      // Note that this may require calling into managed code (to resolve security policy).
      BOOL IsSymbolReadingEnabled(void);
  
      BOOL IsPersistedObject(void *address);
  
  
      // Get the in-memory symbol stream for this module, if any.
      // If none, this will return null.  This is used by modules loaded in-memory (eg. from a byte-array)
      // and by dynamic modules.  Callers that actually do anything with the return value will almost
      // certainly want to check GetInMemorySymbolStreamFormat to know how to interpret the bytes
      // in the stream.
      PTR_CGrowableStream GetInMemorySymbolStream()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
  
          // Symbol format should be "none" if-and-only-if our stream is null
          // If this fails, it may mean somebody is trying to examine this module after 
          // code:Module::Destruct has been called.
          _ASSERTE( (m_symbolFormat == eSymbolFormatNone) == (m_pIStreamSym == NULL) );
  
          return m_pIStreamSym;
      }
  
      // Get the format of the in-memory symbol stream for this module, or 
      // eSymbolFormatNone if no in-memory symbols.
      ESymbolFormat GetInMemorySymbolStreamFormat()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
  
          // Symbol format should be "none" if-and-only-if our stream is null
          // If this fails, it may mean somebody is trying to examine this module after 
          // code:Module::Destruct has been called.
          _ASSERTE( (m_symbolFormat == eSymbolFormatNone) == (m_pIStreamSym == NULL) );
  
          return m_symbolFormat;
      }
  
  #ifndef DACCESS_COMPILE
      // Set the in-memory stream for debug symbols
      // This must only be called when there is no existing stream.
      // This takes an AddRef on the supplied stream.
      void SetInMemorySymbolStream(CGrowableStream *pStream, ESymbolFormat symbolFormat)
      {
          LIMITED_METHOD_CONTRACT;
  
          // Must have provided valid stream data
          CONSISTENCY_CHECK(pStream != NULL);
          CONSISTENCY_CHECK(symbolFormat != eSymbolFormatNone);
  
          // we expect set to only be called once
          CONSISTENCY_CHECK(m_pIStreamSym == NULL);
          CONSISTENCY_CHECK(m_symbolFormat == eSymbolFormatNone);    
  
          m_symbolFormat = symbolFormat;
          m_pIStreamSym = pStream;
          m_pIStreamSym->AddRef();
      }
  
      // Release and clear the in-memory symbol stream if any
      void ClearInMemorySymbolStream()
      {      
          LIMITED_METHOD_CONTRACT;
          if( m_pIStreamSym != NULL )
          {
              m_pIStreamSym->Release();
              m_pIStreamSym = NULL;
              // We could set m_symbolFormat to eSymbolFormatNone to be consistent with not having
              // a stream, but no-one should be trying to look at it after destruct time, so it's
              // better to leave it inconsistent and get an ASSERT if someone tries to examine the
              // module's sybmol stream after the module was destructed.
          }
      }
  
      // Release the symbol reader if any
      // Caller is responsible for aquiring the reader lock if this could occur
      // concurrently with other uses of the reader (i.e. not shutdown/unload time)
      void ReleaseISymUnmanagedReader(void);
  
      virtual void ReleaseILData();
  
  #ifdef FEATURE_FUSION
      void FusionCopyPDBs(LPCWSTR moduleName);
      // This function will return PDB stream if exist.
      HRESULT GetHostPdbStream(IStream **ppStream);
  #endif // FEATURE_FUSION
  
  #endif // DACCESS_COMPILE
  
      // IL stub cache
      ILStubCache* GetILStubCache();
  
      // Classes
      void AddClass(mdTypeDef classdef);
      void BuildClassForModule();
      PTR_EEClassHashTable GetAvailableClassHash()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC; 
          {
              // IsResource() may lock when accessing metadata, but this is only in debug,
              // for the assert below
              CONTRACT_VIOLATION(TakesLockViolation);
  
              _ASSERTE(!IsResource());
          }
  
          return m_pAvailableClasses;
      }
  #ifndef DACCESS_COMPILE
      void SetAvailableClassHash(EEClassHashTable *pAvailableClasses)
      {
          LIMITED_METHOD_CONTRACT;
          {
              // IsResource() may lock when accessing metadata, but this is only in debug,
              // for the assert below
              CONTRACT_VIOLATION(TakesLockViolation);
  
              _ASSERTE(!IsResource());
          }
          m_pAvailableClasses = pAvailableClasses;
      }
  #endif // !DACCESS_COMPILE
      PTR_EEClassHashTable GetAvailableClassCaseInsHash()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
          {
              // IsResource() may lock when accessing metadata, but this is only in debug,
              // for the assert below
              CONTRACT_VIOLATION(TakesLockViolation);
  
              _ASSERTE(!IsResource());
          }
          return m_pAvailableClassesCaseIns;
      }
  #ifndef DACCESS_COMPILE
      void SetAvailableClassCaseInsHash(EEClassHashTable *pAvailableClassesCaseIns)
      {
          LIMITED_METHOD_CONTRACT;
          {
              // IsResource() may lock when accessing metadata, but this is only in debug,
              // for the assert below
              CONTRACT_VIOLATION(TakesLockViolation);
  
              _ASSERTE(!IsResource());
          }
          m_pAvailableClassesCaseIns = pAvailableClassesCaseIns;
      }
  #endif // !DACCESS_COMPILE
  
      // Constructed types tables
      EETypeHashTable *GetAvailableParamTypes()
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
          {
              // IsResource() may lock when accessing metadata, but this is only in debug,
              // for the assert below
              CONTRACT_VIOLATION(TakesLockViolation);
  
              _ASSERTE(!IsResource());
          }
          return m_pAvailableParamTypes;
      }
  
      InstMethodHashTable *GetInstMethodHashTable()
      {
          LIMITED_METHOD_CONTRACT;
          {
              // IsResource() may lock when accessing metadata, but this is only in debug,
              // for the assert below
              CONTRACT_VIOLATION(TakesLockViolation);
  
              _ASSERTE(!IsResource());
          }
          return m_pInstMethodHashTable;
      }
  
  #ifdef FEATURE_PREJIT    
      // Gets or creates the token -> IL stub MethodDesc hash.
      StubMethodHashTable *GetStubMethodHashTable();
  #endif // FEATURE_PREJIT    
  
      // Creates a new Method table for an array.  Used to make type handles
      // Note that if kind == SZARRAY or ARRAY, we get passed the GENERIC_ARRAY
      // needed to create the array.  That way we dont need to load classes during
      // the class load, which avoids the need for a 'being loaded' list
      MethodTable* CreateArrayMethodTable(TypeHandle elemType, CorElementType kind, unsigned rank, class AllocMemTracker *pamTracker);
  
      // This is called from CreateArrayMethodTable
      MethodTable* CreateGenericArrayMethodTable(TypeHandle elemType);
  
      // string helper
      void InitializeStringData(DWORD token, EEStringData *pstrData, CQuickBytes *pqb);
  
      // Resolving
      OBJECTHANDLE ResolveStringRef(DWORD Token, BaseDomain *pDomain, bool bNeedToSyncWithFixups);
  #ifdef FEATURE_PREJIT
      OBJECTHANDLE ResolveStringRefHelper(DWORD token, BaseDomain *pDomain, PTR_CORCOMPILE_IMPORT_SECTION pSection, EEStringData *strData);
  #endif
      
      CHECK CheckStringRef(RVA rva);
  
      // Module/Assembly traversal
      Assembly * GetAssemblyIfLoaded(
              mdAssemblyRef       kAssemblyRef, 
              LPCSTR              szWinRtNamespace = NULL, 
              LPCSTR              szWinRtClassName = NULL, 
              IMDInternalImport * pMDImportOverride = NULL,
              BOOL                fDoNotUtilizeExtraChecks = FALSE,
              ICLRPrivBinder      *pBindingContextForLoadedAssembly = NULL
              );
  
  private:
      // Helper function used by GetAssemblyIfLoaded. Do not call directly.
      Assembly *GetAssemblyIfLoadedFromNativeAssemblyRefWithRefDefMismatch(mdAssemblyRef kAssemblyRef, BOOL *pfDiscoveredAssemblyRefMatchesTargetDefExactly);
  public:
  
      DomainAssembly * LoadAssembly(
              AppDomain *   pDomain, 
              mdAssemblyRef kAssemblyRef, 
              LPCUTF8       szWinRtTypeNamespace = NULL,
              LPCUTF8       szWinRtTypeClassName = NULL);
      Module *GetModuleIfLoaded(mdFile kFile, BOOL onlyLoadedInAppDomain, BOOL loadAllowed);
      DomainFile *LoadModule(AppDomain *pDomain, mdFile kFile, BOOL loadResources = TRUE, BOOL bindOnly = FALSE);
      PTR_Module LookupModule(mdToken kFile, BOOL loadResources = TRUE); //wrapper over GetModuleIfLoaded, takes modulerefs as well
      DWORD GetAssemblyRefFlags(mdAssemblyRef tkAssemblyRef);
  
      bool HasBindableIdentity(mdAssemblyRef tkAssemblyRef)
      { 
          WRAPPER_NO_CONTRACT; 
          return !IsAfContentType_WindowsRuntime(GetAssemblyRefFlags(tkAssemblyRef)); 
      }
  
      // RID maps
      TypeHandle LookupTypeDef(mdTypeDef token, ClassLoadLevel *pLoadLevel = NULL)
      {
          LIMITED_METHOD_DAC_CONTRACT;
  
          BAD_FORMAT_NOTHROW_ASSERT(TypeFromToken(token) == mdtTypeDef);
  
          g_IBCLogger.LogRidMapAccess( MakePair( this, token ) );
  
          TADDR flags;
          TypeHandle th = TypeHandle(m_TypeDefToMethodTableMap.GetElementAndFlags(RidFromToken(token), &flags));
  
          if (pLoadLevel && !th.IsNull())
          {
              if (!IsCompilationProcess() && (flags & ZAPPED_TYPE_NEEDS_NO_RESTORE))
              {
                  // Make sure the flag is consistent with the target data and implies the load level we think it does
                  _ASSERTE(th.AsMethodTable()->IsPreRestored());
                  _ASSERTE(th.GetLoadLevel() == CLASS_LOADED);
  
                  *pLoadLevel = CLASS_LOADED;
              }
              else
              {
                  *pLoadLevel = th.GetLoadLevel();
              }
          }
  
          return th;
      }
  
      TypeHandle LookupFullyCanonicalInstantiation(mdTypeDef token, ClassLoadLevel *pLoadLevel = NULL)
      {
          LIMITED_METHOD_DAC_CONTRACT;
  
          BAD_FORMAT_NOTHROW_ASSERT(TypeFromToken(token) == mdtTypeDef);
  
          g_IBCLogger.LogRidMapAccess( MakePair( this, token ) );
  
          TADDR flags;
          TypeHandle th = TypeHandle(m_GenericTypeDefToCanonMethodTableMap.GetElementAndFlags(RidFromToken(token), &flags));
  
          if (pLoadLevel && !th.IsNull())
          {
              if (!IsCompilationProcess() && (flags & ZAPPED_GENERIC_TYPE_NEEDS_NO_RESTORE))
              {
                  // Make sure the flag is consistent with the target data and implies the load level we think it does
                  _ASSERTE(th.AsMethodTable()->IsPreRestored());
                  _ASSERTE(th.GetLoadLevel() == CLASS_LOADED);
  
                  *pLoadLevel = CLASS_LOADED;
              }
              else
              {
                  *pLoadLevel = th.GetLoadLevel();
              }
          }
  
          return th;
      }
  
  #ifndef DACCESS_COMPILE
      VOID EnsureTypeDefCanBeStored(mdTypeDef token)
      {
          WRAPPER_NO_CONTRACT; // THROWS/GC_NOTRIGGER/INJECT_FAULT()/MODE_ANY
          m_TypeDefToMethodTableMap.EnsureElementCanBeStored(this, RidFromToken(token));
      }
  
      void EnsuredStoreTypeDef(mdTypeDef token, TypeHandle value)
      {
          WRAPPER_NO_CONTRACT; // NOTHROW/GC_NOTRIGGER/FORBID_FAULT/MODE_ANY
  
          _ASSERTE(TypeFromToken(token) == mdtTypeDef);
          m_TypeDefToMethodTableMap.SetElement(RidFromToken(token), value.AsMethodTable());
      }
  
  #endif // !DACCESS_COMPILE
  
      TypeHandle LookupTypeRef(mdTypeRef token);
  
      mdTypeRef LookupTypeRefByMethodTable(MethodTable *pMT);
  
      mdMemberRef LookupMemberRefByMethodDesc(MethodDesc *pMD);
  
  #ifndef DACCESS_COMPILE
      //
      // Increase the size of the TypeRef-to-MethodTable LookupMap to make sure the specified token
      // can be stored.  Note that nothing is actually added to the LookupMap at this point.
      //
      // Arguments:
      //    token - the TypeRef metadata token we need to accommodate
      //
  
      void EnsureTypeRefCanBeStored(mdTypeRef token)
      {
          WRAPPER_NO_CONTRACT; // THROWS/GC_NOTRIGGER/INJECT_FAULT()/MODE_ANY
  
          _ASSERTE(TypeFromToken(token) == mdtTypeRef);
          m_TypeRefToMethodTableMap.EnsureElementCanBeStored(this, RidFromToken(token));
      }
  
      void StoreTypeRef(mdTypeRef token, TypeHandle value)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtTypeRef);
  
          g_IBCLogger.LogRidMapAccess( MakePair( this, token ) );
  
          // The TypeRef cache is strictly a lookaside cache. If we get an OOM trying to grow the table,
          // we cannot abort the load. (This will cause fatal errors during gc promotion.)
          m_TypeRefToMethodTableMap.TrySetElement(RidFromToken(token), 
              dac_cast<PTR_TypeRef>(value.AsTAddr()));
      }
  #endif // !DACCESS_COMPILE
  
      MethodDesc *LookupMethodDef(mdMethodDef token);
  
  #ifndef DACCESS_COMPILE
      void EnsureMethodDefCanBeStored(mdMethodDef token)
      {
          WRAPPER_NO_CONTRACT; // THROWS/GC_NOTRIGGER/INJECT_FAULT()/MODE_ANY
          m_MethodDefToDescMap.EnsureElementCanBeStored(this, RidFromToken(token));
      }
  
      void EnsuredStoreMethodDef(mdMethodDef token, MethodDesc *value)
      {
          WRAPPER_NO_CONTRACT; // NOTHROW/GC_NOTRIGGER/FORBID_FAULT/MODE_ANY
  
          _ASSERTE(TypeFromToken(token) == mdtMethodDef);
          m_MethodDefToDescMap.SetElement(RidFromToken(token), value);
      }
  #endif // !DACCESS_COMPILE
  
  #ifndef DACCESS_COMPILE
      FieldDesc *LookupFieldDef(mdFieldDef token)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtFieldDef);
          return m_FieldDefToDescMap.GetElement(RidFromToken(token));
      }
  #else // DACCESS_COMPILE
      // FieldDesc isn't defined at this point so PTR_FieldDesc can't work.
      FieldDesc *LookupFieldDef(mdFieldDef token);
  #endif // DACCESS_COMPILE
  
  #ifndef DACCESS_COMPILE
      void EnsureFieldDefCanBeStored(mdFieldDef token)
      {
          WRAPPER_NO_CONTRACT; // THROWS/GC_NOTRIGGER/INJECT_FAULT()/MODE_ANY
          m_FieldDefToDescMap.EnsureElementCanBeStored(this, RidFromToken(token));
      }
  
      void EnsuredStoreFieldDef(mdFieldDef token, FieldDesc *value)
      {
          WRAPPER_NO_CONTRACT; // NOTHROW/GC_NOTRIGGER/FORBID_FAULT/MODE_ANY
  
          _ASSERTE(TypeFromToken(token) == mdtFieldDef);
          m_FieldDefToDescMap.SetElement(RidFromToken(token), value);
      }
  #endif // !DACCESS_COMPILE
  
      FORCEINLINE TADDR LookupMemberRef(mdMemberRef token, BOOL *pfIsMethod)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtMemberRef);
  
          TADDR pResult = dac_cast<TADDR>(m_pMemberRefToDescHashTable->GetValue(token, pfIsMethod));
          g_IBCLogger.LogRidMapAccess( MakePair( this, token ) );
          return pResult;
      }
      MethodDesc *LookupMemberRefAsMethod(mdMemberRef token);
  #ifndef DACCESS_COMPILE
      void StoreMemberRef(mdMemberRef token, FieldDesc *value)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtMemberRef);
          CrstHolder ch(this->GetLookupTableCrst());
          m_pMemberRefToDescHashTable->Insert(token, value);
      }
      void StoreMemberRef(mdMemberRef token, MethodDesc *value)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtMemberRef);
          CrstHolder ch(this->GetLookupTableCrst());
          m_pMemberRefToDescHashTable->Insert(token, value);
      }
  #endif // !DACCESS_COMPILE
  
      PTR_TypeVarTypeDesc LookupGenericParam(mdGenericParam token)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtGenericParam);
          return m_GenericParamToDescMap.GetElement(RidFromToken(token));
      }
  #ifndef DACCESS_COMPILE
      void StoreGenericParamThrowing(mdGenericParam token, TypeVarTypeDesc *value)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtGenericParam);
          m_GenericParamToDescMap.AddElement(this, RidFromToken(token), value);
      }
  #endif // !DACCESS_COMPILE
  
      PTR_Module LookupFile(mdFile token)
      {
          WRAPPER_NO_CONTRACT;
          SUPPORTS_DAC;
  
          _ASSERTE(TypeFromToken(token) == mdtFile);
          return m_FileReferencesMap.GetElement(RidFromToken(token));
      }
  
  
  #ifndef DACCESS_COMPILE
      void EnsureFileCanBeStored(mdFile token)
      {
          WRAPPER_NO_CONTRACT; // THROWS/GC_NOTRIGGER/INJECT_FAULT()/MODE_ANY
  
          _ASSERTE(TypeFromToken(token) == mdtFile);
          m_FileReferencesMap.EnsureElementCanBeStored(this, RidFromToken(token));
      }
  
      void EnsuredStoreFile(mdFile token, Module *value)
      {
          WRAPPER_NO_CONTRACT; // NOTHROW/GC_NOTRIGGER/FORBID_FAULT
  
  
          _ASSERTE(TypeFromToken(token) == mdtFile);
          m_FileReferencesMap.SetElement(RidFromToken(token), value);
      }
  
  
      void StoreFileThrowing(mdFile token, Module *value)
      {
          WRAPPER_NO_CONTRACT;
  
  
          _ASSERTE(TypeFromToken(token) == mdtFile);
          m_FileReferencesMap.AddElement(this, RidFromToken(token), value);
      }
  
      BOOL StoreFileNoThrow(mdFile token, Module *value)
      {
          WRAPPER_NO_CONTRACT;
  
          _ASSERTE(TypeFromToken(token) == mdtFile);
          return m_FileReferencesMap.TrySetElement(RidFromToken(token), value);
      }
  
      mdAssemblyRef FindManifestModule(Module *value)
      {
          WRAPPER_NO_CONTRACT;
  
          return m_ManifestModuleReferencesMap.Find(value) | mdtAssembly;
      }
  #endif // !DACCESS_COMPILE
  
      DWORD GetFileMax() { LIMITED_METHOD_DAC_CONTRACT;  return m_FileReferencesMap.GetSize(); }
  
      Assembly *LookupAssemblyRef(mdAssemblyRef token);
  
  #ifndef DACCESS_COMPILE
      //
      // Increase the size of the AssemblyRef-to-Module LookupMap to make sure the specified token
      // can be stored.  Note that nothing is actually added to the LookupMap at this point.
      //
      // Arguments:
      //    token - the AssemblyRef metadata token we need to accommodate
      //
  
      void EnsureAssemblyRefCanBeStored(mdAssemblyRef token)
      {
          WRAPPER_NO_CONTRACT; // THROWS/GC_NOTRIGGER/INJECT_FAULT()/MODE_ANY
  
          _ASSERTE(TypeFromToken(token) == mdtAssemblyRef);
          m_ManifestModuleReferencesMap.EnsureElementCanBeStored(this, RidFromToken(token));
      }
  
      void ForceStoreAssemblyRef(mdAssemblyRef token, Assembly *value);
      void StoreAssemblyRef(mdAssemblyRef token, Assembly *value);
  
      mdAssemblyRef FindAssemblyRef(Assembly *targetAssembly);
  
      void          CreateAssemblyRefByNameTable(AllocMemTracker *pamTracker);
      bool          HasReferenceByName(LPCUTF8 pModuleName);
  
  #endif // !DACCESS_COMPILE
  
  #ifdef FEATURE_PREJIT
      void FinalizeLookupMapsPreSave(DataImage *image);
  #endif
  
      DWORD GetAssemblyRefMax() {LIMITED_METHOD_CONTRACT;  return m_ManifestModuleReferencesMap.GetSize(); }
  
      MethodDesc *FindMethodThrowing(mdToken pMethod);
      MethodDesc *FindMethod(mdToken pMethod);
  
      void PopulatePropertyInfoMap();
      HRESULT GetPropertyInfoForMethodDef(mdMethodDef md, mdProperty *ppd, LPCSTR *pName, ULONG *pSemantic);
  
      #define NUM_PROPERTY_SET_HASHES 4
  #ifdef FEATURE_PREJIT
      void PrecomputeMatchingProperties(DataImage *image);
  #endif
      BOOL MightContainMatchingProperty(mdProperty tkProperty, ULONG nameHash);
  
  private:
      ArrayDPTR(BYTE)    m_propertyNameSet;
      DWORD              m_nPropertyNameSet;
  
  public:
  
      // Debugger stuff
      BOOL NotifyDebuggerLoad(AppDomain *pDomain, DomainFile * pDomainFile, int level, BOOL attaching);
      void NotifyDebuggerUnload(AppDomain *pDomain);
  
      void SetDebuggerInfoBits(DebuggerAssemblyControlFlags newBits);
  
      DebuggerAssemblyControlFlags GetDebuggerInfoBits(void)
      {
          LIMITED_METHOD_CONTRACT;
          SUPPORTS_DAC;
  
          return (DebuggerAssemblyControlFlags)((m_dwTransientFlags &
                                                 DEBUGGER_INFO_MASK_PRIV) >>
                                                DEBUGGER_INFO_SHIFT_PRIV);
      }
  
  #ifdef PROFILING_SUPPORTED
      BOOL IsProfilerNotified() {LIMITED_METHOD_CONTRACT;  return (m_dwTransientFlags & IS_PROFILER_NOTIFIED) != 0; }
      void NotifyProfilerLoadFinished(HRESULT hr);
  #endif // PROFILING_SUPPORTED
  
      PTR_PersistentInlineTrackingMap GetNgenInlineTrackingMap();
  
  public:
      void NotifyEtwLoadFinished(HRESULT hr);
  
      // Get any cached ITypeLib* for the module.
      ITypeLib *GetTypeLib();
      // Cache the ITypeLib*, if one is not already cached.
      void SetTypeLib(ITypeLib *pITLB);
      ITypeLib *GetTypeLibTCE();
      void SetTypeLibTCE(ITypeLib *pITLB);
  
      // Enregisters a VASig.
      VASigCookie *GetVASigCookie(Signature vaSignature);
  
      // DLL entry point
      MethodDesc *GetDllEntryPoint()
      {
          LIMITED_METHOD_CONTRACT;
          return m_pDllMain;
      }
      void SetDllEntryPoint(MethodDesc *pMD)
      {
          LIMITED_METHOD_CONTRACT;
          m_pDllMain = pMD;
      }
  
      BOOL CanExecuteCode();
  
  #ifdef FEATURE_MIXEDMODE
      LPVOID GetUMThunk(LPVOID pManagedIp, PCCOR_SIGNATURE pSig, ULONG cSig);
      LPVOID GetMUThunk(LPVOID pUnmanagedIp, PCCOR_SIGNATURE pSig, ULONG cSig);
  #endif // FEATURE_MIXEDMODE
  
      // This data is only valid for NGEN'd modules, and for modules we're creating at NGEN time.
      ModuleCtorInfo* GetZapModuleCtorInfo()
      {
          LIMITED_METHOD_DAC_CONTRACT;
          
          return &m_ModuleCtorInfo;
      }
  
   private:
  
  #ifdef FEATURE_MIXEDMODE 
      class MUThunkHash *m_pMUThunkHash;
  #endif // FEATURE_MIXEDMODE
  
   public:
  #ifndef DACCESS_COMPILE
      BOOL Equals(Module *pModule) { WRAPPER_NO_CONTRACT; return m_file->Equals(pModule->m_file); }
      BOOL Equals(PEFile *pFile) { WRAPPER_NO_CONTRACT; return m_file->Equals(pFile); }
  #endif // !DACCESS_COMPILE
  
      LPCUTF8 GetSimpleName()
      { 
          WRAPPER_NO_CONTRACT;
          _ASSERTE(m_pSimpleName != NULL);
          return m_pSimpleName;
      }
  
      HRESULT GetScopeName(LPCUTF8 * pszName) { WRAPPER_NO_CONTRACT; return m_file->GetScopeName(pszName); }
      const SString &GetPath() { WRAPPER_NO_CONTRACT; return m_file->GetPath(); }
  
  #ifdef LOGGING
      LPCWSTR GetDebugName() { WRAPPER_NO_CONTRACT; return m_file->GetDebugName(); }
  #endif
  
      BOOL IsILOnly() { WRAPPER_NO_CONTRACT; return m_file->IsILOnly(); }
  
  #ifdef FEATURE_PREJIT
      BOOL HasNativeImage() 
      { 
          WRAPPER_NO_CONTRACT;
          SUPPORTS_DAC;
          return m_file->HasNativeImage(); 
      }
      
      PEImageLayout *GetNativeImage()
      {
          CONTRACT(PEImageLayout *)
          {
              PRECONDITION(m_file->HasNativeImage());
              POSTCONDITION(CheckPointer(RETVAL));
              NOTHROW;
              GC_NOTRIGGER;
              SUPPORTS_DAC;
              CANNOT_TAKE_LOCK;
              SO_TOLERANT;
          }
          CONTRACT_END;
  
          RETURN m_file->GetLoadedNative();
      }
  #else
      BOOL HasNativeImage()
      {
          LIMITED_METHOD_CONTRACT;
          return FALSE;
      }
  
      PEImageLayout * GetNativeImage()
      {
          // Should never get here
          PRECONDITION(HasNativeImage());
          return NULL;
      }
  #endif // FEATURE_PREJIT
  
      PEImageLayout * GetNativeOrReadyToRunImage();
      PTR_CORCOMPILE_IMPORT_SECTION GetImportSections(COUNT_T *pCount);
      PTR_CORCOMPILE_IMPORT_SECTION GetImportSectionFromIndex(COUNT_T index);
      PTR_CORCOMPILE_IMPORT_SECTION GetImportSectionForRVA(RVA rva);
  
      // These are overridden by reflection modules
      virtual TADDR GetIL(RVA il);
  
      virtual PTR_VOID GetRvaField(RVA field, BOOL fZapped);
      CHECK CheckRvaField(RVA field);
      CHECK CheckRvaField(RVA field, COUNT_T size);
  
      const void *GetInternalPInvokeTarget(RVA target)
      { WRAPPER_NO_CONTRACT; return m_file->GetInternalPInvokeTarget(target); }
  
      BOOL HasTls();
      BOOL IsRvaFieldTls(DWORD field);
      UINT32 GetFieldTlsOffset(DWORD field);
      UINT32 GetTlsIndex();
  
      PCCOR_SIGNATURE GetSignature(RVA signature);
      RVA GetSignatureRva(PCCOR_SIGNATURE signature);
      CHECK CheckSignatureRva(RVA signature);
      CHECK CheckSignature(PCCOR_SIGNATURE signature);
      BOOL IsSigInIL(PCCOR_SIGNATURE signature);
  
      mdToken GetEntryPointToken();
  
      BYTE *GetProfilerBase();
  
  
      // Active transition path management
      // 
      // This list keeps track of module which we have active transition
      // paths to.  An active transition path is where we move from
      // active execution in one module to another module without
      // involving triggering the file loader to ensure that the
      // destination module is active.  We must explicitly list these
      // relationships so the the loader can ensure that the activation
      // constraints are a priori satisfied.
      //
      // Conditional vs. Unconditional describes how we deal with
      // activation failure of a dependency.  In the unconditional case,
      // we propagate the activation failure to the depending module.
      // In the conditional case, we activate a "trigger" in the active
      // transition path which will cause the path to fail in particular
      // app domains where the destination module failed to activate.
      // (This trigger in the path typically has a perf cost even in the
      // nonfailing case.)
      //
      // In either case we must try to perform the activation eagerly -
      // even in the conditional case we have to know whether to turn on
      // the trigger or not before we let the active transition path
      // execute.
  
      void AddActiveDependency(Module *pModule, BOOL unconditional);
  
      // Active dependency iterator
      class DependencyIterator
      {
        protected:
          ArrayList::Iterator m_i;
          COUNT_T             m_index;
          SynchronizedBitMask* m_unconditionalFlags;
  
          friend class Module;
  
          DependencyIterator(ArrayList *list, SynchronizedBitMask *unconditionalFlags)
            : m_index((COUNT_T)-1),
              m_unconditionalFlags(unconditionalFlags)
          {
              WRAPPER_NO_CONTRACT;
              m_i = list->Iterate();
          }
  
        public:
          Module *GetDependency()
          {
              return ((FixupPointer<PTR_Module> *)m_i.GetElementPtr())->GetValue();
          }
  
          BOOL Next()
          {
              LIMITED_METHOD_CONTRACT;
              while (m_i.Next())
              {
                  ++m_index;
  
  #ifdef FEATURE_PREJIT
                  // When iterating all dependencies, we do not restore any tokens
                  // as we want to be lazy.
                  PTR_Module pModule = ((FixupPointer<PTR_Module> *)m_i.GetElementPtr())->GetValue();
                  if (!CORCOMPILE_IS_POINTER_TAGGED(dac_cast<TADDR>(pModule)))
                      return TRUE;
  
  #else
                  return TRUE;
  #endif
  
              }
              return FALSE;
          }
          BOOL IsUnconditional()
          {
              if (m_unconditionalFlags == NULL)
                  return TRUE;
              else
                  return m_unconditionalFlags->TestBit(m_index);
          }
      };
  
      DependencyIterator IterateActiveDependencies()
      {
          WRAPPER_NO_CONTRACT;
          return DependencyIterator(&m_activeDependencies, &m_unconditionalDependencies);
      }
  
      BOOL HasActiveDependency(Module *pModule);
      BOOL HasUnconditionalActiveDependency(Module *pModule);
  
      // Turn triggers from this module into runtime checks
      void EnableModuleFailureTriggers(Module *pModule, AppDomain *pDomain);
  
  #ifdef FEATURE_PREJIT
      BOOL IsZappedCode(PCODE code);
      BOOL IsZappedPrecode(PCODE code);
  
      CORCOMPILE_DEBUG_ENTRY GetMethodDebugInfoOffset(MethodDesc *pMD);
      PTR_BYTE GetNativeDebugInfo(MethodDesc * pMD);
  
      // The methods below must be called when loading back an ngen'ed image for any fields that
      // might be an encoded token (rather than a hard pointer) and/or need a restore operation
      //
      static void RestoreMethodTablePointerRaw(PTR_MethodTable * ppMT,
                                               Module *pContainingModule = NULL,
                                               ClassLoadLevel level = CLASS_LOADED);
      static void RestoreTypeHandlePointerRaw(TypeHandle *pHandle,
                                              Module *pContainingModule = NULL,
                                              ClassLoadLevel level = CLASS_LOADED);
      static void RestoreMethodDescPointerRaw(PTR_MethodDesc * ppMD,
                                              Module *pContainingModule = NULL,
                                              ClassLoadLevel level = CLASS_LOADED);
  
      static void RestoreMethodTablePointer(FixupPointer<PTR_MethodTable> * ppMT,
                                            Module *pContainingModule = NULL,
                                            ClassLoadLevel level = CLASS_LOADED);
      static void RestoreTypeHandlePointer(FixupPointer<TypeHandle> *pHandle,
                                           Module *pContainingModule = NULL,
                                           ClassLoadLevel level = CLASS_LOADED);
      static void RestoreMethodDescPointer(FixupPointer<PTR_MethodDesc> * ppMD,
                                            Module *pContainingModule = NULL,
                                            ClassLoadLevel level = CLASS_LOADED);
  
      static void RestoreMethodTablePointer(RelativeFixupPointer<PTR_MethodTable> * ppMT,
                                            Module *pContainingModule = NULL,
                                           ClassLoadLevel level = CLASS_LOADED);
      static void RestoreTypeHandlePointer(RelativeFixupPointer<TypeHandle> *pHandle,
                                           Module *pContainingModule = NULL,
                                        ClassLoadLevel level = CLASS_LOADED);
      static void RestoreMethodDescPointer(RelativeFixupPointer<PTR_MethodDesc> * ppMD,
                                           Module *pContainingModule = NULL,
                                           ClassLoadLevel level = CLASS_LOADED);
  
      static void RestoreFieldDescPointer(FixupPointer<PTR_FieldDesc> * ppFD);
  
      static void RestoreModulePointer(RelativeFixupPointer<PTR_Module> * ppModule, Module *pContainingModule);
  
      static PTR_Module RestoreModulePointerIfLoaded(DPTR(RelativeFixupPointer<PTR_Module>) ppModule, Module *pContainingModule);
  
      PCCOR_SIGNATURE GetEncodedSig(RVA fixupRva, Module **ppDefiningModule);
      PCCOR_SIGNATURE GetEncodedSigIfLoaded(RVA fixupRva, Module **ppDefiningModule);
  
      BYTE *GetNativeFixupBlobData(RVA fixup);
  
      IMDInternalImport *GetNativeAssemblyImport(BOOL loadAllowed = TRUE);
  
      BOOL FixupNativeEntry(CORCOMPILE_IMPORT_SECTION * pSection, SIZE_T fixupIndex, SIZE_T *fixup);
  
      //this split exists to support new CLR Dump functionality in DAC.  The
      //template removes any indirections.
      BOOL FixupDelayList(TADDR pFixupList);
  
      template<typename Ptr, typename FixupNativeEntryCallback>
      BOOL FixupDelayListAux(TADDR pFixupList,
                             Ptr pThis, FixupNativeEntryCallback pfnCB,
                             PTR_CORCOMPILE_IMPORT_SECTION pImportSections, COUNT_T nImportSections,
                             PEDecoder * pNativeImage);
      void RunEagerFixups();
  
      IMDInternalImport *GetNativeFixupImport();
      Module *GetModuleFromIndex(DWORD ix);
      Module *GetModuleFromIndexIfLoaded(DWORD ix);
  
      // This is to rebuild stub dispatch maps to module-local values.
      void UpdateStubDispatchTypeTable(DataImage *image);
  
      void SetProfileData(CorProfileData * profileData);
      CorProfileData *GetProfileData();
  
  
      mdTypeDef     LookupIbcTypeToken(  Module *   pExternalModule, mdToken ibcToken, SString* optionalFullNameOut = NULL);
      mdMethodDef   LookupIbcMethodToken(TypeHandle enclosingType,   mdToken ibcToken, SString* optionalFullNameOut = NULL);
  
      SString *     IBCErrorNameString();
  
      void          IBCTypeLoadFailed(  CORBBTPROF_BLOB_PARAM_SIG_ENTRY *pBlobSigEntry, 
                                        SString& exceptionMessage, SString* typeNameError);
      void          IBCMethodLoadFailed(CORBBTPROF_BLOB_PARAM_SIG_ENTRY *pBlobSigEntry, 
                                        SString& exceptionMessage, SString* typeNameError);
  
      TypeHandle    LoadIBCTypeHelper(  CORBBTPROF_BLOB_PARAM_SIG_ENTRY *pBlobSigEntry);
      MethodDesc *  LoadIBCMethodHelper(CORBBTPROF_BLOB_PARAM_SIG_ENTRY *pBlobSigEntry);
   
  
      void ExpandAll(DataImage *image);
      // profileData may be different than the profileData passed in to
      // ExpandAll() depending on more information that may now be available
      // (after all the methods have been compiled)
  
      void Save(DataImage *image);
      void Arrange(DataImage *image);
      void PlaceType(DataImage *image, TypeHandle th, DWORD profilingFlags);
      void PlaceMethod(DataImage *image, MethodDesc *pMD, DWORD profilingFlags);
      void Fixup(DataImage *image);
  
      bool AreAllClassesFullyLoaded();
  
      // Precompute type-specific auxiliary information saved into NGen image
      void PrepareTypesForSave(DataImage *image);
  
      static void SaveMethodTable(DataImage *image,
                                  MethodTable *pMT,
                                  DWORD profilingFlags);
  
      static void SaveTypeHandle(DataImage *image,
                                 TypeHandle t,
                                 DWORD profilingFlags);
  
  private:
      static BOOL CanEagerBindTo(Module *targetModule, Module *pPreferredZapModule, void *address);
  public:
  
      static PTR_Module ComputePreferredZapModule(Module * pDefinitionModule,        // the module that declares the generic type or method
                                                  Instantiation classInst,           // the type arguments to the type (if any)
                                                  Instantiation methodInst = Instantiation()); // the type arguments to the method (if any)
  
      static PTR_Module ComputePreferredZapModuleHelper(Module * pDefinitionModule,
                                                        Instantiation classInst,
                                                        Instantiation methodInst);
  
      static PTR_Module ComputePreferredZapModule(TypeKey * pKey);
  
      // Return true if types or methods of this instantiation are *always* precompiled and saved
      // in the preferred zap module
      // At present, only true for <__Canon,...,__Canon> instantiation
      static BOOL IsAlwaysSavedInPreferredZapModule(Instantiation classInst,
                                                    Instantiation methodInst = Instantiation());
  
      static PTR_Module GetPreferredZapModuleForTypeHandle(TypeHandle t);
      static PTR_Module GetPreferredZapModuleForMethodTable(MethodTable * pMT);
      static PTR_Module GetPreferredZapModuleForMethodDesc(const MethodDesc * pMD);
      static PTR_Module GetPreferredZapModuleForFieldDesc(FieldDesc * pFD);
      static PTR_Module GetPreferredZapModuleForTypeDesc(PTR_TypeDesc pTD);
  
      void PrepopulateDictionaries(DataImage *image, BOOL nonExpansive);
  
  
      void LoadTokenTables();
      void LoadHelperTable();
  
      PTR_NGenLayoutInfo GetNGenLayoutInfo()
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return m_pNGenLayoutInfo;
      }
  
      PCODE GetPrestubJumpStub()
      { 
          LIMITED_METHOD_DAC_CONTRACT; 
  
          if (!m_pNGenLayoutInfo)
              return NULL;
  
          return m_pNGenLayoutInfo->m_pPrestubJumpStub;
      }
  
  #ifdef HAS_FIXUP_PRECODE
      PCODE GetPrecodeFixupJumpStub()
      { 
          LIMITED_METHOD_DAC_CONTRACT; 
  
          if (!m_pNGenLayoutInfo)
              return NULL;
  
          return m_pNGenLayoutInfo->m_pPrecodeFixupJumpStub;
      }
  #endif
  
      BOOL IsVirtualImportThunk(PCODE code)
      {
          LIMITED_METHOD_DAC_CONTRACT;
  
          if (!m_pNGenLayoutInfo)
              return FALSE;
  
          return m_pNGenLayoutInfo->m_VirtualMethodThunks.IsInRange(code);
      }
  
      BOOL IsReadyToRun()
      {
          LIMITED_METHOD_DAC_CONTRACT;
  
  #ifdef FEATURE_READYTORUN
          return m_pReadyToRunInfo != NULL;
  #else
          return FALSE;
  #endif
      }
  
  #ifdef FEATURE_READYTORUN
      PTR_ReadyToRunInfo GetReadyToRunInfo()
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return m_pReadyToRunInfo;
      }
  #endif
  
      ICorJitInfo::ProfileBuffer * AllocateProfileBuffer(mdToken _token, DWORD _size, DWORD _ILSize);
      HANDLE OpenMethodProfileDataLogFile(GUID mvid);
      static void ProfileDataAllocateTokenLists(ProfileEmitter * pEmitter, TokenProfileData* pTokenProfileData);
      HRESULT WriteMethodProfileDataLogFile(bool cleanup);
      static void WriteAllModuleProfileData(bool cleanup);
  
      void CreateProfilingData();
      void DeleteProfilingData();
  
      PTR_ProfilingBlobTable GetProfilingBlobTable();
  
      void LogTokenAccess(mdToken token, SectionFormat format, ULONG flagNum);
      void LogTokenAccess(mdToken token, ULONG flagNum);
  
      BOOL AreTypeSpecsTriaged()
      {
          return m_dwTransientFlags & TYPESPECS_TRIAGED;
      }
  
      void SetTypeSpecsTriaged()
      {
          FastInterlockOr(&m_dwTransientFlags, TYPESPECS_TRIAGED);
      }
  
      BOOL IsModuleSaved()
      {
          return m_dwTransientFlags & MODULE_SAVED;
      }
  
      void SetIsModuleSaved()
      {
          FastInterlockOr(&m_dwTransientFlags, MODULE_SAVED);
      }
  
  #endif  // FEATURE_PREJIT
  
  #ifdef _DEBUG
      //Similar to the ExpandAll we use for NGen, this forces jitting of all methods in a module.  This is
      //used for debug purposes though.
      void ExpandAll();
  #endif
  
      BOOL IsIJWFixedUp() { return m_dwTransientFlags & IS_IJW_FIXED_UP; }
      void SetIsIJWFixedUp();
  
      BOOL IsBeingUnloaded() { return m_dwTransientFlags & IS_BEING_UNLOADED; }
      void   SetBeingUnloaded();
      void   StartUnload();
      
  
  public:
      idTypeSpec   LogInstantiatedType(TypeHandle typeHnd, ULONG flagNum);
      idMethodSpec LogInstantiatedMethod(const MethodDesc * md, ULONG flagNum);
  
      static DWORD EncodeModuleHelper(void* pModuleContext, Module *pReferencedModule);
      static void  TokenDefinitionHelper(void* pModuleContext, Module *pReferencedModule, DWORD index, mdToken* token);
  
  public:
      MethodTable* MapZapType(UINT32 typeID);
  
      void SetDynamicIL(mdToken token, TADDR blobAddress, BOOL fTemporaryOverride);
      TADDR GetDynamicIL(mdToken token, BOOL fAllowTemporary);
  
      // store and retrieve the instrumented IL offset mapping for a particular method
  #if !defined(DACCESS_COMPILE)
      void SetInstrumentedILOffsetMapping(mdMethodDef token, InstrumentedILOffsetMapping mapping);
  #endif // !DACCESS_COMPILE
      InstrumentedILOffsetMapping GetInstrumentedILOffsetMapping(mdMethodDef token);
  
  public:
      // This helper returns to offsets for the slots/bytes/handles. They return the offset in bytes from the beggining
      // of the 1st GC pointer in the statics block for the module.
      void        GetOffsetsForRegularStaticData(
                      mdTypeDef cl,
                      BOOL bDynamic,
                      DWORD dwGCStaticHandles,
                      DWORD dwNonGCStaticBytes,
                      DWORD * pOutStaticHandleOffset,
                      DWORD * pOutNonGCStaticOffset);
  
      void        GetOffsetsForThreadStaticData(
                      mdTypeDef cl,
                      BOOL bDynamic,
                      DWORD dwGCStaticHandles,
                      DWORD dwNonGCStaticBytes,
                      DWORD * pOutStaticHandleOffset,
                      DWORD * pOutNonGCStaticOffset);
  
  
      BOOL        IsStaticStoragePrepared(mdTypeDef tkType);
  
      DWORD       GetNumGCThreadStaticHandles()
      {
          return m_dwMaxGCThreadStaticHandles;;
      }
  
      CrstBase*           GetFixupCrst()
      {
          return &m_FixupCrst;
      }
  
      void                AllocateRegularStaticHandles(AppDomain* pDomainMT);
  
      void                FreeModuleIndex();
  
      DWORD               GetDomainLocalModuleSize()
      {
          return m_dwRegularStaticsBlockSize;
      }
  
      DWORD               GetThreadLocalModuleSize()
      {
          return m_dwThreadStaticsBlockSize;
      }
  
      DWORD               AllocateDynamicEntry(MethodTable *pMT);
  
      // We need this for the jitted shared case,
      inline MethodTable* GetDynamicClassMT(DWORD dynamicClassID);
  
      static BOOL IsEncodedModuleIndex(SIZE_T ModuleID)
      {
          LIMITED_METHOD_DAC_CONTRACT;
              
          return (ModuleID&1)==1;
      }
  
      static SIZE_T IndexToID(ModuleIndex index)
      {
          LIMITED_METHOD_CONTRACT
              
          return (index.m_dwIndex << 1) | 1;
      }
  
      static ModuleIndex IDToIndex(SIZE_T ModuleID)
      {
          LIMITED_METHOD_CONTRACT
          SUPPORTS_DAC;
              
          _ASSERTE(IsEncodedModuleIndex(ModuleID));
          ModuleIndex index(ModuleID >> 1);
  
          return index;
      }
  
      static ModuleIndex AllocateModuleIndex();
      static void FreeModuleIndex(ModuleIndex index);
  
      ModuleIndex          GetModuleIndex()
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return m_ModuleIndex;
      }
  
      SIZE_T               GetModuleID()
      {
          LIMITED_METHOD_DAC_CONTRACT;
          return dac_cast<TADDR>(m_ModuleID);
      }
  
      SIZE_T *             GetAddrModuleID()
      {
          LIMITED_METHOD_CONTRACT;
          return (SIZE_T*) &m_ModuleID;
      }
  
      static SIZE_T       GetOffsetOfModuleID()
      {
          LIMITED_METHOD_CONTRACT;
          return offsetof(Module, m_ModuleID);
      }
  
      PTR_DomainLocalModule   GetDomainLocalModule(AppDomain *pDomain);
  
  #ifndef DACCESS_COMPILE
      PTR_DomainLocalModule   GetDomainLocalModule()  { WRAPPER_NO_CONTRACT; return GetDomainLocalModule(NULL); };
  #endif
  
  #ifdef FEATURE_PREJIT
      NgenStats *GetNgenStats()
      {
          LIMITED_METHOD_CONTRACT;
          return m_pNgenStats;
      }
  #endif // FEATURE_PREJIT
  
      void            EnumRegularStaticGCRefs        (AppDomain* pAppDomain, promote_func* fn, ScanContext* sc);
  
  protected:    
  
      void            BuildStaticsOffsets     (AllocMemTracker *pamTracker);
      void            AllocateStatics         (AllocMemTracker *pamTracker);
  
      // ModuleID is quite ugly. We should try to switch to using ModuleIndex instead
      // where appropriate, and we should clean up code that uses ModuleID
      PTR_DomainLocalModule   m_ModuleID;       // MultiDomain case: tagged (low bit 1) ModuleIndex
                                                // SingleDomain case: pointer to domain local module
  
      ModuleIndex             m_ModuleIndex;
  
      // reusing the statics area of a method table to store
      // these for the non domain neutral case, but they're now unified
      // it so that we don't have different code paths for this.
      PTR_DWORD               m_pRegularStaticOffsets;        // Offset of statics in each class
      PTR_DWORD               m_pThreadStaticOffsets;         // Offset of ThreadStatics in each class
  
      // All types with RID <= this value have static storage allocated within the module by AllocateStatics
      // If AllocateStatics hasn't run yet, the value is 0
      RID                     m_maxTypeRidStaticsAllocated;
  
      // @NICE: see if we can remove these fields
      DWORD                   m_dwMaxGCRegularStaticHandles;  // Max number of handles we can have.
      DWORD                   m_dwMaxGCThreadStaticHandles;
  
      // Size of the precomputed statics block. This includes class init bytes, gc handles and non gc statics
      DWORD                   m_dwRegularStaticsBlockSize;
      DWORD                   m_dwThreadStaticsBlockSize;
  
      // For 'dynamic' statics (Reflection and generics)
      SIZE_T                  m_cDynamicEntries;              // Number of used entries in DynamicStaticsInfo table
      SIZE_T                  m_maxDynamicEntries;            // Size of table itself, including unused entries
  
      // Info we need for dynamic statics that we can store per-module (ie, no need for it to be duplicated
      // per appdomain)
      struct DynamicStaticsInfo
      {
          MethodTable*        pEnclosingMT;                   // Enclosing type; necessarily in this loader module
      };
      DynamicStaticsInfo*     m_pDynamicStaticsInfo;          // Table with entry for each dynamic ID
  
  
  public:
      //-----------------------------------------------------------------------------------------
      // If true,  strings only need to be interned at a per module basis, instead of at a
      // per appdomain basis, which is the default. Use the module accessor so you don't need
      // to touch the metadata in the ngen case
      //-----------------------------------------------------------------------------------------
      BOOL                    IsNoStringInterning();
  
      //-----------------------------------------------------------------------------------------
      // Returns a BOOL to indicate if we have computed whether compiler has instructed us to
      // wrap the non-CLS compliant exceptions or not.
      //-----------------------------------------------------------------------------------------
      BOOL                    IsRuntimeWrapExceptionsStatusComputed();
  
      //-----------------------------------------------------------------------------------------
      // If true,  any non-CLSCompliant exceptions (i.e. ones which derive from something other
      // than System.Exception) are wrapped in a RuntimeWrappedException instance.  In other
      // words, they become compliant
      //-----------------------------------------------------------------------------------------
      BOOL                    IsRuntimeWrapExceptions();
  
      BOOL                    HasDefaultDllImportSearchPathsAttribute();
  
      BOOL IsDefaultDllImportSearchPathsAttributeCached()
      {
          LIMITED_METHOD_CONTRACT;
          return (m_dwPersistedFlags & DEFAULT_DLL_IMPORT_SEARCH_PATHS_IS_CACHED) != 0;
      }
  
      ULONG DefaultDllImportSearchPathsAttributeCachedValue()
      {
          LIMITED_METHOD_CONTRACT;
          return m_DefaultDllImportSearchPathsAttributeValue & 0xFFFFFFFD;
      }
  
      BOOL DllImportSearchAssemblyDirectory()
      {
          LIMITED_METHOD_CONTRACT;
          return (m_DefaultDllImportSearchPathsAttributeValue & 0x2) != 0;
      }
  
      //-----------------------------------------------------------------------------------------
      // True iff metadata version string is 1.* or 2.*.
      // @TODO (post-Dev10): All places that need this information should call this function
      // instead of parsing the version themselves.
      //-----------------------------------------------------------------------------------------
      BOOL                    IsPreV4Assembly();
  
      //-----------------------------------------------------------------------------------------
      // Get reliability contract info, see ConstrainedExecutionRegion.cpp for details.
      //-----------------------------------------------------------------------------------------
      DWORD                   GetReliabilityContract();
  
      //-----------------------------------------------------------------------------------------
      // Parse/Return NeutralResourcesLanguageAttribute if it exists (updates Module member variables at ngen time)
      //-----------------------------------------------------------------------------------------
      BOOL                    GetNeutralResourcesLanguage(LPCUTF8 * cultureName, ULONG * cultureNameLength, INT16 * fallbackLocation, BOOL cacheAttribute);
  
  protected:
  
      Volatile<DWORD>         m_dwReliabilityContract;
  
      // initialize Crst controlling the Dynamic IL hashtables
      void                    InitializeDynamicILCrst();
  
  #ifndef DACCESS_COMPILE
  public:
  
      // Support for getting and creating information about Constrained Execution Regions rooted in this module.
  
      // Access to CerPrepInfo, the structure used to track CERs prepared at runtime (as opposed to ngen time). GetCerPrepInfo will
      // return the structure associated with the given method desc if it exists or NULL otherwise. CreateCerPrepInfo will get the
      // structure if it exists or allocate and return a new struct otherwise. Creation of CerPrepInfo structures is automatically
      // synchronized by the CerCrst (lazily allocated as needed).
      CerPrepInfo *GetCerPrepInfo(MethodDesc *pMD);
      CerPrepInfo *CreateCerPrepInfo(MethodDesc *pMD);
  
  #ifdef FEATURE_PREJIT
      // Access to CerNgenRootTable which holds holds information for all the CERs rooted at a method in this module (that were
      // discovered during an ngen).
  
      // Add a list of MethodContextElements representing a CER to the root table keyed by the MethodDesc* of the root method. Creates
      // or expands the root table as necessary.
      void AddCerListToRootTable(MethodDesc *pRootMD, MethodContextElement *pList);
  
      // Returns true if the given method is a CER root detected at ngen time.
      bool IsNgenCerRootMethod(MethodDesc *pMD);
  
      // Restores the CER rooted at this method (no-op if this method isn't a CER root).
      void RestoreCer(MethodDesc *pMD);
  #endif // FEATURE_PREJIT
  
      Crst *GetCerCrst()
      {
          LIMITED_METHOD_CONTRACT;
          return m_pCerCrst;
      }
  #endif // !DACCESS_COMPILE
  
  #ifdef FEATURE_CORECLR
      void VerifyAllMethods();
  #endif //FEATURE_CORECLR
  
      CrstBase *GetLookupTableCrst()
      {
          LIMITED_METHOD_CONTRACT;
          return &m_LookupTableCrst;
      }
  
  private:
      EEPtrHashTable       *m_pCerPrepInfo;       // Root methods prepared for Constrained Execution Regions
      Crst                 *m_pCerCrst;           // Mutex protecting update access to both of the above hashes
  #ifdef FEATURE_PREJIT
      CerNgenRootTable     *m_pCerNgenRootTable;  // Root methods of CERs found during ngen and requiring runtime restoration
  #endif
  
      // This struct stores the data used by the managed debugging infrastructure.  If it turns out that 
      // the debugger is increasing the size of the Module class by too much, we can consider allocating
      // this struct lazily on demand.
      struct DebuggerSpecificData
      {
          // Mutex protecting update access to the DynamicILBlobTable and TemporaryILBlobTable
          PTR_Crst                 m_pDynamicILCrst;
      
                                                  // maps tokens for EnC/dynamics/reflection emit to their corresponding IL blobs
                                                  // this map *always* overrides the Metadata RVA
          PTR_DynamicILBlobTable   m_pDynamicILBlobTable;
  
                                                  // maps tokens for to their corresponding overriden IL blobs
                                                  // this map conditionally overrides the Metadata RVA and the DynamicILBlobTable
          PTR_DynamicILBlobTable   m_pTemporaryILBlobTable;
  
          // hash table storing any profiler-provided instrumented IL offset mapping
          PTR_ILOffsetMappingTable m_pILOffsetMappingTable;
  
          // Strict count of # of methods in this module that are JMC-enabled.
          LONG    m_cTotalJMCFuncs;
  
          // The default JMC status for methods in this module.
          // Individual methods can be overridden.
          bool    m_fDefaultJMCStatus;
      };
  
      DebuggerSpecificData  m_debuggerSpecificData;
  
      // This is a compressed read only copy of m_inlineTrackingMap, which is being saved to NGEN image.
      PTR_PersistentInlineTrackingMap m_persistentInlineTrackingMap;
  
  
      LPCSTR               *m_AssemblyRefByNameTable;  // array that maps mdAssemblyRef tokens into their simple name
      DWORD                 m_AssemblyRefByNameCount;  // array size
  
  #if defined(FEATURE_PREJIT)
      // a.dll calls a method in b.dll and that method call a method in c.dll. When ngening
      // a.dll it is possible then method in b.dll can be inlined. When that happens a.ni.dll stores
      // an added native metadata which has information about assemblyRef to c.dll
      // Now due to facades, this scenario is very common. This led to lots of calls to 
      // binder to get the module corresponding to assemblyRef in native metadata. 
      // Adding a lookup map to cache assembly ptr so that AssemblySpec::LoadAssembly()
      // is not called for each fixup
  
      PTR_Assembly           *m_NativeMetadataAssemblyRefMap; 
  #endif // defined(FEATURE_PREJIT)
  
  public:
      ModuleSecurityDescriptor* m_pModuleSecurityDescriptor;
  
  #if !defined(DACCESS_COMPILE) && defined(FEATURE_PREJIT)
      PTR_Assembly GetNativeMetadataAssemblyRefFromCache(DWORD rid)
      {
          PTR_Assembly * NativeMetadataAssemblyRefMap = VolatileLoadWithoutBarrier(&m_NativeMetadataAssemblyRefMap);
  
          if (NativeMetadataAssemblyRefMap == NULL)
              return NULL;
  
          _ASSERTE(rid <= GetNativeAssemblyImport()->GetCountWithTokenKind(mdtAssemblyRef));
          return NativeMetadataAssemblyRefMap[rid - 1];
      }
  
      void SetNativeMetadataAssemblyRefInCache(DWORD rid, PTR_Assembly pAssembly);
  #endif // !defined(DACCESS_COMPILE) && defined(FEATURE_PREJIT)
  };
  
  //
  // A ReflectionModule is a module created by reflection
  //
  
  class ReflectionModule : public Module
  {
      VPTR_VTABLE_CLASS(ReflectionModule, Module)
  
   public:
      HCEESECTION m_sdataSection;
  
   protected:
      ICeeGen * m_pCeeFileGen;
  private:
      Assembly             *m_pCreatingAssembly;
      ISymUnmanagedWriter  *m_pISymUnmanagedWriter;
      RefClassWriter       *m_pInMemoryWriter;
  
  
      // Simple Critical Section used for basic leaf-lock operatons.
      CrstExplicitInit        m_CrstLeafLock;
  
      // Buffer of Metadata storage for dynamic modules. May be NULL. This provides a reasonable way for
      // the debugger to get metadata of dynamic modules from out of process.
      // A dynamic module will eagerly serialize its metadata to this buffer.
      PTR_SBuffer m_pDynamicMetadata;
      
      // If true, does not eagerly serialize metadata in code:ReflectionModule.CaptureModuleMetaDataToMemory.
      // This is used to allow bulk emitting types without re-emitting the metadata between each type. 
      bool m_fSuppressMetadataCapture;
  
      // If true, then only other transient modules can depend on this module.
      bool m_fIsTransient;
  
  #if !defined DACCESS_COMPILE && !defined CROSSGEN_COMPILE
      // Returns true iff metadata capturing is suppressed
      bool IsMetadataCaptureSuppressed();
  
      // Toggle whether CaptureModuleMetaDataToMemory should do antyhing. This can be an important perf win to
      // allow batching up metadata capture. Use SuppressMetadataCaptureHolder to ensure they're balanced.
      // These are not nestable.
      void SuppressMetadataCapture();
      void ResumeMetadataCapture();
  
      // Glue functions for holders.
      static void SuppressCaptureWrapper(ReflectionModule * pModule)
      {
          pModule->SuppressMetadataCapture();
      }
      static void ResumeCaptureWrapper(ReflectionModule * pModule)
      {
          pModule->ResumeMetadataCapture();
      }
  
      ReflectionModule(Assembly *pAssembly, mdFile token, PEFile *pFile);
  #endif // !DACCESS_COMPILE && !CROSSGEN_COMPILE
  
  public:
  
  #ifdef DACCESS_COMPILE
      // Accessor to expose m_pDynamicMetadata to debugger.
      PTR_SBuffer GetDynamicMetadataBuffer() const;
  #endif
  
  #if !defined DACCESS_COMPILE && !defined CROSSGEN_COMPILE
      static ReflectionModule *Create(Assembly *pAssembly, PEFile *pFile, AllocMemTracker *pamTracker, LPCWSTR szName, BOOL fIsTransient);
      void Initialize(AllocMemTracker *pamTracker, LPCWSTR szName);
      void Destruct();
  
      void ReleaseILData();
  #endif // !DACCESS_COMPILE && !CROSSGEN_COMPILE
  
      // Overides functions to access sections
      virtual TADDR GetIL(RVA target);
      virtual PTR_VOID GetRvaField(RVA rva, BOOL fZapped);
  
      Assembly* GetCreatingAssembly( void )
      {
          LIMITED_METHOD_CONTRACT;
  
          return m_pCreatingAssembly;
      }
  
      void SetCreatingAssembly( Assembly* assembly )
      {
          LIMITED_METHOD_CONTRACT;
  
          m_pCreatingAssembly = assembly;
      }
  
      ICeeGen *GetCeeGen() {LIMITED_METHOD_CONTRACT;  return m_pCeeFileGen; }
  
      RefClassWriter *GetClassWriter()
      {
          LIMITED_METHOD_CONTRACT;
  
          return m_pInMemoryWriter;
      }
  
      ISymUnmanagedWriter *GetISymUnmanagedWriter()
      {
          LIMITED_METHOD_CONTRACT;
          return m_pISymUnmanagedWriter;
      }
  
      // Note: we now use the same writer instance for the life of a module,
      // so there should no longer be any need for the extra indirection.
      ISymUnmanagedWriter **GetISymUnmanagedWriterAddr()
      {
          LIMITED_METHOD_CONTRACT;
  
          // We must have setup the writer before trying to get
          // the address for it. Any calls to this before a
          // SetISymUnmanagedWriter are very incorrect.
          _ASSERTE(m_pISymUnmanagedWriter != NULL);
  
          return &m_pISymUnmanagedWriter;
      }
  
      bool IsTransient()
      {
          LIMITED_METHOD_CONTRACT;
  
          return m_fIsTransient;
      }
  
      void SetIsTransient(bool fIsTransient)
      {
          LIMITED_METHOD_CONTRACT;
  
          m_fIsTransient = fIsTransient;
      }
  
  #ifndef DACCESS_COMPILE
  #ifndef CROSSGEN_COMPILE
  
      typedef Wrapper<
          ReflectionModule*, 
          ReflectionModule::SuppressCaptureWrapper, 
          ReflectionModule::ResumeCaptureWrapper> SuppressMetadataCaptureHolder;
  #endif // !CROSSGEN_COMPILE
  
      HRESULT SetISymUnmanagedWriter(ISymUnmanagedWriter *pWriter)
      {
          CONTRACTL
          {
              NOTHROW;
              GC_NOTRIGGER;
              INJECT_FAULT(return E_OUTOFMEMORY;);
          }
          CONTRACTL_END
  
  
          // Setting to NULL when we've never set a writer before should
          // do nothing.
          if ((pWriter == NULL) && (m_pISymUnmanagedWriter == NULL))
              return S_OK;
  
          if (m_pISymUnmanagedWriter != NULL)
          {
              // We shouldn't be trying to replace an existing writer anymore
              _ASSERTE( pWriter == NULL );
  
              m_pISymUnmanagedWriter->Release();
          }
          
          m_pISymUnmanagedWriter = pWriter;
          return S_OK;
      }
  #endif // !DACCESS_COMPILE
  
      // Eagerly serialize the metadata to a buffer that the debugger can retrieve.
      void CaptureModuleMetaDataToMemory();
  };
  
  // Module holders
  FORCEINLINE void VoidModuleDestruct(Module *pModule)
  {
  #ifndef DACCESS_COMPILE
      if (g_fEEStarted)
          pModule->Destruct();
  #endif
  }
  
  typedef Wrapper<Module*, DoNothing, VoidModuleDestruct, 0> ModuleHolder;
  
  
  
  FORCEINLINE void VoidReflectionModuleDestruct(ReflectionModule *pModule)
  {
  #ifndef DACCESS_COMPILE
      pModule->Destruct();
  #endif
  }
  
  typedef Wrapper<ReflectionModule*, DoNothing, VoidReflectionModuleDestruct, 0> ReflectionModuleHolder;
  
  
  
  //----------------------------------------------------------------------
  // VASigCookieEx (used to create a fake VASigCookie for unmanaged->managed
  // calls to vararg functions. These fakes are distinguished from the
  // real thing by having a null mdVASig.
  //----------------------------------------------------------------------
  struct VASigCookieEx : public VASigCookie
  {
      const BYTE *m_pArgs;        // pointer to first unfixed unmanaged arg
  };
  
  bool IsSingleAppDomain();
  
  #endif // !CEELOAD_H_
  