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)
{
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);
}
}
}
}
}
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 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 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 Render(MachineInstructionWriter writer)
{
var op = string.Format("{0}{1}",
opcode,
setsCR0 ? "." : "");
writer.WriteOpcode(op);
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);
if (op4 != null)
{
writer.Write(",");
op4.Write(true, writer);
if (op5 != null)
{
writer.Write(",");
op5.Write(true, 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 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 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 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("#");
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)
{
string s;
if (base.Width.Size == 2)
s = string.Format("{0:X4}", Address.ToLinear());
else
s = Address.ToString();
writer.WriteAddress(s, Address);
}
public override void Render(MachineInstructionWriter writer)
{
writer.WriteOpcode(Code.ToString());
if (Operand != null)
{
writer.Tab();
Operand.Write(true, writer);
}
}
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 Render(MachineInstructionWriter writer)
{
try
{
writer.WriteOpcode(mpopcodetostring[Opcode]);
}
catch
{
throw new NotImplementedException("Lolwut: " + Opcode);
}
}
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 (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(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)
{
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));
}
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 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)
{
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)
{
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 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 Render(MachineInstructionWriter writer)
{
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);
}
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 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(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.Write("st(" + fpuReg + ")");
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteAddress(string.Format("${0:X8}", Address.Offset), Address);
}
protected override void RenderOperand(MachineOperand op, MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
switch (op)
{
case RegisterOperand reg:
writer.WriteString(reg.Register.Name);
return;
case ImmediateOperand imm:
var sbImm = new StringBuilder("#");
var sImm = imm.Value.ToString();
writer.WriteString(sImm);
return;
case MemoryOperand mem:
if (Prefix != null)
{
writer.WriteFormat("{0}:", Prefix.Name);
}
writer.WriteChar('[');
if (mem.Base != null)
{
writer.WriteString(mem.Base.Name);
if (mem.Index != null)
{
writer.WriteFormat("+{0}", mem.Index.Name);
}
else if (mem.Offset != 0)
{
if (mem.Offset >= 0xA0)
{
writer.WriteFormat("+0{0:X2}h", mem.Offset);
}
else
{
writer.WriteFormat("+{0:X2}h", mem.Offset);
}
}
}
else
{
if (mem.Offset >= 0xA000)
{
writer.WriteFormat("0{0:X4}h", mem.Offset);
}
else
{
writer.WriteFormat("{0:X4}h", mem.Offset);
}
if (mem.Index != null)
{
writer.WriteFormat("+{0}", mem.Index.Name);
}
}
writer.WriteChar(']');
return;
case BitOperand bit:
this.RenderOperand(bit.Operand, writer, options);
writer.WriteFormat(".{0}", bit.BitPosition);
return;
case AddressOperand aop:
writer.WriteAddress(aop.Address.ToString(), aop.Address);
return;
case RegisterBankOperand rbop:
writer.WriteFormat("rb{0}", rbop.Bank);
return;
case FlagGroupOperand grf:
writer.WriteString(grf.FlagGroup.Name);
return;
}
throw new NotImplementedException($"Rl78Instruction - RenderOperand {op.GetType().Name}.");
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteMnemonic(mpopcodetostring[Opcode]);
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
RenderMnemonic(writer);
RenderOperands(writer, options);
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
string fmt;
int offset;
string regName = "";
if (Indirect)
{
writer.WriteChar('[');
}
switch (AccessMode)
{
case Mode.Direct:
writer.WriteFormat(">${0:X2}", Offset);
break;
case Mode.ConstantOffset:
offset = Offset;
if (Base == null)
{
fmt = "${0:X4}";
}
else if (offset < 0)
{
offset = -offset;
fmt = "-${0:X2},{1}";
regName = Base.Name;
}
else if (Offset == 0)
{
fmt = ",{1}";
regName = Base.Name;
}
else
{
if (offset < 0x0100)
{
fmt = "${0:X2},{1}";
}
else
{
fmt = "${0:X4},{1}";
}
regName = Base.Name;
}
writer.WriteFormat(fmt, offset, regName);
break;
case Mode.AccumulatorOffset:
writer.WriteFormat("{0},{1}", Index.Name, Base.Name);
break;
case Mode.PostInc1:
writer.WriteFormat(",{0}+", Base.Name);
break;
case Mode.PostInc2:
writer.WriteFormat(",{0}++", Base.Name);
break;
case Mode.PreDec1:
writer.WriteFormat(",-{0}", Base.Name);
break;
case Mode.PreDec2:
writer.WriteFormat(",--{0}", Base.Name);
break;
default:
throw new NotImplementedException($"Unimplemented address mode {AccessMode}.");
}
if (Indirect)
{
writer.WriteChar(']');
}
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
if ((options & MachineInstructionWriterOptions.ExplicitOperandSize) != 0)
{
string s;
if (Width == PrimitiveType.Byte)
{
s = "byte ptr ";
}
else if (Width == PrimitiveType.Word16)
{
s = "word ptr ";
}
else if (Width.Size == 4)
{
s = "dword ptr ";
}
else if (Width == PrimitiveType.Word64)
{
s = "qword ptr ";
}
else if (Width == PrimitiveType.Real32)
{
s = "float ptr ";
}
else if (Width == PrimitiveType.Real64)
{
s = "double ptr ";
}
else if (Width == PrimitiveType.Real80 || Width == PrimitiveType.Bcd80)
{
s = "tword ptr ";
}
else if (Width == PrimitiveType.Word128)
{
s = "xmmword ptr ";
}
else if (Width == PrimitiveType.Word256)
{
s = "ymmword ptr ";
}
else
{
throw new ArgumentOutOfRangeException();
}
writer.Write(s);
}
if (SegOverride != RegisterStorage.None)
{
writer.Write(SegOverride.ToString());
writer.Write(":");
}
writer.Write("[");
if (Base != RegisterStorage.None)
{
writer.Write(Base.ToString());
}
else
{
var s = FormatUnsignedValue(Offset);
writer.WriteAddress(s, Address.FromConstant(Offset));
}
if (Index != RegisterStorage.None)
{
writer.Write("+");
writer.Write(Index.ToString());
if (Scale > 1)
{
writer.Write("*");
writer.Write(Scale);
}
}
if (Base != RegisterStorage.None && Offset != null && Offset.IsValid)
{
if (Offset.DataType == PrimitiveType.Byte || Offset.DataType == PrimitiveType.SByte)
{
writer.Write(FormatSignedValue(Offset));
}
else
{
var off = Offset.ToInt32();
if (off == Int32.MinValue)
{
writer.Write("-80000000");
}
else
{
var absOff = Math.Abs(off);
if (Offset.DataType.Size > 2 && off < 0 && absOff < 0x10000)
{
// Special case for negative 32-bit offsets whose
// absolute value < 0x10000 (GitHub issue #252)
writer.Write("-");
writer.Write("{0:X8}", absOff);
}
else
{
writer.Write("+");
writer.Write(FormatUnsignedValue(Offset));
}
}
}
}
writer.Write("]");
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
if (repPrefix == 3)
{
writer.WriteOpcode("rep");
writer.WriteChar(' ');
}
else if (repPrefix == 2)
{
writer.WriteOpcode("repne");
writer.WriteChar(' ');
}
// Get opcode.
string s = code.ToString();
switch (code)
{
case Mnemonic.cwd:
if (dataWidth == PrimitiveType.Word32)
{
s = "cdq";
}
break;
case Mnemonic.cbw:
if (dataWidth == PrimitiveType.Word32)
{
s = "cwde";
}
break;
case Mnemonic.ins:
case Mnemonic.outs:
case Mnemonic.movs:
case Mnemonic.cmps:
case Mnemonic.stos:
case Mnemonic.lods:
case Mnemonic.scas:
switch (dataWidth.Size)
{
case 1: s += 'b'; break;
case 2: s += 'w'; break;
case 4: s += 'd'; break;
case 8: s += 'q'; break;
default: throw new ArgumentOutOfRangeException();
}
break;
}
writer.WriteOpcode(s);
if (NeedsExplicitMemorySize())
{
options |= MachineInstructionWriterOptions.ExplicitOperandSize;
}
RenderOperands(writer, options);
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write("far");
writer.Write(" ");
writer.WriteAddress(Address.ToString(), Address);
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
uint bitSet = BitSet;
WriteRegisterSet(bitSet, writer);
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteString(Display);
}
private void RenderMnemonic(MachineInstructionWriter writer)
{
writer.WriteMnemonic(Mnemonic.ToString());
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteString(Option.ToString().ToLower());
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteOpcode("opcode.l");
}
private bool WriteRegisterSetInstruction(MachineInstructionWriter writer)
{
IEnumerable <ArmInstructionOperand> ops =
instruction.ArchitectureDetail.Operands;
switch (instruction.Id)
{
case Opcode.POP:
case Opcode.PUSH:
break;
case Opcode.LDM:
case Opcode.STM:
case Opcode.STMDB:
Write(ops.First(), writer, MachineInstructionWriterOptions.None);
if (instruction.ArchitectureDetail.WriteBack)
{
writer.Write("!");
}
ops = ops.Skip(1);
writer.Write(",");
break;
default:
return(false);
}
writer.Write("{");
var sep = "";
RegisterStorage regPrev = null;
RegisterStorage reg = null;
foreach (var op in ops)
{
reg = A32Registers.RegisterByCapstoneID[op.RegisterValue.Value];
if (regPrev == null)
{
writer.Write(sep);
writer.Write(reg.Name);
sep = ",";
}
else if (regPrev.Number + 1 < reg.Number)
{
if (sep == "-")
{
writer.Write(sep);
writer.Write(regPrev.Name);
sep = ",";
}
writer.Write(sep);
writer.Write(reg.Name);
sep = ",";
}
else
{
sep = "-";
}
regPrev = reg;
}
if (sep == "-")
{
writer.Write("-");
writer.Write(reg.Name);
}
writer.Write("}");
return(true);
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteString("#");
writer.WriteString(MachineOperand.FormatValue(Constant, false, M68kDisassembler.HexStringFormat));
}
public void Write(ArmInstructionOperand op, MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
switch (op.Type)
{
case ArmInstructionOperandType.Immediate:
if (instruction.Id == Opcode.B ||
instruction.Id == Opcode.BL ||
instruction.Id == Opcode.BLX)
{
writer.Write("$");
writer.WriteAddress(
string.Format("{0:X8}", op.ImmediateValue.Value),
Address.Ptr32((uint)op.ImmediateValue.Value));
break;
}
writer.Write("#");
WriteImmediateValue(op.ImmediateValue.Value, writer);
break;
case ArmInstructionOperandType.CImmediate:
writer.Write("c{0}", op.ImmediateValue);
break;
case ArmInstructionOperandType.PImmediate:
writer.Write("p{0}", op.ImmediateValue);
break;
case ArmInstructionOperandType.Register:
if (op.IsSubtracted)
{
writer.Write('-');
}
writer.Write(A32Registers.RegisterByCapstoneID[op.RegisterValue.Value].Name);
WriteShift(op, writer);
break;
case ArmInstructionOperandType.SysRegister:
writer.Write(A32Registers.SysRegisterByCapstoneID[op.SysRegisterValue.Value].Name);
break;
case ArmInstructionOperandType.Memory:
if (op.MemoryValue.BaseRegister == ArmRegister.PC)
{
var uAddr = (uint)((int)this.Address.ToUInt32() + op.MemoryValue.Displacement) + 8u;
var addr = Address.Ptr32(uAddr);
if (op.MemoryValue.IndexRegister == ArmRegister.Invalid &&
(options & MachineInstructionWriterOptions.ResolvePcRelativeAddress) != 0)
{
writer.Write('[');
writer.WriteAddress(addr.ToString(), addr);
writer.Write(']');
var sr = new StringRenderer();
WriteMemoryOperand(op, sr);
writer.AddAnnotation(sr.ToString());
}
else
{
WriteMemoryOperand(op, writer);
writer.AddAnnotation(addr.ToString());
}
return;
}
WriteMemoryOperand(op, writer);
break;
case ArmInstructionOperandType.SetEnd:
writer.Write(op.SetEndValue.ToString().ToLowerInvariant());
break;
case ArmInstructionOperandType.FloatingPoint:
var f = op.FloatingPointValue.Value.ToString("g", CultureInfo.InvariantCulture);
if (f.IndexOfAny(nosuffixRequired) < 0)
{
f += ".0";
}
writer.Write("#{0}", f);
break;
default:
throw new NotImplementedException(string.Format(
"Can't disassemble {0} {1}. Unknown operand type: {2}",
instruction.Mnemonic,
instruction.Operand,
op.Type));
}
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteFormat("{0}({1})", Offset, Base.Name);
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
//@base = EXT_BASE_DISPLACEMENT_PRESENT(extension) ? (EXT_BASE_DISPLACEMENT_LONG(extension) ? read_imm_32() : read_imm_16()) : 0;
//outer = EXT_OUTER_DISPLACEMENT_PRESENT(extension) ? (EXT_OUTER_DISPLACEMENT_LONG(extension) ? read_imm_32() : read_imm_16()) : 0;
//if (EXT_BASE_REGISTER_PRESENT(extension))
// base_reg = string.Format("A{0}", instruction & 7);
//else
// base_reg = "";
//if (EXT_INDEX_REGISTER_PRESENT(extension))
//{
// index_reg = string.Format("{0}{1}.{2}", EXT_INDEX_AR(extension) ? 'A' : 'D', EXT_INDEX_REGISTER(extension), EXT_INDEX_LONG(extension) ? 'l' : 'w');
// if (EXT_INDEX_SCALE(extension) != 0)
// index_reg += string.Format("*{0}", 1 << EXT_INDEX_SCALE(extension));
//}
//else
// index_reg = "";
//preindex = (extension & 7) > 0 && (extension & 7) < 4;
//postindex = (extension & 7) > 4;
writer.WriteString("(");
if (preindex || postindex)
{
writer.WriteString("[");
}
var sep = "";
if (Base != null)
{
writer.WriteString(MachineOperand.FormatValue(Base));
sep = ",";
}
if (base_reg != null)
{
writer.WriteString(sep);
writer.WriteString(base_reg.ToString());
sep = ",";
}
if (postindex)
{
writer.WriteString("]");
sep = ",";
}
if (index_reg != null)
{
writer.WriteString(sep);
writer.WriteString(index_reg.Name);
if (index_reg_width.BitSize == 16)
{
writer.WriteString(".w");
}
if (index_scale > 1)
{
writer.WriteFormat("*{0}", index_scale);
}
sep = ",";
}
if (preindex)
{
writer.WriteString("]");
sep = ",";
}
if (outer != null)
{
writer.WriteString(sep);
writer.WriteString(MachineOperand.FormatSignedValue(outer));
}
writer.WriteString(")");
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.Write(reg.ToString());
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteString("far");
writer.WriteString(" ");
writer.WriteAddress(Address.ToString(), Address);
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteOpcode(operation.ToString().ToLower());
}
public abstract void Write(bool fExplicit, MachineInstructionWriter writer);
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteString("(");
writer.WriteString(Register.Name);
writer.WriteString(")+");
}
public override void Write(bool fExplicit, MachineInstructionWriter writer)
{
writer.Write("st(" + fpuReg + ")");
}
private void Render(MachineOperand op, MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
throw new NotImplementedException();
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteOpcode(Mnemonic.ToString());
RenderOperands(writer, options);
}
public override void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteFormat("{0},{1}", Register1.Name, Register2.Name);
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteOpcode(Opcode.ToString());
writer.Tab();
op1.Write(writer, options);
}
public abstract void Write(MachineInstructionWriter writer, MachineInstructionWriterOptions options);
