Extract out the minimal structure to support referencing information from a R2R image without requiring the PE format

jkoritzinsky · jkoritzinsky · commit f654ce0cbb64 · 2025-10-16T09:54:07.000-07:00
diff --git a/src/coreclr/debug/daccess/request.cpp b/src/coreclr/debug/daccess/request.cpp
@@ -1232,7 +1232,7 @@ HRESULT ClrDataAccess::GetTieredVersions(
             PTR_Module pModule = (PTR_Module)pMD->GetModule();
             if (pModule->IsReadyToRun())
             {
-                PTR_PEImageLayout pImage = pModule->GetReadyToRunInfo()->GetImage();
+                PTR_ReadyToRunLoadedImage pImage = pModule->GetReadyToRunInfo()->GetImage();
                 r2rImageBase = dac_cast<TADDR>(pImage->GetBase());
                 r2rImageEnd = r2rImageBase + pImage->GetVirtualSize();
             }
diff --git a/src/coreclr/vm/ceeload.cpp b/src/coreclr/vm/ceeload.cpp
@@ -2060,7 +2060,7 @@ BOOL Module::IsVisibleToDebugger()
     return TRUE;
 }
 
-PEImageLayout * Module::GetReadyToRunImage()
+ReadyToRunLoadedImage * Module::GetReadyToRunImage()
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -3583,7 +3583,7 @@ void Module::RunEagerFixupsUnlocked()
 {
     COUNT_T nSections;
     PTR_READYTORUN_IMPORT_SECTION pSections = GetImportSections(&nSections);
-    PEImageLayout *pNativeImage = GetReadyToRunImage();
+    ReadyToRunLoadedImage *pNativeImage = GetReadyToRunImage();
 
     for (COUNT_T iSection = 0; iSection < nSections; iSection++)
     {
diff --git a/src/coreclr/vm/ceeload.h b/src/coreclr/vm/ceeload.h
@@ -1445,7 +1445,7 @@ class Module : public ModuleBase
     LPCUTF8 GetDebugName() { WRAPPER_NO_CONTRACT; return m_pPEAssembly->GetDebugName(); }
 #endif
 
-    PEImageLayout * GetReadyToRunImage();
+    ReadyToRunLoadedImage * GetReadyToRunImage();
     PTR_READYTORUN_IMPORT_SECTION GetImportSections(COUNT_T *pCount);
     PTR_READYTORUN_IMPORT_SECTION GetImportSectionFromIndex(COUNT_T index);
     PTR_READYTORUN_IMPORT_SECTION GetImportSectionForRVA(RVA rva);
@@ -1490,7 +1490,7 @@ class Module : public ModuleBase
     BOOL FixupDelayListAux(TADDR pFixupList,
                            Ptr pThis, FixupNativeEntryCallback pfnCB,
                            PTR_READYTORUN_IMPORT_SECTION pImportSections, COUNT_T nImportSections,
-                           PEDecoder * pNativeImage, BOOL mayUsePrecompiledPInvokeMethods = TRUE);
+                           ReadyToRunLoadedImage * pNativeImage, BOOL mayUsePrecompiledPInvokeMethods = TRUE);
     void RunEagerFixups();
     void RunEagerFixupsUnlocked();
 
diff --git a/src/coreclr/vm/ceeload.inl b/src/coreclr/vm/ceeload.inl
@@ -354,7 +354,7 @@ template<typename Ptr, typename FixupNativeEntryCallback>
 BOOL Module::FixupDelayListAux(TADDR pFixupList,
                                Ptr pThis, FixupNativeEntryCallback pfnCB,
                                PTR_READYTORUN_IMPORT_SECTION pImportSections, COUNT_T nImportSections,
-                               PEDecoder * pNativeImage, BOOL mayUsePrecompiledPInvokeMethods)
+                               ReadyToRunLoadedImage * pNativeImage, BOOL mayUsePrecompiledPInvokeMethods)
 {
     CONTRACTL
     {
diff --git a/src/coreclr/vm/codeman.cpp b/src/coreclr/vm/codeman.cpp
@@ -6289,7 +6289,7 @@ unsigned ReadyToRunJitManager::InitializeEHEnumeration(const METHODTOKEN& Method
     if (pExceptionInfoDir == NULL)
         return 0;
 
-    PEImageLayout * pLayout = pReadyToRunInfo->GetImage();
+    ReadyToRunLoadedImage * pLayout = pReadyToRunInfo->GetImage();
 
     PTR_CORCOMPILE_EXCEPTION_LOOKUP_TABLE pExceptionLookupTable = dac_cast<PTR_CORCOMPILE_EXCEPTION_LOOKUP_TABLE>(pLayout->GetRvaData(pExceptionInfoDir->VirtualAddress));
 
diff --git a/src/coreclr/vm/frames.cpp b/src/coreclr/vm/frames.cpp
@@ -840,7 +840,7 @@ static PTR_BYTE FindGCRefMap(PTR_Module pZapModule, TADDR ptr)
 {
     LIMITED_METHOD_DAC_CONTRACT;
 
-    PEImageLayout *pNativeImage = pZapModule->GetReadyToRunImage();
+    ReadyToRunLoadedImage *pNativeImage = pZapModule->GetReadyToRunImage();
 
     RVA rva = pNativeImage->GetDataRva(ptr);
 
diff --git a/src/coreclr/vm/nativeimage.cpp b/src/coreclr/vm/nativeimage.cpp
@@ -41,7 +41,7 @@ NativeImageIndexTraits::count_t NativeImageIndexTraits::Hash(LPCUTF8 a)
     return SString(SString::Utf8Literal, a).HashCaseInsensitive();
 }
 
-NativeImage::NativeImage(AssemblyBinder *pAssemblyBinder, PEImageLayout *pImageLayout, LPCUTF8 imageFileName)
+NativeImage::NativeImage(AssemblyBinder *pAssemblyBinder, ReadyToRunLoadedImage *pImageLayout, LPCUTF8 imageFileName)
     : m_eagerFixupsLock(CrstNativeImageEagerFixups)
 {
     CONTRACTL
@@ -236,7 +236,14 @@ NativeImage *NativeImage::Open(
     {
         COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
     }
-    NewHolder<NativeImage> image = new NativeImage(pAssemblyBinder, peLoadedImage.Extract(), nativeImageFileName);
+
+    NewHolder<ReadyToRunLoadedImage> peLoadedImageHolder = new ReadyToRunLoadedImage(
+        (TADDR)peLoadedImage->GetBase(),
+        peLoadedImage->GetSize(),
+        peLoadedImage.Extract(),
+        [](void* img) { delete (PEImageLayout*)img; });
+
+    NewHolder<NativeImage> image = new NativeImage(pAssemblyBinder, peLoadedImageHolder.Extract(), nativeImageFileName);
     AllocMemTracker amTracker;
     image->Initialize(pHeader, pLoaderAllocator, &amTracker);
     pExistingImage = AppDomain::GetCurrentDomain()->SetNativeImage(nativeImageFileName, image);
diff --git a/src/coreclr/vm/nativeimage.h b/src/coreclr/vm/nativeimage.h
@@ -12,10 +12,10 @@ struct AssemblyNameIndex
 {
     LPCUTF8 Name;
     int32_t Index;
-    
+
     AssemblyNameIndex() : Name(NULL), Index(-1) {}
     AssemblyNameIndex(LPCUTF8 name, int32_t index) : Name(name), Index(index) {}
-    
+
     static AssemblyNameIndex GetNull() { return AssemblyNameIndex(); }
     bool IsNull() const { return Index < 0; }
 };
@@ -57,6 +57,7 @@ class NativeImageIndexTraits : public NoRemoveSHashTraits<MapSHashTraits<LPCUTF8
 };
 
 class ReadyToRunInfo;
+class ReadyToRunLoadedImage;
 class PEAssembly;
 class PEImage;
 
@@ -83,21 +84,21 @@ class NativeImage
     AssemblyBinder *m_pAssemblyBinder;
     ReadyToRunInfo *m_pReadyToRunInfo;
     IMDInternalImport *m_pManifestMetadata;
-    PEImageLayout *m_pImageLayout;
+    ReadyToRunLoadedImage *m_pImageLayout;
     PTR_Assembly *m_pNativeMetadataAssemblyRefMap;
     PTR_ModuleBase m_pNativeManifestModule;
-    
+
     IMAGE_DATA_DIRECTORY *m_pComponentAssemblies;
     uint32_t m_componentAssemblyCount;
     uint32_t m_manifestAssemblyCount;
     SHash<AssemblyNameIndexHashTraits> m_assemblySimpleNameToIndexMap;
-    
+
     Crst m_eagerFixupsLock;
     bool m_eagerFixupsHaveRun;
     bool m_readyToRunCodeDisabled;
 
 private:
-    NativeImage(AssemblyBinder *pAssemblyBinder, PEImageLayout *peImageLayout, LPCUTF8 imageFileName);
+    NativeImage(AssemblyBinder *pAssemblyBinder, ReadyToRunLoadedImage *peImageLayout, LPCUTF8 imageFileName);
 
 protected:
     void Initialize(READYTORUN_HEADER *header, LoaderAllocator *loaderAllocator, AllocMemTracker *pamTracker);
@@ -125,7 +126,7 @@ class NativeImage
     AssemblyBinder *GetAssemblyBinder() const { return m_pAssemblyBinder; }
 
     Assembly *LoadManifestAssembly(uint32_t rowid, Assembly *pParentAssembly);
-    
+
     PTR_READYTORUN_CORE_HEADER GetComponentAssemblyHeader(LPCUTF8 assemblySimpleName);
 
     void CheckAssemblyMvid(Assembly *assembly) const;
diff --git a/src/coreclr/vm/pgo.cpp b/src/coreclr/vm/pgo.cpp
@@ -1002,13 +1002,13 @@ class R2RInstrumentationDataReader
 {
     ReadyToRunInfo *m_pReadyToRunInfo;
     Module* m_pModule;
-    PEDecoder* m_pNativeImage;
+    ReadyToRunLoadedImage* m_pNativeImage;
 
 public:
     StackSArray<ICorJitInfo::PgoInstrumentationSchema> schemaArray;
     StackSArray<BYTE> instrumentationData;
 
-    R2RInstrumentationDataReader(ReadyToRunInfo *pReadyToRunInfo, Module* pModule, PEDecoder* pNativeImage) :
+    R2RInstrumentationDataReader(ReadyToRunInfo *pReadyToRunInfo, Module* pModule, ReadyToRunLoadedImage* pNativeImage) :
         m_pReadyToRunInfo(pReadyToRunInfo),
         m_pModule(pModule),
         m_pNativeImage(pNativeImage)
@@ -1103,7 +1103,7 @@ class R2RInstrumentationDataReader
 
 HRESULT PgoManager::getPgoInstrumentationResultsFromR2RFormat(ReadyToRunInfo *pReadyToRunInfo,
                                                               Module* pModule,
-                                                              PEDecoder* pNativeImage,
+                                                              ReadyToRunLoadedImage* pNativeImage,
                                                               BYTE* pR2RFormatData,
                                                               size_t pR2RFormatDataMaxSize,
                                                               BYTE** pAllocatedData,
diff --git a/src/coreclr/vm/pgo.h b/src/coreclr/vm/pgo.h
@@ -7,6 +7,7 @@
 #include "shash.h"
 
 class ReadyToRunInfo;
+class ReadyToRunLoadedImage;
 
 // PgoManager handles in-process and out of band profile data for jitted code.
 class PgoManager
@@ -26,7 +27,7 @@ class PgoManager
     static HRESULT allocPgoInstrumentationBySchema(MethodDesc* pMD, ICorJitInfo::PgoInstrumentationSchema* pSchema, UINT32 countSchemaItems, BYTE** pInstrumentationData);
     static HRESULT getPgoInstrumentationResultsFromR2RFormat(ReadyToRunInfo *pReadyToRunInfo,
                                                              Module* pModule,
-                                                             PEDecoder* pNativeImage,
+                                                             ReadyToRunLoadedImage* pNativeImage,
                                                              BYTE* pR2RFormatData,
                                                              size_t pR2RFormatDataMaxSize,
                                                              BYTE** pAllocatedData,
diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp
@@ -2604,7 +2604,7 @@ EXTERN_C PCODE STDCALL ExternalMethodFixupWorker(TransitionBlock * pTransitionBl
     {
         GCX_PREEMP_THREAD_EXISTS(CURRENT_THREAD);
 
-        PEImageLayout *pNativeImage = pModule->GetReadyToRunImage();
+        ReadyToRunLoadedImage *pNativeImage = pModule->GetReadyToRunImage();
 
         RVA rva = pNativeImage->GetDataRva(pIndirection);
 
@@ -3216,7 +3216,7 @@ PCODE DynamicHelperFixup(TransitionBlock * pTransitionBlock, TADDR * pCell, DWOR
 {
     STANDARD_VM_CONTRACT;
 
-    PEImageLayout *pNativeImage = pModule->GetReadyToRunImage();
+    ReadyToRunLoadedImage *pNativeImage = pModule->GetReadyToRunImage();
 
     RVA rva = pNativeImage->GetDataRva((TADDR)pCell);
 
diff --git a/src/coreclr/vm/readytoruninfo.cpp b/src/coreclr/vm/readytoruninfo.cpp
@@ -63,7 +63,7 @@ ReadyToRunCoreInfo::ReadyToRunCoreInfo()
 {
 }
 
-ReadyToRunCoreInfo::ReadyToRunCoreInfo(PEImageLayout* pLayout, READYTORUN_CORE_HEADER *pCoreHeader)
+ReadyToRunCoreInfo::ReadyToRunCoreInfo(ReadyToRunLoadedImage* pLayout, READYTORUN_CORE_HEADER *pCoreHeader)
     : m_pLayout(pLayout), m_pCoreHeader(pCoreHeader), m_fForbidLoadILBodyFixups(false)
 {
 }
@@ -647,9 +647,16 @@ PTR_ReadyToRunInfo ReadyToRunInfo::Initialize(Module * pModule, AllocMemTracker
     LoaderHeap *pHeap = pModule->GetLoaderAllocator()->GetHighFrequencyHeap();
     void * pMemory = pamTracker->Track(pHeap->AllocMem((S_SIZE_T)sizeof(ReadyToRunInfo)));
 
+
+    void * pLoadedImageMemory = pamTracker->Track(pHeap->AllocMem((S_SIZE_T)sizeof(ReadyToRunLoadedImage)));
+
+    ReadyToRunLoadedImage* r2rLoadedImage = new(pLoadedImageMemory) ReadyToRunLoadedImage(
+        (TADDR)pLayout->GetBase(),
+        pLayout->GetSize());
+
     DoLog("Ready to Run initialized successfully");
 
-    return new (pMemory) ReadyToRunInfo(pModule, pModule->GetLoaderAllocator(), pLayout, pHeader, nativeImage, pamTracker);
+    return new (pMemory) ReadyToRunInfo(pModule, pModule->GetLoaderAllocator(), r2rLoadedImage, pHeader, nativeImage, pamTracker);
 }
 
 bool ReadyToRunInfo::IsNativeImageSharedBy(PTR_Module pModule1, PTR_Module pModule2)
@@ -762,7 +769,7 @@ PTR_ReadyToRunInfo ReadyToRunInfo::ComputeAlternateGenericLocationForR2RCode(Met
     }
 }
 
-ReadyToRunInfo::ReadyToRunInfo(Module * pModule, LoaderAllocator* pLoaderAllocator, PEImageLayout * pLayout, READYTORUN_HEADER * pHeader, NativeImage *pNativeImage, AllocMemTracker *pamTracker)
+ReadyToRunInfo::ReadyToRunInfo(Module * pModule, LoaderAllocator* pLoaderAllocator, ReadyToRunLoadedImage * pLayout, READYTORUN_HEADER * pHeader, NativeImage *pNativeImage, AllocMemTracker *pamTracker)
     : m_pModule(pModule),
     m_pHeader(pHeader),
     m_pNativeImage(pModule != NULL ? pNativeImage: NULL), // m_pNativeImage is only set for composite image components, not the composite R2R info itself
diff --git a/src/coreclr/vm/readytoruninfo.h b/src/coreclr/vm/readytoruninfo.h
@@ -20,25 +20,27 @@ typedef DPTR(struct READYTORUN_SECTION) PTR_READYTORUN_SECTION;
 
 class NativeImage;
 class PrepareCodeConfig;
+class ReadyToRunLoadedImage;
 
 typedef DPTR(class ReadyToRunCoreInfo) PTR_ReadyToRunCoreInfo;
+typedef DPTR(class ReadyToRunLoadedImage) PTR_ReadyToRunLoadedImage;
 class ReadyToRunCoreInfo
 {
 private:
-    PTR_PEImageLayout               m_pLayout;
+    PTR_ReadyToRunLoadedImage       m_pLayout;
     PTR_READYTORUN_CORE_HEADER      m_pCoreHeader;
     Volatile<bool>                  m_fForbidLoadILBodyFixups;
 
 public:
     ReadyToRunCoreInfo();
-    ReadyToRunCoreInfo(PEImageLayout * pLayout, READYTORUN_CORE_HEADER * pCoreHeader);
+    ReadyToRunCoreInfo(ReadyToRunLoadedImage * pLayout, READYTORUN_CORE_HEADER * pCoreHeader);
 
-    PTR_PEImageLayout GetLayout() const { return m_pLayout; }
+    PTR_ReadyToRunLoadedImage GetLayout() const { return m_pLayout; }
     IMAGE_DATA_DIRECTORY * FindSection(ReadyToRunSectionType type) const;
     void ForbidProcessMoreILBodyFixups() { m_fForbidLoadILBodyFixups = true; }
     bool IsForbidProcessMoreILBodyFixups() { return m_fForbidLoadILBodyFixups; }
 
-    PTR_PEImageLayout GetImage() const
+    PTR_ReadyToRunLoadedImage GetImage() const
     {
         LIMITED_METHOD_CONTRACT;
         return m_pLayout;
@@ -144,7 +146,7 @@ class ReadyToRunInfo
     PTR_ReadyToRunInfo              m_pNextR2RForUnrelatedCode;
 
 public:
-    ReadyToRunInfo(Module * pModule, LoaderAllocator* pLoaderAllocator, PEImageLayout * pLayout, READYTORUN_HEADER * pHeader, NativeImage * pNativeImage, AllocMemTracker *pamTracker);
+    ReadyToRunInfo(Module * pModule, LoaderAllocator* pLoaderAllocator, ReadyToRunLoadedImage * pLayout, READYTORUN_HEADER * pHeader, NativeImage * pNativeImage, AllocMemTracker *pamTracker);
 
     static PTR_ReadyToRunInfo ComputeAlternateGenericLocationForR2RCode(MethodDesc *pMethod);
     static PTR_ReadyToRunInfo GetUnrelatedR2RModules();
@@ -165,7 +167,7 @@ class ReadyToRunInfo
 
     PTR_NativeImage GetNativeImage() const { return m_pNativeImage; }
 
-    PTR_PEImageLayout GetImage() const { return m_pComposite->GetImage(); }
+    PTR_ReadyToRunLoadedImage GetImage() const { return m_pComposite->GetImage(); }
     IMAGE_DATA_DIRECTORY * FindSection(ReadyToRunSectionType type) const { return m_pComposite->FindSection(type); }
 
     PCODE GetEntryPoint(MethodDesc * pMD, PrepareCodeConfig* pConfig, BOOL fFixups);
@@ -391,4 +393,64 @@ struct GenericDictionaryDynamicHelperStubData
     GenericHandleArgs *HandleArgs;
 };
 
+class ReadyToRunLoadedImage
+{
+    TADDR m_pImageBase;
+    uint32_t m_imageSize;
+
+    void* m_pImageCleanupData;
+
+    void(*m_pfnCleanup)(void*);
+
+public:
+    ReadyToRunLoadedImage(TADDR m_pImageBase, uint32_t imageSize)
+        : m_pImageBase(m_pImageBase), m_imageSize(imageSize), m_pImageCleanupData(nullptr), m_pfnCleanup(nullptr)
+    {
+    }
+
+    ReadyToRunLoadedImage(TADDR m_pImageBase, uint32_t imageSize, void* pImageCleanupData, void(*pfnCleanup)(void*))
+        : m_pImageBase(m_pImageBase), m_imageSize(imageSize), m_pImageCleanupData(pImageCleanupData), m_pfnCleanup(pfnCleanup)
+    {
+    }
+
+    ~ReadyToRunLoadedImage()
+    {
+        if (m_pfnCleanup)
+            m_pfnCleanup(m_pImageCleanupData);
+    }
+
+    TADDR GetBase()
+    {
+        return m_pImageBase;
+    }
+
+    uint32_t GetVirtualSize()
+    {
+        return m_imageSize;
+    }
+
+    TADDR GetDirectoryData(IMAGE_DATA_DIRECTORY* pDir)
+    {
+        return m_pImageBase + pDir->VirtualAddress;
+    }
+
+    TADDR GetDirectoryData(IMAGE_DATA_DIRECTORY* pDir, uint32_t* pSize)
+    {
+        if (pSize != nullptr)
+            *pSize = pDir->Size;
+        return m_pImageBase + pDir->VirtualAddress;
+    }
+
+    TADDR GetRvaData(RVA rva)
+    {
+        return m_pImageBase + rva;
+    }
+
+    RVA GetDataRva(TADDR data)
+    {
+        _ASSERTE_MSG(data >= m_pImageBase && data < m_pImageBase + m_imageSize, "Data pointer is outside of loaded image.");
+        return (RVA)(data - m_pImageBase);
+    }
+};
+
 #endif // _READYTORUNINFO_H_

Original file line number	Diff line number	Diff line change
`@@ -1232,7 +1232,7 @@ HRESULT ClrDataAccess::GetTieredVersions(`
`1232`	`1232`	`PTR_Module pModule = (PTR_Module)pMD->GetModule();`
`1233`	`1233`	`if (pModule->IsReadyToRun())`
`1234`	`1234`	`{`
`1235`		`- PTR_PEImageLayout pImage = pModule->GetReadyToRunInfo()->GetImage();`
	`1235`	`+ PTR_ReadyToRunLoadedImage pImage = pModule->GetReadyToRunInfo()->GetImage();`
`1236`	`1236`	`r2rImageBase = dac_cast<TADDR>(pImage->GetBase());`
`1237`	`1237`	`r2rImageEnd = r2rImageBase + pImage->GetVirtualSize();`
`1238`	`1238`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2060,7 +2060,7 @@ BOOL Module::IsVisibleToDebugger()`
`2060`	`2060`	`return TRUE;`
`2061`	`2061`	`}`
`2062`	`2062`
`2063`		`-PEImageLayout * Module::GetReadyToRunImage()`
	`2063`	`+ReadyToRunLoadedImage * Module::GetReadyToRunImage()`
`2064`	`2064`	`{`
`2065`	`2065`	`LIMITED_METHOD_CONTRACT;`
`2066`	`2066`
`@@ -3583,7 +3583,7 @@ void Module::RunEagerFixupsUnlocked()`
`3583`	`3583`	`{`
`3584`	`3584`	`COUNT_T nSections;`
`3585`	`3585`	`PTR_READYTORUN_IMPORT_SECTION pSections = GetImportSections(&nSections);`
`3586`		`- PEImageLayout *pNativeImage = GetReadyToRunImage();`
	`3586`	`+ ReadyToRunLoadedImage *pNativeImage = GetReadyToRunImage();`
`3587`	`3587`
`3588`	`3588`	`for (COUNT_T iSection = 0; iSection < nSections; iSection++)`
`3589`	`3589`	`{`
Original file line number	Diff line number	Diff line change
`@@ -354,7 +354,7 @@ template<typename Ptr, typename FixupNativeEntryCallback>`
`354`	`354`	`BOOL Module::FixupDelayListAux(TADDR pFixupList,`
`355`	`355`	`Ptr pThis, FixupNativeEntryCallback pfnCB,`
`356`	`356`	`PTR_READYTORUN_IMPORT_SECTION pImportSections, COUNT_T nImportSections,`
`357`		`- PEDecoder * pNativeImage, BOOL mayUsePrecompiledPInvokeMethods)`
	`357`	`+ ReadyToRunLoadedImage * pNativeImage, BOOL mayUsePrecompiledPInvokeMethods)`
`358`	`358`	`{`
`359`	`359`	`CONTRACTL`
`360`	`360`	`{`
Original file line number	Diff line number	Diff line change
`@@ -840,7 +840,7 @@ static PTR_BYTE FindGCRefMap(PTR_Module pZapModule, TADDR ptr)`
`840`	`840`	`{`
`841`	`841`	`LIMITED_METHOD_DAC_CONTRACT;`
`842`	`842`
`843`		`- PEImageLayout *pNativeImage = pZapModule->GetReadyToRunImage();`
	`843`	`+ ReadyToRunLoadedImage *pNativeImage = pZapModule->GetReadyToRunImage();`
`844`	`844`
`845`	`845`	`RVA rva = pNativeImage->GetDataRva(ptr);`
`846`	`846`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ NativeImageIndexTraits::count_t NativeImageIndexTraits::Hash(LPCUTF8 a)`
`41`	`41`	`return SString(SString::Utf8Literal, a).HashCaseInsensitive();`
`42`	`42`	`}`
`43`	`43`
`44`		`-NativeImage::NativeImage(AssemblyBinder pAssemblyBinder, PEImageLayout pImageLayout, LPCUTF8 imageFileName)`
	`44`	`+NativeImage::NativeImage(AssemblyBinder pAssemblyBinder, ReadyToRunLoadedImage pImageLayout, LPCUTF8 imageFileName)`
`45`	`45`	`: m_eagerFixupsLock(CrstNativeImageEagerFixups)`
`46`	`46`	`{`
`47`	`47`	`CONTRACTL`
`@@ -236,7 +236,14 @@ NativeImage *NativeImage::Open(`
`236`	`236`	`{`
`237`	`237`	`COMPlusThrowHR(COR_E_BADIMAGEFORMAT);`
`238`	`238`	`}`
`239`		`- NewHolder<NativeImage> image = new NativeImage(pAssemblyBinder, peLoadedImage.Extract(), nativeImageFileName);`
	`239`	`+`
	`240`	`+ NewHolder<ReadyToRunLoadedImage> peLoadedImageHolder = new ReadyToRunLoadedImage(`
	`241`	`+ (TADDR)peLoadedImage->GetBase(),`
	`242`	`+ peLoadedImage->GetSize(),`
	`243`	`+ peLoadedImage.Extract(),`
	`244`	`+ [](void* img) { delete (PEImageLayout*)img; });`
	`245`	`+`
	`246`	`+ NewHolder<NativeImage> image = new NativeImage(pAssemblyBinder, peLoadedImageHolder.Extract(), nativeImageFileName);`
`240`	`247`	`AllocMemTracker amTracker;`
`241`	`248`	`image->Initialize(pHeader, pLoaderAllocator, &amTracker);`
`242`	`249`	`pExistingImage = AppDomain::GetCurrentDomain()->SetNativeImage(nativeImageFileName, image);`