public List <string> FindProcedureUsages(int?id)
{
DecoderContext db = null;
try
{
db = new DecoderContext();
var decoder = db.Decoders.Find(id);
if (decoder != null)
{
var proceduresThatUseIt =
db.Decoders.Where(d => d.BlocklyDef.Contains("<mutation name=\"" + decoder.Name + "\">"))
.Select(d => d.Name)
.ToList();
return(proceduresThatUseIt);
}
else
{
throw new KeyNotFoundException();
}
}
finally
{
db?.Dispose();
}
}
public void HandleUpstream(IPipelineHandlerContext ctx, IPipelineMessage message)
{
if (message is Connected)
{
_context = new DecoderContext {
ParserMethod = ParseBeforeHeader
};
}
else if (message is Closed)
{
_context = null;
}
if (!(message is Received))
{
ctx.SendUpstream(message);
return;
}
var evt = (Received)message;
var buffer = evt.BufferSlice;
_logger.Trace("Pos: " + buffer.Position);
_context.Reader.Assign(buffer);
try
{
var canrun = true;
while (canrun)
{
_logger.Trace("Parsing using " + _context.ParserMethod.Method.Name);
canrun = _context.ParserMethod();
}
}
catch (Exception err)
{
_logger.Error("Failed to parse message.", err);
ctx.SendUpstream(new PipelineFailure(err));
return;
}
if (!_context.IsComplete)
{
//_leftOvers = Encoding.UTF8.GetString(buffer.Buffer, buffer.Offset, buffer.RemainingLength);
return; // Need more data from the channel
}
_context.ParserMethod = ParseBeforeHeader;
_logger.Debug("Got message " + _context.Message.Headers["Content-Type"]);
if (string.IsNullOrEmpty(_context.Message.Headers["Content-Type"]))
{
_logger.Warning("Malformed message\r\n" +
Encoding.ASCII.GetString(buffer.Buffer, buffer.StartOffset, buffer.Count));
Debugger.Break();
}
ctx.SendUpstream(new ReceivedMessage(_context.Message));
_context.Message = new Message();
}
public Decoder GetDecoder(Guid?id)
{
DecoderContext db = null;
try
{
var decoder = db.Decoders.Find(id);
return(decoder);
}
catch (Exception e)
{
throw;
}
finally
{
try
{
db?.Dispose();
}
catch (Exception e)
{
throw;
}
}
}
//private DecoderContext db = new DecoderContext();
public void AddDecoder(Decoder decoder)
{
DecoderContext db = null;
try
{
db = new DecoderContext();
decoder.SetCategoryAndTags();
db.Decoders.Add(decoder);
db.SaveChanges();
}
catch (Exception e)
{
throw;
}
finally
{
try
{
db?.Dispose();
}
catch (Exception e)
{
throw;
}
}
}
public void UpdateDecoder(Guid?id, string xml, string code)
{
DecoderContext db = null;
try
{
var decoder = db.Decoders.Find(id);
if (decoder != null)
{
decoder.Xml = xml;
decoder.Code = code;
decoder.SetCategoryAndTags();
db.SaveChanges();
}
else
{
throw new KeyNotFoundException();
}
}
catch (Exception e)
{
throw;
}
finally
{
try
{
db?.Dispose();
}
catch (Exception e)
{
throw;
}
}
}
public Dictionary <string, List <BlockInfos> > GetCategoryInfos()
{
DecoderContext db = null;
try
{
db = new DecoderContext();
/* Dictionary<string, List<BlockInfos>> categoryInfos = db.Decoders
* //.Select(d => new { d.Category, callInfos = new CallInfos(d.Id, d.Name, d.Parameters, d.Tags, d.Editable) })
* .GroupBy(d => d.Category, d => new BlockInfos(d.Id, d.Name, d.Parameters, d.Tags, d.Editable))
* .ToDictionary(g => g.Key, g => g.ToList());*/
var fromServer =
db.Decoders.Select(
d => new { d.Category, d.Id, d.Name, d.Parameters, d.Tags, d.Version, d.Editable }).ToList();
var categoryInfos =
fromServer.GroupBy(
d => d.Category,
d => new BlockInfos((int)d.Id, d.Name, d.Category, d.Parameters, d.Tags, d.Version, d.Editable))
.ToDictionary(d => d.Key, d => d.ToList());
return(categoryInfos);
}
finally
{
db?.Dispose();
}
}
/// <summary>
/// Decodes an instruction.
/// </summary>
/// <param name="code">X86 binary code.</param>
/// <param name="startIndex">Index of the first byte to start
/// decoding.</param>
/// <param name="context">Decoding context.</param>
/// <returns>The decoded instruction.</returns>
/// <exception cref="InvalidInstructionException">If decoding failed.
/// </exception>
public Instruction Decode(
byte[] code,
int startIndex,
int count,
DecoderContext context)
{
Instruction instruction = new Instruction();
// Create an instruction reader.
InstructionReader reader = new InstructionReader(code, startIndex, count);
// Reset the context.
context.AddressSize = CpuSize.Use16Bit;
context.OperandSize = CpuSize.Use16Bit;
context.SegmentOverride = Register.None;
// Decode prefixes.
Prefixes prefix = DecodeLegacyPrefixes(reader);
if ((prefix & Prefixes.OperandSizeOverride) != 0)
{
context.OperandSize = CpuSize.Use32Bit;
}
if ((prefix & Prefixes.AddressSizeOverride) != 0)
{
context.AddressSize = CpuSize.Use32Bit;
}
if ((prefix & Prefixes.Group2) != 0)
{
Register seg = Register.None;
switch (prefix & Prefixes.Group2)
{
case Prefixes.ES: seg = Register.ES; break;
case Prefixes.CS: seg = Register.CS; break;
case Prefixes.SS: seg = Register.SS; break;
case Prefixes.DS: seg = Register.DS; break;
case Prefixes.FS: seg = Register.FS; break;
case Prefixes.GS: seg = Register.GS; break;
}
context.SegmentOverride = seg;
}
instruction.Prefix = prefix;
// Decode the opcode to retrieve opcode specification.
Op spec = DecodeOpcode(reader);
instruction.Operation = spec.Operation;
// Decode operands.
instruction.Operands = new Operand[spec.Operands.Length];
for (int i = 0; i < spec.Operands.Length; i++)
{
instruction.Operands[i] =
DecodeOperand(spec.Operands[i], reader, context);
}
// Update the encoded length of the instruction.
instruction.EncodedLength = reader.Position;
//instruction.Location = location;
return instruction;
}
public void HandleUpstream(IPipelineHandlerContext ctx, IPipelineMessage message)
{
if (message is Connected)
{
_context = new DecoderContext {ParserMethod = ParseBeforeHeader};
}
else if (message is Closed)
{
_context = null;
}
if (!(message is Received))
{
ctx.SendUpstream(message);
return;
}
var evt = (Received) message;
var buffer = evt.BufferReader;
_logger.Trace("Pos: " + buffer.Position);
_context.Reader.Assign(buffer);
try
{
var canrun = true;
while (canrun)
{
_logger.Trace("Parsing using " + _context.ParserMethod.Method.Name);
canrun = _context.ParserMethod();
}
}
catch (Exception err)
{
_logger.Error("Failed to parse message.", err);
ctx.SendUpstream(new PipelineFailure(err));
return;
}
if (!_context.IsComplete)
{
//_leftOvers = Encoding.UTF8.GetString(buffer.Buffer, buffer.Offset, buffer.RemainingLength);
return; // Need more data from the channel
}
_context.ParserMethod = ParseBeforeHeader;
_logger.Debug("Got message " + _context.Message.Headers["Content-Type"]);
if (string.IsNullOrEmpty(_context.Message.Headers["Content-Type"]))
{
_logger.Warning("Malformed message\r\n" +
Encoding.ASCII.GetString(buffer.Buffer, buffer.StartOffset, buffer.Count));
Debugger.Break();
}
ctx.SendUpstream(new ReceivedMessage(_context.Message));
_context.Message = new Message();
}
public static T Decode <T>(DecoderContext context, RlpBehaviors rlpBehaviors = RlpBehaviors.None)
{
if (Decoders.ContainsKey(typeof(T)))
{
return(((IRlpDecoder <T>)Decoders[typeof(T)]).Decode(context, rlpBehaviors));
}
throw new RlpException($"{nameof(Rlp)} does not support decoding {typeof(T).Name}");
}
/// <summary>
/// Decodes an instruction.
/// </summary>
/// <param name="code">Code buffer.</param>
/// <param name="cpuMode">CPU operating mode.</param>
/// <returns>The decoded instruction.</returns>
/// <exception cref="InvalidInstructionException">If decoding fails.
/// </exception>
public static Instruction Decode(ArraySegment<byte> code, CpuMode cpuMode)
{
if (cpuMode != CpuMode.RealAddressMode)
throw new NotSupportedException();
DecoderContext context = new DecoderContext();
context.AddressSize = CpuSize.Use16Bit;
context.OperandSize = CpuSize.Use16Bit;
X86Codec.Decoder decoder = new X86Codec.Decoder();
return decoder.Decode(code.Array, code.Offset, code.Count, context);
}
public static T[] DecodeArray <T>(DecoderContext context, RlpBehaviors rlpBehaviors = RlpBehaviors.None)
{
if (Decoders.ContainsKey(typeof(T)))
{
IRlpDecoder <T> decoder = (IRlpDecoder <T>)Decoders[typeof(T)];
int checkPosition = context.ReadSequenceLength() + context.Position;
T[] result = new T[context.ReadNumberOfItemsRemaining(checkPosition)];
for (int i = 0; i < result.Length; i++)
{
result[i] = decoder.Decode(context, rlpBehaviors);
}
return(result);
}
throw new RlpException($"{nameof(Rlp)} does not support decoding {typeof(T).Name}");
}
// private DecoderContext db = new DecoderContext();
public int?AddDecoder(Decoder decoder)
{
DecoderContext db = null;
try
{
db = new DecoderContext();
decoder.UpdateFieldsFromXml();
db.Decoders.Add(decoder);
db.SaveChanges();
return(decoder.Id);
}
finally
{
db?.Dispose();
}
}
public bool UpdateDecoder(Decoder updatedDecoder)
{
DecoderContext db = null;
var mustRefreshToolbox = false;
try
{
db = new DecoderContext();
updatedDecoder.UpdateFieldsFromXml();
var decoder = db.Decoders.Find(updatedDecoder.Id);
if (decoder != null)
{
/*decoder.Name = updatedDecoder.Name;
* decoder.Version = updatedDecoder.Version;
* decoder.Category = updatedDecoder.Category;
* decoder.Tags = updatedDecoder.Tags;
* decoder.Xml = updatedDecoder.Xml;
* decoder.Code = updatedDecoder.Code;
* decoder.FrenchSpec = updatedDecoder.FrenchSpec;
* decoder.UpdateFieldsFromXml();*/
if (decoder.Name != updatedDecoder.Name || decoder.Version != updatedDecoder.Version ||
decoder.Category != updatedDecoder.Category ||
decoder.Parameters != updatedDecoder.Parameters || decoder.Tags != updatedDecoder.Tags ||
decoder.Editable != updatedDecoder.Editable)
{
mustRefreshToolbox = true;
}
//TODO DO NOT OVERRIDE CODE AND SPEC
db.Entry(decoder).CurrentValues.SetValues(updatedDecoder);
db.SaveChanges();
return(mustRefreshToolbox);
}
else
{
throw new KeyNotFoundException();
}
}
finally
{
db?.Dispose();
}
}
public IEnumerable <BlockInfos> GetAllBlockInfos()
{
DecoderContext db = null;
try
{
db = new DecoderContext();
var fromServer =
db.Decoders.ToList()
.Select(
d =>
new BlockInfos((int)d.Id, d.Name, d.Category, d.Parameters, d.Tags, d.Version, d.Editable));
return(fromServer);
}
finally
{
db?.Dispose();
}
}
public void HandleUpstream(IChannelHandlerContext ctx, IChannelEvent e)
{
if (e is ConnectedEvent)
{
ctx.State = new DecoderContext
{
ParserMethod = ParseBeforeHeader
};
}
else if (e is ClosedEvent)
{
ctx.State = null;
}
if (!(e is MessageEvent))
{
ctx.SendUpstream(e);
return;
}
var evt = e.As<MessageEvent>();
_context = ctx.State.As<DecoderContext>();
var buffer = evt.Message.As<BufferSlice>();
_context.Reader.Assign(buffer);
try
{
while (_context.ParserMethod()) ;
}
catch (Exception err)
{
ctx.SendUpstream(new ExceptionEvent(err));
return;
}
if (!_context.IsComplete)
return; // no more processing
evt.Message = _context.Message;
_context.ParserMethod = ParseBeforeHeader;
ctx.SendUpstream(evt);
_context.Message.Reset();
}
public static void ParseHeaders(Dictionary <string, string> headers, DecoderContext decoder)
{
decoder.Headers = "";
decoder.Referer = "";
decoder.UserAgent = "";
foreach (var hdr in headers)
{
if (hdr.Key.ToLower() == "user-agent")
{
decoder.UserAgent = hdr.Value;
}
else if (hdr.Key.ToLower() == "referer")
{
decoder.Referer = hdr.Value;
}
else
{
decoder.Headers += hdr.Key + ": " + hdr.Value + "\r\n";
}
}
}
public Decoder GetDecoder(int?id)
{
DecoderContext db = null;
try
{
db = new DecoderContext();
var decoder = db.Decoders.Find(id);
if (decoder != null)
{
return(decoder);
}
else
{
throw new KeyNotFoundException("L'ID envoyée ne correspond à aucun décodeur dans la base de donnée");
}
}
finally
{
db?.Dispose();
}
}
public void DeleteDecoder(int?id)
{
DecoderContext db = null;
try
{
db = new DecoderContext();
var decoder = db.Decoders.Find(id);
if (decoder != null)
{
db.Decoders.Remove(decoder);
db.SaveChanges();
}
else
{
throw new KeyNotFoundException("L'ID envoyée ne correspond à aucun décodeur dans la base de donnée");
}
}
finally
{
db?.Dispose();
}
}
private static Rlp[] ExtractRlpList(DecoderContext context)
{
List <Rlp> result = new List <Rlp>();
while (context.CurrentIndex < context.MaxIndex)
{
byte prefix = context.Pop();
byte[] lenghtBytes = null;
int concatenationLength;
if (prefix == 0)
{
result.Add(new Rlp(new byte[] { 0 }));
continue;
}
if (prefix < 128)
{
result.Add(new Rlp(new[] { prefix }));
continue;
}
if (prefix == 128)
{
result.Add(new Rlp(new byte[] { }));
continue;
}
if (prefix <= 183)
{
int length = prefix - 128;
byte[] content = context.Pop(length);
if (content.Length == 1 && content[0] < 128)
{
throw new RlpException($"Unexpected byte value {content[0]}");
}
result.Add(new Rlp(new[] { prefix }.Concat(content).ToArray()));
continue;
}
if (prefix <= 247)
{
concatenationLength = prefix - 192;
}
else
{
int lengthOfConcatenationLength = prefix - 247;
if (lengthOfConcatenationLength > 4)
{
// strange but needed to pass tests -seems that spec gives int64 length and tests int32 length
throw new RlpException("Expected length of lenth less or equal 4");
}
lenghtBytes = context.Pop(lengthOfConcatenationLength);
concatenationLength = DeserializeLength(lenghtBytes);
if (concatenationLength < 56)
{
throw new RlpException("Expected length greater or equal 56");
}
}
byte[] data = context.Pop(concatenationLength);
byte[] itemBytes = { prefix };
if (lenghtBytes != null)
{
itemBytes = itemBytes.Concat(lenghtBytes).ToArray();
}
result.Add(new Rlp(itemBytes.Concat(data).ToArray()));
}
return(result.ToArray());
}
/// <summary>
/// Decodes a register operand from the REG field of the ModR/M byte.
/// Since the REG field only contains the register number, additional
/// parameters are used to determine the register's type and size.
/// </summary>
/// <param name="reader">Instruction reader.</param>
/// <param name="registerType">Type of the register to return.</param>
/// <param name="operandSize">Size of the register to return.</param>
/// <param name="context">Decoding context.</param>
/// <returns>The decoded register operand.</returns>
private static RegisterOperand DecodeRegisterOperand(
InstructionReader reader,
RegisterType registerType,
CpuSize operandSize,
DecoderContext context)
{
if (context.CpuMode == CpuMode.X64Mode)
throw new NotSupportedException();
if (operandSize == CpuSize.Default)
throw new ArgumentException("operandSize is not specified.");
int reg = reader.GetModRM().REG;
if (registerType == RegisterType.General &&
operandSize == CpuSize.Use8Bit &&
reg >= 4)
{
return new RegisterOperand(new Register(
RegisterType.HighByte,
reg - 4,
CpuSize.Use8Bit));
}
return new RegisterOperand(new Register(registerType, reg, operandSize));
}
private void TestDecode(
byte[] image,
Pointer startAddress,
Pointer baseAddress)
{
DecoderContext options = new DecoderContext();
options.AddressSize = CpuSize.Use16Bit;
options.OperandSize = CpuSize.Use16Bit;
X86Codec.Decoder decoder = new X86Codec.Decoder();
Pointer ip = startAddress;
for (int index = startAddress - baseAddress; index < image.Length;)
{
Instruction instruction = null;
try
{
instruction = decoder.Decode(image, index, ip, options);
}
catch (InvalidInstructionException ex)
{
if (MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OKCancel)
== DialogResult.Cancel)
{
throw;
}
break;
}
#if false
// Output address.
StringBuilder sb = new StringBuilder();
sb.AppendFormat("0000:{0:X4} ", index - startAddress);
// Output binary code. */
for (int i = 0; i < 8; i++)
{
if (i < instruction.EncodedLength)
{
sb.AppendFormat("{0:x2} ", image[index + i]);
}
else
{
sb.Append(" ");
}
}
// Output the instruction.
string s = instruction.ToString();
if (s.StartsWith("*"))
{
throw new InvalidOperationException("Cannot format instruction.");
}
sb.Append(s);
System.Diagnostics.Debug.WriteLine(sb.ToString());
#else
DisplayInstruction(instruction);
#endif
index += instruction.EncodedLength;
ip += instruction.EncodedLength;
}
}
public List <Decoder> FindDescendants(int?id)
{
DecoderContext db = null;
try
{
db = new DecoderContext();
var decoder = db.Decoders.Find(id);
if (decoder != null)
{
var names = new List <string>();
var decoders = new List <Decoder> {
decoder
};
// names.AddRange(decoder.FindDescendants());
var firsts = decoder.FindDescendants();
foreach (var name in firsts)
{
if (!names.Exists(x => x == name))
{
names.Add(name);
}
}
for (var i = 0; i < names.Count; i++)
{
var curName = names[i];
var descendant = db.Decoders.Single(d => d.Name == curName);
var namesToAdd = descendant.FindDescendants();
foreach (var name in namesToAdd)
{
if (!names.Exists(x => x == name))
{
names.Add(name);
}
}
decoders.Add(descendant);
}
return(decoders);
/*var decoders = new List<Decoder>();
* foreach (var name in names)
* {
* decoders.Add(db.Decoders.Find(name));
* }
* return decoders;*/
}
else
{
throw new KeyNotFoundException();
}
}
finally
{
db?.Dispose();
}
}
// Note: we need to take into account OperandSizeOverride and
// AddressSizeOverride!!!!!!
/// <summary>
/// Decodes a memory operand encoded by the ModRM byte, SIB byte, and
/// Displacement, or a register operand if MOD=3 and registerType is
/// specified.
/// </summary>
/// <param name="reader">Instruction reader.</param>
/// <param name="registerType">Type of the register to return if the
/// Mod field of the ModR/M byte is 3. If this parameter is set to
/// RegisterType.None, an exception is thrown if Mod=3.</param>
/// <param name="operandSize">Size of the returned operand.</param>
/// <param name="context">Decoding context.</param>
/// <returns>The decoded memory or register operand.</returns>
/// <exception cref="InvalidInstructionException">If registerType is
/// set to None but the ModR/M byte encodes a register.</exception>
static Operand DecodeMemoryOperand(
InstructionReader reader,
RegisterType registerType,
CpuSize operandSize,
DecoderContext context)
{
if (context.CpuMode == CpuMode.X64Mode)
throw new NotSupportedException();
//if (operandSize == CpuSize.Default)
// throw new ArgumentException("operandSize is not specified.");
if (context.AddressSize != CpuSize.Use16Bit)
throw new NotSupportedException("32-bit addressing mode is not supported.");
ModRM modrm = reader.GetModRM();
int rm = modrm.RM;
int mod = modrm.MOD;
// Decode a register if MOD = (11).
if (mod == 3)
{
// If the instruction expects a memory operand, throw an exception.
if (registerType == RegisterType.None)
{
throw new InvalidInstructionException(
"The instruction expects a memory operand, but the ModR/M byte encodes a register.");
}
// Treat AH-DH specially.
if (registerType == RegisterType.General &&
operandSize == CpuSize.Use8Bit &&
rm >= 4)
{
return new RegisterOperand(new Register(
RegisterType.HighByte,
rm - 4,
CpuSize.Use8Bit));
}
else
{
return new RegisterOperand(new Register(registerType, rm, operandSize));
}
}
// Take into account segment override prefix if present.
Register segment = context.SegmentOverride;
// Special treatment for MOD = (00) and RM = (110).
// This encodes a 16-bit sign-extended displacement.
if (mod == 0 && rm == 6)
{
return new MemoryOperand
{
Size = operandSize,
Segment = segment,
Displacement = reader.ReadImmediate(CpuSize.Use16Bit)
};
}
/* Decode an indirect memory address XX[+YY][+disp]. */
MemoryOperand mem = new MemoryOperand();
mem.Size = operandSize;
mem.Segment = segment;
switch (rm)
{
case 0: /* [BX+SI] */
mem.Base = Register.BX;
mem.Index = Register.SI;
break;
case 1: /* [BX+DI] */
mem.Base = Register.BX;
mem.Index = Register.DI;
break;
case 2: /* [BP+SI] */
mem.Base = Register.BP;
mem.Index = Register.SI;
break;
case 3: /* [BP+DI] */
mem.Base = Register.BP;
mem.Index = Register.DI;
break;
case 4: /* [SI] */
mem.Base = Register.SI;
break;
case 5: /* [DI] */
mem.Base = Register.DI;
break;
case 6: /* [BP] */
mem.Base = Register.BP;
break;
case 7: /* [BX] */
mem.Base = Register.BX;
break;
}
if (mod == 1) /* disp8, sign-extended */
{
mem.Displacement = reader.ReadImmediate(CpuSize.Use8Bit);
}
else if (mod == 2) /* disp16, sign-extended */
{
mem.Displacement = reader.ReadImmediate(CpuSize.Use16Bit);
}
return mem;
}
static Operand DecodeOperand(O spec,
InstructionReader reader, DecoderContext context)
{
int number;
CpuSize size;
switch (spec)
{
case O.Imm0:
case O.Imm1:
case O.Imm2:
case O.Imm3:
return new ImmediateOperand(spec - O.Imm0, CpuSize.Use8Bit);
case O.ES:
case O.CS:
case O.SS:
case O.DS:
return CreateRegisterOperand(
RegisterType.Segment,
spec - O.ES,
CpuSize.Use16Bit);
case O.AL:
case O.CL:
case O.DL:
case O.BL:
return CreateRegisterOperand(
RegisterType.General,
spec - O.AL,
CpuSize.Use8Bit);
case O.AH:
case O.CH:
case O.DH:
case O.BH:
return CreateRegisterOperand(
RegisterType.HighByte,
spec - O.AH,
CpuSize.Use8Bit);
case O.AX:
case O.CX:
case O.DX:
case O.BX:
case O.SP:
case O.BP:
case O.SI:
case O.DI:
return CreateRegisterOperand(
RegisterType.General,
spec - O.AX,
CpuSize.Use16Bit);
case O.eAX:
case O.eCX:
case O.eDX:
case O.eBX:
case O.eSP:
case O.eBP:
case O.eSI:
case O.eDI:
number = spec - O.eAX;
size = (context.OperandSize == CpuSize.Use16Bit) ?
CpuSize.Use16Bit : CpuSize.Use32Bit;
return CreateRegisterOperand(RegisterType.General, number, size);
case O.rAX:
case O.rCX:
case O.rDX:
case O.rBX:
case O.rSP:
case O.rBP:
case O.rSI:
case O.rDI:
number = spec - O.rAX;
return CreateRegisterOperand(RegisterType.General, number, context.OperandSize);
case O.ST0:
return new RegisterOperand(Register.ST0);
case O.Ap: // off:seg encoded in the instruction
if (context.OperandSize != CpuSize.Use16Bit)
{
throw new NotSupportedException();
}
else
{
var off = reader.ReadImmediate(CpuSize.Use16Bit);
var seg = reader.ReadImmediate(CpuSize.Use16Bit);
return new PointerOperand(
new Operand.LocationAware<UInt16>(seg.Location, (UInt16)seg.Value),
new Operand.LocationAware<UInt32>(off.Location, (UInt16)off.Value));
}
case O.Eb: // r/m; 8-bit
return DecodeMemoryOperand(reader, RegisterType.General, CpuSize.Use8Bit, context);
case O.Ep: // r/m; contains far ptr
if (context.OperandSize != CpuSize.Use16Bit)
throw new NotSupportedException();
// TBD: operand size? address size?
return DecodeMemoryOperand(reader, RegisterType.General, CpuSize.Use16Bit, context);
case O.Ev: // r/m; 16, 32, or 64 bit
return DecodeMemoryOperand(reader, RegisterType.General, context.OperandSize, context);
case O.Ew: // r/m; 16-bit
return DecodeMemoryOperand(reader, RegisterType.General, CpuSize.Use16Bit, context);
case O.Fv: // FLAGS/EFLAGS/RFLAGS
return new RegisterOperand(Register.FLAGS.Resize(context.OperandSize));
case O.Gb: // general-purpose register; byte
return DecodeRegisterOperand(reader, RegisterType.General, CpuSize.Use8Bit, context);
case O.Gv: // general-purpose register; 16, 32, or 64 bit
return DecodeRegisterOperand(reader, RegisterType.General, context.OperandSize, context);
case O.Gw: // general-purpose register; 16-bit
return DecodeRegisterOperand(reader, RegisterType.General, CpuSize.Use16Bit, context);
case O.Gz: // general-purpose register; 16 or 32 bit
return DecodeRegisterOperand(
reader,
RegisterType.General,
context.OperandSize == CpuSize.Use16Bit ? CpuSize.Use16Bit : CpuSize.Use32Bit,
context);
case O.Ib: // immediate; byte
return DecodeImmediateOperand(reader, CpuSize.Use8Bit);
case O.Iw: // immediate; 16 bit
return DecodeImmediateOperand(reader, CpuSize.Use16Bit);
case O.Iv: // immediate, 16, 32, or 64 bit
return DecodeImmediateOperand(reader, context.OperandSize);
case O.Iz: // immediate, 16 or 32 bit
return DecodeImmediateOperand(reader,
(context.OperandSize == CpuSize.Use16Bit) ?
CpuSize.Use16Bit : CpuSize.Use32Bit);
case O.Jb: // immediate encodes relative offset; byte
return DecodeRelativeOperand(reader, CpuSize.Use8Bit);
case O.Jz: // immediate encodes relative offset; 16 or 32 bit
return DecodeRelativeOperand(reader,
(context.OperandSize == CpuSize.Use16Bit) ?
CpuSize.Use16Bit : CpuSize.Use32Bit);
case O.M_: // r/m must refer to memory; contains void pointer
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Default, context);
case O.Ma: // r/m must refer to memory; contains a pair of words or dwords
// TODO: handle 32-bit
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use32Bit, context);
case O.Mp: // r/m must refer to memory; contains far pointer
// seg:ptr of 32, 48, or 80 bits.
if (context.OperandSize != CpuSize.Use16Bit)
throw new NotSupportedException();
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use32Bit, context);
case O.Mb: // r/m refers to memory; byte
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use8Bit, context);
case O.Mw: // r/m refers to memory; word
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use16Bit, context);
case O.Md: // r/m refers to memory; dword
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use32Bit, context);
case O.Mq:
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use64Bit, context);
case O.M14or28b: // r/m refers to memory; 14 or 28 bytes
// TODO: we actually need to check the CPU operation mode,
// not the operand-size attribute.
return DecodeMemoryOperand(
reader,
RegisterType.None,
(context.OperandSize == CpuSize.Use16Bit) ?
CpuSize.Use14Bytes : CpuSize.Use28Bytes,
context);
case O.M32fp: // r/m refers to memory; single-precision float
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use32Bit, context);
case O.M64fp: // r/m refers to memory; double-precision float
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use64Bit, context);
case O.M80fp: // r/m refers to memory; extended-precision float
return DecodeMemoryOperand(reader, RegisterType.None, CpuSize.Use80Bit, context);
case O.Ob: // absolute address (w/o segment); byte
// TODO: check 64-bit mode behavior
return new MemoryOperand
{
Size = CpuSize.Use8Bit,
Displacement = reader.ReadImmediate(context.AddressSize),
// Segment = Register.DS,
};
case O.Ov: // absolute address (w/o segment); 16, 32, or 64 bit
// TODO: check 64-bit mode behavior
return new MemoryOperand
{
Size = context.OperandSize,
Displacement = reader.ReadImmediate(context.AddressSize),
// Segment = Register.DS,
};
case O.Sw: // REG(modrm) selects segment register
return DecodeRegisterOperand(reader, RegisterType.Segment, CpuSize.Use16Bit, context);
case O.T80fp: // r/m selects x87 FPU register ST0-ST7
return CreateRegisterOperand(RegisterType.Fpu, reader.GetModRM().RM, CpuSize.Use80Bit);
case O.Xb: // memory addressed by DS:rSI; byte
return new MemoryOperand
{
Size = CpuSize.Use8Bit,
Segment = Register.DS,
Base = Register.SI.Resize(context.AddressSize)
};
case O.Xv: // memory addressed by DS:rSI; 16, 32, or 64 bit
return new MemoryOperand
{
Size = context.OperandSize,
Segment = Register.DS,
Base = Register.SI.Resize(context.AddressSize)
};
case O.Xz: // memory addressed by DS:rSI; 16 or 32 bit
return new MemoryOperand
{
Size = CpuSize.Use16Bit, // TODO: handle 32 bit
Segment = Register.DS,
Base = Register.SI.Resize(context.AddressSize)
};
case O.Yb: // memory addressed by ES:rDI; byte
return new MemoryOperand
{
Size = CpuSize.Use8Bit,
Segment = Register.ES,
Base = Register.DI.Resize(context.AddressSize)
};
case O.Yv: // memory addressed by ES:rDI; 16, 32, or 64 bit
return new MemoryOperand
{
Size = context.OperandSize,
Segment = Register.ES,
Base = Register.DI.Resize(context.AddressSize)
};
case O.Yz: // memory addressed by ES:rDI; 16 or 32 bit
return new MemoryOperand
{
Size = CpuSize.Use16Bit, // TODO: handle 32 bit
Segment = Register.ES,
Base = Register.DI.Resize(context.AddressSize)
};
case O._XLAT:
return new MemoryOperand
{
Size = CpuSize.Use8Bit,
Segment = context.SegmentOverride,
Base = (context.AddressSize == CpuSize.Use16Bit) ?
Register.BX : Register.EBX
};
default:
throw new NotImplementedException(
"DecodeOperand() is not implemented for operand type " + spec.ToString());
}
}
unsafe public void UseContext(DecoderContext ctx)
{
this.ctx = ctx;
timebase_den = ctx.CodecCtx->time_base.den;
}
private void TestDecode(
byte[] image,
Pointer startAddress,
Pointer baseAddress)
{
DecoderContext options = new DecoderContext();
options.AddressSize = CpuSize.Use16Bit;
options.OperandSize = CpuSize.Use16Bit;
X86Codec.Decoder decoder = new X86Codec.Decoder();
Pointer ip = startAddress;
for (int index = startAddress - baseAddress; index < image.Length; )
{
Instruction instruction = null;
try
{
instruction = decoder.Decode(image, index, ip, options);
}
catch (InvalidInstructionException ex)
{
if (MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OKCancel)
== DialogResult.Cancel)
{
throw;
}
break;
}
#if false
// Output address.
StringBuilder sb = new StringBuilder();
sb.AppendFormat("0000:{0:X4} ", index - startAddress);
// Output binary code. */
for (int i = 0; i < 8; i++)
{
if (i < instruction.EncodedLength)
sb.AppendFormat("{0:x2} ", image[index + i]);
else
sb.Append(" ");
}
// Output the instruction.
string s = instruction.ToString();
if (s.StartsWith("*"))
throw new InvalidOperationException("Cannot format instruction.");
sb.Append(s);
System.Diagnostics.Debug.WriteLine(sb.ToString());
#else
DisplayInstruction(instruction);
#endif
index += instruction.EncodedLength;
ip += instruction.EncodedLength;
}
}
public MessageDecoder()
{
_context = new DecoderContext {
ParserMethod = ParseBeforeHeader
};
}
public void UseContext(DecoderContext ctx)
{
this.ctx = ctx;
}
public MessageDecoder()
{
_context = new DecoderContext {ParserMethod = ParseBeforeHeader};
}
