internal AssemblyProcessorTable(int numberOfRows, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
ProcessorOffset = 0;
RowSize = ProcessorOffset + sizeof(UInt32);
Table = block.GetRange(start, RowSize * numberOfRows);
}
public MemoryReader(MemoryBlock block)
{
if (block == null) {
throw new ArgumentNullException("block");
}
_block = block;
}
internal AssemblyOSTable(int numberOfRows, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
OSPlatformIdOffset = 0;
OSMajorVersionIdOffset = OSPlatformIdOffset + sizeof(UInt32);
OSMinorVersionIdOffset = OSMajorVersionIdOffset + sizeof(UInt32);
RowSize = OSMinorVersionIdOffset + sizeof(UInt32);
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal TypeRefTable(int numberOfRows, int resolutionScopeRefSize, int stringHeapRefSize, int start, MemoryBlock block) {
NumberOfRows = numberOfRows;
IsResolutionScopeRefSizeSmall = resolutionScopeRefSize == 2;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
ResolutionScopeOffset = 0;
NameOffset = ResolutionScopeOffset + resolutionScopeRefSize;
NamespaceOffset = NameOffset + stringHeapRefSize;
RowSize = NamespaceOffset + stringHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal MetadataImport(MemoryBlock image) {
_image = image;
try {
ReadPEFileLevelData();
ReadCORModuleLevelData();
ReadMetadataLevelData();
} catch (ArgumentOutOfRangeException) {
throw new BadImageFormatException();
}
}
internal ModuleTable(int numberOfRows, int stringHeapRefSize, int guidHeapRefSize, int start, MemoryBlock block) {
NumberOfRows = numberOfRows;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
IsGUIDHeapRefSizeSmall = guidHeapRefSize == 2;
GenerationOffset = 0;
NameOffset = GenerationOffset + sizeof(UInt16);
MVIdOffset = NameOffset + stringHeapRefSize;
EnCIdOffset = MVIdOffset + guidHeapRefSize;
EnCBaseIdOffset = EnCIdOffset + guidHeapRefSize;
RowSize = EnCBaseIdOffset + guidHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal MethodSpecTable(int numberOfRows, int methodDefOrRefRefSize, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsMethodDefOrRefRefSizeSmall = methodDefOrRefRefSize == 2;
IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
MethodOffset = 0;
InstantiationOffset = MethodOffset + methodDefOrRefRefSize;
RowSize = InstantiationOffset + blobHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal DeclSecurityTable(int numberOfRows, int hasDeclSecurityRefSize, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
// IsHasDeclSecurityRefSizeSmall = hasDeclSecurityRefSize == 2;
// IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
ActionOffset = 0;
ParentOffset = ActionOffset + sizeof(UInt16);
PermissionSetOffset = ParentOffset + hasDeclSecurityRefSize;
RowSize = PermissionSetOffset + blobHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal EnCMapTable(int numberOfRows, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
TokenOffset = 0;
RowSize = TokenOffset + sizeof(UInt32);
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal ParamPtrTable(int numberOfRows, int paramTableRowRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsParamTableRowRefSizeSmall = paramTableRowRefSize == 2;
ParamOffset = 0;
RowSize = ParamOffset + paramTableRowRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal CustomAttributeTable(int numberOfRows, int hasCustomAttributeRefSize, int customAttributeTypeRefSize, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsHasCustomAttributeRefSizeSmall = hasCustomAttributeRefSize == 2;
IsCustomAttriubuteTypeRefSizeSmall = customAttributeTypeRefSize == 2;
IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
ParentOffset = 0;
TypeOffset = ParentOffset + hasCustomAttributeRefSize;
ValueOffset = TypeOffset + customAttributeTypeRefSize;
RowSize = ValueOffset + blobHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal EventTable(int numberOfRows, int typeDefOrRefRefSize, int stringHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsTypeDefOrRefRefSizeSmall = typeDefOrRefRefSize == 2;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
FlagsOffset = 0;
NameOffset = FlagsOffset + sizeof(UInt16);
EventTypeOffset = NameOffset + stringHeapRefSize;
RowSize = EventTypeOffset + typeDefOrRefRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal FieldLayoutTable(int numberOfRows, int fieldTableRowRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
// IsFieldTableRowRefSizeSmall = fieldTableRowRefSize == 2;
OffsetOffset = 0;
FieldOffset = OffsetOffset + sizeof(UInt32);
RowSize = FieldOffset + fieldTableRowRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal AssemblyTable(int numberOfRows, int stringHeapRefSize, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
HashAlgIdOffset = 0;
MajorVersionOffset = HashAlgIdOffset + sizeof(UInt32);
MinorVersionOffset = MajorVersionOffset + sizeof(UInt16);
BuildNumberOffset = MinorVersionOffset + sizeof(UInt16);
RevisionNumberOffset = BuildNumberOffset + sizeof(UInt16);
FlagsOffset = RevisionNumberOffset + sizeof(UInt16);
PublicKeyOffset = FlagsOffset + sizeof(UInt32);
NameOffset = PublicKeyOffset + blobHeapRefSize;
CultureOffset = NameOffset + stringHeapRefSize;
RowSize = CultureOffset + stringHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
private void ProcessAndCacheStreams(MemoryBlock metadataRoot) {
_metadataStreamKind = MetadataStreamKind.Illegal;
foreach (StreamHeader streamHeader in _streamHeaders) {
if ((long)streamHeader.Offset + streamHeader.Size > metadataRoot.Length) {
throw new BadImageFormatException();
}
MemoryBlock block = metadataRoot.GetRange((int)streamHeader.Offset, (int)streamHeader.Size);
switch (streamHeader.Name) {
case COR20Constants.StringStreamName:
if (_stringStream != null) {
throw new BadImageFormatException();
}
// the first and the last byte of the heap must be zero:
if (block.Length == 0 || block.ReadByte(0) != 0 || block.ReadByte(block.Length - 1) != 0) {
throw new BadImageFormatException();
}
_stringStream = block;
break;
case COR20Constants.BlobStreamName:
if (_blobStream != null) {
throw new BadImageFormatException();
}
_blobStream = block;
break;
case COR20Constants.GUIDStreamName:
if (_guidStream != null) {
throw new BadImageFormatException();
}
_guidStream = block;
break;
case COR20Constants.UserStringStreamName:
if (_userStringStream != null) {
throw new BadImageFormatException();
}
_userStringStream = block;
break;
case COR20Constants.CompressedMetadataTableStreamName:
if (_metadataStreamKind != MetadataStreamKind.Illegal) {
throw new BadImageFormatException();
}
_metadataStreamKind = MetadataStreamKind.Compressed;
_metadataTableStream = block;
break;
case COR20Constants.UncompressedMetadataTableStreamName:
if (_metadataStreamKind != MetadataStreamKind.Illegal) {
throw new BadImageFormatException();
}
_metadataStreamKind = MetadataStreamKind.UnCompressed;
_metadataTableStream = block;
break;
default:
throw new BadImageFormatException();
}
}
// mandatory streams:
if (_stringStream == null || _guidStream == null || _metadataStreamKind == MetadataStreamKind.Illegal) {
throw new BadImageFormatException();
}
}
internal PropertyTable(int numberOfRows, int stringHeapRefSize, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
FlagsOffset = 0;
NameOffset = FlagsOffset + sizeof(UInt16);
SignatureOffset = NameOffset + stringHeapRefSize;
RowSize = SignatureOffset + blobHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal TypeDefTable(int numberOfRows, int fieldRefSize, int methodRefSize, int typeDefOrRefRefSize, int stringHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsFieldRefSizeSmall = fieldRefSize == 2;
IsMethodRefSizeSmall = methodRefSize == 2;
IsTypeDefOrRefRefSizeSmall = typeDefOrRefRefSize == 2;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
FlagsOffset = 0;
NameOffset = FlagsOffset + sizeof(UInt32);
NamespaceOffset = NameOffset + stringHeapRefSize;
ExtendsOffset = NamespaceOffset + stringHeapRefSize;
FieldListOffset = ExtendsOffset + typeDefOrRefRefSize;
MethodListOffset = FieldListOffset + fieldRefSize;
RowSize = MethodListOffset + methodRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal PropertyPtrTable(int numberOfRows, int propertyTableRowRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsPropertyTableRowRefSizeSmall = propertyTableRowRefSize == 2;
PropertyOffset = 0;
RowSize = PropertyOffset + propertyTableRowRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal PropertyMapTable(int numberOfRows, int typeDefTableRowRefSize, int propertyRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsTypeDefTableRowRefSizeSmall = typeDefTableRowRefSize == 2;
IsPropertyRefSizeSmall = propertyRefSize == 2;
ParentOffset = 0;
PropertyListOffset = ParentOffset + typeDefTableRowRefSize;
RowSize = PropertyListOffset + propertyRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal ParamTable(int numberOfRows, int stringHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
FlagsOffset = 0;
SequenceOffset = FlagsOffset + sizeof(UInt16);
NameOffset = SequenceOffset + sizeof(UInt16);
RowSize = NameOffset + stringHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal EventMapTable(int numberOfRows, int typeDefTableRowRefSize, int eventRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsTypeDefTableRowRefSizeSmall = typeDefTableRowRefSize == 2;
IsEventRefSizeSmall = eventRefSize == 2;
ParentOffset = 0;
EventListOffset = ParentOffset + typeDefTableRowRefSize;
RowSize = EventListOffset + eventRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal ModuleRefTable(int numberOfRows, int stringHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
NameOffset = 0;
RowSize = NameOffset + stringHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal EventPtrTable(int numberOfRows, int eventTableRowRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsEventTableRowRefSizeSmall = eventTableRowRefSize == 2;
EventOffset = 0;
RowSize = EventOffset + eventTableRowRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal MethodTable(int numberOfRows, int paramRefSize, int stringHeapRefSize, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsParamRefSizeSmall = paramRefSize == 2;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
RVAOffset = 0;
ImplFlagsOffset = RVAOffset + sizeof(UInt32);
FlagsOffset = ImplFlagsOffset + sizeof(UInt16);
NameOffset = FlagsOffset + sizeof(UInt16);
SignatureOffset = NameOffset + stringHeapRefSize;
ParamListOffset = SignatureOffset + blobHeapRefSize;
RowSize = ParamListOffset + paramRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal ExportedTypeTable(int numberOfRows, int implementationRefSize, int stringHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsImplementationRefSizeSmall = implementationRefSize == 2;
IsStringHeapRefSizeSmall = stringHeapRefSize == 2;
FlagsOffset = 0;
TypeDefIdOffset = FlagsOffset + sizeof(UInt32);
TypeNameOffset = TypeDefIdOffset + sizeof(UInt32);
TypeNamespaceOffset = TypeNameOffset + stringHeapRefSize;
ImplementationOffset = TypeNamespaceOffset + stringHeapRefSize;
RowSize = ImplementationOffset + implementationRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal ConstantTable(int numberOfRows, int hasConstantRefSize, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsHasConstantRefSizeSmall = hasConstantRefSize == 2;
IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
TypeOffset = 0;
ParentOffset = TypeOffset + sizeof(Byte) + 1; // Alignment here (+1)...
ValueOffset = ParentOffset + hasConstantRefSize;
RowSize = ValueOffset + blobHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal TypeSpecTable(int numberOfRows, int blobHeapRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsBlobHeapRefSizeSmall = blobHeapRefSize == 2;
SignatureOffset = 0;
RowSize = SignatureOffset + blobHeapRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
internal NestedClassTable(int numberOfRows, int typeDefTableRowRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
IsTypeDefTableRowRefSizeSmall = typeDefTableRowRefSize == 2;
NestedClassOffset = 0;
EnclosingClassOffset = NestedClassOffset + typeDefTableRowRefSize;
RowSize = EnclosingClassOffset + typeDefTableRowRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
private void ProcessAndCacheMetadataTableBlocks(MemoryBlock metadataTablesMemoryBlock) {
int[] rowCountArray = _tableRowCounts = new int[TableCount];
int[] rowRefSizeArray = new int[TableCount];
int[] rowCountCompressedArray = _metadataTableHeader.CompressedMetadataTableRowCount;
ulong validTables = (ulong)_metadataTableHeader.ValidTables;
// Fill in the row count and table reference sizes...
for (int tableIndex = 0, arrayIndex = 0; tableIndex < rowRefSizeArray.Length; tableIndex++) {
if ((validTables & 0x0000000000000001UL) != 0) {
int rowCount = rowCountCompressedArray[arrayIndex++];
rowCountArray[tableIndex] = rowCount;
rowRefSizeArray[tableIndex] = rowCount < MetadataStreamConstants.LargeTableRowCount ? 2 : 4;
} else {
rowRefSizeArray[tableIndex] = 2;
}
validTables >>= 1;
}
// Compute ref sizes for tables that can have pointer tables for it
int fieldRefSize = rowRefSizeArray[FieldPtrTable.TableIndex] > 2 ? 4 : rowRefSizeArray[FieldPtrTable.TableIndex];
int methodRefSize = rowRefSizeArray[MethodPtrTable.TableIndex] > 2 ? 4 : rowRefSizeArray[MethodPtrTable.TableIndex];
int paramRefSize = rowRefSizeArray[ParamPtrTable.TableIndex] > 2 ? 4 : rowRefSizeArray[ParamPtrTable.TableIndex];
int eventRefSize = rowRefSizeArray[EventPtrTable.TableIndex] > 2 ? 4 : rowRefSizeArray[EventPtrTable.TableIndex];
int propertyRefSize = rowRefSizeArray[PropertyPtrTable.TableIndex] > 2 ? 4 : rowRefSizeArray[PropertyPtrTable.TableIndex];
// Compute the coded token ref sizes
int typeDefOrRefRefSize = ComputeCodedTokenSize(TypeDefOrRefTag.LargeRowSize, rowCountArray, TypeDefOrRefTag.TablesReferenced);
int hasConstantRefSize = ComputeCodedTokenSize(HasConstantTag.LargeRowSize, rowCountArray, HasConstantTag.TablesReferenced);
int hasCustomAttributeRefSize = ComputeCodedTokenSize(HasCustomAttributeTag.LargeRowSize, rowCountArray, HasCustomAttributeTag.TablesReferenced);
int hasFieldMarshalRefSize = ComputeCodedTokenSize(HasFieldMarshalTag.LargeRowSize, rowCountArray, HasFieldMarshalTag.TablesReferenced);
int hasDeclSecurityRefSize = ComputeCodedTokenSize(HasDeclSecurityTag.LargeRowSize, rowCountArray, HasDeclSecurityTag.TablesReferenced);
int memberRefParentRefSize = ComputeCodedTokenSize(MemberRefParentTag.LargeRowSize, rowCountArray, MemberRefParentTag.TablesReferenced);
int hasSemanticsRefSize = ComputeCodedTokenSize(HasSemanticsTag.LargeRowSize, rowCountArray, HasSemanticsTag.TablesReferenced);
int methodDefOrRefRefSize = ComputeCodedTokenSize(MethodDefOrRefTag.LargeRowSize, rowCountArray, MethodDefOrRefTag.TablesReferenced);
int memberForwardedRefSize = ComputeCodedTokenSize(MemberForwardedTag.LargeRowSize, rowCountArray, MemberForwardedTag.TablesReferenced);
int implementationRefSize = ComputeCodedTokenSize(ImplementationTag.LargeRowSize, rowCountArray, ImplementationTag.TablesReferenced);
int customAttributeTypeRefSize = ComputeCodedTokenSize(CustomAttributeTypeTag.LargeRowSize, rowCountArray, CustomAttributeTypeTag.TablesReferenced);
int resolutionScopeRefSize = ComputeCodedTokenSize(ResolutionScopeTag.LargeRowSize, rowCountArray, ResolutionScopeTag.TablesReferenced);
int typeOrMethodDefRefSize = ComputeCodedTokenSize(TypeOrMethodDefTag.LargeRowSize, rowCountArray, TypeOrMethodDefTag.TablesReferenced);
// Compute HeapRef Sizes
int stringHeapRefSize = (_metadataTableHeader.HeapSizeFlags & HeapSizeFlag.StringHeapLarge) == HeapSizeFlag.StringHeapLarge ? 4 : 2;
int guidHeapRefSize = (_metadataTableHeader.HeapSizeFlags & HeapSizeFlag.GUIDHeapLarge) == HeapSizeFlag.GUIDHeapLarge ? 4 : 2;
int blobHeapRefSize = (_metadataTableHeader.HeapSizeFlags & HeapSizeFlag.BlobHeapLarge) == HeapSizeFlag.BlobHeapLarge ? 4 : 2;
// Populate the Table blocks
int totalRequiredSize = 0;
int currentTableSize = 0;
int currentPointer = 0;
ModuleTable = new ModuleTable(rowCountArray[ModuleTable.TableIndex], stringHeapRefSize, guidHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = ModuleTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
TypeRefTable = new TypeRefTable(rowCountArray[TypeRefTable.TableIndex], resolutionScopeRefSize, stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = TypeRefTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
TypeDefTable = new TypeDefTable(rowCountArray[TypeDefTable.TableIndex], fieldRefSize, methodRefSize, typeDefOrRefRefSize, stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = TypeDefTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
FieldPtrTable = new FieldPtrTable(rowCountArray[FieldPtrTable.TableIndex], rowRefSizeArray[FieldPtrTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = FieldPtrTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
FieldTable = new FieldTable(rowCountArray[FieldTable.TableIndex], stringHeapRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = FieldTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
MethodPtrTable = new MethodPtrTable(rowCountArray[MethodPtrTable.TableIndex], rowRefSizeArray[MethodPtrTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = MethodPtrTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
MethodTable = new MethodTable(rowCountArray[MethodTable.TableIndex], paramRefSize, stringHeapRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = MethodTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ParamPtrTable = new ParamPtrTable(rowCountArray[ParamPtrTable.TableIndex], rowRefSizeArray[ParamPtrTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = ParamPtrTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ParamTable = new ParamTable(rowCountArray[ParamTable.TableIndex], stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = ParamTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
InterfaceImplTable = new InterfaceImplTable(rowCountArray[InterfaceImplTable.TableIndex], rowRefSizeArray[InterfaceImplTable.TableIndex], typeDefOrRefRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = InterfaceImplTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
MemberRefTable = new MemberRefTable(rowCountArray[MemberRefTable.TableIndex], memberRefParentRefSize, stringHeapRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = MemberRefTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ConstantTable = new ConstantTable(rowCountArray[ConstantTable.TableIndex], hasConstantRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = ConstantTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
CustomAttributeTable = new CustomAttributeTable(rowCountArray[CustomAttributeTable.TableIndex], hasCustomAttributeRefSize, customAttributeTypeRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = CustomAttributeTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
FieldMarshalTable = new FieldMarshalTable(rowCountArray[FieldMarshalTable.TableIndex], hasFieldMarshalRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = FieldMarshalTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
DeclSecurityTable = new DeclSecurityTable(rowCountArray[DeclSecurityTable.TableIndex], hasDeclSecurityRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = DeclSecurityTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ClassLayoutTable = new ClassLayoutTable(rowCountArray[ClassLayoutTable.TableIndex], rowRefSizeArray[ClassLayoutTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = ClassLayoutTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
FieldLayoutTable = new FieldLayoutTable(rowCountArray[FieldLayoutTable.TableIndex], rowRefSizeArray[FieldLayoutTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = FieldLayoutTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
StandAloneSigTable = new StandAloneSigTable(rowCountArray[StandAloneSigTable.TableIndex], blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = StandAloneSigTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
EventMapTable = new EventMapTable(rowCountArray[EventMapTable.TableIndex], rowRefSizeArray[EventMapTable.TableIndex], eventRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = EventMapTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
EventPtrTable = new EventPtrTable(rowCountArray[EventPtrTable.TableIndex], rowRefSizeArray[EventPtrTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = EventPtrTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
EventTable = new EventTable(rowCountArray[EventTable.TableIndex], typeDefOrRefRefSize, stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = EventTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
PropertyMapTable = new PropertyMapTable(rowCountArray[PropertyMapTable.TableIndex], rowRefSizeArray[PropertyMapTable.TableIndex], propertyRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = PropertyMapTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
PropertyPtrTable = new PropertyPtrTable(rowCountArray[PropertyPtrTable.TableIndex], rowRefSizeArray[PropertyPtrTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = PropertyPtrTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
PropertyTable = new PropertyTable(rowCountArray[PropertyTable.TableIndex], stringHeapRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = PropertyTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
MethodSemanticsTable = new MethodSemanticsTable(rowCountArray[MethodSemanticsTable.TableIndex], rowRefSizeArray[MethodSemanticsTable.TableIndex], hasSemanticsRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = MethodSemanticsTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
MethodImplTable = new MethodImplTable(rowCountArray[MethodImplTable.TableIndex], rowRefSizeArray[MethodImplTable.TableIndex], methodDefOrRefRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = MethodImplTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ModuleRefTable = new ModuleRefTable(rowCountArray[ModuleRefTable.TableIndex], stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = ModuleRefTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
TypeSpecTable = new TypeSpecTable(rowCountArray[TypeSpecTable.TableIndex], blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = TypeSpecTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ImplMapTable = new ImplMapTable(rowCountArray[ImplMapTable.TableIndex], rowRefSizeArray[ImplMapTable.TableIndex], memberForwardedRefSize, stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = ImplMapTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
FieldRVATable = new FieldRVATable(rowCountArray[FieldRVATable.TableIndex], rowRefSizeArray[FieldRVATable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = FieldRVATable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
EnCLogTable = new EnCLogTable(rowCountArray[EnCLogTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = EnCLogTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
EnCMapTable = new EnCMapTable(rowCountArray[EnCMapTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = EnCMapTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
AssemblyTable = new AssemblyTable(rowCountArray[AssemblyTable.TableIndex], stringHeapRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = AssemblyTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
AssemblyProcessorTable = new AssemblyProcessorTable(rowCountArray[AssemblyProcessorTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = AssemblyProcessorTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
AssemblyOSTable = new AssemblyOSTable(rowCountArray[AssemblyOSTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = AssemblyOSTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
AssemblyRefTable = new AssemblyRefTable(rowCountArray[AssemblyRefTable.TableIndex], stringHeapRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = AssemblyRefTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
AssemblyRefProcessorTable = new AssemblyRefProcessorTable(rowCountArray[AssemblyRefProcessorTable.TableIndex], rowRefSizeArray[AssemblyRefProcessorTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = AssemblyRefProcessorTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
AssemblyRefOSTable = new AssemblyRefOSTable(rowCountArray[AssemblyRefOSTable.TableIndex], rowRefSizeArray[AssemblyRefOSTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = AssemblyRefOSTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
FileTable = new FileTable(rowCountArray[FileTable.TableIndex], stringHeapRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = FileTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ExportedTypeTable = new ExportedTypeTable(rowCountArray[ExportedTypeTable.TableIndex], implementationRefSize, stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = ExportedTypeTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
ManifestResourceTable = new ManifestResourceTable(rowCountArray[ManifestResourceTable.TableIndex], implementationRefSize, stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = ManifestResourceTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
NestedClassTable = new NestedClassTable(rowCountArray[NestedClassTable.TableIndex], rowRefSizeArray[NestedClassTable.TableIndex], currentPointer, metadataTablesMemoryBlock);
currentTableSize = NestedClassTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
GenericParamTable = new GenericParamTable(rowCountArray[GenericParamTable.TableIndex], typeOrMethodDefRefSize, stringHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = GenericParamTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
MethodSpecTable = new MethodSpecTable(rowCountArray[MethodSpecTable.TableIndex], methodDefOrRefRefSize, blobHeapRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = MethodSpecTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
GenericParamConstraintTable = new GenericParamConstraintTable(rowCountArray[GenericParamConstraintTable.TableIndex], rowRefSizeArray[GenericParamConstraintTable.TableIndex], typeDefOrRefRefSize, currentPointer, metadataTablesMemoryBlock);
currentTableSize = GenericParamConstraintTable.Table.Length;
totalRequiredSize += currentTableSize;
currentPointer += currentTableSize;
}
internal ClassLayoutTable(int numberOfRows, int typeDefTableRowRefSize, int start, MemoryBlock block)
{
NumberOfRows = numberOfRows;
// IsTypeDefTableRowRefSizeSmall = typeDefTableRowRefSize == 2;
PackagingSizeOffset = 0;
ClassSizeOffset = PackagingSizeOffset + sizeof(UInt16);
ParentOffset = ClassSizeOffset + sizeof(UInt32);
RowSize = ParentOffset + typeDefTableRowRefSize;
Table = block.GetRange(start, RowSize * numberOfRows);
}
