summaryrefslogtreecommitdiff
path: root/src/debug/daccess/nidump.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/debug/daccess/nidump.h')
-rw-r--r--src/debug/daccess/nidump.h624
1 files changed, 624 insertions, 0 deletions
diff --git a/src/debug/daccess/nidump.h b/src/debug/daccess/nidump.h
new file mode 100644
index 0000000000..d14eb89f24
--- /dev/null
+++ b/src/debug/daccess/nidump.h
@@ -0,0 +1,624 @@
+// 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.
+
+
+#ifndef _NIDUMP_H_
+#define _NIDUMP_H_
+
+
+#ifdef FEATURE_PREJIT
+#include <daccess.h>
+
+//some DPTR definitions that aren't elsewhere in the source
+typedef DPTR(const COR_SIGNATURE) PTR_CCOR_SIGNATURE;
+typedef DPTR(IMAGE_SECTION_HEADER) PTR_IMAGE_SECTION_HEADER;
+typedef DPTR(CerNgenRootTable) PTR_CerNgenRootTable;
+typedef DPTR(struct CerRoot) PTR_CerRoot;
+typedef DPTR(MethodContextElement) PTR_MethodContextElement;
+typedef DPTR(ModuleSecurityDescriptor) PTR_ModuleSecurityDescriptor;
+typedef DPTR(DictionaryEntry) PTR_DictionaryEntry;
+typedef DPTR(GuidInfo) PTR_GuidInfo;
+#if defined(FEATURE_COMINTEROP)
+typedef DPTR(SparseVTableMap) PTR_SparseVTableMap;
+#endif
+#if defined(FEATURE_COMINTEROP)
+typedef DPTR(ClassFactoryBase) PTR_ClassFactoryBase;
+#endif
+typedef DPTR(LayoutEEClass) PTR_LayoutEEClass;
+typedef DPTR(ArrayClass) PTR_ArrayClass;
+typedef DPTR(DelegateEEClass) PTR_DelegateEEClass;
+typedef DPTR(UMThunkMarshInfo) PTR_UMThunkMarshInfo;
+typedef DPTR(CORCOMPILE_DEPENDENCY) PTR_CORCOMPILE_DEPENDENCY;
+typedef DPTR(struct RemotableMethodInfo) PTR_RemotableMethodInfo;
+typedef DPTR(struct ModuleCtorInfo) PTR_ModuleCtorInfo;
+typedef DPTR(class EEImplMethodDesc) PTR_EEImplMethodDesc;
+typedef DPTR(class EEClassLayoutInfo) PTR_EEClassLayoutInfo;
+typedef DPTR(class FieldMarshaler) PTR_FieldMarshaler;
+typedef DPTR(LPCUTF8) PTR_LPCUTF8;
+typedef DPTR(struct STORAGESIGNATURE UNALIGNED) PTR_STORAGESIGNATURE;
+typedef DPTR(struct STORAGEHEADER UNALIGNED) PTR_STORAGEHEADER;
+typedef DPTR(struct STORAGESTREAM UNALIGNED) PTR_STORAGESTREAM;
+typedef DPTR(ArrayMethodDesc) PTR_ArrayMethodDesc;
+
+
+#if 0
+template<typename PtrType>
+class TokenHashMap : CClosedHash< Pair<DPTR(PtrType), mdToken> >
+{
+public:
+ typedef DPTR(PtrType) Key;
+ typedef mdTypeRef Data;
+ typedef Pair<Key, Data> Entry;
+ typedef CClosedHash< Entry > Parent;
+ TokenHashMap(int buckets = 23) : Parent(buckets)
+ {
+
+ }
+ ~TokenHashMap() { }
+
+ void Add(const Key key, const Data data)
+ {
+ Entry * newEntry = Parent::Add((void*)PTR_HOST_TO_TADDR(key));
+ newEntry->First() = key;
+ newEntry->Second() = data;
+ }
+
+ Data Find(const Key key)
+ {
+ Entry * found = Parent::Find((void*)PTR_HOST_TO_TADDR(key));
+ if( !found )
+ return mdTokenNil;
+ else
+ return found->Second();
+ }
+ inline Key GetKey(Entry * entry) { return entry->First(); }
+ Parent::ELEMENTSTATUS Status(Entry * entry)
+ {
+ if( entry->First() == 0xffffffff && entry->Second() == 0xffffffff )
+ return Parent::DELETED;
+ else if( entry->First() == 0x00000000 && entry->Second() == 0x00000000 )
+ return Parent::FREE;
+ else
+ return Parent::USED;
+ }
+ void SetStatus(Entry * entry, Parent::ELEMENTSTATUS status)
+ {
+ switch(status)
+ {
+ case Parent::FREE:
+ entry->First() = Key((TADDR)0x00000000);
+ entry->Second() = 0x00000000;
+ break;
+ case Parent::DELETED:
+ entry->First() = Key((TADDR)0xffffffff);
+ entry->Second() = 0xffffffff;
+ break;
+ }
+ }
+
+ unsigned int Compare(const Entry * lhs, Entry * rhs)
+ {
+ return lhs->First() == rhs->First() && lhs->Second() == rhs->Second();
+ }
+
+ //parent methods
+ unsigned int Hash(const void *pData)
+ {
+ return (int)(INT_PTR)pData;
+ }
+ unsigned int Compare(const void * p1, BYTE * p2)
+ {
+ return Compare((const Entry *) p1, (Entry*) p2);
+ }
+ Parent::ELEMENTSTATUS Status(BYTE * p){
+ return Status((Entry*)p);
+ }
+ void SetStatus(BYTE * p, Parent::ELEMENTSTATUS status) {
+ SetStatus((Entry*)p, status);
+ }
+ void * GetKey(BYTE *p) { return (void*)GetKey((Entry*)p); }
+};
+typedef TokenHashMap<EEClass> EEClassToTypeRefMap;
+typedef TokenHashMap<MethodTable> MTToTypeRefMap;
+#endif
+
+class NativeImageDumper
+{
+public:
+ //DPTR to private field needs to be a member of NativeImageDumper
+#if defined(FEATURE_COMINTEROP)
+ typedef DPTR(SparseVTableMap::Entry) PTR_SparseVTableMap_Entry;
+#endif
+
+ NativeImageDumper(PTR_VOID loadedBase, const WCHAR * const name,
+ IXCLRDataDisplay * display, IXCLRLibrarySupport *support,
+ IXCLRDisassemblySupport * dis);
+ ~NativeImageDumper();
+
+ //type dumping methods
+ void DumpNativeImage();
+
+ void ComputeMethodFixupHistogram( PTR_Module module );
+ void DumpFixupTables( PTR_Module module);
+
+ void WriteElementTypeHandle( const char * name, TypeHandle th );
+ void DoWriteFieldFieldDesc( const char * name, unsigned offset,
+ unsigned fieldSize, PTR_FieldDesc fd );
+ void DoWriteFieldMethodDesc( const char * name, unsigned offset,
+ unsigned fieldSize, PTR_MethodDesc md );
+ void DoWriteFieldTypeHandle( const char * name, unsigned offset,
+ unsigned fieldSize, TypeHandle th );
+ void DoWriteFieldMDToken( const char * name, unsigned offset,
+ unsigned fieldsize, mdToken token,
+ IMetaDataImport2 *pAssemblyImport = NULL);
+ void DoWriteFieldMethodTable( const char * name, unsigned offset,
+ unsigned fieldSize, PTR_MethodTable mt );
+ //if fixup is a fixup, it writes the field as if it were a fixup (including
+ //subelements) and returns true. Otherwise, it returns false.
+ BOOL DoWriteFieldAsFixup( const char * name, unsigned offset,
+ unsigned fieldSize, TADDR fixup );
+
+ void WriteElementMethodTable( const char * name, PTR_MethodTable mt );
+ void WriteElementMethodDesc( const char * name, PTR_MethodDesc md );
+
+ void DoWriteFieldCorElementType( const char * name, unsigned offset,
+ unsigned fieldSize, CorElementType type );
+ void WriteElementMDToken( const char * name, mdToken token );
+
+ void DoWriteFieldAsHex( const char * name, unsigned offset,
+ unsigned fieldSize, PTR_BYTE data,
+ unsigned dataLen );
+
+ void DumpMethods(PTR_Module module);
+
+ void DumpCompleteMethod(PTR_Module module, MethodIterator& mi);
+
+ void DisassembleMethod(BYTE *method, SIZE_T size);
+
+ void DumpModule( PTR_Module module );
+ void DumpNative();
+ void DumpNativeHeader();
+
+ void DumpBaseRelocs();
+ void DumpHelperTable();
+
+ void DumpMethodFixups(PTR_Module module,
+ TADDR fixupList);
+
+ void DumpTypes( PTR_Module module );
+
+ void DumpNgenRootTable( PTR_CerNgenRootTable table, const char * name,
+ unsigned offset, unsigned fieldSize );
+
+ void DumpMethodTable( PTR_MethodTable mt, const char * name,
+ PTR_Module module );
+
+#ifndef STUB_DISPATCH_ALL
+ void DumpMethodTableSlotChunk( PTR_PCODE slotChunk, COUNT_T size );
+#endif
+
+ void DumpSlot( unsigned index, PCODE tgt );
+ void DumpFieldDesc( PTR_FieldDesc fd, const char * name );
+ void DumpEEClassForMethodTable( PTR_MethodTable mt );
+ void DumpTypeDesc( PTR_TypeDesc td );
+
+ void DumpMethodDesc( PTR_MethodDesc md, PTR_Module module );
+ void DumpPrecode( PTR_Precode precode, PTR_Module module );
+
+
+
+
+
+
+
+ //utility routines
+ void AppendTokenName(mdToken token, SString& str);
+ void AppendTokenName(mdToken token, SString& str, IMetaDataImport2 *pImport,
+ bool force = false);
+ void PrintManifestTokenName(mdToken token, SString& str);
+ void PrintManifestTokenName(mdToken token, SString& str,
+ IMetaDataAssemblyImport *pAssemblyImport,
+ bool force = false);
+ void WriteElementsFixupBlob(PTR_CORCOMPILE_IMPORT_SECTION pSection, SIZE_T fixup);
+ void WriteElementsFixupTargetAndName(RVA rva);
+ void FixupBlobToString(RVA rva, SString& buf);
+
+ void AppendToken(mdToken token, SString& buf);
+ void AppendToken(mdToken token, SString& buf, IMetaDataImport2 *pImport);
+ IMetaDataImport2* TypeToString(PTR_CCOR_SIGNATURE &sig, SString& buf); // assumes pImport is m_import
+ IMetaDataImport2* TypeToString(PTR_CCOR_SIGNATURE &sig, SString& buf,
+ IMetaDataImport2 *pImport,
+ IMetaDataImport2 *pOrigImport =NULL);
+ void MethodTableToString( PTR_MethodTable mt, SString& buf );
+ void TypeHandleToString( TypeHandle td, SString& buf );
+ void TypeDescToString( PTR_TypeDesc td, SString& buf );
+ void DictionaryToArgString( PTR_Dictionary dictionary, unsigned numArgs, SString& buf );
+
+ void EntryPointToString( PCODE pEntryPoint, SString& buf );
+ void MethodDescToString( PTR_MethodDesc md, SString& buf );
+ void FieldDescToString( PTR_FieldDesc fd, SString& buf );
+ //uses tok to generate a name if fd == NULL
+ void FieldDescToString( PTR_FieldDesc fd, mdFieldDef tok, SString& buf );
+
+#ifdef FEATURE_READYTORUN
+private:
+ READYTORUN_HEADER * m_pReadyToRunHeader;
+
+ PTR_RUNTIME_FUNCTION m_pRuntimeFunctions;
+ DWORD m_nRuntimeFunctions;
+
+ NativeFormat::NativeReader m_nativeReader;
+ NativeFormat::NativeArray m_methodDefEntryPoints;
+
+ IMAGE_DATA_DIRECTORY * FindReadyToRunSection(DWORD type);
+
+public:
+ void DumpReadyToRun();
+ void DumpReadyToRunHeader();
+ void DumpReadyToRunMethods();
+ void DumpReadyToRunMethod(PCODE pEntryPoint, PTR_RUNTIME_FUNCTION pRuntimeFunction, SString& name);
+#endif // FEATURE_READYTORUN
+
+private:
+ PEDecoder m_decoder;
+ const WCHAR * const m_name;
+ PTR_VOID m_baseAddress;
+ SIZE_T m_imageSize;
+ IXCLRDataDisplay * m_display;
+ IXCLRLibrarySupport * m_librarySupport;
+
+ bool isInRange(TADDR ptr)
+ {
+ return dac_cast<TADDR>(m_baseAddress) <= ptr
+ && ptr < (dac_cast<TADDR>(m_baseAddress) + m_imageSize);
+ }
+
+
+ COUNT_T ** m_fixupHistogram;
+
+ #define COUNT_HISTOGRAM_SIZE 16
+ COUNT_T m_fixupCountHistogram[COUNT_HISTOGRAM_SIZE];
+ COUNT_T m_fixupCount; //used to track above counts
+
+ // Primary image metadata
+ IMetaDataImport2 *m_import;
+ IMetaDataAssemblyImport *m_assemblyImport;
+
+ // Installation manifest metadata. For native images this is metadata
+ // copied from the IL image.
+ IMetaDataImport2 *m_manifestImport;
+ IMetaDataAssemblyImport *m_manifestAssemblyImport;
+
+ //helper for ComputeMethodFixupHistogram
+ BOOL HandleFixupForHistogram(PTR_CORCOMPILE_IMPORT_SECTION pSection, SIZE_T fixupIndex, SIZE_T *fixupCell);
+
+ //helper for DumpMethodFixups
+ BOOL HandleFixupForMethodDump(PTR_CORCOMPILE_IMPORT_SECTION pSection, SIZE_T fixupIndex, SIZE_T *fixupCell);
+
+ // Dependencies
+
+public:
+ struct Dependency
+ {
+ CORCOMPILE_DEPENDENCY * entry;
+ //CORINFO_ASSEMBLY_HANDLE assembly;
+
+ TADDR pPreferredBase;
+ TADDR pLoadedAddress;
+ SIZE_T size;
+
+ PTR_Module pModule;
+ IMetaDataImport2 *pImport;
+ TADDR pMetadataStartTarget;
+ TADDR pMetadataStartHost;
+ SIZE_T MetadataSize;
+ bool fIsMscorlib;
+ bool fIsHardbound;
+ WCHAR name[128];
+ };
+
+ /* REVISIT_TODO Fri 12/09/2005
+ * Perhaps the module and import should be in the dependency. In order to
+ * properly name tokens in modules w/o import entries.
+ */
+ struct Import
+ {
+ PTR_CORCOMPILE_IMPORT_TABLE_ENTRY entry;
+ Dependency *dependency;
+ };
+private:
+
+ Dependency *m_dependencies;
+ COUNT_T m_numDependencies;
+ Import *m_imports;
+ COUNT_T m_numImports;
+ CORCOMPILE_DEPENDENCY m_self;
+
+ bool inline isSelf(const Dependency* dep) {
+ return &m_dependencies[0] == dep;
+ }
+
+
+ void OpenMetadata();
+ void WriteElementsMetadata( const char * elementName,
+ TADDR data, SIZE_T size );
+ NativeImageDumper::Dependency*
+ GetDependency(mdAssemblyRef token, IMetaDataAssemblyImport *pImport = NULL);
+ NativeImageDumper::Import *OpenImport(int i);
+ NativeImageDumper::Dependency * OpenDependency(int index);
+ void TraceDumpImport(int idx, NativeImageDumper::Import * import);
+ void TraceDumpDependency(int idx, NativeImageDumper::Dependency * dependency);
+ mdAssemblyRef MapAssemblyRefToManifest(mdAssemblyRef token, IMetaDataAssemblyImport *pAssemblyImport);
+
+ const Dependency * GetDependencyForFixup(RVA rva);
+ const Dependency * GetDependencyForModule( PTR_Module module );
+#if 0
+ const Import * GetImportForPointer( TADDR ptr );
+#endif
+ const Dependency * GetDependencyForPointer( TADDR ptr );
+#ifdef MANUAL_RELOCS
+ template< typename T >
+ inline T RemapPointerForReloc( T ptr );
+
+ inline TADDR RemapTAddrForReloc( TADDR ptr );
+
+ inline TADDR RemapTAddrForReloc( const NativeImageDumper::Dependency * d,
+ TADDR ptr );
+
+ template< typename T >
+ inline T RemapPointerForReloc( const NativeImageDumper::Dependency * d,
+ T ptr );
+#endif
+
+
+ // msdis support
+
+#if 0
+ static size_t TranslateFixupCallback(const DIS *, DIS::ADDR, size_t, WCHAR *, size_t, DWORDLONG *);
+ static size_t TranslateRegrelCallback(const DIS *, DIS::REGA, DWORD, WCHAR *, size_t, DWORD *);
+ static size_t TranslateConstCallback(const DIS *, DWORD, WCHAR *, size_t);
+#endif
+ IXCLRDisassemblySupport * m_dis;
+ static SIZE_T __stdcall TranslateFixupCallback(IXCLRDisassemblySupport *dis,
+ CLRDATA_ADDRESS addr,
+ SIZE_T size, __out_ecount(nameSize) WCHAR *name,
+ SIZE_T nameSize,
+ DWORDLONG *offset);
+ static SIZE_T __stdcall TranslateAddressCallback(IXCLRDisassemblySupport *dis,
+ CLRDATA_ADDRESS addr,
+ __out_ecount(nameSize) WCHAR *name, SIZE_T nameSize,
+ DWORDLONG *offset);
+ size_t TranslateSymbol(IXCLRDisassemblySupport *dis,
+ CLRDATA_ADDRESS addr, __out_ecount(nameSize) WCHAR *name,
+ SIZE_T nameSize, DWORDLONG *offset);
+
+ CLRDATA_ADDRESS m_currentAddress;
+ bool m_currentIsAddress;
+
+ //mscorwks sizes
+ TADDR m_mscorwksBase;
+ TADDR m_mscorwksPreferred;
+ SIZE_T m_mscorwksSize;
+
+
+ //internal type dumpers
+ void DumpDictionaryEntry( const char * name, DictionaryEntryKind kind,
+ PTR_DictionaryEntry entry );
+ void WriteFieldDictionaryLayout( const char * name, unsigned offset,
+ unsigned fieldSize,
+ PTR_DictionaryLayout layout,
+ IMetaDataImport2 * import );
+
+
+ IMAGE_SECTION_HEADER * FindSection( char const * name );
+
+
+ //map traversal methods and helpers
+ void IterateTypeDefToMTCallback(TADDR taddrTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+ void IterateTypeRefToMTCallback(TADDR taddrTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+ void IterateMethodDefToMDCallback(TADDR taddrTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+ void IterateFieldDefToFDCallback(TADDR taddrTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+ void IterateMemberRefToDescCallback(TADDR taddrTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+ void IterateGenericParamToDescCallback(TADDR fdTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+ void IterateFileReferencesCallback(TADDR moduleTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+ void IterateManifestModules(TADDR moduleTarget, TADDR flags, PTR_LookupMapBase map, DWORD rid);
+
+ void TraverseMap(PTR_LookupMapBase map, const char * name, unsigned offset,
+ unsigned fieldSize,
+ void(NativeImageDumper::*cb)(TADDR, TADDR, PTR_LookupMapBase, DWORD));
+
+ template<typename HASH_CLASS, typename HASH_ENTRY_CLASS>
+ void TraverseNgenHash(DPTR(HASH_CLASS) pTable, const char * name,
+ unsigned offset, unsigned fieldSize,
+ bool saveClasses,
+ void (NativeImageDumper::*DisplayEntryFunction)(void *, DPTR(HASH_ENTRY_CLASS), bool),
+ void *pContext);
+ template<typename HASH_CLASS, typename HASH_ENTRY_CLASS>
+ void TraverseNgenPersistedEntries(DPTR(HASH_CLASS) pTable,
+ DPTR(typename HASH_CLASS::PersistedEntries) pEntries,
+ bool saveClasses,
+ void (NativeImageDumper::*DisplayEntryFunction)(void *, DPTR(HASH_ENTRY_CLASS), bool),
+ void *pContext);
+
+ void TraverseClassHashEntry(void *pContext, PTR_EEClassHashEntry pEntry, bool saveClasses);
+ void TraverseClassHash(PTR_EEClassHashTable pTable, const char * name,
+ unsigned offset, unsigned fieldSize,
+ bool saveClasses);
+
+#ifdef FEATURE_COMINTEROP
+ void TraverseGuidToMethodTableEntry(void *pContext, PTR_GuidToMethodTableEntry pEntry, bool saveClasses);
+ void TraverseGuidToMethodTableHash(PTR_GuidToMethodTableHashTable pTable, const char * name,
+ unsigned offset, unsigned fieldSize, bool saveClasses);
+#endif // FEATURE_COMINTEROP
+
+ void TraverseMemberRefToDescHashEntry(void *pContext, PTR_MemberRefToDescHashEntry pEntry, bool saveClasses);
+
+ void TraverseMemberRefToDescHash(PTR_MemberRefToDescHashTable pTable, const char * name,
+ unsigned offset, unsigned fieldSize, bool saveClasses);
+
+
+ void TraverseTypeHashEntry(void *pContext, PTR_EETypeHashEntry pEntry, bool saveClasses);
+ void TraverseTypeHash(PTR_EETypeHashTable pTable, const char * name,
+ unsigned offset, unsigned fieldSize );
+
+ void TraverseInstMethodHashEntry(void *pContext, PTR_InstMethodHashEntry pEntry, bool saveClasses);
+ void TraverseInstMethodHash(PTR_InstMethodHashTable pTable,
+ const char * name, unsigned offset,
+ unsigned fieldSize, PTR_Module module);
+
+ void TraverseStubMethodHashEntry(void *pContext, PTR_StubMethodHashEntry pEntry, bool saveClasses);
+ void TraverseStubMethodHash(PTR_StubMethodHashTable pTable,
+ const char * name, unsigned offset,
+ unsigned fieldSize, PTR_Module module);
+
+ void DoWriteFieldStr( PTR_BYTE ptr, const char * name, unsigned offset,
+ unsigned fieldSize );
+
+
+ template<typename T>
+ TADDR DPtrToPreferredAddr( T ptr );
+
+ void DumpAssemblySignature(CORCOMPILE_ASSEMBLY_SIGNATURE & assemblySignature);
+
+ SIZE_T CountFields( PTR_MethodTable mt );
+ mdToken ConvertToTypeDef( mdToken typeSpecOrRef, IMetaDataImport2* (&pImport) );
+ SIZE_T CountDictionariesInClass( mdToken typeDefOrRef, IMetaDataImport2 * pImport );
+ PTR_EEClass GetClassFromMT( PTR_MethodTable mt );
+ PTR_MethodTable GetParent( PTR_MethodTable mt );
+
+ const Dependency* GetDependencyFromFD( PTR_FieldDesc fd );
+ const Dependency* GetDependencyFromMD( PTR_MethodDesc md );
+ const Dependency* GetDependencyFromMT( PTR_MethodTable mt );
+
+ CLRNativeImageDumpOptions m_dumpOptions;
+ inline TADDR RvaToDisplay( SIZE_T rva );
+ inline TADDR DataPtrToDisplay(TADDR ptr);
+ inline int CheckOptions( CLRNativeImageDumpOptions opt );
+
+ //support various LookupMap Iterators
+ SArray<PTR_MethodTable> m_discoveredMTs;
+
+ struct SlotChunk
+ {
+ PTR_PCODE addr;
+ WORD nSlots;
+
+ inline bool operator==(const SlotChunk& sc) const
+ {
+ return (addr == sc.addr) && (nSlots == sc.nSlots);
+ }
+
+ inline bool operator<(const SlotChunk& sc) const
+ {
+ if (addr < sc.addr)
+ {
+ return TRUE;
+ }
+ else if (addr > sc.addr)
+ {
+ return FALSE;
+ }
+ else
+ {
+ return nSlots < sc.nSlots;
+ }
+ }
+ };
+
+ SArray<SlotChunk> m_discoveredSlotChunks;
+ //SArray<PTR_MethodDesc> m_discoveredMDs;
+ //SArray<PTR_FieldDesc> m_discoveredFDs;
+ SArray<PTR_MethodTable> m_discoveredClasses;
+ SArray<PTR_TypeDesc> m_discoveredTypeDescs;
+
+ typedef InlineSString<128> TempBuffer;
+
+ /* XXX Mon 10/03/2005
+ * When we encounter pointers from metadata they are already in the host
+ * process because we read all of metadata in as one big block (since the
+ * metadata api isn't dac-ized. Map the metadata pointers back to good DAC
+ * pointers for compatibility with certain sig parsing code.
+ */
+ TADDR m_MetadataStartHost;
+ TADDR m_MetadataStartTarget;
+ COUNT_T m_MetadataSize;
+
+ //Support dumping IL. The COR_ILMETHOD_DECODER is not DACized, so read the
+ //whole IL section in, and translate RVAs into host pointers into the IL
+ //section copy
+ RVA m_ILSectionStart;
+ BYTE * m_ILHostCopy;
+#ifdef _DEBUG
+ COUNT_T m_ILSectionSize;
+#endif
+
+ //This is true if we are hard bound to mscorlib. This enables various forms of generics dumping and MT
+ //dumping that require g_pObjectClass to be set.
+ bool m_isMscorlibHardBound;
+
+#if 0
+ PTR_CCOR_SIGNATURE metadataToHostDAC( PCCOR_SIGNATURE pSig,
+ IMetaDataImport2 * import );
+#endif
+ template<typename T>
+ DPTR(T) metadataToHostDAC( T * pSig, IMetaDataImport2 * import);
+
+ void DoDumpFieldStub( PTR_Stub stub, unsigned offset, unsigned fieldSize,
+ const char * name );
+#ifdef FEATURE_COMINTEROP
+ void DoDumpComPlusCallInfo( PTR_ComPlusCallInfo compluscall );
+#endif // FEATURE_COMINTEROP
+
+ SIZE_T m_sectionAlignment;
+ inline SIZE_T GetSectionAlignment() const;
+
+public:
+ //this is the list of valid precode addresses for the current module.
+ struct PrecodeRange
+ {
+ PrecodeRange( CorCompileSection section, TADDR start, SIZE_T size )
+ : m_sectionType(section), m_rangeStart(start),
+ m_rangeSize(size) { }
+ CorCompileSection m_sectionType;
+ TADDR m_rangeStart;
+ SIZE_T m_rangeSize;
+ };
+private:
+ bool isPrecode(TADDR maybePrecode);
+ void FixupThunkToString(PTR_CORCOMPILE_IMPORT_SECTION pImportSection, TADDR thunkAddr, SString& buf);
+
+#if 0
+ MTToTypeRefMap m_mtToTypeRefMap;
+ EEClassToTypeRefMap m_eeClassToTypeRefMap;
+ void RecordTypeRef( mdTypeRef token, PTR_MethodTable mt );
+ void RecordTypeRef( mdTypeRef token, PTR_EEClass clazz );
+ mdTypeRef FindTypeRefForMT( PTR_MethodTable mt );
+ mdTypeRef FindTypeRefForEEClass( PTR_EEClass clazz );
+#endif
+
+
+public:
+ struct EnumMnemonics
+ {
+ EnumMnemonics( DWORD val, const WCHAR * m )
+ : value(val), mask(val), mnemonic(m){ }
+ EnumMnemonics( DWORD val, DWORD msk, const WCHAR * m )
+ : value(val), mask(msk), mnemonic(m) { }
+ DWORD value;
+ DWORD mask;
+ const WCHAR * mnemonic;
+ };
+
+ static EnumMnemonics s_ModulePersistedFlags[];
+ static EnumMnemonics s_MDC[];
+ static EnumMnemonics s_MDFlag2[];
+ static EnumMnemonics s_TDFlags[];
+ static EnumMnemonics s_SSMDExtendedFlags[];
+ static EnumMnemonics s_IMDFlags[];
+ static EnumMnemonics s_EECLIFlags[];
+};
+#include "nidump.inl"
+
+#endif //FEATURE_PREJIT
+#endif