protected MetadataIterator(MetadataTables _tables, byte[] _data, uint _pos, CorTokenType _tokenType)
{
tables = _tables;
data = _data;
pos = _pos;
tokenType = _tokenType;
}
internal static ClrTable GetTable(this CorTokenType mdToken)
{
if (mdToken > CorTokenType.mdtString)
{
throw new InvalidOperationException("Token does not have an associated table.");
}
// table = the high byte of the MD token
return((ClrTable)(((int)mdToken) >> 24));
}
public uint GetTableIndexSize(CorTokenType id)
{
uint v = (0x01 << 16);
int index = (int)id;
if (NumberOfTableRow[index] >= v)
{
return(4);
}
else
{
return(2);
}
}
// compress a token
// The least significant bit of the first compress byte will indicate the token type.
//
public void EmitToken(mdToken token)
{
uint rid = RidFromToken(token);
CorTokenType type = (CorTokenType)TypeFromToken(token);
if (rid > 0x3FFFFFF)
{
// token is too big to be compressed
throw new NotImplementedException();
}
rid = (rid << 2);
// TypeDef is encoded with low bits 00
// TypeRef is encoded with low bits 01
// TypeSpec is encoded with low bits 10
// BaseType is encoded with low bit 11
switch (type)
{
case CorTokenType.mdtTypeDef:
break;
case CorTokenType.mdtTypeRef:
// make the last two bits 01
rid |= 0x1;
break;
case CorTokenType.mdtTypeSpec:
// make last two bits 0
rid |= 0x2;
break;
case CorTokenType.mdtBaseType:
rid |= 0x3;
break;
default:
throw new NotImplementedException();
}
EmitUInt(rid);
}
public static bool Is(this int token, CorTokenType tokenBase)
{
return (token & 0xff000000) == (int)tokenBase;
}
public static bool IsNotEmpty(this int token, CorTokenType tokenBase)
{
return token != (int) tokenBase;
}
public MetadataTables(byte[] buffer, uint pos, uint size)
{
metadataPosition = pos;
metadataSize = size;
ReadMetadataRoot(buffer, pos);
pos += metadataHeader.Offset;
sortedOfTable = new bool[64];
numberOfTableRow = new uint[64];
tables = new IMetadataIterator[64];
metadataStreamRoot = ReadMetadataStream(buffer, pos);
pos += MetadataStream.StructSize;
if (((HeapSizeType)MetadataStreamRoot.HeapSizes & HeapSizeType.Blob) == HeapSizeType.Blob)
{
blobIndexSize = 4;
}
else
{
blobIndexSize = 2;
}
if (((HeapSizeType)MetadataStreamRoot.HeapSizes & HeapSizeType.GUID) == HeapSizeType.GUID)
{
guidIndexSize = 4;
}
else
{
guidIndexSize = 2;
}
if (((HeapSizeType)MetadataStreamRoot.HeapSizes & HeapSizeType.String) == HeapSizeType.String)
{
stringIndexSize = 4;
}
else
{
stringIndexSize = 2;
}
for (int i = 0; i < 64; i++)
{
UInt64 bit = (((UInt64)0x01) << i);
if ((MetadataStreamRoot.Valid & bit) == bit)
{
numberOfTableRow[i] = ReadUInt(buffer, pos);
pos += 4;
}
else
{
numberOfTableRow[i] = 0;
}
if ((MetadataStreamRoot.Sorted & bit) == bit)
{
sortedOfTable[i] = true;
}
else
{
sortedOfTable[i] = false;
}
}
for (int i = 0; i < 64; i++)
{
CorTokenType type = (CorTokenType)i;
tables[i] = MetadataIterator.Create(this, buffer, pos, type);
tables[i].MoveToEnd();
pos = tables[i].Position;
}
}
internal static int TokenFromRid(int rid, CorTokenType tktype) => rid | (int)tktype;
public static uint TokenFromRid(uint rid, CorTokenType tktype)
{
return(((uint)rid) | ((uint)tktype));
}
//
// Build / decompose tokens.
//
public static uint RidToToken(uint rid, CorTokenType tktype)
{
return(((uint)rid) | ((uint)tktype));
}
public static void Disassemble(byte[] ilCode, CorMetadataImport importer, out string[] lines, out int[] ip2line)
{
ArrayList ils = new ArrayList();
ip2line = new int[ilCode.Length];
int pc = 0;
while (pc < ilCode.Length)
{
string instruction = "";
int instruction_start = pc;
int opCodeSize;
ILOpCode opCode = DecodeOpcode(ilCode, pc, out opCodeSize);
pc += opCodeSize;
switch ((OpcodeFormat)GenTables.opCodeTypeInfo[(int)opCode].Type)
{
default:
Debug.Assert(false);
break;
case OpcodeFormat.InlineNone:
instruction = GenTables.opCodeTypeInfo[(int)opCode].Name;
break;
case OpcodeFormat.ShortInlineI:
case OpcodeFormat.ShortInlineVar:
{
byte arg = ilCode[pc];
pc++;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
arg });
break;
}
case OpcodeFormat.InlineVar:
{
Int16 arg = BitConverter.ToInt16(ilCode, pc);
pc += 2;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
arg });
break;
}
case OpcodeFormat.InlineI:
case OpcodeFormat.InlineRVA:
{
Int32 arg = BitConverter.ToInt32(ilCode, pc);
pc += 4;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
arg });
break;
}
case OpcodeFormat.InlineI8:
{
Int64 arg = BitConverter.ToInt64(ilCode, pc);
pc += 8;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
arg });
break;
}
case OpcodeFormat.ShortInlineR:
{
float arg = BitConverter.ToSingle(ilCode, pc);
pc += 4;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
arg });
break;
}
case OpcodeFormat.InlineR:
{
double arg = BitConverter.ToDouble(ilCode, pc);
pc += 8;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
arg });
break;
}
case OpcodeFormat.ShortInlineBrTarget:
{
sbyte offset = (sbyte)ilCode[pc];
pc++;
int dest = pc + offset;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} IL_{1,-4:X}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
dest });
break;
}
case OpcodeFormat.InlineBrTarget:
{
Int32 offset = BitConverter.ToInt32(ilCode, pc);
pc += 4;
int dest = pc + offset;
instruction = String.Format(CultureInfo.InvariantCulture, "{0} IL_{1,-4:X}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
dest });
break;
}
case OpcodeFormat.InlineSwitch:
case OpcodeFormat.InlinePhi:
instruction = "MESSED UP!";
// variable size
Debug.Assert(false);
break;
case OpcodeFormat.InlineString:
case OpcodeFormat.InlineField:
case OpcodeFormat.InlineType:
case OpcodeFormat.InlineToken:
case OpcodeFormat.InlineMethod:
{
int token = BitConverter.ToInt32(ilCode, pc);
pc += 4;
CorTokenType tokenType = TokenUtils.TypeFromToken(token);
// if it is reference token we need to dereference it.
string arg = null;
switch (tokenType)
{
default:
Debug.Assert(false);
break;
case CorTokenType.mdtTypeDef:
int extendsToken;
arg = importer.GetTypeNameFromDef(token, out extendsToken);
break;
case CorTokenType.mdtTypeRef:
arg = importer.GetTypeNameFromRef(token);
break;
case CorTokenType.mdtTypeSpec:
arg = "NYI";
break;
case CorTokenType.mdtMethodDef:
MethodInfo mi = importer.GetMethodInfo(token);
Type dt = mi.DeclaringType;
arg = (dt == null ? "" : dt.Name) + "." + mi.Name;
break;
case CorTokenType.mdtFieldDef:
arg = "NYI";
break;
case CorTokenType.mdtMemberRef:
arg = importer.GetMemberRefName(token);
break;
case CorTokenType.mdtString:
arg = "\"" + importer.GetUserString(token) + "\"";
break;
} // switch(tokenType)
instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[] { GenTables.opCodeTypeInfo[(int)opCode].Name,
arg });
break;
}
case OpcodeFormat.InlineSig:
instruction = GenTables.opCodeTypeInfo[(int)opCode].Name;
pc += 4;
break;
} // switch((OpcodeFormat)GenTables.opCodeTypeInfo[(int)opCode].Type)
ils.Add(String.Format(CultureInfo.InvariantCulture, "IL_{0,-4:X}: {1}", new Object[] { instruction_start, instruction }));
// add ip2line mapping
for (int i = instruction_start; i < pc; i++)
{
ip2line[i] = ils.Count - 1; // last line
}
} // while(pc<ilCode.Length)
lines = (string[])ils.ToArray(typeof(string));
return;
}
internal static int TokenFromRid(int rid, CorTokenType tktype)
{
// #define TokenFromRid(rid,tktype) ((rid) | (tktype))
return(rid | (int)tktype);
}
internal static int RidToToken(int rid, CorTokenType tktype)
{
// #define RidToToken(rid,tktype) ((rid) |= (tktype))
(rid) |= ((int)tktype);
return(rid);
}
public static IMetadataIterator Create(MetadataTables _tables, byte[] _data, uint _pos, CorTokenType _tokenType)
{
switch (_tokenType)
{
case CorTokenType.mdtAssembly:
return(new AssemblyIterator(_tables, _data, _pos));
case CorTokenType.mdtAssemblyOS:
return(new AssemblyOSIterator(_tables, _data, _pos));
case CorTokenType.mdtAssemblyProcessor:
return(new AssemblyProcessorIterator(_tables, _data, _pos));
case CorTokenType.mdtAssemblyRef:
return(new AssemblyRefIterator(_tables, _data, _pos));
case CorTokenType.mdtAssemblyRefOS:
return(new AssemblyRefOSIterator(_tables, _data, _pos));
case CorTokenType.mdtAssemblyRefProcessor:
return(new AssemblyRefProcessorIterator(_tables, _data, _pos));
case CorTokenType.mdtClassLayout:
return(new ClassLayoutIterator(_tables, _data, _pos));
case CorTokenType.mdtConstant:
return(new ConstantIterator(_tables, _data, _pos));
case CorTokenType.mdtCustomAttribute:
return(new CustomAttributeIterator(_tables, _data, _pos));
case CorTokenType.mdtDeclSecurity:
return(new DeclSecurityIterator(_tables, _data, _pos));
case CorTokenType.mdtEvent:
return(new EventIterator(_tables, _data, _pos));
case CorTokenType.mdtEventMap:
return(new EventMapIterator(_tables, _data, _pos));
case CorTokenType.mdtExportedType:
return(new ExportedTypeIterator(_tables, _data, _pos));
case CorTokenType.mdtFieldDef:
return(new FieldIterator(_tables, _data, _pos));
case CorTokenType.mdtFieldLayout:
return(new FieldLayoutIterator(_tables, _data, _pos));
case CorTokenType.mdtFieldMarshal:
return(new FieldMarshalIterator(_tables, _data, _pos));
case CorTokenType.mdtFieldRVA:
return(new FieldRVAIterator(_tables, _data, _pos));
case CorTokenType.mdtFile:
return(new FileIterator(_tables, _data, _pos));
case CorTokenType.mdtGenericParam:
return(new GenericParamIterator(_tables, _data, _pos));
case CorTokenType.mdtGenericParamConstraint:
return(new GenericParamConstraintIterator(_tables, _data, _pos));
case CorTokenType.mdtImplMap:
return(new ImplMapIterator(_tables, _data, _pos));
case CorTokenType.mdtInterfaceImpl:
return(new InterfaceImplIterator(_tables, _data, _pos));
case CorTokenType.mdtManifestResource:
return(new ManifestResourceIterator(_tables, _data, _pos));
case CorTokenType.mdtMemberRef:
return(new MemberRefIterator(_tables, _data, _pos));
case CorTokenType.mdtMethodDef:
return(new MethodDefIterator(_tables, _data, _pos));
case CorTokenType.mdtMethodImpl:
return(new MethodImplIterator(_tables, _data, _pos));
case CorTokenType.mdtMethodSemantics:
return(new MethodSemanticsIterator(_tables, _data, _pos));
case CorTokenType.mdtMethodSpec:
return(new MethodSpecIterator(_tables, _data, _pos));
case CorTokenType.mdtModule:
return(new ModuleIterator(_tables, _data, _pos));
case CorTokenType.mdtModuleRef:
return(new ModuleRefIterator(_tables, _data, _pos));
case CorTokenType.mdtNestedClass:
return(new NestedClassIterator(_tables, _data, _pos));
case CorTokenType.mdtParamDef:
return(new ParamIterator(_tables, _data, _pos));
case CorTokenType.mdtProperty:
return(new PropertyIterator(_tables, _data, _pos));
case CorTokenType.mdtPropertyMap:
return(new PropertyMapIterator(_tables, _data, _pos));
case CorTokenType.mdtSignature:
return(new StandAloneSigIterator(_tables, _data, _pos));
case CorTokenType.mdtTypeDef:
return(new TypeDefIterator(_tables, _data, _pos));
case CorTokenType.mdtTypeRef:
return(new TypeRefIterator(_tables, _data, _pos));
case CorTokenType.mdtTypeSpec:
return(new TypeSpecIterator(_tables, _data, _pos));
default:
return(new NullIterator(_tables, _data, _pos));
}
}
