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);