protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (!mnemonics.TryGetValue(Mnemonic, out var sMnemonic))
{
sMnemonic = Mnemonic.ToString();
}
renderer.WriteMnemonic(sMnemonic);
RenderOperands(renderer, options);
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (Negated)
{
renderer.WriteString("/");
}
renderer.WriteString(Register.Name);
renderer.WriteString($".{Bit}");
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (!ImmediateValue.IsValid)
{
renderer.WriteString("???");
return;
}
renderer.WriteString(FormatValue(ImmediateValue, false, "{0}0x{1}"));
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (FSRNum == 255)
{
renderer.WriteString("FSR");
return;
}
renderer.WriteString($"FSR{FSRNum}");
}
public void Render(X86Instruction instr, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (instr.repPrefix == 3)
{
renderer.WriteMnemonic("rep");
renderer.WriteChar(' ');
}
else if (instr.repPrefix == 2)
{
renderer.WriteMnemonic("repne");
renderer.WriteChar(' ');
}
var s = new StringBuilder(instr.Mnemonic.ToString());
switch (instr.Mnemonic)
{
case Mnemonic.ins:
case Mnemonic.outs:
case Mnemonic.movs:
case Mnemonic.cmps:
case Mnemonic.stos:
case Mnemonic.lods:
case Mnemonic.scas:
switch (instr.dataWidth.Size)
{
case 1: s.Append('b'); break;
case 2: s.Append('w'); break;
case 4: s.Append('d'); break;
case 8: s.Append('q'); break;
default: throw new ArgumentOutOfRangeException();
}
break;
}
renderer.WriteMnemonic(s.ToString());
var flags = options.Flags;
if (NeedsExplicitMemorySize(instr))
{
flags |= MachineInstructionRendererFlags.ExplicitOperandSize;
}
if (instr.Operands.Length > 0)
{
renderer.Tab();
RenderOperand(instr.Operands[0], instr, renderer, flags);
for (int i = 1; i < instr.Operands.Length; ++i)
{
renderer.WriteString(options.OperandSeparator ?? ",");
RenderOperand(instr.Operands[i], instr, renderer, flags);
}
}
}
private void RenderMnemonic(MachineInstructionRenderer writer)
{
var s = this.Mnemonic
.ToString()
.Replace('_', '.')
.Replace("..", "_");
writer.WriteMnemonic(s);
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
switch (Mode)
{
case FSRIndexedMode.None:
if (FSRNum == 255)
{
renderer.WriteString($"[{Offset:X2}]");
return;
}
renderer.WriteString($"FSR{FSRNum},{Offset:X2}");
return;
case FSRIndexedMode.FSR2INDEXED:
var offs = Offset.ToByte();
if (offs <= 31)
{
renderer.WriteString($"[0x{offs:X2}]");
}
else
{
renderer.WriteString($"[{Offset:X2}]");
}
return;
case FSRIndexedMode.INDEXED:
renderer.WriteString($"{Offset}[{FSRNum}]");
return;
case FSRIndexedMode.POSTDEC:
renderer.WriteString($"FSR{FSRNum}--");
return;
case FSRIndexedMode.POSTINC:
renderer.WriteString($"FSR{FSRNum}++");
return;
case FSRIndexedMode.PREDEC:
renderer.WriteString($"--FSR{FSRNum}");
return;
case FSRIndexedMode.PREINC:
renderer.WriteString($"++FSR{FSRNum}");
return;
case FSRIndexedMode.INDF:
renderer.WriteString($"[{FSRNum}]");
return;
case FSRIndexedMode.PLUSW:
renderer.WriteString($"[FSR{FSRNum}+WREG]");
return;
}
throw new NotImplementedException();
}
private void RenderMnemonic(MachineInstructionRenderer renderer)
{
var sMnemonic = Mnemonic.ToString();
if (sMnemonic.StartsWith("xio_"))
{
sMnemonic = sMnemonic.Substring(4);
}
renderer.WriteMnemonic(sMnemonic);
}
protected override void RenderOperand(MachineOperand operand, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (operand is ImmediateOperand imm)
{
renderer.WriteChar('#');
WriteHex(imm.Value.ToUInt16(), renderer);
return;
}
base.RenderOperand(operand, renderer, options);
}
protected override void RenderOperand(MachineOperand operand, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (operand is ImmediateOperand imm)
{
renderer.WriteString("0x");
renderer.WriteFormat("{0:X}", imm.Value.ToUInt32());
return;
}
base.RenderOperand(operand, renderer, options);
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (Offset != null)
{
renderer.WriteString(MachineOperand.FormatValue(Offset, false, M68kDisassembler.HexStringFormat));
}
renderer.WriteString("(");
renderer.WriteString(Base.Name);
renderer.WriteString(")");
}
private int WriteMnemonic(MachineInstructionRenderer renderer)
{
if (Mnemonic == Mnemonic.b && Operands[0] is ConditionOperand cop)
{
renderer.WriteMnemonic($"b.{cop.Condition.ToString().ToLower()}");
return(1);
}
renderer.WriteMnemonic(Mnemonic.ToString());
return(0);
}
private void RenderMnemonic(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
var sb = new StringBuilder(Mnemonic.ToString().Replace('_', '.'));
if (Condition != Avr32Condition.al)
{
sb.Append(Condition.ToString());
}
renderer.WriteMnemonic(sb.ToString());
}
protected override void RenderOperand(MachineOperand op, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
switch (op)
{
case ImmediateOperand immOp:
renderer.WriteString(MachineOperand.FormatUnsignedValue(immOp.Value, "#${1}"));
return;
}
op.Render(renderer, options);
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
renderer.WriteFormat("[%{0}", Base.Name);
if (!Offset.IsNegative)
{
renderer.WriteString("+");
}
renderer.WriteString(Offset.ToInt16().ToString());
renderer.WriteString("]");
}
private void Render4(string infix1, string infix2, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
RenderOperand(Operands[0], renderer, options);
renderer.WriteString(" ");
RenderOperand(Operands[1], renderer, options);
renderer.WriteString(infix1);
RenderOperand(Operands[2], renderer, options);
renderer.WriteString(infix2);
RenderOperand(Operands[3], renderer, options);
}
public static void RenderIntelHexNumber(int number, MachineInstructionRenderer renderer)
{
var sOffset = number.ToString("X");
if ("ABCDEF".Contains(sOffset[0]))
{
renderer.WriteChar('0');
}
renderer.WriteString(sOffset);
renderer.WriteChar('h');
}
protected override void RenderOperand(MachineOperand operand, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
switch (operand)
{
case ImmediateOperand imm:
renderer.WriteChar('#');
WriteNumber(imm.Value, renderer);
return;
}
base.RenderOperand(operand, renderer, options);
}
private void RenderLoad(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
RenderOperand(Operands[0], renderer, options);
renderer.WriteString(" ");
RenderOperand(Operands[1], renderer, options);
renderer.WriteString(",");
if (Operands.Length == 3)
{
RenderOperand(Operands[2], renderer, options);
}
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (Value == 0 && (Mnemonic == Mnemonic.lsl || Mnemonic == Mnemonic.lsr))
{
renderer.WriteString(Register.Name);
}
else
{
renderer.WriteFormat("{0}{1}{2}", Register.Name, mpMnemonicToString[Mnemonic], Value);
}
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
string sep = "";
foreach (var reg in GetRegisters())
{
renderer.WriteString(sep);
sep = ",";
renderer.WriteString(reg.Name);
}
}
public static void WriteHex(ushort n, MachineInstructionRenderer renderer)
{
if (n > 9)
{
renderer.WriteFormat("0x{0:X}", n);
}
else
{
renderer.WriteFormat("{0:X}", n);
}
}
protected override void RenderOperand(MachineOperand operand, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (operand is ImmediateOperand imm)
{
renderer.WriteFormat("#${0:X2}", imm.Value.ToUInt32());
}
else
{
base.RenderOperand(operand, renderer, options);
}
}
protected override void RenderOperand(MachineOperand op, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (op is AddressOperand && (base.InstructionClass & InstrClass.Transfer) == 0)
{
renderer.WriteString("#");
}
if (op is ImmediateOperand && Mnemonic != Mnemonics.call)
{
renderer.WriteString("#");
}
op.Render(renderer, options);
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (Mnemonic == Mnemonic.ex_af)
{
renderer.WriteMnemonic("ex");
renderer.Tab();
renderer.WriteString("af,af'");
return;
}
renderer.WriteMnemonic(Mnemonic.ToString());
RenderOperands(renderer, options);
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (Base is null)
{
renderer.WriteAddress($"${Offset:X4}", Address.Ptr16(Offset));
}
else
{
renderer.WriteChar('@');
renderer.WriteString(Base !.Name);
}
}
protected override void RenderOperand(MachineOperand op, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
switch (op)
{
case RegisterOperand reg:
renderer.WriteFormat("%{0}", reg.Register.Name);
return;
default:
op.Render(renderer, options);
return;
}
}
private void RenderMnemonic(MachineInstructionRenderer renderer)
{
var sb = new StringBuilder();
sb.Append(Mnemonic.ToString());
if (Annul)
sb.Append(",a");
if (Prediction == Prediction.NotTaken)
sb.Append(",pn");
if (Prediction == Prediction.Taken)
sb.Append(",pt");
renderer.WriteMnemonic(sb.ToString());
}
protected override void RenderOperand(MachineOperand operand, MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
if (operand is ImmediateOperand imm)
{
renderer.WriteString("#$");
imm.Render(renderer, options);
}
else
{
base.RenderOperand(operand, renderer, options);
}
}
protected override void DoRender(MachineInstructionRenderer renderer, MachineInstructionRendererOptions options)
{
int offset = Offset;
if (offset < 0)
{
offset = -offset;
renderer.WriteChar('-');
}
renderer.WriteFormat("{0:X}(", offset);
renderer.WriteString(this.Base.Name);
renderer.WriteString(")");
}
