PHXH
/
obfuz4hybridclr
mirror of https://github.com/focus-creative-games/obfuz4hybridclr.git
54
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove: remove Templates~

main
walon 2026-10-09 12:18:50 +08:00
parent 7b7865e3f0
commit 2b3ebc54a0
5 changed files with 0 additions and 1159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
Templates~/MetadataReader.h.tpl
View File

@ -1,96 +0,0 @@
#pragma once
#include "MetadataUtil.h"
namespace hybridclr
{
namespace metadata
{
struct ByteSpan
{
const byte* data;
uint32_t length;
ByteSpan() : data(nullptr), length(0) {}
ByteSpan(const byte* data, uint32_t length) : data(data), length(length) {}
};
class MetadataReader
{
private:
const byte* _data;
public:
MetadataReader(const byte* data) : _data(data) {}
int16_t ReadInt16()
{
int16_t value = GetI2LittleEndian(_data);
_data += 2;
return value;
}
bool ReadBool()
{
return *(_data++) != 0;
}
uint8_t ReadUInt8()
{
return *(_data++);
}
uint16_t ReadUInt16()
{
uint16_t value = GetU2LittleEndian(_data);
_data += 2;
return value;
}
int32_t ReadInt32()
{
int32_t value = GetI4LittleEndian(_data);
_data += 4;
return value;
}
uint32_t ReadUInt32()
{
uint32_t value = GetU4LittleEndian(_data);
_data += 4;
return value;
}
int64_t ReadInt64()
{
int64_t value = GetI8LittleEndian(_data);
_data += 8;
return value;
}
uint64_t ReadUInt64()
{
uint64_t value = GetU8LittleEndian(_data);
_data += 8;
return value;
}
const byte* ReadFixedBytes(int32_t byteCount)
{
const byte* value = _data;
_data += byteCount;
return value;
}
ByteSpan ReadBytes()
{
uint32_t byteCount = ReadUInt32();
const byte* buffer = _data;
_data += byteCount;
return ByteSpan(buffer, byteCount);
}
const byte* CurrentDataPtr() const
{
return _data;
}
};
}
}

88
Templates~/PolymorphicDatas.h.tpl
View File

@ -1,88 +0,0 @@
#pragma once
#include "MetadataReader.h"
namespace hybridclr
{
namespace metadata
{
//!!!{{POLYMORPHIC_DATA
struct HeaderBaseData
{
uint32_t metadataSize;
uint32_t sectionCount;
const byte* dummyData;
uint32_t metadataRva;
uint32_t entryPointToken;
void Read(MetadataReader& reader)
{
metadataSize = reader.ReadUInt32();
sectionCount = reader.ReadUInt32();
dummyData = reader.ReadFixedBytes(8);
metadataRva = reader.ReadUInt32();
entryPointToken = reader.ReadUInt32();
}
};
struct SectionData
{
uint32_t rva;
uint32_t fileOffset;
uint32_t virtualSize;
uint32_t fileLength;
void Read(MetadataReader& reader)
{
rva = reader.ReadUInt32();
fileOffset = reader.ReadUInt32();
virtualSize = reader.ReadUInt32();
fileLength = reader.ReadUInt32();
}
};
struct MetadataHeaderBaseData
{
uint32_t signature;
uint8_t reserved2;
ByteSpan versionString;
uint16_t majorVersion;
uint16_t heapsCount;
uint32_t reserved1;
uint8_t storageFlags;
uint16_t minorVersion;
void Read(MetadataReader& reader)
{
signature = reader.ReadUInt32();
reserved2 = reader.ReadUInt8();
versionString = reader.ReadBytes();
majorVersion = reader.ReadUInt16();
heapsCount = reader.ReadUInt16();
reserved1 = reader.ReadUInt32();
storageFlags = reader.ReadUInt8();
minorVersion = reader.ReadUInt16();
}
};
struct TablesHeapHeaderBaseData
{
uint64_t validMask;
uint32_t reserved1;
uint8_t streamFlags;
uint8_t majorVersion;
uint64_t sortedMask;
uint8_t minorVersion;
uint8_t log2Rid;
void Read(MetadataReader& reader)
{
validMask = reader.ReadUInt64();
reserved1 = reader.ReadUInt32();
streamFlags = reader.ReadUInt8();
majorVersion = reader.ReadUInt8();
sortedMask = reader.ReadUInt64();
minorVersion = reader.ReadUInt8();
log2Rid = reader.ReadUInt8();
}
};
//!!!}}POLYMORPHIC_DATA
}
}

28
Templates~/PolymorphicDefs.h.tpl
View File

@ -1,28 +0,0 @@
#pragma once
#include "MetadataReader.h"
namespace hybridclr
{
namespace metadata
{
//!!!{{POLYMORPHIC_DEFINES
#define POLYMORPHIC_IMAGE_SIGNATURE "CODEPHPY"
constexpr uint32_t kPolymorphicImageVersion = 1;
constexpr uint32_t kFormatVariantVersion = 0;
//!!!}}POLYMORPHIC_DEFINES
struct PolymorphicImageHeaderData
{
const byte* signature;
uint32_t formatVersion;
uint32_t formatVariant;
void Read(MetadataReader& reader)
{
signature = reader.ReadFixedBytes(8);
formatVersion = reader.ReadUInt32();
formatVariant = reader.ReadUInt32();
}
};
}
}

889
Templates~/PolymorphicRawImage.cpp.tpl
View File

@ -1,889 +0,0 @@
#include "PolymorphicRawImage.h"
#include <memory>
#include "PolymorphicDefs.h"
#include "PolymorphicDatas.h"
namespace hybridclr
{
namespace metadata
{
LoadImageErrorCode PolymorphicRawImage::LoadCLIHeader(uint32_t& entryPointToken, uint32_t& metadataRva, uint32_t& metadataSize)
{
if (_imageLength < 0x100)
{
return LoadImageErrorCode::BAD_IMAGE;
}
MetadataReader reader(_imageData);
PolymorphicImageHeaderData imageHeaderData = {};
imageHeaderData.Read(reader);
const char* sig = (const char*)_imageData;
if (std::strncmp((const char*)imageHeaderData.signature, POLYMORPHIC_IMAGE_SIGNATURE, sizeof(POLYMORPHIC_IMAGE_SIGNATURE) - 1))
{
return LoadImageErrorCode::BAD_IMAGE;
}
if (imageHeaderData.formatVersion != kPolymorphicImageVersion)
{
return LoadImageErrorCode::UNSUPPORT_FORMAT_VERSION;
}
if (imageHeaderData.formatVariant != kFormatVariantVersion)
{
return LoadImageErrorCode::UNMATCH_FORMAT_VARIANT;
}
//reader.ReadFixedBytes(polymorphic::kImageHeaderDummyDataSize); // Skip dummy data
PolymorphicHeaderBaseData headerBaseData = {};
headerBaseData.Read(reader);
const size_t kEntryPointTokenOffset = 16;
entryPointToken = headerBaseData.entryPointToken;
metadataRva = headerBaseData.metadataRva;
metadataSize = headerBaseData.metadataSize;
uint32_t sectionCount = headerBaseData.sectionCount;
for (uint32_t i = 0; i < sectionCount; i++)
{
PolymorphicSectionData sectionData = {};
sectionData.Read(reader);
_sections.push_back({ sectionData.rva, sectionData.rva + sectionData.virtualSize, sectionData.fileOffset - sectionData.rva });
}
return LoadImageErrorCode::OK;
}
LoadImageErrorCode PolymorphicRawImage::LoadStreamHeaders(uint32_t metadataRva, uint32_t metadataSize)
{
uint32_t metaOffset;
if (!TranslateRVAToImageOffset(metadataRva, metaOffset))
{
return LoadImageErrorCode::BAD_IMAGE;
}
if (metaOffset >= _imageLength)
{
return LoadImageErrorCode::BAD_IMAGE;
}
const byte* ptrMetaData = _imageData + metaOffset;
MetadataReader reader(ptrMetaData);
PolymorphicMetadataHeaderBaseData metadataHeader = {};
metadataHeader.Read(reader);
if (metadataHeader.signature != 0x424A5342)
{
return LoadImageErrorCode::BAD_IMAGE;
}
uint16_t numStreamHeader = metadataHeader.heapsCount;
const StreamHeader* ptrStreamHeaders = (const StreamHeader*)(reader.CurrentDataPtr());
const StreamHeader* curSH = ptrStreamHeaders;
const size_t maxStreamNameSize = 16;
for (int i = 0; i < numStreamHeader; i++)
{
//std::cout << "name:" << (char*)curSH->name << ", offset:" << curSH->offset << ", size:" << curSH->size << std::endl;
if (curSH->offset >= metadataSize)
{
return LoadImageErrorCode::BAD_IMAGE;
}
CliStream* rs = nullptr;
CliStream nonStandardStream;
CliStream pdbStream;
if (!std::strncmp(curSH->name, "#~", maxStreamNameSize))
{
rs = &_streamTables;
}
else if (!std::strncmp(curSH->name, "#Strings", maxStreamNameSize))
{
rs = &_streamStringHeap;
}
else if (!std::strncmp(curSH->name, "#US", maxStreamNameSize))
{
rs = &_streamUS;
}
else if (!std::strncmp(curSH->name, "#GUID", maxStreamNameSize))
{
rs = &_streamGuidHeap;
if (curSH->size % 16 != 0)
{
return LoadImageErrorCode::BAD_IMAGE;
}
}
else if (!std::strncmp(curSH->name, "#Blob", maxStreamNameSize))
{
rs = &_streamBlobHeap;
}
else if (!std::strncmp(curSH->name, "#-", maxStreamNameSize))
{
rs = &nonStandardStream;
}
else if (!std::strncmp(curSH->name, "#Pdb", maxStreamNameSize))
{
rs = &pdbStream;
}
else
{
//std::cerr << "unknown stream name:" << curSH->name << std::endl;
return LoadImageErrorCode::BAD_IMAGE;
}
rs->data = ptrMetaData + curSH->offset;
rs->size = curSH->size;
rs->name = curSH->name;
size_t sizeOfStream = 8 + (std::strlen(curSH->name) / 4 + 1) * 4;
curSH = (const StreamHeader*)((byte*)curSH + sizeOfStream);
}
return LoadImageErrorCode::OK;
}
LoadImageErrorCode PolymorphicRawImage::LoadTables()
{
MetadataReader reader(_streamTables.data);
PolymorphicTablesHeapHeaderBaseData heapHeader = {};
heapHeader.Read(reader);
if (heapHeader.reserved1 != 0 || heapHeader.majorVersion != 2 || heapHeader.minorVersion != 0)
{
return LoadImageErrorCode::BAD_IMAGE;
}
if ((heapHeader.streamFlags & ~0x7))
{
return LoadImageErrorCode::BAD_IMAGE;
}
_4byteStringIndex = heapHeader.streamFlags & 0x1;
_4byteGUIDIndex = heapHeader.streamFlags & 0x2;
_4byteBlobIndex = heapHeader.streamFlags & 0x4;
uint64_t validMask = ((uint64_t)1 << TABLE_NUM) - 1;
if (heapHeader.validMask & ~validMask)
{
return LoadImageErrorCode::BAD_IMAGE;
}
// sorted include not exist table, so check is not need.
//if (heapHeader.sorted & ~validMask)
//{
// return LoadImageErrorCode::BAD_IMAGE;
//}
uint32_t validTableNum = GetNotZeroBitCount(heapHeader.validMask);
//std::cout << "valid table num:" << validTableNum << std::endl;
//printf("#~ size:%0x\n", _streamTables.size);
const uint32_t* tableRowNums = (uint32_t*)(reader.CurrentDataPtr());
const byte* tableDataBegin = (const byte*)(tableRowNums + validTableNum);
{
int curValidTableIndex = 0;
for (int i = 0; i <= MAX_TABLE_INDEX; i++)
{
uint64_t mask = (uint64_t)1 << i;
_tables[i] = {};
if (heapHeader.validMask & mask)
{
uint32_t rowNum = tableRowNums[curValidTableIndex];
_tables[i].rowNum = rowNum;
++curValidTableIndex;
}
}
}
BuildTableRowMetas();
int curValidTableIndex = 0;
const byte* curTableData = tableDataBegin;
for (int i = 0; i <= MAX_TABLE_INDEX; i++)
{
uint64_t mask = (uint64_t)1 << i;
bool sorted = heapHeader.sortedMask & mask;
if (heapHeader.validMask & mask)
{
uint32_t rowNum = tableRowNums[curValidTableIndex];
uint32_t totalSize = 0;
auto& table = _tableRowMetas[i];
for (auto& col : table)
{
col.offset = totalSize;
totalSize += col.size;
}
uint32_t metaDataRowSize = totalSize;
//uint64_t offset = curTableData - _imageData;
_tables[i] = { curTableData, metaDataRowSize, rowNum, true, sorted };
curTableData += metaDataRowSize * rowNum;
//std::cout << "table:" << i << " ," << curValidTableIndex << ", row_size:" << metaDataRowSize << ", row_num:" << rowNum << std::endl;
//printf("table:[%d][%d] offset:%0llx row_size:%d row_count:%d\n", i, curValidTableIndex, offset, metaDataRowSize, rowNum);
++curValidTableIndex;
}
else
{
_tables[i] = { nullptr, 0, 0, false, sorted };
}
}
return LoadImageErrorCode::OK;
}
void PolymorphicRawImage::BuildTableRowMetas()
{
//!!!{{TABLE_ROW_METADS
{
auto& table = _tableRowMetas[(int)TableType::MODULE];
table.push_back({2});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputGUIDIndexByte()});
table.push_back({ComputGUIDIndexByte()});
table.push_back({ComputGUIDIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::TYPEREF];
table.push_back({ComputStringIndexByte()});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputTableIndexByte(TableType::MODULE, TableType::MODULEREF, TableType::ASSEMBLYREF, TableType::TYPEREF, TagBits::ResoulutionScope)});
}
{
auto& table = _tableRowMetas[(int)TableType::TYPEDEF];
table.push_back({ComputStringIndexByte()});
table.push_back({ComputTableIndexByte(TableType::FIELD)});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef)});
table.push_back({4});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputTableIndexByte(TableType::METHOD)});
}
{
auto& table = _tableRowMetas[(int)TableType::FIELDPTR];
table.push_back({ComputTableIndexByte(TableType::FIELD)});
}
{
auto& table = _tableRowMetas[(int)TableType::FIELD];
table.push_back({ComputBlobIndexByte()});
table.push_back({2});
table.push_back({ComputStringIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::METHODPTR];
table.push_back({ComputTableIndexByte(TableType::METHOD)});
}
{
auto& table = _tableRowMetas[(int)TableType::METHOD];
table.push_back({ComputBlobIndexByte()});
table.push_back({2});
table.push_back({2});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputTableIndexByte(TableType::PARAM)});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::PARAMPTR];
table.push_back({ComputTableIndexByte(TableType::PARAM)});
}
{
auto& table = _tableRowMetas[(int)TableType::PARAM];
table.push_back({2});
table.push_back({ComputStringIndexByte()});
table.push_back({2});
}
{
auto& table = _tableRowMetas[(int)TableType::INTERFACEIMPL];
table.push_back({ComputTableIndexByte(TableType::TYPEDEF)});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef)});
}
{
auto& table = _tableRowMetas[(int)TableType::MEMBERREF];
table.push_back({ComputStringIndexByte()});
table.push_back({ComputBlobIndexByte()});
table.push_back({ComputTableIndexByte(TableType::METHOD, TableType::MODULEREF, TableType::TYPEDEF, TableType::TYPEREF, TagBits::MemberRefParent)});
}
{
auto& table = _tableRowMetas[(int)TableType::CONSTANT];
table.push_back({1});
table.push_back({1});
table.push_back({ComputTableIndexByte(TableType::PARAM, TableType::FIELD, TableType::PROPERTY, TagBits::HasConstant)});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::CUSTOMATTRIBUTE];
table.push_back({ComputTableIndexByte(HasCustomAttributeAssociateTables, sizeof(HasCustomAttributeAssociateTables) / sizeof(TableType), TagBits::HasCustomAttribute)});
table.push_back({ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::CustomAttributeType)});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::FIELDMARSHAL];
table.push_back({ComputTableIndexByte(TableType::FIELD, TableType::PARAM, TagBits::HasFieldMarshal)});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::DECLSECURITY];
table.push_back({2});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF, TableType::METHOD, TableType::ASSEMBLY, TagBits::HasDeclSecurity)});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::CLASSLAYOUT];
table.push_back({4});
table.push_back({2});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF)});
}
{
auto& table = _tableRowMetas[(int)TableType::FIELDLAYOUT];
table.push_back({ComputTableIndexByte(TableType::FIELD)});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::STANDALONESIG];
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::EVENTMAP];
table.push_back({ComputTableIndexByte(TableType::TYPEDEF)});
table.push_back({ComputTableIndexByte(TableType::EVENT)});
}
{
auto& table = _tableRowMetas[(int)TableType::EVENTPTR];
table.push_back({ComputTableIndexByte(TableType::EVENT)});
}
{
auto& table = _tableRowMetas[(int)TableType::EVENT];
table.push_back({ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef)});
table.push_back({ComputStringIndexByte()});
table.push_back({2});
}
{
auto& table = _tableRowMetas[(int)TableType::PROPERTYMAP];
table.push_back({ComputTableIndexByte(TableType::PROPERTY)});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF)});
}
{
auto& table = _tableRowMetas[(int)TableType::PROPERTYPTR];
table.push_back({ComputTableIndexByte(TableType::PROPERTY)});
}
{
auto& table = _tableRowMetas[(int)TableType::PROPERTY];
table.push_back({2});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::METHODSEMANTICS];
table.push_back({ComputTableIndexByte(TableType::EVENT, TableType::PROPERTY, TagBits::HasSemantics)});
table.push_back({ComputTableIndexByte(TableType::METHOD)});
table.push_back({2});
}
{
auto& table = _tableRowMetas[(int)TableType::METHODIMPL];
table.push_back({ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef)});
table.push_back({ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef)});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF)});
}
{
auto& table = _tableRowMetas[(int)TableType::MODULEREF];
table.push_back({ComputStringIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::TYPESPEC];
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::IMPLMAP];
table.push_back({2});
table.push_back({ComputTableIndexByte(TableType::MODULEREF)});
table.push_back({ComputTableIndexByte(TableType::FIELD, TableType::METHOD, TagBits::MemberForwarded)});
table.push_back({ComputStringIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::FIELDRVA];
table.push_back({ComputTableIndexByte(TableType::FIELD)});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::ENCLOG];
table.push_back({4});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::ENCMAP];
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::ASSEMBLY];
table.push_back({2});
table.push_back({4});
table.push_back({2});
table.push_back({2});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputBlobIndexByte()});
table.push_back({2});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::ASSEMBLYPROCESSOR];
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::ASSEMBLYOS];
table.push_back({4});
table.push_back({4});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::ASSEMBLYREF];
table.push_back({4});
table.push_back({2});
table.push_back({2});
table.push_back({ComputBlobIndexByte()});
table.push_back({ComputBlobIndexByte()});
table.push_back({2});
table.push_back({2});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputStringIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::ASSEMBLYREFPROCESSOR];
table.push_back({ComputTableIndexByte(TableType::ASSEMBLYREF)});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::ASSEMBLYREFOS];
table.push_back({4});
table.push_back({4});
table.push_back({4});
table.push_back({ComputTableIndexByte(TableType::ASSEMBLYREF)});
}
{
auto& table = _tableRowMetas[(int)TableType::FILE];
table.push_back({4});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::EXPORTEDTYPE];
table.push_back({4});
table.push_back({4});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputTableIndexByte(TableType::FILE, TableType::EXPORTEDTYPE, TableType::ASSEMBLY, TagBits::Implementation)});
}
{
auto& table = _tableRowMetas[(int)TableType::MANIFESTRESOURCE];
table.push_back({4});
table.push_back({4});
table.push_back({ComputStringIndexByte()});
table.push_back({ComputTableIndexByte(TableType::FILE, TableType::ASSEMBLYREF, TagBits::Implementation)});
}
{
auto& table = _tableRowMetas[(int)TableType::NESTEDCLASS];
table.push_back({ComputTableIndexByte(TableType::TYPEDEF)});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF)});
}
{
auto& table = _tableRowMetas[(int)TableType::GENERICPARAM];
table.push_back({2});
table.push_back({2});
table.push_back({ComputTableIndexByte(TableType::TYPEDEF, TableType::METHOD, TagBits::TypeOrMethodDef)});
table.push_back({ComputStringIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::METHODSPEC];
table.push_back({ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef)});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::GENERICPARAMCONSTRAINT];
table.push_back({ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef)});
table.push_back({ComputTableIndexByte(TableType::GENERICPARAM)});
}
{
auto& table = _tableRowMetas[(int)TableType::DOCUMENT];
table.push_back({ComputBlobIndexByte()});
table.push_back({ComputGUIDIndexByte()});
table.push_back({ComputBlobIndexByte()});
table.push_back({ComputGUIDIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::METHODDEBUGINFORMATION];
table.push_back({ComputTableIndexByte(TableType::DOCUMENT)});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::LOCALSCOPE];
table.push_back({ComputTableIndexByte(TableType::METHOD)});
table.push_back({ComputTableIndexByte(TableType::IMPORTSCOPE)});
table.push_back({ComputTableIndexByte(TableType::LOCALVARIABLE)});
table.push_back({ComputTableIndexByte(TableType::LOCALCONSTANT)});
table.push_back({4});
table.push_back({4});
}
{
auto& table = _tableRowMetas[(int)TableType::LOCALVARIABLE];
table.push_back({2});
table.push_back({2});
table.push_back({ComputStringIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::LOCALCONSTANT];
table.push_back({ComputStringIndexByte()});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::IMPORTSCOPE];
table.push_back({ComputTableIndexByte(TableType::IMPORTSCOPE)});
table.push_back({ComputBlobIndexByte()});
}
{
auto& table = _tableRowMetas[(int)TableType::STATEMACHINEMETHOD];
table.push_back({ComputTableIndexByte(TableType::METHOD)});
table.push_back({ComputTableIndexByte(TableType::METHOD)});
}
{
auto& table = _tableRowMetas[(int)TableType::CUSTOMDEBUGINFORMATION];
table.push_back({ComputTableIndexByte(HasCustomDebugInformation, sizeof(HasCustomDebugInformation) / sizeof(TableType), TagBits::HasCustomDebugInformation)});
table.push_back({ComputGUIDIndexByte()});
table.push_back({ComputBlobIndexByte()});
}
//!!!}}TABLE_ROW_METADS
for (int i = 0; i < TABLE_NUM; i++)
{
auto& table = _tableRowMetas[i];
if (table.empty())
{
IL2CPP_ASSERT(_tables[i].rowNum == 0 && _tables[i].rowMetaDataSize == 0);
}
else
{
uint32_t totalSize = 0;
for (auto& col : table)
{
col.offset = totalSize;
totalSize += col.size;
}
uint32_t computSize = ComputTableRowMetaDataSize((TableType)i);
IL2CPP_ASSERT(totalSize == computSize);
}
}
}
//!!!{{READ_TABLES_IMPLEMENTATIONS
TbTypeRef PolymorphicRawImage::ReadTypeRef(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::TYPEREF).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::TYPEREF, rawIndex);
auto& rowSchema = GetRowSchema(TableType::TYPEREF);
TbTypeRef data;
data.typeNamespace = ReadColumn(rowPtr, rowSchema[0]);
data.typeName = ReadColumn(rowPtr, rowSchema[1]);
data.resolutionScope = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbTypeDef PolymorphicRawImage::ReadTypeDef(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::TYPEDEF).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::TYPEDEF, rawIndex);
auto& rowSchema = GetRowSchema(TableType::TYPEDEF);
TbTypeDef data;
data.typeName = ReadColumn(rowPtr, rowSchema[0]);
data.fieldList = ReadColumn(rowPtr, rowSchema[1]);
data.extends = ReadColumn(rowPtr, rowSchema[2]);
data.flags = ReadColumn(rowPtr, rowSchema[3]);
data.typeNamespace = ReadColumn(rowPtr, rowSchema[4]);
data.methodList = ReadColumn(rowPtr, rowSchema[5]);
return data;
}
TbField PolymorphicRawImage::ReadField(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::FIELD).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::FIELD, rawIndex);
auto& rowSchema = GetRowSchema(TableType::FIELD);
TbField data;
data.signature = ReadColumn(rowPtr, rowSchema[0]);
data.flags = ReadColumn(rowPtr, rowSchema[1]);
data.name = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbMethod PolymorphicRawImage::ReadMethod(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::METHOD).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::METHOD, rawIndex);
auto& rowSchema = GetRowSchema(TableType::METHOD);
TbMethod data;
data.signature = ReadColumn(rowPtr, rowSchema[0]);
data.flags = ReadColumn(rowPtr, rowSchema[1]);
data.implFlags = ReadColumn(rowPtr, rowSchema[2]);
data.name = ReadColumn(rowPtr, rowSchema[3]);
data.paramList = ReadColumn(rowPtr, rowSchema[4]);
data.rva = ReadColumn(rowPtr, rowSchema[5]);
return data;
}
TbParam PolymorphicRawImage::ReadParam(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::PARAM).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::PARAM, rawIndex);
auto& rowSchema = GetRowSchema(TableType::PARAM);
TbParam data;
data.flags = ReadColumn(rowPtr, rowSchema[0]);
data.name = ReadColumn(rowPtr, rowSchema[1]);
data.sequence = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbInterfaceImpl PolymorphicRawImage::ReadInterfaceImpl(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::INTERFACEIMPL).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::INTERFACEIMPL, rawIndex);
auto& rowSchema = GetRowSchema(TableType::INTERFACEIMPL);
TbInterfaceImpl data;
data.classIdx = ReadColumn(rowPtr, rowSchema[0]);
data.interfaceIdx = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
TbMemberRef PolymorphicRawImage::ReadMemberRef(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::MEMBERREF).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::MEMBERREF, rawIndex);
auto& rowSchema = GetRowSchema(TableType::MEMBERREF);
TbMemberRef data;
data.name = ReadColumn(rowPtr, rowSchema[0]);
data.signature = ReadColumn(rowPtr, rowSchema[1]);
data.classIdx = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbConstant PolymorphicRawImage::ReadConstant(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::CONSTANT).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::CONSTANT, rawIndex);
auto& rowSchema = GetRowSchema(TableType::CONSTANT);
TbConstant data;
data.padding = ReadColumn(rowPtr, rowSchema[0]);
data.type = ReadColumn(rowPtr, rowSchema[1]);
data.parent = ReadColumn(rowPtr, rowSchema[2]);
data.value = ReadColumn(rowPtr, rowSchema[3]);
return data;
}
TbCustomAttribute PolymorphicRawImage::ReadCustomAttribute(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::CUSTOMATTRIBUTE).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::CUSTOMATTRIBUTE, rawIndex);
auto& rowSchema = GetRowSchema(TableType::CUSTOMATTRIBUTE);
TbCustomAttribute data;
data.parent = ReadColumn(rowPtr, rowSchema[0]);
data.type = ReadColumn(rowPtr, rowSchema[1]);
data.value = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbClassLayout PolymorphicRawImage::ReadClassLayout(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::CLASSLAYOUT).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::CLASSLAYOUT, rawIndex);
auto& rowSchema = GetRowSchema(TableType::CLASSLAYOUT);
TbClassLayout data;
data.classSize = ReadColumn(rowPtr, rowSchema[0]);
data.packingSize = ReadColumn(rowPtr, rowSchema[1]);
data.parent = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbFieldLayout PolymorphicRawImage::ReadFieldLayout(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::FIELDLAYOUT).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::FIELDLAYOUT, rawIndex);
auto& rowSchema = GetRowSchema(TableType::FIELDLAYOUT);
TbFieldLayout data;
data.field = ReadColumn(rowPtr, rowSchema[0]);
data.offset = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
TbStandAloneSig PolymorphicRawImage::ReadStandAloneSig(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::STANDALONESIG).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::STANDALONESIG, rawIndex);
auto& rowSchema = GetRowSchema(TableType::STANDALONESIG);
TbStandAloneSig data;
data.signature = ReadColumn(rowPtr, rowSchema[0]);
return data;
}
TbEventMap PolymorphicRawImage::ReadEventMap(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::EVENTMAP).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::EVENTMAP, rawIndex);
auto& rowSchema = GetRowSchema(TableType::EVENTMAP);
TbEventMap data;
data.parent = ReadColumn(rowPtr, rowSchema[0]);
data.eventList = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
TbEvent PolymorphicRawImage::ReadEvent(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::EVENT).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::EVENT, rawIndex);
auto& rowSchema = GetRowSchema(TableType::EVENT);
TbEvent data;
data.eventType = ReadColumn(rowPtr, rowSchema[0]);
data.name = ReadColumn(rowPtr, rowSchema[1]);
data.eventFlags = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbPropertyMap PolymorphicRawImage::ReadPropertyMap(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::PROPERTYMAP).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::PROPERTYMAP, rawIndex);
auto& rowSchema = GetRowSchema(TableType::PROPERTYMAP);
TbPropertyMap data;
data.propertyList = ReadColumn(rowPtr, rowSchema[0]);
data.parent = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
TbProperty PolymorphicRawImage::ReadProperty(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::PROPERTY).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::PROPERTY, rawIndex);
auto& rowSchema = GetRowSchema(TableType::PROPERTY);
TbProperty data;
data.flags = ReadColumn(rowPtr, rowSchema[0]);
data.name = ReadColumn(rowPtr, rowSchema[1]);
data.type = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbMethodSemantics PolymorphicRawImage::ReadMethodSemantics(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::METHODSEMANTICS).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::METHODSEMANTICS, rawIndex);
auto& rowSchema = GetRowSchema(TableType::METHODSEMANTICS);
TbMethodSemantics data;
data.association = ReadColumn(rowPtr, rowSchema[0]);
data.method = ReadColumn(rowPtr, rowSchema[1]);
data.semantics = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbMethodImpl PolymorphicRawImage::ReadMethodImpl(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::METHODIMPL).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::METHODIMPL, rawIndex);
auto& rowSchema = GetRowSchema(TableType::METHODIMPL);
TbMethodImpl data;
data.methodDeclaration = ReadColumn(rowPtr, rowSchema[0]);
data.methodBody = ReadColumn(rowPtr, rowSchema[1]);
data.classIdx = ReadColumn(rowPtr, rowSchema[2]);
return data;
}
TbModuleRef PolymorphicRawImage::ReadModuleRef(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::MODULEREF).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::MODULEREF, rawIndex);
auto& rowSchema = GetRowSchema(TableType::MODULEREF);
TbModuleRef data;
data.name = ReadColumn(rowPtr, rowSchema[0]);
return data;
}
TbTypeSpec PolymorphicRawImage::ReadTypeSpec(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::TYPESPEC).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::TYPESPEC, rawIndex);
auto& rowSchema = GetRowSchema(TableType::TYPESPEC);
TbTypeSpec data;
data.signature = ReadColumn(rowPtr, rowSchema[0]);
return data;
}
TbImplMap PolymorphicRawImage::ReadImplMap(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::IMPLMAP).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::IMPLMAP, rawIndex);
auto& rowSchema = GetRowSchema(TableType::IMPLMAP);
TbImplMap data;
data.mappingFlags = ReadColumn(rowPtr, rowSchema[0]);
data.importScope = ReadColumn(rowPtr, rowSchema[1]);
data.memberForwarded = ReadColumn(rowPtr, rowSchema[2]);
data.importName = ReadColumn(rowPtr, rowSchema[3]);
return data;
}
TbFieldRVA PolymorphicRawImage::ReadFieldRVA(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::FIELDRVA).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::FIELDRVA, rawIndex);
auto& rowSchema = GetRowSchema(TableType::FIELDRVA);
TbFieldRVA data;
data.field = ReadColumn(rowPtr, rowSchema[0]);
data.rva = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
TbAssembly PolymorphicRawImage::ReadAssembly(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::ASSEMBLY).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::ASSEMBLY, rawIndex);
auto& rowSchema = GetRowSchema(TableType::ASSEMBLY);
TbAssembly data;
data.minorVersion = ReadColumn(rowPtr, rowSchema[0]);
data.hashAlgId = ReadColumn(rowPtr, rowSchema[1]);
data.buildNumber = ReadColumn(rowPtr, rowSchema[2]);
data.revisionNumber = ReadColumn(rowPtr, rowSchema[3]);
data.locale = ReadColumn(rowPtr, rowSchema[4]);
data.name = ReadColumn(rowPtr, rowSchema[5]);
data.publicKey = ReadColumn(rowPtr, rowSchema[6]);
data.majorVersion = ReadColumn(rowPtr, rowSchema[7]);
data.flags = ReadColumn(rowPtr, rowSchema[8]);
return data;
}
TbAssemblyRef PolymorphicRawImage::ReadAssemblyRef(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::ASSEMBLYREF).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::ASSEMBLYREF, rawIndex);
auto& rowSchema = GetRowSchema(TableType::ASSEMBLYREF);
TbAssemblyRef data;
data.flags = ReadColumn(rowPtr, rowSchema[0]);
data.majorVersion = ReadColumn(rowPtr, rowSchema[1]);
data.buildNumber = ReadColumn(rowPtr, rowSchema[2]);
data.publicKeyOrToken = ReadColumn(rowPtr, rowSchema[3]);
data.hashValue = ReadColumn(rowPtr, rowSchema[4]);
data.revisionNumber = ReadColumn(rowPtr, rowSchema[5]);
data.minorVersion = ReadColumn(rowPtr, rowSchema[6]);
data.locale = ReadColumn(rowPtr, rowSchema[7]);
data.name = ReadColumn(rowPtr, rowSchema[8]);
return data;
}
TbNestedClass PolymorphicRawImage::ReadNestedClass(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::NESTEDCLASS).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::NESTEDCLASS, rawIndex);
auto& rowSchema = GetRowSchema(TableType::NESTEDCLASS);
TbNestedClass data;
data.enclosingClass = ReadColumn(rowPtr, rowSchema[0]);
data.nestedClass = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
TbGenericParam PolymorphicRawImage::ReadGenericParam(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::GENERICPARAM).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::GENERICPARAM, rawIndex);
auto& rowSchema = GetRowSchema(TableType::GENERICPARAM);
TbGenericParam data;
data.flags = ReadColumn(rowPtr, rowSchema[0]);
data.number = ReadColumn(rowPtr, rowSchema[1]);
data.owner = ReadColumn(rowPtr, rowSchema[2]);
data.name = ReadColumn(rowPtr, rowSchema[3]);
return data;
}
TbMethodSpec PolymorphicRawImage::ReadMethodSpec(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::METHODSPEC).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::METHODSPEC, rawIndex);
auto& rowSchema = GetRowSchema(TableType::METHODSPEC);
TbMethodSpec data;
data.method = ReadColumn(rowPtr, rowSchema[0]);
data.instantiation = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
TbGenericParamConstraint PolymorphicRawImage::ReadGenericParamConstraint(uint32_t rawIndex)
{
IL2CPP_ASSERT(rawIndex > 0 && rawIndex <= GetTable(TableType::GENERICPARAMCONSTRAINT).rowNum);
const byte* rowPtr = GetTableRowPtr(TableType::GENERICPARAMCONSTRAINT, rawIndex);
auto& rowSchema = GetRowSchema(TableType::GENERICPARAMCONSTRAINT);
TbGenericParamConstraint data;
data.constraint = ReadColumn(rowPtr, rowSchema[0]);
data.owner = ReadColumn(rowPtr, rowSchema[1]);
return data;
}
//!!!}}READ_TABLES_IMPLEMENTATIONS
}
}

58
Templates~/PolymorphicRawImage.h.tpl
View File

@ -1,58 +0,0 @@
#pragma once
#include "RawImageBase.h"
namespace hybridclr
{
namespace metadata
{
class PolymorphicRawImage : public RawImageBase
{
public:
PolymorphicRawImage() : RawImageBase()
{
}
LoadImageErrorCode LoadCLIHeader(uint32_t& entryPointToken, uint32_t& metadataRva, uint32_t& metadataSize) override;
virtual LoadImageErrorCode LoadStreamHeaders(uint32_t metadataRva, uint32_t metadataSize) override;
virtual LoadImageErrorCode LoadTables() override;
virtual void BuildTableRowMetas() override;
//!!!{{READ_TABLES_OVERRIDES
virtual TbTypeRef ReadTypeRef(uint32_t rawIndex) override;
virtual TbTypeDef ReadTypeDef(uint32_t rawIndex) override;
virtual TbField ReadField(uint32_t rawIndex) override;
virtual TbMethod ReadMethod(uint32_t rawIndex) override;
virtual TbParam ReadParam(uint32_t rawIndex) override;
virtual TbInterfaceImpl ReadInterfaceImpl(uint32_t rawIndex) override;
virtual TbMemberRef ReadMemberRef(uint32_t rawIndex) override;
virtual TbConstant ReadConstant(uint32_t rawIndex) override;
virtual TbCustomAttribute ReadCustomAttribute(uint32_t rawIndex) override;
virtual TbClassLayout ReadClassLayout(uint32_t rawIndex) override;
virtual TbFieldLayout ReadFieldLayout(uint32_t rawIndex) override;
virtual TbStandAloneSig ReadStandAloneSig(uint32_t rawIndex) override;
virtual TbEventMap ReadEventMap(uint32_t rawIndex) override;
virtual TbEvent ReadEvent(uint32_t rawIndex) override;
virtual TbPropertyMap ReadPropertyMap(uint32_t rawIndex) override;
virtual TbProperty ReadProperty(uint32_t rawIndex) override;
virtual TbMethodSemantics ReadMethodSemantics(uint32_t rawIndex) override;
virtual TbMethodImpl ReadMethodImpl(uint32_t rawIndex) override;
virtual TbModuleRef ReadModuleRef(uint32_t rawIndex) override;
virtual TbTypeSpec ReadTypeSpec(uint32_t rawIndex) override;
virtual TbImplMap ReadImplMap(uint32_t rawIndex) override;
virtual TbFieldRVA ReadFieldRVA(uint32_t rawIndex) override;
virtual TbAssembly ReadAssembly(uint32_t rawIndex) override;
virtual TbAssemblyRef ReadAssemblyRef(uint32_t rawIndex) override;
virtual TbNestedClass ReadNestedClass(uint32_t rawIndex) override;
virtual TbGenericParam ReadGenericParam(uint32_t rawIndex) override;
virtual TbMethodSpec ReadMethodSpec(uint32_t rawIndex) override;
virtual TbGenericParamConstraint ReadGenericParamConstraint(uint32_t rawIndex) override;
//!!!}}READ_TABLES_OVERRIDES
private:
};
}
}