/// <summary>
/// Write register mask. Bits are:
/// 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
/// d0 d1 d2 d3 d4 d5 d6 d7 a0 a1 a2 a3 a4 a5 a6 a7
/// </summary>
/// <param name="data"></param>
/// <param name="bitPos"></param>
/// <param name="incr"></param>
/// <param name="regType"></param>
/// <param name="writer"></param>
public void WriteRegisterSet(uint data, MachineInstructionWriter writer)
{
string sep = "";
int maxReg = this.Width.Domain == Domain.Real ? 8 : 16;
int bitPos = maxReg - 1;
for (int i = 0; i < maxReg; i++, --bitPos)
{
if (bit(data, bitPos))
{
int first = i;
int run_length = 0;
while (i != 7 && i != 15 && bit(data, bitPos - 1))
{
--bitPos;
++i;
++run_length;
}
writer.Write(sep);
writer.Write(GetRegister(first).ToString());
if (run_length > 0)
{
writer.Write("-{0}", GetRegister(first + run_length));
}
sep = "/";
}
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write("#");
long imm8 = Value.ToInt64();
if (imm8 > 256 && ((imm8 & (imm8 - 1)) == 0))
{
/* only one bit set, and that later than bit 8.
* Represent as 1<<... .
*/
writer.Write("1<<");
uint n = 0;
while ((imm8 & 0xF) == 0)
{
n += 4; imm8 = imm8 >> 4;
}
// Now imm8 is 1, 2, 4 or 8.
n += (uint)((0x30002010 >> (int)(4 * (imm8 - 1))) & 15);
writer.Write(n);
}
else
{
if (imm8 < 0 && imm8 > -100)
{
writer.Write('-'); imm8 = -imm8;
}
writer.Write("&{0:X}", imm8);
}
}
/// <summary>
/// Write register mask. Bits are:
/// 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
/// d0 d1 d2 d3 d4 d5 d6 d7 a0 a1 a2 a3 a4 a5 a6 a7
/// </summary>
/// <param name="data"></param>
/// <param name="bitPos"></param>
/// <param name="incr"></param>
/// <param name="regType"></param>
/// <param name="writer"></param>
public void WriteRegisterSet(uint data, MachineInstructionWriter writer)
{
string sep = "";
int bitPos = 15;
for (int i = 0; i < 16; i++, --bitPos)
{
if (bit(data, bitPos))
{
int first = i;
int run_length = 0;
while (i != 7 && i != 15 && bit(data, bitPos - 1))
{
--bitPos;
++i;
++run_length;
}
writer.Write(sep);
writer.Write(Registers.GetRegister(first).ToString());
if (run_length > 0)
{
writer.Write("-{0}", Registers.GetRegister(first + run_length));
}
sep = "/";
}
}
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
var s = FormatValue(value);
var pt = value.DataType as PrimitiveType;
if (pt != null)
{
if (pt.Domain == Domain.Pointer)
{
writer.WriteAddress(s, Address.FromConstant(value));
}
else
{
writer.Write(s);
}
}
else if (value.DataType is Pointer)
{
writer.WriteAddress(s, Address.FromConstant(value));
}
else
{
writer.Write(s);
}
}
public void Write(MachineOperand op, MachineInstructionWriter writer)
{
var imm = op as ImmediateOperand;
if (imm != null)
{
writer.Write("#");
int imm8 = imm.Value.ToInt32();
if (imm8 > 256 && ((imm8 & (imm8 - 1)) == 0))
{
/* only one bit set, and that later than bit 8.
* Represent as 1<<... .
*/
writer.Write("1<<");
{
uint n = 0;
while ((imm8 & 15) == 0)
{
n += 4; imm8 = imm8 >> 4;
}
// Now imm8 is 1, 2, 4 or 8.
n += (uint)((0x30002010 >> (int)(4 * (imm8 - 1))) & 15);
writer.Write(n);
}
}
else
{
var fmt = (-9 <= imm8 && imm8 <= 9) ? "{0}{1}" : "&{0}{1:X}";
var sign = "";
if (((int)imm8) < 0 && ((int)imm8) > -100)
{
imm8 = -imm8;
sign = "-";
}
writer.Write(fmt,sign,imm8);
}
return;
}
var adr = op as AddressOperand;
if (adr != null)
{
adr.Write(false, writer);
return;
}
var mem = op as ArmMemoryOperand;
if (mem != null)
{
mem.Write(false, writer);
return;
}
var sh = op as ShiftOperand;
if (sh != null)
{
sh.Write(false, writer);
return;
}
if (op == null)
writer.Write("<null>");
else
op.Write(false, writer);
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
if (Base != null)
{
if (Offset != null)
{
int offset = Offset.ToInt32();
string fmt;
if (offset > 0)
{
fmt = "({0}+{1:X2})";
}
else if (offset < 0)
{
offset = -offset;
fmt = "({0}-{1:X2})";
}
else
{
fmt = "({0})";
}
writer.Write(string.Format(fmt, Base, offset));
}
else
{
writer.Write(string.Format("({0})", Base));
}
}
else
{
writer.Write("(");
writer.WriteAddress(string.Format("{0:X4}", Offset.ToUInt16()), Address.Ptr16(Offset.ToUInt16()));
writer.Write(")");
}
}
private void Write(MachineOperand op, MachineInstructionWriter writer)
{
var reg = op as RegisterOperand;
if (reg != null)
{
writer.Write("%{0}", reg.Register.Name);
return;
}
var imm = op as ImmediateOperand;
if (imm != null)
{
writer.Write(imm.Value.ToString());
return;
}
var mem = op as MemoryOperand;
if (mem != null)
{
mem.Write(false, writer);
return;
}
var idx = op as IndexedMemoryOperand;
if (idx != null)
{
idx.Write(false, writer);
return;
}
writer.Write(op.ToString());
}
public override void Render(MachineInstructionWriter writer)
{
if (code == Opcode.illegal && op1 != null && writer.Platform != null)
{
var imm = op1 as M68kImmediateOperand;
// MacOS uses invalid opcodes to invoke Macintosh Toolbox services.
// We may have to generalize the Platform API to allow specifying
// the opcode of the invoking instruction, to disambiguate from
// "legitimate" TRAP calls.
var svc = writer.Platform.FindService((int)imm.Constant.ToUInt32(), null);
if (svc != null)
{
writer.Write(svc.Name);
return;
}
}
if (dataWidth != null)
{
writer.WriteOpcode(string.Format("{0}{1}", code, DataSizeSuffix(dataWidth)));
}
else
{
writer.WriteOpcode(code.ToString());
}
writer.Tab();
if (op1 != null)
{
op1.Write(false, writer);
if (op2 != null)
{
writer.Write(',');
op2.Write(false, writer);
}
}
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
var op = string.Format("{0}{1}",
opcode,
setsCR0 ? "." : "");
writer.WriteOpcode(op);
if (op1 != null)
{
writer.Tab();
op1.Write(writer, options);
if (op2 != null)
{
writer.Write(',');
op2.Write(writer, options);
if (op3 != null)
{
writer.Write(',');
op3.Write(writer, options);
if (op4 != null)
{
writer.Write(",");
op4.Write(writer, options);
if (op5 != null)
{
writer.Write(",");
op5.Write(writer, options);
}
}
}
}
}
}
private void WriteImmShift(string op, int value, MachineInstructionWriter writer)
{
writer.Write(",");
writer.WriteOpcode(op);
writer.Write(" #");
WriteImmediateValue(value, writer);
}
private void WriteRegShift(string op, int value, MachineInstructionWriter writer)
{
writer.Write(",");
writer.WriteOpcode(op);
writer.Write(' ');
writer.Write(A32Registers.RegisterByCapstoneID[(ArmRegister)value].Name);
}
private static void WriteImmediateValue(long imm, MachineInstructionWriter writer)
{
writer.Write("#");
if (imm > 256 && ((imm & (imm - 1)) == 0))
{
/* only one bit set, and that later than bit 8.
* Represent as 1<<... .
*/
writer.Write("1<<");
uint n = 0;
while ((imm & 0xF) == 0)
{
n += 4; imm = imm >> 4;
}
// Now imm8 is 1, 2, 4 or 8.
n += (uint)((0x30002010 >> (int)(4 * (imm - 1))) & 15);
writer.Write(n);
}
else
{
if (imm < 0 && imm > -100)
{
writer.Write('-'); imm = -imm;
}
writer.Write("&{0:X}", imm);
}
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
string name;
if (!opcodeNames.TryGetValue(opcode, out name))
{
name = opcode.ToString();
}
writer.WriteOpcode(name);
if (op1 == null)
{
return;
}
writer.Tab();
WriteOp(op1, writer);
if (op2 == null)
{
return;
}
writer.Write(',');
WriteOp(op2, writer);
if (op3 == null)
{
return;
}
writer.Write(',');
WriteOp(op3, writer);
if (op4 == null)
{
return;
}
writer.Write(',');
WriteOp(op4, writer);
}
private void WriteOp(MachineOperand op, MachineInstructionWriter writer)
{
var rop = op as RegisterOperand;
if (rop != null)
{
writer.Write(rop.Register.Name);
return;
}
var immop = op as ImmediateOperand;
if (immop != null)
{
writer.Write(immop.Value.ToString());
return;
}
var addrop = op as AddressOperand;
if (addrop != null)
{
//$TODO: 32-bit?
writer.WriteAddress(string.Format("{0:X16}", addrop.Address.ToLinear()), addrop.Address);
return;
}
throw new NotImplementedException();
}
private static void WriteImmediateValue(int imm8, MachineInstructionWriter writer)
{
if (imm8 > 256 && ((imm8 & (imm8 - 1)) == 0))
{
/* only one bit set, and that later than bit 8.
* Represent as 1<<... .
*/
writer.Write("1<<");
{
uint n = 0;
while ((imm8 & 15) == 0)
{
n += 4; imm8 = imm8 >> 4;
}
// Now imm8 is 1, 2, 4 or 8.
n += (uint)((0x30002010 >> (int)(4 * (imm8 - 1))) & 15);
writer.Write(n);
}
}
else
{
var fmt = (-9 <= imm8 && imm8 <= 9) ? "{0}{1}" : "&{0}{1:X}";
var sign = "";
if (((int)imm8) < 0 && ((int)imm8) > -100)
{
imm8 = -imm8;
sign = "-";
}
writer.Write(fmt, sign, imm8);
}
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(string.Format("{0}{1}{2}",
Opcode,
Cond != Condition.al ? Cond.ToString() : "",
OpFlags != OpFlags.None ? OpFlags.ToString().ToLower() : ""));
if (Dst != null)
{
writer.Tab();
Write(Dst, writer);
if (Update)
{
writer.Write("!");
}
if (Src1 != null)
{
writer.Write(",");
Write(Src1, writer);
if (Src2 != null)
{
writer.Write(",");
Write(Src2, writer);
if (Src3 != null)
{
writer.Write(",");
Write(Src3, writer);
}
}
}
}
}
private void Write(MachineOperand op, MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
var memOp = op as MemoryOperand;
if (memOp != null)
{
if (memOp.Base == Registers.rip)
{
var addr = this.Address + this.Length + memOp.Offset.ToInt32();
if ((options & MachineInstructionWriterOptions.ResolvePcRelativeAddress) != 0)
{
writer.Write("[");
writer.WriteAddress(addr.ToString(), addr);
writer.Write("]");
writer.AddAnnotation(op.ToString());
}
else
{
op.Write(writer, options);
writer.AddAnnotation(addr.ToString());
}
return;
}
}
op.Write(writer, options);
}
private void Write(Arm64InstructionOperand op, MachineInstructionWriter writer)
{
switch (op.Type)
{
case Arm64InstructionOperandType.Register:
writer.Write(A64Registers.RegisterByCapstoneID[op.RegisterValue.Value].Name);
return;
case Arm64InstructionOperandType.Immediate:
if (IsJump())
{
writer.Write("${0:X16}", op.ImmediateValue.Value);
}
else
{
WriteImmediateValue(op.ImmediateValue.Value, writer);
if (op.Shifter != null)
{
this.WriteShift(op, writer);
}
}
return;
}
throw new NotImplementedException(op.Type.ToString());
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteOpcode(instruction.Mnemonic);
var ops = Internal.ArchitectureDetail.Operands;
if (ops.Length < 1)
{
return;
}
writer.Tab();
Write(ops[0], writer);
if (ops.Length < 2)
{
return;
}
writer.Write(",");
Write(ops[1], writer);
if (ops.Length < 3)
{
return;
}
writer.Write(",");
Write(ops[2], writer);
if (ops.Length < 4)
{
return;
}
writer.Write(",");
Write(ops[3], writer);
}
public override void Render(MachineInstructionWriter writer)
{
writer.Write("{0} ", Address.ToLinear());
bool inString = false;
for (int i = 0; i < Line.Length; ++i)
{
int b = Line[i];
if (inString)
{
writer.Write(Encoding.UTF8.GetString(Line, i, 1));
inString = (b != 0x22);
}
else
{
if (TokenMin <= b && b < TokenMax)
{
writer.Write(TokenStrs[b - TokenMin]);
}
else
{
writer.Write(Encoding.UTF8.GetString(Line, i, 1));
}
inString = (b == 0x22);
}
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
if (Base != null)
{
if (Offset != null)
{
int offset = Offset.ToInt32();
string fmt;
if (offset > 0)
{
fmt = "({0}+{1:X2})";
}
else if (offset < 0)
{
offset = -offset;
fmt = "({0}-{1:X2})";
}
else
{
fmt = "({0})";
}
writer.Write(string.Format(fmt, Base, offset));
}
else
{
writer.Write(string.Format("({0})", Base));
}
}
else
{
writer.Write("(");
writer.WriteAddress(string.Format("{0:X4}", Offset.ToUInt16()), Address.Ptr16(Offset.ToUInt16()));
writer.Write(")");
}
}
public override void Render(MachineInstructionWriter writer)
{
writer.Write("{0} ", Address.ToLinear());
bool inString = false;
for (int i = 0; i < Line.Length; ++i)
{
int b = Line[i];
if (inString)
{
writer.Write(Encoding.UTF8.GetString(Line, i, 1));
inString = (b != 0x22);
}
else
{
if (TokenMin <= b && b < TokenMax)
{
writer.Write(TokenStrs[b - TokenMin]);
}
else
{
writer.Write(Encoding.UTF8.GetString(Line, i, 1));
}
inString = (b == 0x22);
}
}
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
string name;
if (!instrNames.TryGetValue(opcode, out name))
{
name = opcode.ToString();
}
writer.WriteOpcode(name);
if (op1 != null)
{
writer.Tab();
op1.Write(writer, options);
if (op2 != null)
{
writer.Write(',');
op2.Write(writer, options);
if (op3 != null)
{
writer.Write(',');
op3.Write(writer, options);
}
}
}
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteOpcode(this.Opcode.ToString());
writer.Tab();
bool sep = false;
foreach (var op in Operands)
{
if (sep)
writer.Write(',');
sep = true;
if (op is ImmediateOperand)
{
writer.Write('#');
op.Write(writer, options);
}
else if (op is MemoryOperand && ((MemoryOperand)op).Base == Registers.pc)
{
var addr = this.Address + (this.Length + ((MemoryOperand)op).Offset.ToInt32());
if ((options & MachineInstructionWriterOptions.ResolvePcRelativeAddress) != 0)
{
writer.WriteAddress(addr.ToString(), addr);
writer.AddAnnotation(op.ToString());
}
else
{
op.Write(writer, options);
writer.AddAnnotation(addr.ToString());
}
}
else
{
op.Write(writer, options);
}
}
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
if (code == Opcode.illegal && op1 != null && writer.Platform != null)
{
var imm = op1 as M68kImmediateOperand;
// MacOS uses invalid opcodes to invoke Macintosh Toolbox services.
// We may have to generalize the Platform API to allow specifying
// the opcode of the invoking instruction, to disambiguate from
// "legitimate" TRAP calls.
var svc = writer.Platform.FindService((int)imm.Constant.ToUInt32(), null);
if (svc != null)
{
writer.Write(svc.Name);
return;
}
}
if (dataWidth != null)
{
writer.WriteOpcode(string.Format("{0}{1}", code, DataSizeSuffix(dataWidth)));
}
else
{
writer.WriteOpcode(code.ToString());
}
writer.Tab();
if (op1 != null)
{
WriteOperand(op1, writer, options);
if (op2 != null)
{
writer.Write(',');
WriteOperand(op2, writer, options);
}
}
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(string.Format("{0}{1}{2}",
Opcode,
Cond != Condition.al ? Cond.ToString() : "",
OpFlags != OpFlags.None ? OpFlags.ToString().ToLower() : ""));
if (Dst != null)
{
writer.Tab();
Write(Dst, writer);
if (Update) writer.Write("!");
if (Src1 != null)
{
writer.Write(",");
Write(Src1, writer);
if (Src2 != null)
{
writer.Write(",");
Write(Src2, writer);
if (Src3 != null)
{
writer.Write(",");
Write(Src3, writer);
}
}
}
}
}
private void Write(MachineOperand op, MachineInstructionWriter writer)
{
var reg = op as RegisterOperand;
if (reg != null)
{
writer.Write("%{0}", reg.Register.Name);
return;
}
var imm = op as ImmediateOperand;
if (imm != null)
{
writer.Write(imm.Value.ToString());
return;
}
var mem = op as MemoryOperand;
if (mem != null)
{
mem.Write(false, writer);
return;
}
var idx = op as IndexedMemoryOperand;
if (idx != null)
{
idx.Write(false, writer);
return;
}
writer.Write(op.ToString());
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write("#");
long imm8 = Value.ToInt64();
if (imm8 > 256 && ((imm8 & (imm8 - 1)) == 0))
{
/* only one bit set, and that later than bit 8.
* Represent as 1<<... .
*/
writer.Write("1<<");
uint n = 0;
while ((imm8 & 0xF) == 0)
{
n += 4; imm8 = imm8 >> 4;
}
// Now imm8 is 1, 2, 4 or 8.
n += (uint)((0x30002010 >> (int)(4 * (imm8 - 1))) & 15);
writer.Write(n);
}
else
{
if (imm8 < 0 && imm8 > -100)
{
writer.Write('-'); imm8 = -imm8;
}
writer.Write("&{0:X}", imm8);
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
Operand.Write(fExplicit, writer);
writer.Write(",");
writer.WriteOpcode(Opcode.ToString());
writer.Write(' ');
Shift.Write(fExplicit, writer);
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
Operand.Write(fExplicit, writer);
writer.Write(",");
writer.WriteOpcode(Opcode.ToString());
writer.Write(' ');
Shift.Write(fExplicit, writer);
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.Write("[%{0}", Base.Name);
if (!Offset.IsNegative)
{
writer.Write("+");
}
writer.Write(Offset.ToString());
writer.Write("]");
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write("[%{0}", Base.Name);
if (!Offset.IsNegative)
{
writer.Write("+");
}
writer.Write(Offset.ToString());
writer.Write("]");
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
if (Offset != null)
{
writer.Write(MachineOperand.FormatValue(Offset, false, M68kDisassembler.HexStringFormat));
}
writer.Write("(");
writer.Write(Base.Name);
writer.Write(")");
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write("[%{0}", Base.Name);
if (!Offset.IsNegative)
{
writer.Write("+");
}
writer.Write(Offset.ToString());
writer.Write("]");
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write('[');
writer.Write(this.Base.ToString());
if (this.Offset != null)
{
if (this.Preindexed)
{
writer.Write(",");
if (this.Subtract)
{
writer.Write("-");
}
Offset.Write(false, writer);
writer.Write("]");
if (this.Writeback)
{
writer.Write("!");
}
}
else
{
writer.Write("],");
if (this.Subtract)
{
writer.Write("-");
}
Offset.Write(false, writer);
}
}
else
{
writer.Write(']');
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write('[');
writer.Write(this.Base.ToString());
if (this.Offset != null)
{
if (this.Preindexed)
{
writer.Write(",");
if (this.Subtract)
writer.Write("-");
Offset.Write(false, writer);
writer.Write("]");
if (this.Writeback)
writer.Write("!");
}
else
{
writer.Write("],");
if (this.Subtract)
writer.Write("-");
Offset.Write(false, writer);
}
}
else
writer.Write(']');
}
private void OpToString(MachineOperand op, MachineInstructionWriter writer)
{
if (op is ImmediateOperand)
{
writer.Write("#" + op.ToString());
}
else
{
writer.Write(op.ToString());
}
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.Write("#");
var pt = Constant.DataType as PrimitiveType;
if (pt == null || pt.Domain != Domain.Real)
{
writer.Write("$");
}
writer.Write(MachineOperand.FormatValue(Constant));
}
private void OpToString(MachineOperand op, MachineInstructionWriter writer)
{
if (op is ImmediateOperand)
{
writer.Write("#" + op.ToString());
}
else
{
writer.Write(op.ToString());
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
if (Offset != null)
{
writer.Write(FormatSignedValue(Offset));
}
if (Base != null)
{
writer.Write("({0})", Base.Name);
}
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
int offset = Offset;
if (offset < 0)
{
offset = -offset;
writer.Write('-');
}
writer.Write("{0:X}(", offset);
writer.Write(this.Base.Name);
writer.Write(")");
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(opcode.ToString());
if (operands.Length > 0)
{
writer.Tab();
writer.Write(operands[0].ToString());
if (operands.Length > 1)
{
writer.Write(",");
writer.Write(operands[1].ToString());
}
}
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(this.Opcode.ToString());
writer.Tab();
bool sep = false;
foreach (var op in Operands)
{
if (sep)
writer.Write(',');
sep = true;
if (op is ImmediateOperand)
writer.Write('#');
op.Write(false, writer);
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write('{');
{
uint w = instr & 0xFFFF;
int i = 0;
while (w != 0)
{
int j;
while ((w & (1u << i)) == 0)
++i;
for (j = i + 1; (w & (1u << j)) != 0; ++j)
;
--j;
// registers [i..j]
writer.Write(A32Registers.GpRegs[i].Name);
if (j - i != 0)
{
writer.Write((j - i > 1) ? '-' : ',');
writer.Write(A32Registers.GpRegs[j].Name);
}
i = j; w = (w >> (j + 1)) << (j + 1);
if (w != 0) writer.Write(',');
}
}
writer.Write('}');
if ((instr & (1 << 22)) != 0) writer.Write('^');
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(Opcode.ToString());
if (op1 == null)
return;
writer.Tab();
op1.Write(false, writer);
if (op2 == null)
return;
writer.Write(",");
op2.Write(false, writer);
if (op3 == null)
return;
writer.Write(",");
op3.Write(false, writer);
}
public override void Render(MachineInstructionWriter writer)
{
if (instruction == null)
{
writer.Write("Invalid");
return;
}
writer.WriteOpcode(instruction.Mnemonic);
var ops = instruction.ArchitectureDetail.Operands;
if (ops.Length < 1)
return;
writer.Tab();
if (WriteRegisterSetInstruction(writer))
return;
Write(ops[0], writer);
if (ops.Length < 2)
return;
writer.Write(",");
Write(ops[1], writer);
if (ops.Length < 3)
return;
writer.Write(",");
Write(ops[2], writer);
if (ops.Length < 4)
return;
writer.Write(",");
Write(ops[3], writer);
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(opcode.ToString());
if (op1 != null)
{
writer.Tab();
op1.Write(true, writer);
if (op2 != null)
{
writer.Write(',');
op2.Write(true, writer);
if (op3 != null)
{
writer.Write(',');
op3.Write(true, writer);
}
}
}
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(instruction.Mnemonic);
var ops = Internal.ArchitectureDetail.Operands;
if (ops.Length < 1)
return;
writer.Tab();
Write(ops[0], writer);
if (ops.Length < 2)
return;
writer.Write(",");
Write(ops[1], writer);
if (ops.Length < 3)
return;
writer.Write(",");
Write(ops[2], writer);
if (ops.Length < 4)
return;
writer.Write(",");
Write(ops[3], writer);
}
public override void Render(MachineInstructionWriter writer)
{
if (Code == Opcode.ex_af)
{
writer.WriteOpcode("ex");
writer.Tab();
writer.Write("af,af'");
return;
}
writer.WriteOpcode(Code.ToString());
if (Op1 != null)
{
writer.Tab();
Op1.Write(true, writer);
if (Op2 != null)
{
writer.Write(",");
Op2.Write(true, writer);
}
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
if (Offset != null)
{
writer.Write(FormatSignedValue(Offset));
}
if (AutoDecrement)
{
writer.Write("-");
}
if (Base != null)
{
writer.Write("({0})", Base.Name);
}
if (AutoIncrement)
{
writer.Write("+");
}
if (Index != null)
{
writer.Write("[{0}]", Index.Name);
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
if (condition > 3)
writer.Write("cr{0}+", condition >> 2);
var s = "";
switch (condition & 3)
{
case 0: s = "lt"; break;
case 1: s = "gt"; break;
case 2: s = "eq"; break;
case 3: s = "so"; break;
}
writer.Write(s);
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(Opcode.ToString());
if (op1 != null)
{
writer.Tab();
OpToString(op1, writer);
if (op2 != null)
{
writer.Write(",");
OpToString(op2, writer);
}
}
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(
string.Format("{0}{1}",
Opcode.ToString(),
Annul ? ",a" : ""));
if (Op1 != null)
{
writer.Tab();
Write(Op1, writer);
if (Op2 != null)
{
writer.Write(',');
Write(Op2, writer);
if (Op3 != null)
{
writer.Write(',');
Write(Op3, writer);
}
}
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
string fmt;
switch (Mode)
{
case AddressMode.RegDef: fmt = "@{0}"; break;
case AddressMode.AutoIncr: fmt = "({0})+"; break;
case AddressMode.AutoDecr: fmt = "-({0})"; break;
case AddressMode.Indexed: fmt = "{1:X4}({0})"; break;
//case AddressMode.Immediate : fmt = "#{1:X4}"; break;
case AddressMode.Absolute: fmt = "@#{1:X4}"; break;
default: throw new NotImplementedException(string.Format("Unknown mode {0}.", Mode));
}
writer.Write(string.Format(fmt, Register, EffectiveAddress));
}
private void Write(Arm64InstructionOperand op, MachineInstructionWriter writer)
{
switch (op.Type)
{
case Arm64InstructionOperandType.Register:
writer.Write(A64Registers.RegisterByCapstoneID[op.RegisterValue.Value].Name);
return;
case Arm64InstructionOperandType.Immediate:
if (IsJump())
{
writer.Write("${0:X16}", op.ImmediateValue.Value);
}
else
{
WriteImmediateValue(op.ImmediateValue.Value, writer);
if (op.Shifter != null)
{
this.WriteShift(op, writer);
}
}
return;
}
throw new NotImplementedException(op.Type.ToString());
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
string fmt;
int offset;
if (Offset >= 0)
{
fmt = "{0:X4}({1})";
offset = Offset;
}
else
{
fmt = "-{0:X4}({1})";
offset = -Offset;
}
writer.Write(string.Format(fmt, offset, Base));
}
public override void Render(MachineInstructionWriter writer)
{
string instrName;
if (!instrNames.TryGetValue(Opcode, out instrName))
{
instrName = Opcode.ToString();
}
writer.WriteOpcode(instrName);
writer.Tab();
var sep = "";
if (this.Operands != null)
{
foreach (var op in this.Operands)
{
writer.Write(sep);
op.Write(false, writer);
sep = ",";
}
}
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
int o = Offset != null ? Offset.ToUInt16() : 0;
string fmt;
switch (Mode)
{
case AddressMode.Accumulator: return; // Implicit, never displayed
case AddressMode.Immediate: fmt = "#${0:X2}"; break;
case AddressMode.ZeroPage: fmt = "${0:X2}"; break;
case AddressMode.ZeroPageX:
case AddressMode.ZeroPageY: fmt = "${0:X2},{1}"; break;
case AddressMode.Relative:
case AddressMode.Absolute: fmt = "${0:X4}"; break;
case AddressMode.AbsoluteX:
case AddressMode.AbsoluteY: fmt = "${0:X4},{1}"; break;
case AddressMode.Indirect: fmt = "(${0:X4})"; break;
case AddressMode.IndexedIndirect: fmt = "(${0:X2},{1})"; break;
case AddressMode.IndirectIndexed: fmt = "(${0:X2}),{1}"; break;
default: throw new NotSupportedException();
}
writer.Write(string.Format(fmt, o, Register));
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write("st(" + fpuReg + ")");
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
var s = FormatValue(value);
var pt = value.DataType as PrimitiveType;
if (pt != null && pt.Domain == Domain.Pointer)
writer.WriteAddress(s, Address.FromConstant(value)); //$TODO: add WriteAddress(string, Constant) to MachineINstructionWriter
else if (value.DataType is Pointer)
writer.WriteAddress(s, Address.FromConstant(value));
else
writer.Write(s);
}
