Free-ebooks-library - Bahar Ali Khan

static Dictionary _opcodes = new Dictionary();
static Disassembler()
{
Dictionary opcodes = new Dictionary();
foreach (FieldInfo fi in typeof (OpCodes).GetFields
(BindingFlags.Public | BindingFlags.Static))
if (typeof (OpCode).IsAssignableFrom (fi.FieldType))
{
OpCode code = (OpCode) fi.GetValue (null); // Get field's value
if (code.OpCodeType != OpCodeType.Nternal)
_opcodes.Add (code.Value, code);
}
}
We’ve written it in a static constructor so that it executes just once.
Now we can write DisassembleNextInstruction. Each IL instruction consists of a 1or
2-byte opcode, followed by an operand of zero, one, two, four, or eight bytes. (An
exception is inline switch opcodes, which are followed by a variable number of operands).
So, we read the opcode, then the operand, and then write out the result:
void DisassembleNextInstruction()
{
int opStart = _pos;
OpCode code = ReadOpCode();
string operand = ReadOperand (code);
_output.AppendFormat ("IL_{0:X4}: {1,-12} {2}",
opStart, code.Name, operand);
_output.AppendLine();
}
To read an opcode, we advance one byte and see whether we have a valid instruction.
If not, we advance another byte and look for a 2-byte instruction:
OpCode ReadOpCode()
{
byte byteCode = _il [_pos++];
if (_opcodes.ContainsKey (byteCode)) return _opcodes [byteCode];
if (_pos == _il.Length) throw new Exception ("Unexpected end of IL");
short shortCode = (short) (byteCode * 256 + _il [_pos++]);
if (!_opcodes.ContainsKey (shortCode))
throw new Exception ("Cannot find opcode " + shortCode);
return _opcodes [shortCode];
}
To read an operand, we first must establish its length. We can do this based on the
operand type. Because most are four bytes long, we can filter out the exceptions
fairly easily in a conditional clause.
730 | Chapter 18: Reflection and Metadata