public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; rtlc = instr.InstructionClass; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); switch (instr.Opcode) { default: EmitUnitTest(); Invalid(); host.Warn( instr.Address, string.Format( "TLCS-90 instruction '{0}' not supported yet.", instr.Opcode)); break; case Opcode.invalid: m.Invalid(); break; case Opcode.adc: RewriteAdcSbc(m.IAdd, "**-**V0*"); break; case Opcode.add: RewriteBinOp(m.IAdd, "**-***0*"); break; case Opcode.and: RewriteBinOp(m.And, "**-10*00"); break; case Opcode.bit: RewriteBit("*--I**0-"); break; case Opcode.call: RewriteCall(); break; case Opcode.callr: RewriteCall(); break; case Opcode.ccf: RewriteCcf(); break; case Opcode.cp: RewriteCp(); break; case Opcode.cpl: RewriteCpl("---1--1-"); break; case Opcode.daa: RewriteDaa(); break; case Opcode.dec: RewriteIncDec(m.ISub, false); break; case Opcode.decx: RewriteIncDec(m.ISub, true); break; case Opcode.di: RewriteDi(); break; case Opcode.div: RewriteDiv(); break; case Opcode.djnz: RewriteDjnz(); break; case Opcode.ei: RewriteEi(); break; case Opcode.ex: RewriteEx(); break; case Opcode.exx: RewriteExx(); break; case Opcode.halt: RewriteHalt(); break; case Opcode.inc: RewriteIncDec(m.IAdd, false); break; case Opcode.incw: RewriteIncwDecw(m.IAdd); break; case Opcode.incx: RewriteIncDec(m.IAdd, true); break; case Opcode.jp: RewriteJp(); break; case Opcode.jr: RewriteJp(); break; case Opcode.ld: RewriteLd(); break; case Opcode.ldar: RewriteLdar(); break; case Opcode.ldir: RewriteLdir("---0-00-"); break; case Opcode.ldw: RewriteLd(); break; case Opcode.mul: RewriteMul(); break; case Opcode.neg: RewriteNeg(); break; case Opcode.nop: m.Nop(); break; case Opcode.or: RewriteBinOp(m.Or, "**-00*00"); break; case Opcode.pop: RewritePop(); break; case Opcode.push: RewritePush(); break; case Opcode.rcf: RewriteRcf(); break; case Opcode.res: RewriteSetRes(false); break; case Opcode.ret: RewriteRet(); break; case Opcode.reti: RewriteReti(); break; case Opcode.rl: RewriteRotation(PseudoProcedure.RolC, true); break; case Opcode.rlc: RewriteRotation(PseudoProcedure.Rol, false); break; case Opcode.rr: RewriteRotation(PseudoProcedure.RorC, true); break; case Opcode.rrc: RewriteRotation(PseudoProcedure.Ror, false); break; case Opcode.sbc: RewriteAdcSbc(m.ISub, "**-**V1*"); break; case Opcode.scf: RewriteScf(); break; case Opcode.set: RewriteSetRes(true); break; case Opcode.tset: RewriteTset("*--I**0-"); break; case Opcode.sla: RewriteShift(m.Shl); break; case Opcode.sll: RewriteShift(m.Shl); break; case Opcode.sra: RewriteShift(m.Sar); break; case Opcode.srl: RewriteShift(m.Shr); break; case Opcode.sub: RewriteBinOp(m.ISub, "**-**V1*"); break; case Opcode.swi: RewriteSwi(); break; case Opcode.xor: RewriteBinOp(m.Xor, "**-10*00"); break; } yield return(new RtlInstructionCluster(instr.Address, instr.Length, instrs.ToArray()) { Class = rtlc, }); } }
private void Invalid() { rtlc = InstrClass.Invalid; m.Invalid(); }
private void Invalid() { m.Invalid(); iclass = InstrClass.Invalid; }
private void Invalid() { rtlInstructions.Clear(); rtlc = RtlClass.Invalid; m.Invalid(); }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instrCur = dasm.Current; this.iclass = instrCur.InstructionClass; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); switch (instrCur.Mnemonic) { default: EmitUnitTest(); this.iclass = InstrClass.Invalid; goto case Mnemonic.Invalid; case Mnemonic.Invalid: m.Invalid(); break; case Mnemonic.j: RewriteJ(); break; case Mnemonic.jan: RewriteJxx(Registers.ARegs[0], m.Ne0); break; case Mnemonic.jam: RewriteJxx(Registers.ARegs[0], m.Lt0); break; case Mnemonic.jap: RewriteJxx(Registers.ARegs[0], m.Ge0); break; case Mnemonic.jaz: RewriteJxx(Registers.ARegs[0], m.Eq0); break; case Mnemonic.jsn: RewriteJxx(Registers.SRegs[0], m.Ne0); break; case Mnemonic.jsm: RewriteJxx(Registers.SRegs[0], m.Lt0); break; case Mnemonic.jsp: RewriteJxx(Registers.SRegs[0], m.Ge0); break; case Mnemonic.jsz: RewriteJxx(Registers.SRegs[0], m.Eq0); break; case Mnemonic.r: RewriteR(); break; case Mnemonic._and: Rewrite3(m.And); break; case Mnemonic._clz: RewriteIntrinsic("__clz", false); break; case Mnemonic._popcnt: RewriteIntrinsic("__popcnt", false); break; case Mnemonic._fmul: Rewrite3(m.FMul); break; case Mnemonic._iadd: Rewrite3(m.IAdd); break; case Mnemonic._isub: Rewrite3(m.ISub); break; case Mnemonic._mov: RewriteMov(); break; case Mnemonic._movz: RewriteMovz(); break; case Mnemonic._lmask: RewriteLmask(); break; case Mnemonic._load: RewriteLoad(); break; case Mnemonic._lsl: RewriteShift(m.Shl); break; case Mnemonic._lsr: RewriteShift(m.Shr); break; case Mnemonic._vor: Rewrite3(m.Or); break; case Mnemonic._store: RewriteStore(); break; case Mnemonic._xor: Rewrite3(m.Xor); break; } yield return(m.MakeCluster(instrCur.Address, instrCur.Length, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instrCur = dasm.Current; var instrs = new List <RtlInstruction>(); this.rtlc = instrCur.InstructionClass; this.m = new RtlEmitter(instrs); switch (instrCur.Mnemonic) { default: EmitUnitTest(); rtlc = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.illegal: m.Invalid(); break; case Mnemonic.adc: Adc(); break; case Mnemonic.and: And(); break; case Mnemonic.asl: Asl(); break; case Mnemonic.bcc: Branch(ConditionCode.UGE, FlagM.CF); break; case Mnemonic.bcs: Branch(ConditionCode.ULT, FlagM.CF); break; case Mnemonic.beq: Branch(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.bit: Bit(); break; case Mnemonic.bmi: Branch(ConditionCode.SG, FlagM.NF); break; case Mnemonic.bne: Branch(ConditionCode.NE, FlagM.ZF); break; case Mnemonic.bpl: Branch(ConditionCode.NS, FlagM.NF); break; case Mnemonic.brk: Brk(); break; case Mnemonic.bvc: Branch(ConditionCode.NO, FlagM.VF); break; case Mnemonic.bvs: Branch(ConditionCode.OV, FlagM.VF); break; case Mnemonic.clc: SetFlag(FlagM.CF, false); break; case Mnemonic.cld: SetFlag(FlagM.DF, false); break; case Mnemonic.cli: SetFlag(FlagM.IF, false); break; case Mnemonic.clv: SetFlag(FlagM.VF, false); break; case Mnemonic.cmp: Cmp(Registers.a); break; case Mnemonic.cpx: Cmp(Registers.x); break; case Mnemonic.cpy: Cmp(Registers.y); break; case Mnemonic.dec: Dec(); break; case Mnemonic.dex: Dec(Registers.x); break; case Mnemonic.dey: Dec(Registers.y); break; case Mnemonic.eor: Eor(); break; case Mnemonic.inc: Inc(); break; case Mnemonic.inx: Inc(Registers.x); break; case Mnemonic.iny: Inc(Registers.y); break; case Mnemonic.jmp: Jmp(); break; case Mnemonic.jsr: Jsr(); break; case Mnemonic.lda: Ld(Registers.a); break; case Mnemonic.ldx: Ld(Registers.x); break; case Mnemonic.ldy: Ld(Registers.y); break; case Mnemonic.lsr: Lsr(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.ora: Ora(); break; case Mnemonic.pha: Push(Registers.a); break; case Mnemonic.php: Push(AllFlags()); break; case Mnemonic.pla: Pull(Registers.a); break; case Mnemonic.plp: Plp(); break; case Mnemonic.rol: Rotate(PseudoProcedure.Rol); break; case Mnemonic.ror: Rotate(PseudoProcedure.Ror); break; case Mnemonic.rti: Rti(); break; case Mnemonic.rts: Rts(); break; case Mnemonic.sbc: Sbc(); break; case Mnemonic.sec: SetFlag(FlagM.CF, true); break; case Mnemonic.sed: SetFlag(FlagM.DF, true); break; case Mnemonic.sei: SetFlag(FlagM.IF, true); break; case Mnemonic.sta: St(Registers.a); break; case Mnemonic.stx: St(Registers.x); break; case Mnemonic.sty: St(Registers.y); break; case Mnemonic.tax: Copy(Registers.x, Registers.a); break; case Mnemonic.tay: Copy(Registers.y, Registers.a); break; case Mnemonic.tsx: Copy(Registers.x, Registers.s); break; case Mnemonic.txa: Copy(Registers.a, Registers.x); break; case Mnemonic.txs: Copy(Registers.s, Registers.x); break; case Mnemonic.tya: Copy(Registers.a, Registers.y); break; } yield return(new RtlInstructionCluster( instrCur.Address, instrCur.Length, instrs.ToArray()) { Class = rtlc }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var instr = dasm.Current; this.iclass = instr.InstructionClass; switch (instr.Mnemonic) { default: EmitUnitTest(instr); goto case Mnemonic.Invalid; case Mnemonic.Invalid: m.Invalid(); iclass = InstrClass.Invalid; break; case Mnemonic.add: RewriteAdd(instr); break; case Mnemonic.adds: RewriteAdds(instr); break; case Mnemonic.addx: RewriteAddxSubx(instr, m.IAdd); break; case Mnemonic.and: RewriteLogical(instr, m.And); break; case Mnemonic.bld: RewriteBtst(instr, C); break; case Mnemonic.bset: RewriteBset(instr, Constant.True()); break; case Mnemonic.bst: RewriteBset(instr, binder.EnsureFlagGroup(C)); break; case Mnemonic.btst: RewriteBtst(instr, Z); break; case Mnemonic.bra: RewriteBranch(instr); break; case Mnemonic.brn: RewriteNop(); break; case Mnemonic.bhi: RewriteBranch(instr, ConditionCode.UGT, ZC); break; case Mnemonic.bls: RewriteBranch(instr, ConditionCode.ULE, ZC); break; case Mnemonic.bcc: RewriteBranch(instr, ConditionCode.UGE, C); break; case Mnemonic.bcs: RewriteBranch(instr, ConditionCode.ULT, C); break; case Mnemonic.bne: RewriteBranch(instr, ConditionCode.NE, Z); break; case Mnemonic.beq: RewriteBranch(instr, ConditionCode.EQ, Z); break; case Mnemonic.bvc: RewriteBranch(instr, ConditionCode.NO, V); break; case Mnemonic.bvs: RewriteBranch(instr, ConditionCode.OV, V); break; case Mnemonic.bpl: RewriteBranch(instr, ConditionCode.GE, N); break; case Mnemonic.bmi: RewriteBranch(instr, ConditionCode.LT, N); break; case Mnemonic.bge: RewriteBranch(instr, ConditionCode.GE, NV); break; case Mnemonic.blt: RewriteBranch(instr, ConditionCode.LT, NV); break; case Mnemonic.bgt: RewriteBranch(instr, ConditionCode.GT, NZV); break; case Mnemonic.ble: RewriteBranch(instr, ConditionCode.LE, NZV); break; case Mnemonic.cmp: RewriteCmp(instr); break; case Mnemonic.extu: RewriteExt(instr, Domain.UnsignedInt); break; case Mnemonic.jmp: RewriteJmp(instr); break; case Mnemonic.jsr: RewriteJsr(instr); break; case Mnemonic.ldc: RewriteLdc(instr); break; case Mnemonic.mov: RewriteMov(instr); break; case Mnemonic.mulxu: RewriteMulxu(instr); break; case Mnemonic.nop: RewriteNop(); break; case Mnemonic.not: RewriteUnaryLogical(instr, m.Comp); break; case Mnemonic.or: RewriteLogical(instr, m.Or); break; case Mnemonic.rotxl: RewriteRotationX(instr, PseudoProcedure.RolC); break; case Mnemonic.rotxr: RewriteRotationX(instr, PseudoProcedure.RorC); break; case Mnemonic.rts: RewriteRts(); break; case Mnemonic.shal: RewriteShift(instr, m.Shl); break; case Mnemonic.shar: RewriteShift(instr, m.Sar); break; case Mnemonic.shll: RewriteShift(instr, m.Shl); break; case Mnemonic.shlr: RewriteShift(instr, m.Shr); break; case Mnemonic.sub: RewriteSub(instr); break; case Mnemonic.subs: RewriteSubs(instr); break; case Mnemonic.subx: RewriteAddxSubx(instr, m.ISub); break; case Mnemonic.xor: RewriteLogical(instr, m.Xor); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); this.m = new RtlEmitter(new List <RtlInstruction>()); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; var addr = dasm.Current.Address; var len = dasm.Current.Length; this.rtlInstructions = new List <RtlInstruction>(); this.rtlc = RtlClass.Linear; this.m = new RtlEmitter(rtlInstructions); switch (instr.opcode) { default: host.Warn( instr.Address, "Rewriting of Risc-V instruction '{0}' not implemented yet.", instr.opcode); rtlc = RtlClass.Invalid; m.Invalid(); break; case Opcode.invalid: rtlc = RtlClass.Invalid; m.Invalid(); break; case Opcode.add: RewriteAdd(); break; case Opcode.addi: RewriteAdd(); break; case Opcode.addiw: RewriteAddw(); break; case Opcode.addw: RewriteAddw(); break; case Opcode.and: RewriteAnd(); break; case Opcode.andi: RewriteAnd(); break; case Opcode.auipc: RewriteAuipc(); break; case Opcode.beq: RewriteBranch(m.Eq); break; case Opcode.bge: RewriteBranch(m.Ge); break; case Opcode.bgeu: RewriteBranch(m.Uge); break; case Opcode.blt: RewriteBranch(m.Lt); break; case Opcode.bltu: RewriteBranch(m.Ult); break; case Opcode.bne: RewriteBranch(m.Ne); break; case Opcode.fcvt_d_s: RewriteFcvt(PrimitiveType.Real64); break; case Opcode.feq_s: RewriteFcmp(PrimitiveType.Real32, m.FEq); break; case Opcode.fmadd_s: RewriteFmadd(PrimitiveType.Real32, m.FAdd); break; case Opcode.fmv_d_x: RewriteFcvt(PrimitiveType.Real64); break; case Opcode.fmv_s_x: RewriteFcvt(PrimitiveType.Real32); break; case Opcode.flw: RewriteFload(PrimitiveType.Real32); break; case Opcode.jal: RewriteJal(); break; case Opcode.jalr: RewriteJalr(); break; case Opcode.lb: RewriteLoad(PrimitiveType.SByte); break; case Opcode.lbu: RewriteLoad(PrimitiveType.Byte); break; case Opcode.ld: RewriteLoad(PrimitiveType.Word64); break; case Opcode.lh: RewriteLoad(PrimitiveType.Int16); break; case Opcode.lhu: RewriteLoad(PrimitiveType.UInt16); break; case Opcode.lui: RewriteLui(); break; case Opcode.lw: RewriteLoad(PrimitiveType.Int32); break; case Opcode.lwu: RewriteLoad(PrimitiveType.UInt32); break; case Opcode.or: RewriteOr(); break; case Opcode.ori: RewriteOr(); break; case Opcode.sb: RewriteStore(PrimitiveType.Byte); break; case Opcode.sd: RewriteStore(PrimitiveType.Word64); break; case Opcode.sh: RewriteStore(PrimitiveType.Word16); break; case Opcode.sw: RewriteStore(PrimitiveType.Word32); break; case Opcode.slli: RewriteShift(m.Shl); break; case Opcode.slliw: RewriteShiftw(m.Shl); break; case Opcode.sllw: RewriteShiftw(m.Shl); break; case Opcode.slt: RewriteSlt(false); break; case Opcode.sltu: RewriteSlt(true); break; case Opcode.srai: RewriteShift(m.Sar); break; case Opcode.sraiw: RewriteShiftw(m.Sar); break; case Opcode.srli: RewriteShift(m.Shr); break; case Opcode.srliw: RewriteShiftw(m.Shr); break; case Opcode.sub: RewriteSub(); break; case Opcode.subw: RewriteSubw(); break; case Opcode.xor: RewriteXor(); break; case Opcode.xori: RewriteXor(); break; } yield return(new RtlInstructionCluster( addr, len, rtlInstructions.ToArray()) { Class = rtlc, }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var addr = dasm.Current.Address; var len = dasm.Current.Length; rtlInstructions = new List <RtlInstruction>(); rtlc = dasm.Current.IClass; m = new RtlEmitter(rtlInstructions); switch (dasm.Current.Opcode) { default: //EmitUnitTest(); //emitter.SideEffect(Constant.String( // dasm.Current.ToString(), // StringType.NullTerminated(PrimitiveType.Char))); host.Warn( dasm.Current.Address, "VAX instruction {0} not supported yet.", dasm.Current.Opcode); m.Invalid(); break; case Opcode.Invalid: m.Invalid(); break; case Opcode.Reserved: m.Invalid(); break; case Opcode.acbb: RewriteAcbi(PrimitiveType.Byte); break; case Opcode.acbd: RewriteAcbf(PrimitiveType.Real64); break; case Opcode.acbf: RewriteAcbf(PrimitiveType.Real32); break; case Opcode.acbg: RewriteAcbf(PrimitiveType.Real64); break; case Opcode.acbh: RewriteAcbf(PrimitiveType.Real128); break; case Opcode.acbl: RewriteAcbi(PrimitiveType.Word32); break; case Opcode.acbw: RewriteAcbi(PrimitiveType.Word16); break; case Opcode.adawi: RewriteAlu2(PrimitiveType.Word16, Adawi, AllFlags); break; case Opcode.addb2: RewriteAlu2(PrimitiveType.Byte, m.IAdd, AllFlags); break; case Opcode.addb3: RewriteAlu3(PrimitiveType.Byte, m.IAdd, AllFlags); break; case Opcode.addd2: RewriteFpu2(PrimitiveType.Real64, m.FAdd, NZ00); break; case Opcode.addd3: RewriteFpu3(PrimitiveType.Real64, m.FAdd, NZ00); break; case Opcode.addf2: RewriteFpu2(PrimitiveType.Real32, m.FAdd, NZ00); break; case Opcode.addf3: RewriteFpu3(PrimitiveType.Real32, m.FAdd, NZ00); break; case Opcode.addl2: RewriteAlu2(PrimitiveType.Word32, m.IAdd, AllFlags); break; case Opcode.addl3: RewriteAlu3(PrimitiveType.Word32, m.IAdd, AllFlags); break; case Opcode.addp4: RewriteP4("vax_addp4"); break; case Opcode.addp6: RewriteP6("vax_addp6"); break; case Opcode.addw2: RewriteAlu2(PrimitiveType.Word16, m.IAdd, AllFlags); break; case Opcode.addw3: RewriteAlu3(PrimitiveType.Word16, m.IAdd, AllFlags); break; case Opcode.adwc: RewriteAdwc(); break; case Opcode.aobleq: RewriteAob(m.Le); break; case Opcode.aoblss: RewriteAob(m.Lt); break; case Opcode.ashl: RewriteAsh(PrimitiveType.Word32); break; case Opcode.ashp: RewriteAshp(); break; case Opcode.ashq: RewriteAsh(PrimitiveType.Word64); break; case Opcode.bbc: RewriteBb(false); break; case Opcode.bbcc: RewriteBbxx(false, false); break; case Opcode.bbcci: RewriteBbxxi(false); break; case Opcode.bbcs: RewriteBbxx(false, true); break; case Opcode.bbs: RewriteBb(true); break; case Opcode.bbsc: RewriteBbxx(true, false); break; case Opcode.bbss: RewriteBbxx(true, true); break; case Opcode.bbssi: RewriteBbxxi(true); break; case Opcode.beql: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break; case Opcode.bgeq: RewriteBranch(ConditionCode.GE, FlagM.NF); break; case Opcode.bgequ: RewriteBranch(ConditionCode.UGE, FlagM.CF); break; case Opcode.bgtr: RewriteBranch(ConditionCode.GT, FlagM.ZF | FlagM.NF); break; case Opcode.bgtru: RewriteBranch(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break; case Opcode.bleq: RewriteBranch(ConditionCode.LE, FlagM.ZF | FlagM.NF); break; case Opcode.blequ: RewriteBranch(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break; case Opcode.blss: RewriteBranch(ConditionCode.LT, FlagM.NF); break; case Opcode.blssu: RewriteBranch(ConditionCode.ULT, FlagM.CF); break; case Opcode.bneq: RewriteBranch(ConditionCode.NE, FlagM.ZF); break; case Opcode.bvc: RewriteBranch(ConditionCode.NO, FlagM.VF); break; case Opcode.bvs: RewriteBranch(ConditionCode.OV, FlagM.VF); break; case Opcode.bicb2: RewriteAlu2(PrimitiveType.Byte, Bic, NZ00); break; case Opcode.bicb3: RewriteAlu3(PrimitiveType.Byte, Bic, NZ00); break; case Opcode.bicl2: RewriteAlu2(PrimitiveType.Word32, Bic, NZ00); break; case Opcode.bicl3: RewriteAlu3(PrimitiveType.Word32, Bic, NZ00); break; case Opcode.bicpsw: RewriteBicpsw(); break; case Opcode.bicw2: RewriteAlu2(PrimitiveType.Word16, Bic, NZ00); break; case Opcode.bicw3: RewriteAlu3(PrimitiveType.Word16, Bic, NZ00); break; case Opcode.bisb2: RewriteAlu2(PrimitiveType.Byte, m.Or, NZ00); break; case Opcode.bisb3: RewriteAlu3(PrimitiveType.Byte, m.Or, NZ00); break; case Opcode.bispsw: RewriteBispsw(); break; case Opcode.bisl2: RewriteAlu2(PrimitiveType.Word32, m.Or, NZ00); break; case Opcode.bisl3: RewriteAlu3(PrimitiveType.Word32, m.Or, NZ00); break; case Opcode.bisw2: RewriteAlu2(PrimitiveType.Word16, m.Or, NZ00); break; case Opcode.bisw3: RewriteAlu3(PrimitiveType.Word16, m.Or, NZ00); break; case Opcode.bitb: RewriteBit(PrimitiveType.Byte); break; case Opcode.bitw: RewriteBit(PrimitiveType.Byte); break; case Opcode.bitl: RewriteBit(PrimitiveType.Byte); break; case Opcode.blbc: RewriteBlb(m.Eq0); break; case Opcode.blbs: RewriteBlb(m.Ne0); break; case Opcode.bpt: RewriteBpt(); break; case Opcode.brb: RewriteBranch(); break; case Opcode.brw: RewriteBranch(); break; case Opcode.bsbb: RewriteBsb(); break; case Opcode.bsbw: RewriteBsb(); break; case Opcode.caseb: goto default; case Opcode.casel: goto default; case Opcode.chme: RewriteChm("vax_chme"); break; case Opcode.chmk: RewriteChm("vax_chmk"); break; case Opcode.chms: RewriteChm("vax_chms"); break; case Opcode.chmu: RewriteChm("vax_chmu"); break; case Opcode.clrb: RewriteClr(PrimitiveType.Byte); break; case Opcode.clrh: RewriteClr(PrimitiveType.Word128); break; case Opcode.clrl: RewriteClr(PrimitiveType.Word32); break; case Opcode.clrq: RewriteClr(PrimitiveType.Word64); break; case Opcode.clrw: RewriteClr(PrimitiveType.Word16); break; case Opcode.cmpb: RewriteCmp(PrimitiveType.Byte); break; case Opcode.cmpd: RewriteCmp(PrimitiveType.Real64); break; case Opcode.cmpf: RewriteCmp(PrimitiveType.Real32); break; case Opcode.cmpg: RewriteCmp(PrimitiveType.Real64); break; case Opcode.cmph: RewriteCmp(PrimitiveType.Real128); break; case Opcode.cmpl: RewriteCmp(PrimitiveType.Word32); break; case Opcode.cmpw: RewriteCmp(PrimitiveType.Word16); break; case Opcode.cmpp3: RewriteCmpp3(); break; case Opcode.cmpp4: RewriteCmpp4(); break; case Opcode.cmpv: goto default; case Opcode.cmpzv: goto default; case Opcode.cvtbd: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break; case Opcode.cvtbf: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real32); break; case Opcode.cvtbg: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break; case Opcode.cvtbh: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real128); break; case Opcode.cvtbl: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int32); break; case Opcode.cvtbw: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int16); break; case Opcode.cvtdb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break; case Opcode.cvtdf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break; case Opcode.cvtdh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break; case Opcode.cvtdl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break; case Opcode.cvtdw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break; case Opcode.cvtfb: RewriteCvt(PrimitiveType.Real32, PrimitiveType.SByte); break; case Opcode.cvtfd: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break; case Opcode.cvtfg: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break; case Opcode.cvtfh: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real128); break; case Opcode.cvtfl: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int32); break; case Opcode.cvtfw: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int16); break; case Opcode.cvtgb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break; case Opcode.cvtgf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break; case Opcode.cvtgh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break; case Opcode.cvtgl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break; case Opcode.cvtgw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break; case Opcode.cvthb: RewriteCvt(PrimitiveType.Real128, PrimitiveType.SByte); break; case Opcode.cvthd: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break; case Opcode.cvthf: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real32); break; case Opcode.cvthg: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break; case Opcode.cvthl: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int32); break; case Opcode.cvthw: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int16); break; case Opcode.cvtps: RewriteCvtComplex("__cvtps"); break; case Opcode.cvtrdl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break; case Opcode.cvtrfl: RewriteCvtr(PrimitiveType.Real32, PrimitiveType.Int32); break; case Opcode.cvtrgl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break; case Opcode.cvtrhl: RewriteCvtr(PrimitiveType.Real128, PrimitiveType.Int32); break; case Opcode.cvtlb: RewriteCvt(PrimitiveType.Int32, PrimitiveType.SByte); break; case Opcode.cvtld: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break; case Opcode.cvtlf: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real32); break; case Opcode.cvtlg: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break; case Opcode.cvtlh: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real128); break; case Opcode.cvtlp: goto default; case Opcode.cvtlw: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Int16); break; case Opcode.cvtpl: goto default; case Opcode.cvtpt: goto default; case Opcode.cvtsp: RewriteCvtComplex("__cvtsp"); break; case Opcode.cvttp: goto default; case Opcode.cvtwb: RewriteCvt(PrimitiveType.Int16, PrimitiveType.SByte); break; case Opcode.cvtwd: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break; case Opcode.cvtwf: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real32); break; case Opcode.cvtwg: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break; case Opcode.cvtwh: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real128); break; case Opcode.cvtwl: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Int32); break;; case Opcode.decb: RewriteIncDec(PrimitiveType.Byte, Dec); break; case Opcode.decl: RewriteIncDec(PrimitiveType.Word32, Dec); break; case Opcode.decw: RewriteIncDec(PrimitiveType.Word16, Dec); break; case Opcode.divb2: RewriteAlu2(PrimitiveType.Byte, m.SDiv, AllFlags); break; case Opcode.divb3: RewriteAlu3(PrimitiveType.Byte, m.SDiv, AllFlags); break; case Opcode.divd2: RewriteFpu2(PrimitiveType.Real64, m.FDiv, AllFlags); break; case Opcode.divd3: RewriteFpu3(PrimitiveType.Real64, m.FDiv, AllFlags); break; case Opcode.divf2: RewriteFpu2(PrimitiveType.Real32, m.FDiv, AllFlags); break; case Opcode.divf3: RewriteFpu3(PrimitiveType.Real32, m.FDiv, AllFlags); break; case Opcode.divl2: RewriteAlu2(PrimitiveType.Word32, m.SDiv, AllFlags); break; case Opcode.divl3: RewriteAlu3(PrimitiveType.Word32, m.SDiv, AllFlags); break; case Opcode.divp: RewriteDivp(); break; case Opcode.divw2: RewriteAlu2(PrimitiveType.Word16, m.SDiv, AllFlags); break; case Opcode.divw3: RewriteAlu3(PrimitiveType.Word16, m.SDiv, AllFlags); break; case Opcode.emodd: RewriteEmod("emodd", PrimitiveType.Real64, PrimitiveType.Byte); break; //$TODO: VAX floating point types case Opcode.emodf: RewriteEmod("emodf", PrimitiveType.Real32, PrimitiveType.Byte); break; //$TODO: VAX floating point types case Opcode.emodg: RewriteEmod("emodg", PrimitiveType.Real64, PrimitiveType.Word16); break; //$TODO: VAX floating point types case Opcode.emodh: RewriteEmod("emodh", PrimitiveType.Real128, PrimitiveType.Word16); break; //$TODO: VAX floating point types case Opcode.ffc: RewriteFfx("__ffc"); break; case Opcode.ffs: RewriteFfx("__ffs"); break; case Opcode.halt: RewriteHalt(); break; case Opcode.incb: RewriteIncDec(PrimitiveType.Byte, Inc); break; case Opcode.incl: RewriteIncDec(PrimitiveType.Word32, Inc); break; case Opcode.incw: RewriteIncDec(PrimitiveType.Word16, Inc); break; case Opcode.insque: RewriteInsque(); break; case Opcode.jmp: RewriteJmp(); break; case Opcode.jsb: RewriteJsb(); break; case Opcode.mcomb: RewriteAluUnary2(PrimitiveType.Byte, m.Comp, NZ00); break; case Opcode.mcoml: RewriteAluUnary2(PrimitiveType.Word32, m.Comp, NZ00); break; case Opcode.mcomw: RewriteAluUnary2(PrimitiveType.Word16, m.Comp, NZ00); break; case Opcode.mnegb: RewriteAluUnary2(PrimitiveType.Byte, m.Neg, AllFlags); break; case Opcode.mnegd: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break; case Opcode.mnegf: RewriteAluUnary2(PrimitiveType.Real32, m.FNeg, NZ00); break; case Opcode.mnegg: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break; case Opcode.mnegh: RewriteAluUnary2(PrimitiveType.Word128, m.FNeg, NZ00); break; case Opcode.mnegl: RewriteAluUnary2(PrimitiveType.Word32, m.Neg, AllFlags); break; case Opcode.mnegw: RewriteAluUnary2(PrimitiveType.Word16, m.Neg, AllFlags); break; case Opcode.movab: RewriteMova(PrimitiveType.Byte); break; case Opcode.movah: RewriteMova(PrimitiveType.Real128); break; case Opcode.moval: RewriteMova(PrimitiveType.Word32); break; case Opcode.movaq: RewriteMova(PrimitiveType.Word64); break; case Opcode.movaw: RewriteMova(PrimitiveType.Word16); break; case Opcode.movb: RewriteAluUnary2(PrimitiveType.Byte, Copy, NZ00); break; case Opcode.movc3: goto default; case Opcode.movc5: goto default; case Opcode.movd: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break; case Opcode.movf: RewriteAluUnary2(PrimitiveType.Real32, Copy, NZ00); break; case Opcode.movg: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break; case Opcode.movh: RewriteAluUnary2(PrimitiveType.Real128, Copy, NZ00); break; case Opcode.movl: RewriteAluUnary2(PrimitiveType.Word32, Copy, NZ00); break; case Opcode.movo: RewriteAluUnary2(PrimitiveType.Word128, Copy, NZ00); break; case Opcode.movp: goto default; case Opcode.movq: RewriteAluUnary2(PrimitiveType.Word64, Copy, NZ00); break; case Opcode.movw: RewriteAluUnary2(PrimitiveType.Word16, Copy, NZ00); break; case Opcode.movzbl: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt32); break; case Opcode.movzbw: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt16); break; case Opcode.movzwl: RewriteMovz(PrimitiveType.Word16, PrimitiveType.UInt32); break; case Opcode.mulb2: RewriteAlu2(PrimitiveType.Byte, m.IMul, AllFlags); break; case Opcode.mulb3: RewriteAlu3(PrimitiveType.Byte, m.IMul, AllFlags); break; case Opcode.muld2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break; case Opcode.muld3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break; case Opcode.mulf2: RewriteAlu2(PrimitiveType.Real32, m.FMul, AllFlags); break; case Opcode.mulf3: RewriteAlu3(PrimitiveType.Real32, m.FMul, AllFlags); break; case Opcode.mulg2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break; case Opcode.mulg3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break; case Opcode.mulh2: RewriteAlu2(PrimitiveType.Real128, m.FMul, AllFlags); break; case Opcode.mulh3: RewriteAlu3(PrimitiveType.Real128, m.FMul, AllFlags); break; case Opcode.mull2: RewriteAlu2(PrimitiveType.Word32, m.IMul, AllFlags); break; case Opcode.mull3: RewriteAlu3(PrimitiveType.Word32, m.IMul, AllFlags); break; case Opcode.mulp: RewriteMulp(); break; case Opcode.mulw2: RewriteAlu2(PrimitiveType.Word16, m.IMul, AllFlags); break; case Opcode.mulw3: RewriteAlu3(PrimitiveType.Word16, m.IMul, AllFlags); break; case Opcode.nop: m.Nop(); break; case Opcode.polyd: RewritePoly(PrimitiveType.Real64); break; case Opcode.polyf: RewritePoly(PrimitiveType.Real32); break; case Opcode.polyg: RewritePoly(PrimitiveType.Real64); break; case Opcode.polyh: RewritePoly(PrimitiveType.Real128); break; case Opcode.popr: goto default; case Opcode.prober: goto default; case Opcode.probew: goto default; case Opcode.pushr: goto default; case Opcode.pushab: RewritePusha(); break; case Opcode.pushal: RewritePusha(); break; case Opcode.pushah: RewritePusha(); break; case Opcode.pushaw: RewritePusha(); break; case Opcode.pushaq: RewritePusha(); break; case Opcode.pushl: RewritePush(PrimitiveType.Word32); break; case Opcode.rei: RewriteRei(); break; case Opcode.ret: RewriteRet(); break; case Opcode.rotl: RewriteAlu3(PrimitiveType.Word32, Rotl, NZ00); break; case Opcode.rsb: RewriteRsb(); break; case Opcode.sbwc: RewriteSbwc(); break; case Opcode.scanc: RewriteScanc(); break; case Opcode.sobgeq: RewriteSob(m.Ge); break; case Opcode.sobgtr: RewriteSob(m.Gt); break; case Opcode.subb2: RewriteAlu2(PrimitiveType.Byte, m.ISub, AllFlags); break; case Opcode.subb3: RewriteAlu3(PrimitiveType.Byte, m.ISub, AllFlags); break; case Opcode.subd2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break; case Opcode.subd3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break; case Opcode.subf2: RewriteAlu2(PrimitiveType.Real32, m.FSub, NZ00); break; case Opcode.subf3: RewriteAlu3(PrimitiveType.Real32, m.FSub, NZ00); break; case Opcode.subg2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break; case Opcode.subg3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break; case Opcode.subh2: RewriteAlu2(PrimitiveType.Real128, m.FSub, NZ00); break; case Opcode.subh3: RewriteAlu3(PrimitiveType.Real128, m.FSub, NZ00); break; case Opcode.subl2: RewriteAlu2(PrimitiveType.Word32, m.ISub, AllFlags); break; case Opcode.subl3: RewriteAlu3(PrimitiveType.Word32, m.ISub, AllFlags); break; case Opcode.subp4: RewriteP4("vax_subp4"); break; case Opcode.subp6: RewriteP6("vax_subp6"); break; case Opcode.subw2: RewriteAlu2(PrimitiveType.Word16, m.ISub, AllFlags); break; case Opcode.subw3: RewriteAlu3(PrimitiveType.Word16, m.ISub, AllFlags); break; case Opcode.tstb: RewriteTst(PrimitiveType.Byte, ICmp0); break; case Opcode.tstd: RewriteTst(PrimitiveType.Real64, FCmp0); break; case Opcode.tstf: RewriteTst(PrimitiveType.Real32, FCmp0); break; case Opcode.tstg: RewriteTst(PrimitiveType.Real64, FCmp0); break; case Opcode.tsth: RewriteTst(PrimitiveType.Real128, FCmp0); break; case Opcode.tstl: RewriteTst(PrimitiveType.Word32, ICmp0); break; case Opcode.tstw: RewriteTst(PrimitiveType.Word16, ICmp0); break; case Opcode.xorb2: RewriteAlu2(PrimitiveType.Byte, m.Xor, NZ00); break; case Opcode.xorb3: RewriteAlu3(PrimitiveType.Byte, m.Xor, NZ00); break; case Opcode.xorl2: RewriteAlu2(PrimitiveType.Word32, m.Xor, NZ00); break; case Opcode.xorl3: RewriteAlu3(PrimitiveType.Word32, m.Xor, NZ00); break; case Opcode.xorw2: RewriteAlu2(PrimitiveType.Word16, m.Xor, NZ00); break; case Opcode.xorw3: RewriteAlu3(PrimitiveType.Word16, m.Xor, NZ00); break; case Opcode.ldpctx: goto default; case Opcode.svpctx: goto default; case Opcode.editpc: goto default; case Opcode.matchc: goto default; case Opcode.index: goto default; case Opcode.locc: goto default; case Opcode.crc: goto default; case Opcode.skpc: goto default; case Opcode.remque: goto default; case Opcode.spanc: goto default; case Opcode.insqhi: goto default; case Opcode.insqti: goto default; case Opcode.movtc: goto default; case Opcode.remqhi: goto default; case Opcode.movtuc: goto default; case Opcode.remqti: goto default; case Opcode.emul: goto default; case Opcode.ediv: goto default; case Opcode.casew: goto default; case Opcode.extv: goto default; case Opcode.extzv: goto default; case Opcode.insv: goto default; case Opcode.mtpr: goto default; case Opcode.callg: goto default; case Opcode.mfpr: goto default; case Opcode.calls: goto default; case Opcode.movpsl: goto default; case Opcode.xfc: goto default; case Opcode.mfvp: goto default; case Opcode.vldl: goto default; case Opcode.vgathl: goto default; case Opcode.vldq: goto default; case Opcode.vgathq: goto default; case Opcode.addg2: goto default; case Opcode.addg3: goto default; case Opcode.divg2: goto default; case Opcode.divg3: goto default; case Opcode.addh2: goto default; case Opcode.addh3: goto default; case Opcode.divh2: goto default; case Opcode.divh3: goto default; case Opcode.vstl: goto default; case Opcode.vscatl: goto default; case Opcode.vstq: goto default; case Opcode.vscatq: goto default; case Opcode.vvmull: goto default; case Opcode.vsmull: goto default; case Opcode.vvmulg: goto default; case Opcode.vsmulg: goto default; case Opcode.vvmulf: goto default; case Opcode.vsmulf: goto default; case Opcode.vvmuld: goto default; case Opcode.vsmuld: goto default; case Opcode.vsync: goto default; case Opcode.mtvp: goto default; case Opcode.vvdivg: goto default; case Opcode.vsdivg: goto default; case Opcode.vvdivf: goto default; case Opcode.vsdivf: goto default; case Opcode.vvdivd: goto default; case Opcode.vsdivd: goto default; case Opcode.vvaddl: goto default; case Opcode.vsaddl: goto default; case Opcode.vvaddg: goto default; case Opcode.vsaddg: goto default; case Opcode.vvaddf: goto default; case Opcode.vsaddf: goto default; case Opcode.vvaddd: goto default; case Opcode.vsaddd: goto default; case Opcode.vvsubl: goto default; case Opcode.vssubl: goto default; case Opcode.vvsubg: goto default; case Opcode.vssubg: goto default; case Opcode.vvsubf: goto default; case Opcode.vssubf: goto default; case Opcode.vvsubd: goto default; case Opcode.vssubd: goto default; case Opcode.vvcmpl: goto default; case Opcode.vvsrll: goto default; case Opcode.vscmpl: goto default; case Opcode.vssrll: goto default; case Opcode.vvcmpg: goto default; case Opcode.vscmpg: goto default; case Opcode.vvcmpf: goto default; case Opcode.vvslll: goto default; case Opcode.vscmpf: goto default; case Opcode.vsslll: goto default; case Opcode.vvcmpd: goto default; case Opcode.vscmpd: goto default; case Opcode.vvbisl: goto default; case Opcode.vvxorl: goto default; case Opcode.vsbisl: goto default; case Opcode.vsxorl: goto default; case Opcode.vvbicl: goto default; case Opcode.vvcvt: goto default; case Opcode.vsbicl: goto default; case Opcode.iota: goto default; case Opcode.vvmerge: goto default; case Opcode.vsmerge: goto default; case Opcode.bugl: goto default; case Opcode.bugw: goto default; } yield return(new RtlInstructionCluster( addr, len, rtlInstructions.ToArray()) { Class = rtlc }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (instrs.MoveNext()) { if (!instrs.Current.TryGetInternal(out this.instr)) { throw new AddressCorrelatedException( instrs.Current.Address, "Invalid opcode cannot be rewritten to IR."); } this.ops = instr.ArchitectureDetail.Operands; this.ric = new RtlInstructionCluster(instrs.Current.Address, instr.Bytes.Length); this.ric.Class = RtlClass.Linear; this.emitter = new RtlEmitter(ric.Instructions); switch (instr.Id) { default: case Opcode.ADC: case Opcode.ADR: case Opcode.AESD: case Opcode.AESE: case Opcode.AESIMC: case Opcode.AESMC: case Opcode.BFC: case Opcode.BFI: case Opcode.BKPT: case Opcode.BXJ: case Opcode.CDP: case Opcode.CDP2: case Opcode.CLREX: case Opcode.CLZ: case Opcode.CPS: case Opcode.CRC32B: case Opcode.CRC32CB: case Opcode.CRC32CH: case Opcode.CRC32CW: case Opcode.CRC32H: case Opcode.CRC32W: case Opcode.DBG: case Opcode.DMB: case Opcode.DSB: case Opcode.VMOV: case Opcode.FLDMDBX: case Opcode.FLDMIAX: case Opcode.VMRS: case Opcode.FSTMDBX: case Opcode.FSTMIAX: case Opcode.HINT: case Opcode.HLT: case Opcode.ISB: case Opcode.LDA: case Opcode.LDAB: case Opcode.LDAEX: case Opcode.LDAEXB: case Opcode.LDAEXD: case Opcode.LDAEXH: case Opcode.LDAH: case Opcode.LDC2L: case Opcode.LDC2: case Opcode.LDCL: case Opcode.LDC: case Opcode.LDMDA: case Opcode.LDMIB: case Opcode.LDRBT: case Opcode.LDRD: case Opcode.LDREX: case Opcode.LDREXB: case Opcode.LDREXD: case Opcode.LDREXH: case Opcode.LDRHT: case Opcode.LDRSBT: case Opcode.LDRSHT: case Opcode.LDRT: case Opcode.MCR: case Opcode.MCR2: case Opcode.MCRR: case Opcode.MCRR2: case Opcode.MLA: case Opcode.MLS: case Opcode.MOVT: case Opcode.MOVW: case Opcode.MRC: case Opcode.MRC2: case Opcode.MRRC: case Opcode.MRRC2: case Opcode.MRS: case Opcode.MSR: case Opcode.MUL: case Opcode.PKHBT: case Opcode.PKHTB: case Opcode.PLDW: case Opcode.PLD: case Opcode.PLI: case Opcode.QADD: case Opcode.QADD16: case Opcode.QADD8: case Opcode.QASX: case Opcode.QDADD: case Opcode.QDSUB: case Opcode.QSAX: case Opcode.QSUB: case Opcode.QSUB16: case Opcode.QSUB8: case Opcode.RBIT: case Opcode.REV: case Opcode.REV16: case Opcode.REVSH: case Opcode.RFEDA: case Opcode.RFEDB: case Opcode.RFEIA: case Opcode.RFEIB: case Opcode.RSC: case Opcode.SADD16: case Opcode.SADD8: case Opcode.SASX: case Opcode.SBC: case Opcode.SBFX: case Opcode.SDIV: case Opcode.SEL: case Opcode.SETEND: case Opcode.SHA1C: case Opcode.SHA1H: case Opcode.SHA1M: case Opcode.SHA1P: case Opcode.SHA1SU0: case Opcode.SHA1SU1: case Opcode.SHA256H: case Opcode.SHA256H2: case Opcode.SHA256SU0: case Opcode.SHA256SU1: case Opcode.SHADD16: case Opcode.SHADD8: case Opcode.SHASX: case Opcode.SHSAX: case Opcode.SHSUB16: case Opcode.SHSUB8: case Opcode.SMC: case Opcode.SMLABB: case Opcode.SMLABT: case Opcode.SMLAD: case Opcode.SMLADX: case Opcode.SMLAL: case Opcode.SMLALBB: case Opcode.SMLALBT: case Opcode.SMLALD: case Opcode.SMLALDX: case Opcode.SMLALTB: case Opcode.SMLALTT: case Opcode.SMLATB: case Opcode.SMLATT: case Opcode.SMLAWB: case Opcode.SMLAWT: case Opcode.SMLSD: case Opcode.SMLSDX: case Opcode.SMLSLD: case Opcode.SMLSLDX: case Opcode.SMMLA: case Opcode.SMMLAR: case Opcode.SMMLS: case Opcode.SMMLSR: case Opcode.SMMUL: case Opcode.SMMULR: case Opcode.SMUAD: case Opcode.SMUADX: case Opcode.SMULBB: case Opcode.SMULBT: case Opcode.SMULL: case Opcode.SMULTB: case Opcode.SMULTT: case Opcode.SMULWB: case Opcode.SMULWT: case Opcode.SMUSD: case Opcode.SMUSDX: case Opcode.SRSDA: case Opcode.SRSDB: case Opcode.SRSIA: case Opcode.SRSIB: case Opcode.SSAT: case Opcode.SSAT16: case Opcode.SSAX: case Opcode.SSUB16: case Opcode.SSUB8: case Opcode.STC2L: case Opcode.STC2: case Opcode.STCL: case Opcode.STC: case Opcode.STL: case Opcode.STLB: case Opcode.STLEX: case Opcode.STLEXB: case Opcode.STLEXD: case Opcode.STLEXH: case Opcode.STLH: case Opcode.STMDA: case Opcode.STRBT: case Opcode.STRD: case Opcode.STREX: case Opcode.STREXB: case Opcode.STREXD: case Opcode.STREXH: case Opcode.STRHT: case Opcode.STRT: case Opcode.SWP: case Opcode.SWPB: case Opcode.SXTAB: case Opcode.SXTAB16: case Opcode.SXTAH: case Opcode.SXTB: case Opcode.SXTB16: case Opcode.SXTH: case Opcode.TRAP: case Opcode.UADD16: case Opcode.UADD8: case Opcode.UASX: case Opcode.UBFX: case Opcode.UDF: case Opcode.UDIV: case Opcode.UHADD16: case Opcode.UHADD8: case Opcode.UHASX: case Opcode.UHSAX: case Opcode.UHSUB16: case Opcode.UHSUB8: case Opcode.UMAAL: case Opcode.UMLAL: case Opcode.UMULL: case Opcode.UQADD16: case Opcode.UQADD8: case Opcode.UQASX: case Opcode.UQSAX: case Opcode.UQSUB16: case Opcode.UQSUB8: case Opcode.USAD8: case Opcode.USADA8: case Opcode.USAT: case Opcode.USAT16: case Opcode.USAX: case Opcode.USUB16: case Opcode.USUB8: case Opcode.UXTAB: case Opcode.UXTAB16: case Opcode.UXTAH: case Opcode.UXTB: case Opcode.UXTB16: case Opcode.UXTH: case Opcode.VABAL: case Opcode.VABA: case Opcode.VABDL: case Opcode.VABD: case Opcode.VABS: case Opcode.VACGE: case Opcode.VACGT: case Opcode.VADD: case Opcode.VADDHN: case Opcode.VADDL: case Opcode.VADDW: case Opcode.VAND: case Opcode.VBIC: case Opcode.VBIF: case Opcode.VBIT: case Opcode.VBSL: case Opcode.VCEQ: case Opcode.VCGE: case Opcode.VCGT: case Opcode.VCLE: case Opcode.VCLS: case Opcode.VCLT: case Opcode.VCLZ: case Opcode.VCMP: case Opcode.VCMPE: case Opcode.VCNT: case Opcode.VCVTA: case Opcode.VCVTB: case Opcode.VCVT: case Opcode.VCVTM: case Opcode.VCVTN: case Opcode.VCVTP: case Opcode.VCVTT: case Opcode.VDIV: case Opcode.VDUP: case Opcode.VEOR: case Opcode.VEXT: case Opcode.VFMA: case Opcode.VFMS: case Opcode.VFNMA: case Opcode.VFNMS: case Opcode.VHADD: case Opcode.VHSUB: case Opcode.VLD1: case Opcode.VLD2: case Opcode.VLD3: case Opcode.VLD4: case Opcode.VLDMDB: case Opcode.VLDMIA: case Opcode.VLDR: case Opcode.VMAXNM: case Opcode.VMAX: case Opcode.VMINNM: case Opcode.VMIN: case Opcode.VMLA: case Opcode.VMLAL: case Opcode.VMLS: case Opcode.VMLSL: case Opcode.VMOVL: case Opcode.VMOVN: case Opcode.VMSR: case Opcode.VMUL: case Opcode.VMULL: case Opcode.VMVN: case Opcode.VNEG: case Opcode.VNMLA: case Opcode.VNMLS: case Opcode.VNMUL: case Opcode.VORN: case Opcode.VORR: case Opcode.VPADAL: case Opcode.VPADDL: case Opcode.VPADD: case Opcode.VPMAX: case Opcode.VPMIN: case Opcode.VQABS: case Opcode.VQADD: case Opcode.VQDMLAL: case Opcode.VQDMLSL: case Opcode.VQDMULH: case Opcode.VQDMULL: case Opcode.VQMOVUN: case Opcode.VQMOVN: case Opcode.VQNEG: case Opcode.VQRDMULH: case Opcode.VQRSHL: case Opcode.VQRSHRN: case Opcode.VQRSHRUN: case Opcode.VQSHL: case Opcode.VQSHLU: case Opcode.VQSHRN: case Opcode.VQSHRUN: case Opcode.VQSUB: case Opcode.VRADDHN: case Opcode.VRECPE: case Opcode.VRECPS: case Opcode.VREV16: case Opcode.VREV32: case Opcode.VREV64: case Opcode.VRHADD: case Opcode.VRINTA: case Opcode.VRINTM: case Opcode.VRINTN: case Opcode.VRINTP: case Opcode.VRINTR: case Opcode.VRINTX: case Opcode.VRINTZ: case Opcode.VRSHL: case Opcode.VRSHRN: case Opcode.VRSHR: case Opcode.VRSQRTE: case Opcode.VRSQRTS: case Opcode.VRSRA: case Opcode.VRSUBHN: case Opcode.VSELEQ: case Opcode.VSELGE: case Opcode.VSELGT: case Opcode.VSELVS: case Opcode.VSHLL: case Opcode.VSHL: case Opcode.VSHRN: case Opcode.VSHR: case Opcode.VSLI: case Opcode.VSQRT: case Opcode.VSRA: case Opcode.VSRI: case Opcode.VST1: case Opcode.VST2: case Opcode.VST3: case Opcode.VST4: case Opcode.VSTMDB: case Opcode.VSTMIA: case Opcode.VSTR: case Opcode.VSUB: case Opcode.VSUBHN: case Opcode.VSUBL: case Opcode.VSUBW: case Opcode.VSWP: case Opcode.VTBL: case Opcode.VTBX: case Opcode.VCVTR: case Opcode.VTRN: case Opcode.VTST: case Opcode.VUZP: case Opcode.VZIP: case Opcode.ADDW: case Opcode.ASR: case Opcode.DCPS1: case Opcode.DCPS2: case Opcode.DCPS3: case Opcode.IT: case Opcode.LSL: case Opcode.LSR: case Opcode.ASRS: case Opcode.LSRS: case Opcode.ORN: case Opcode.ROR: case Opcode.RRX: case Opcode.SUBS: case Opcode.SUBW: case Opcode.TBB: case Opcode.TBH: case Opcode.CBNZ: case Opcode.CBZ: case Opcode.MOVS: case Opcode.POP: case Opcode.YIELD: case Opcode.WFE: case Opcode.WFI: case Opcode.SEV: case Opcode.SEVL: case Opcode.VPUSH: case Opcode.VPOP: host.Error( instrs.Current.Address, string.Format( "Rewriting ARM opcode '{0}' is not supported yet.", instr.Mnemonic)); emitter.Invalid(); break; case Opcode.AND: RewriteBinOp(emitter.And, instr.ArchitectureDetail.UpdateFlags); break; case Opcode.ADD: RewriteBinOp(emitter.IAdd, instr.ArchitectureDetail.UpdateFlags); break; case Opcode.EOR: RewriteBinOp(emitter.Xor, instr.ArchitectureDetail.UpdateFlags); break; case Opcode.B: RewriteB(false); break; case Opcode.BIC: RewriteBic(); break; case Opcode.BL: RewriteB(true); break; case Opcode.BLX: RewriteB(true); break; case Opcode.BX: RewriteB(false); break; case Opcode.CMN: RewriteCmn(); break; case Opcode.CMP: RewriteCmp(); break; case Opcode.LDR: RewriteLdr(PrimitiveType.Word32); break; case Opcode.LDRB: RewriteLdr(PrimitiveType.Byte); break; case Opcode.LDRH: RewriteLdr(PrimitiveType.UInt16); break; case Opcode.LDRSB: RewriteLdr(PrimitiveType.SByte); break; case Opcode.LDRSH: RewriteLdr(PrimitiveType.Int16); break; case Opcode.LDM: RewriteLdm(); break; case Opcode.LDMDB: RewriteLdm(); break; case Opcode.NOP: emitter.Nop(); break; case Opcode.MOV: RewriteMov(); break; case Opcode.MVN: RewriteUnaryOp(Operator.Not); break; case Opcode.ORR: RewriteBinOp(emitter.Or, false); break; case Opcode.PUSH: RewritePush(); break; case Opcode.RSB: RewriteRevBinOp(Operator.ISub, instr.ArchitectureDetail.UpdateFlags); break; case Opcode.STM: RewriteStm(); break; case Opcode.STMDB: RewriteStm(); break; case Opcode.STMIB: RewriteStmib(); break; case Opcode.STR: RewriteStr(PrimitiveType.Word32); break; case Opcode.STRB: RewriteStr(PrimitiveType.Byte); break; case Opcode.STRH: RewriteStr(PrimitiveType.UInt16); break; case Opcode.SUB: RewriteBinOp(emitter.ISub, instr.ArchitectureDetail.UpdateFlags); break; case Opcode.SVC: RewriteSvc(); break; case Opcode.TEQ: RewriteTeq(); break; case Opcode.TST: RewriteTst(); break; } yield return(ric); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.iclass = instr.InstructionClass; var rtls = new List <RtlInstruction>(); this.m = new RtlEmitter(rtls); switch (instr.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.Invalid; case Mnemonic.Invalid: case Mnemonic.reserved: m.Invalid(); break; case Mnemonic.add: RewriteBinop(m.IAdd); break; case Mnemonic.addi: RewriteBinop(m.IAdd); break; case Mnemonic.and: RewriteBinop(m.And); break; case Mnemonic.andhi: RewriteHiImm(m.And); break; case Mnemonic.andi: RewriteBinop(m.And); break; case Mnemonic.b: RewriteIndirectGoto(); break; case Mnemonic.be: RewriteBranch(m.Eq); break; case Mnemonic.bg: RewriteBranch(m.Gt); break; case Mnemonic.bge: RewriteBranch(m.Ge); break; case Mnemonic.bgeu: RewriteBranch(m.Uge); break; case Mnemonic.bgu: RewriteBranch(m.Ugt); break; case Mnemonic.bi: RewriteGoto(); break; case Mnemonic.bne: RewriteBranch(m.Ne); break; case Mnemonic.call: RewriteCall(); break; case Mnemonic.calli: RewriteCall(); break; case Mnemonic.cmpe: RewriteCmp(m.Eq); break; case Mnemonic.cmpei: RewriteCmp(m.Eq); break; case Mnemonic.cmpg: RewriteCmp(m.Gt); break; case Mnemonic.cmpgi: RewriteCmp(m.Gt); break; case Mnemonic.cmpge: RewriteCmp(m.Ge); break; case Mnemonic.cmpgei: RewriteCmp(m.Ge); break; case Mnemonic.cmpgeu: RewriteCmp(m.Uge); break; case Mnemonic.cmpgeui: RewriteCmp(m.Uge); break; case Mnemonic.cmpgu: RewriteCmp(m.Ugt); break; case Mnemonic.cmpgui: RewriteCmp(m.Ugt); break; case Mnemonic.cmpne: RewriteCmp(m.Ne); break; case Mnemonic.cmpnei: RewriteCmp(m.Ne); break; case Mnemonic.div: RewriteBinop(m.SDiv); break; case Mnemonic.divu: RewriteBinop(m.UDiv); break; case Mnemonic.lb: RewriteLoad(PrimitiveType.Int32); break; case Mnemonic.lbu: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.lh: RewriteLoad(PrimitiveType.Int32); break; case Mnemonic.lhu: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.lw: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.mod: RewriteBinop(m.Mod); break; case Mnemonic.modu: RewriteBinop(m.Mod); break; case Mnemonic.mul: RewriteBinop(m.IMul); break; case Mnemonic.muli: RewriteBinop(m.IMul); break; case Mnemonic.nor: RewriteBinop(Nor); break; case Mnemonic.nori: RewriteBinop(Nor); break; case Mnemonic.or: RewriteBinop(m.Or); break; case Mnemonic.orhi: RewriteHiImm(m.Or); break; case Mnemonic.ori: RewriteBinop(m.Or); break; case Mnemonic.sb: RewriteStore(); break; case Mnemonic.sextb: RewriteSext(PrimitiveType.SByte); break; case Mnemonic.sexth: RewriteSext(PrimitiveType.Int16); break; case Mnemonic.sh: RewriteStore(); break; case Mnemonic.sl: RewriteBinop(m.Shl); break; case Mnemonic.sli: RewriteBinop(m.Shl); break; case Mnemonic.sr: RewriteBinop(m.Sar); break; case Mnemonic.sri: RewriteBinop(m.Sar); break; case Mnemonic.sru: RewriteBinop(m.Shr); break; case Mnemonic.srui: RewriteBinop(m.Shr); break; case Mnemonic.sub: RewriteBinop(m.ISub); break; case Mnemonic.sw: RewriteStore(); break; case Mnemonic.xnor: RewriteBinop(Xnor); break; case Mnemonic.xnori: RewriteBinop(Xnor); break; case Mnemonic.xor: RewriteBinop(m.Xor); break; case Mnemonic.xori: RewriteBinop(m.Xor); break; } yield return(new RtlInstructionCluster(instr.Address, instr.Length, rtls.ToArray()) { Class = iclass }); } }
private void RewriteExg() { EmitUnitTest(); iclass = InstrClass.Invalid; m.Invalid(); }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { var instrs = new List <RtlInstruction>(); while (dasm.MoveNext()) { this.instr = dasm.Current; this.iclass = instr.InstructionClass; instrs.Clear(); this.m = new RtlEmitter(instrs); switch (instr.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.invalid; case Mnemonic.invalid: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.abx: RewriteAbx(); break; case Mnemonic.adca: RewriteBinary(Registers.A, Adc, NZVC); break; case Mnemonic.adcb: RewriteBinary(Registers.B, Adc, NZVC); break; case Mnemonic.adda: RewriteBinary(Registers.A, m.IAdd, NZVC); break; case Mnemonic.addb: RewriteBinary(Registers.B, m.IAdd, NZVC); break; case Mnemonic.addd: RewriteBinary(Registers.D, m.IAdd, NZVC); break; case Mnemonic.anda: RewriteBinary(Registers.A, m.And, NZ0_); break; case Mnemonic.andb: RewriteBinary(Registers.B, m.And, NZ0_); break; case Mnemonic.andcc: RewriteModifyCc(m.And); break; case Mnemonic.asr: RewriteUnary(Shl1, NZ_C); break; case Mnemonic.beq: RewriteBranch(ConditionCode.EQ, FlagM.Z); break; case Mnemonic.bge: RewriteBranch(ConditionCode.GE, FlagM.N | FlagM.V); break; case Mnemonic.bgt: RewriteBranch(ConditionCode.GT, FlagM.N | FlagM.Z | FlagM.V); break; case Mnemonic.bhi: RewriteBranch(ConditionCode.UGT, FlagM.Z | FlagM.C); break; case Mnemonic.bhs: RewriteBranch(ConditionCode.UGE, FlagM.C); break; case Mnemonic.bita: RewriteBinaryTest(Registers.A, m.And, NZ0_); break; case Mnemonic.bitb: RewriteBinaryTest(Registers.A, m.And, NZ0_); break; case Mnemonic.ble: RewriteBranch(ConditionCode.LE, FlagM.N | FlagM.Z | FlagM.V); break; case Mnemonic.blo: RewriteBranch(ConditionCode.ULT, FlagM.C); break; case Mnemonic.bls: RewriteBranch(ConditionCode.ULE, FlagM.Z | FlagM.C); break; case Mnemonic.blt: RewriteBranch(ConditionCode.LT, FlagM.N | FlagM.V); break; case Mnemonic.bmi: RewriteBranch(ConditionCode.LT, FlagM.N); break; case Mnemonic.bne: RewriteBranch(ConditionCode.NE, FlagM.Z); break; case Mnemonic.bpl: RewriteBranch(ConditionCode.GE, FlagM.N); break; case Mnemonic.bra: RewriteBra(); break; case Mnemonic.brn: m.Nop(); break; case Mnemonic.bsr: RewriteBsr(); break; case Mnemonic.bvc: RewriteBranch(ConditionCode.NO, FlagM.V); break; case Mnemonic.bvs: RewriteBranch(ConditionCode.OV, FlagM.V); break; case Mnemonic.clr: RewriteUnary(Clr, ClrCc); break; case Mnemonic.cmpa: RewriteBinaryTest(Registers.A, m.ISub, NZVC); break; case Mnemonic.cmpb: RewriteBinaryTest(Registers.B, m.ISub, NZVC); break; case Mnemonic.cmpd: RewriteBinaryTest(Registers.D, m.ISub, NZVC); break; case Mnemonic.cmps: RewriteBinaryTest(Registers.S, m.ISub, NZVC); break; case Mnemonic.cmpu: RewriteBinaryTest(Registers.U, m.ISub, NZVC); break; case Mnemonic.cmpx: RewriteBinaryTest(Registers.X, m.ISub, NZVC); break; case Mnemonic.cmpy: RewriteBinaryTest(Registers.Y, m.ISub, NZVC); break; case Mnemonic.com: RewriteUnary(m.Comp, NZ01); break; case Mnemonic.cwai: RewriteCwai(); break; case Mnemonic.daa: RewriteDaa(); break; case Mnemonic.dec: RewriteUnary(Dec, NZV); break; case Mnemonic.eora: RewriteBinaryTest(Registers.A, m.Xor, NZ0_); break; case Mnemonic.eorb: RewriteBinaryTest(Registers.B, m.Xor, NZ0_); break; case Mnemonic.exg: RewriteExg(); break; case Mnemonic.inc: RewriteUnary(Inc, NZV); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.jsr: RewriteJsr(); break; case Mnemonic.lbeq: RewriteBranch(ConditionCode.EQ, FlagM.Z); break; case Mnemonic.lbge: RewriteBranch(ConditionCode.GE, FlagM.N | FlagM.V); break; case Mnemonic.lbgt: RewriteBranch(ConditionCode.GT, FlagM.N | FlagM.Z | FlagM.V); break; case Mnemonic.lbhi: RewriteBranch(ConditionCode.UGT, FlagM.Z | FlagM.C); break; case Mnemonic.lbhs: RewriteBranch(ConditionCode.UGE, FlagM.C); break; case Mnemonic.lble: RewriteBranch(ConditionCode.LE, FlagM.N | FlagM.Z | FlagM.V); break; case Mnemonic.lblo: RewriteBranch(ConditionCode.ULT, FlagM.C); break; case Mnemonic.lbls: RewriteBranch(ConditionCode.ULE, FlagM.Z | FlagM.C); break; case Mnemonic.lblt: RewriteBranch(ConditionCode.LT, FlagM.N | FlagM.V); break; case Mnemonic.lbmi: RewriteBranch(ConditionCode.LT, FlagM.N); break; case Mnemonic.lbne: RewriteBranch(ConditionCode.NE, FlagM.Z); break; case Mnemonic.lbpl: RewriteBranch(ConditionCode.GE, FlagM.N); break; case Mnemonic.lbra: RewriteBra(); break; case Mnemonic.lbrn: m.Nop(); break; case Mnemonic.lbsr: RewriteBsr(); break; case Mnemonic.lbvc: RewriteBranch(ConditionCode.NO, FlagM.V); break; case Mnemonic.lbvs: RewriteBranch(ConditionCode.OV, FlagM.V); break; case Mnemonic.lda: RewriteBinary(Registers.A, Load, NZ0_); break; case Mnemonic.ldb: RewriteBinary(Registers.B, Load, NZ0_); break; case Mnemonic.ldd: RewriteBinary(Registers.D, Load, NZ0_); break; case Mnemonic.lds: RewriteBinary(Registers.S, Load, NZ0_); break; case Mnemonic.ldu: RewriteBinary(Registers.U, Load, NZ0_); break; case Mnemonic.ldx: RewriteBinary(Registers.X, Load, NZ0_); break; case Mnemonic.ldy: RewriteBinary(Registers.Y, Load, NZ0_); break; case Mnemonic.leas: RewriteLea(Registers.S, NoCc); break; case Mnemonic.leau: RewriteLea(Registers.U, NoCc); break; case Mnemonic.leax: RewriteLea(Registers.X, _Z__); break; case Mnemonic.leay: RewriteLea(Registers.Y, _Z__); break; case Mnemonic.lsl: RewriteUnary(Shl1, NZVC); break; case Mnemonic.lsr: RewriteUnary(Shr1, NZ_C); break; case Mnemonic.mul: RewriteMul(); break; case Mnemonic.neg: RewriteUnary(m.Neg, NZVC); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.ora: RewriteBinary(Registers.A, m.Or, NZ0_); break; case Mnemonic.orb: RewriteBinary(Registers.B, m.Or, NZ0_); break; case Mnemonic.orcc: RewriteModifyCc(m.Or); break; case Mnemonic.pshs: RewritePsh(Registers.S); break; case Mnemonic.pshu: RewritePsh(Registers.U); break; case Mnemonic.puls: RewritePul(Registers.S); break; case Mnemonic.pulu: RewritePul(Registers.U); break; case Mnemonic.rol: RewriteUnary(Rol1, NZVC); break; case Mnemonic.ror: RewriteUnary(Ror1, NZ_C); break; case Mnemonic.rti: RewriteRti(); break; case Mnemonic.rts: RewriteRts(); break; case Mnemonic.sbca: RewriteBinary(Registers.A, Sbc, NZVC); break; case Mnemonic.sbcb: RewriteBinary(Registers.B, Sbc, NZVC); break; case Mnemonic.sex: RewriteSex(); break; case Mnemonic.sta: RewriteUnary(Store(Registers.A), NZ0_); break; case Mnemonic.stb: RewriteUnary(Store(Registers.B), NZ0_); break; case Mnemonic.std: RewriteUnary(Store(Registers.D), NZ0_); break; case Mnemonic.sts: RewriteUnary(Store(Registers.S), NZ0_); break; case Mnemonic.stu: RewriteUnary(Store(Registers.U), NZ0_); break; case Mnemonic.stx: RewriteUnary(Store(Registers.X), NZ0_); break; case Mnemonic.sty: RewriteUnary(Store(Registers.Y), NZ0_); break; case Mnemonic.suba: RewriteBinary(Registers.A, m.ISub, NZVC); break; case Mnemonic.subb: RewriteBinary(Registers.B, m.ISub, NZVC); break; case Mnemonic.subd: RewriteBinary(Registers.D, m.ISub, NZVC); break; case Mnemonic.swi: RewriteSwi(0xFFFA); break; case Mnemonic.swi2: RewriteSwi(0xFFF4); break; case Mnemonic.swi3: RewriteSwi(0xFFF2); break; case Mnemonic.sync: RewriteSync(); break; case Mnemonic.tfr: RewriteTfr(); break; case Mnemonic.tst: RewriteTst(); break; } yield return(new RtlInstructionCluster(instr.Address, instr.Length, instrs.ToArray()) { Class = iclass, }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.iclass = instr.InstructionClass; switch (instr.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.Invalid; case Mnemonic.Invalid: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.add: RewriteAddSub(m.IAdd); break; case Mnemonic.and: RewriteLogical(m.And); break; case Mnemonic.bclr: RewriteBclr(); break; case Mnemonic.bset: RewriteBset(); break; case Mnemonic.calla: RewriteCalla(); break; case Mnemonic.cmp: RewriteCmp(); break; case Mnemonic.cmpb: RewriteCmp(); break; case Mnemonic.cmpd1: RewriteCmpIncDec(-1); break; case Mnemonic.diswdt: RewriteDiswdt(); break; case Mnemonic.einit: RewriteEinit(); break; case Mnemonic.jmpa: RewriteJmpa(); break; case Mnemonic.jmpr: RewriteJmpr(); break; case Mnemonic.jmps: RewriteJmps(); break; case Mnemonic.jnb: RewriteJnb(); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.movb: RewriteMov(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.reti: RewriteReti(); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); instrs.Clear(); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.iclass = InstrClass.Linear; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); switch (instr.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.invalid; case Mnemonic.invalid: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.aghi: RewriteAhi(PrimitiveType.Word64); break; case Mnemonic.ahi: RewriteAhi(PrimitiveType.Word32); break; case Mnemonic.agr: RewriteAgr(); break; case Mnemonic.ar: RewriteAr(); break; case Mnemonic.basr: RewriteBasr(); break; case Mnemonic.ber: RewriteBranch(ConditionCode.EQ); break; case Mnemonic.bler: RewriteBranch(ConditionCode.LE); break; case Mnemonic.br: RewriteBr(); break; case Mnemonic.brasl: RewriteBrasl(); break; case Mnemonic.brctg: RewriteBrctg(); break; case Mnemonic.chi: RewriteChi(); break; case Mnemonic.clc: RewriteClc(); break; case Mnemonic.clg: RewriteClg(); break; case Mnemonic.cli: RewriteCli(); break; case Mnemonic.j: RewriteJ(); break; case Mnemonic.je: RewriteJcc(ConditionCode.EQ); break; case Mnemonic.jg: RewriteJcc(ConditionCode.GT); break; case Mnemonic.jh: RewriteJcc(ConditionCode.UGT); break; case Mnemonic.jne: RewriteJcc(ConditionCode.NE); break; case Mnemonic.la: RewriteLa(); break; case Mnemonic.larl: RewriteLarl(); break; case Mnemonic.l: RewriteL(PrimitiveType.Word32); break; case Mnemonic.lg: RewriteL(PrimitiveType.Word64); break; case Mnemonic.lgf: RewriteLgf(); break; case Mnemonic.lgfr: RewriteLgfr(); break; case Mnemonic.lghi: RewriteLghi(); break; case Mnemonic.lgr: RewriteLgr(); break; case Mnemonic.lhi: RewriteLhi(); break; case Mnemonic.lmg: RewriteLmg(); break; case Mnemonic.lr: RewriteLr(); break; case Mnemonic.ltgr: RewriteLtgr(); break; case Mnemonic.mvi: RewriteMvi(); break; case Mnemonic.mvz: RewriteMvz(); break; case Mnemonic.nc: RewriteNc(); break; case Mnemonic.ngr: RewriteNgr(); break; case Mnemonic.nopr: m.Nop(); break; case Mnemonic.sgr: RewriteSgr(); break; case Mnemonic.srag: RewriteSrag(); break; case Mnemonic.srlg: RewriteSrlg(); break; case Mnemonic.st: RewriteSt(PrimitiveType.Word32); break; case Mnemonic.stg: RewriteSt(PrimitiveType.Word64); break; case Mnemonic.stmg: RewriteStmg(); break; case Mnemonic.xc: RewriteXc(); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { instrCur = dasm.Current; var addr = instrCur.Address; var rtlInstructions = new List <RtlInstruction>(); iclass = InstrClass.Linear; m = new RtlEmitter(rtlInstructions); switch (instrCur.Mnemonic) { default: EmitUnitTest(); host.Warn( instrCur.Address, "SPARC instruction '{0}' is not supported yet.", instrCur.Mnemonic); goto case Mnemonic.illegal; case Mnemonic.illegal: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.add: RewriteAlu(m.IAdd, false); break; case Mnemonic.addcc: RewriteAluCc(m.IAdd, false); break; case Mnemonic.addx: RewriteAddxSubx(m.IAdd, false); break; case Mnemonic.addxcc: RewriteAddxSubx(m.IAdd, true); break; case Mnemonic.and: RewriteAlu(m.And, false); break; case Mnemonic.andcc: RewriteAluCc(m.And, false); break; case Mnemonic.andn: RewriteAlu(m.And, true); break; case Mnemonic.ba: RewriteBranch(Constant.True()); break; case Mnemonic.bn: RewriteBranch(Constant.False()); break; case Mnemonic.bne: RewriteBranch(m.Test(ConditionCode.NE, Grf(FlagM.ZF))); break; case Mnemonic.be: RewriteBranch(m.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break; case Mnemonic.bg: RewriteBranch(m.Test(ConditionCode.GT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Mnemonic.bge: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.NF | FlagM.VF))); break; case Mnemonic.bgu: RewriteBranch(m.Test(ConditionCode.UGE, Grf(FlagM.CF | FlagM.ZF))); break; case Mnemonic.bl: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Mnemonic.ble: RewriteBranch(m.Test(ConditionCode.LE, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Mnemonic.bleu: RewriteBranch(m.Test(ConditionCode.ULE, Grf(FlagM.CF | FlagM.ZF))); break; case Mnemonic.bcc: RewriteBranch(m.Test(ConditionCode.UGE, Grf(FlagM.CF))); break; case Mnemonic.bcs: RewriteBranch(m.Test(ConditionCode.ULT, Grf(FlagM.CF))); break; case Mnemonic.bneg: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.NF))); break; case Mnemonic.bpos: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.NF))); break; case Mnemonic.brgz: RewriteBranchReg(m.Gt0); break; case Mnemonic.brgez: RewriteBranchReg(m.Ge0); break; case Mnemonic.brlz: RewriteBranchReg(m.Lt0); break; case Mnemonic.brlez: RewriteBranchReg(m.Le0); break; case Mnemonic.brnz: RewriteBranchReg(m.Ne0); break; case Mnemonic.brz: RewriteBranchReg(m.Eq0); break; // Z //case Mnemonic.bgu not (C or Z) //case Mnemonic.bleu (C or Z) //case Mnemonic.bcc not C //case Mnemonic.bcs C //case Mnemonic.bpos not N //case Mnemonic.bneg N //case Mnemonic.bvc not V //case Mnemonic.bvs V case Mnemonic.call: RewriteCall(); break; case Mnemonic.fabss: RewriteFabss(); break; case Mnemonic.fadds: RewriteFadds(); break; case Mnemonic.fbne: RewriteBranch(m.Test(ConditionCode.NE, Grf(FlagM.LF | FlagM.GF))); break; case Mnemonic.fba: RewriteBranch(Constant.True()); break; case Mnemonic.fbn: RewriteBranch(Constant.False()); break; case Mnemonic.fbu: RewriteBranch(m.Test(ConditionCode.NE, Grf(FlagM.UF))); break; case Mnemonic.fbg: RewriteBranch(m.Test(ConditionCode.GT, Grf(FlagM.GF))); break; case Mnemonic.fbug: RewriteBranch(m.Test(ConditionCode.GT, Grf(FlagM.GF | FlagM.UF))); break; //case Mnemonic.fbug : on Unordered or Greater G or U //case Mnemonic.fbl : on Less L case Mnemonic.fbul: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.GF | FlagM.UF))); break; //case Mnemonic.fbul : on Unordered or Less L or U //case Mnemonic.fblg : on Less or Greater L or G //case Mnemonic.fbne : on Not Equal L or G or U case Mnemonic.fbe: RewriteBranch(m.Test(ConditionCode.EQ, Grf(FlagM.EF))); break; case Mnemonic.fbue: RewriteBranch(m.Test(ConditionCode.EQ, Grf(FlagM.EF | FlagM.UF))); break; case Mnemonic.fbuge: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.EF | FlagM.GF | FlagM.UF))); break; case Mnemonic.fble: RewriteBranch(m.Test(ConditionCode.LE, Grf(FlagM.EF | FlagM.LF))); break; //case Mnemonic.fbule : on Unordered or Less or Equal E or L or U case Mnemonic.fbule: RewriteBranch(m.Test(ConditionCode.LE, Grf(FlagM.EF | FlagM.LF | FlagM.UF))); break; case Mnemonic.fbge: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.EF | FlagM.GF))); break; // case Mnemonic.FBO : on Ordered E or L or G case Mnemonic.fcmpes: RewriteFcmpes(); break; case Mnemonic.fcmped: RewriteFcmped(); break; case Mnemonic.fcmpd: RewriteFcmpd(); break; case Mnemonic.fcmpq: RewriteFcmpq(); break; case Mnemonic.fcmps: RewriteFcmps(); break; case Mnemonic.fdivd: RewriteFdivs(); break; case Mnemonic.fdivs: RewriteFdivd(); break; case Mnemonic.fdtos: RewriteFdtos(); break; case Mnemonic.fitod: RewriteFitod(); break; case Mnemonic.fitoq: RewriteFitoq(); break; case Mnemonic.fitos: RewriteFitos(); break; case Mnemonic.fmovs: RewriteFmovs(); break; case Mnemonic.fmuls: RewriteFmuls(); break; case Mnemonic.fnegs: RewriteFmovs(); break; case Mnemonic.fstod: RewriteFstod(); break; case Mnemonic.fsubs: RewriteFsubs(); break; case Mnemonic.jmpl: RewriteJmpl(); break; case Mnemonic.ld: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.lddf: RewriteLoad(PrimitiveType.Real64); break; case Mnemonic.ldf: RewriteLoad(PrimitiveType.Real32); break; case Mnemonic.ldd: RewriteLoad(PrimitiveType.Word64); break; case Mnemonic.ldsb: RewriteLoad(PrimitiveType.SByte); break; case Mnemonic.ldsh: RewriteLoad(PrimitiveType.Int16); break; case Mnemonic.ldsw: RewriteLoad(PrimitiveType.Int32); break; case Mnemonic.ldstub: RewriteLdstub(); break; case Mnemonic.ldub: RewriteLoad(PrimitiveType.Byte); break; case Mnemonic.lduh: RewriteLoad(PrimitiveType.Word16); break; case Mnemonic.lduw: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.ldx: RewriteLoad(PrimitiveType.Word64); break; case Mnemonic.ldfsr: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.mulx: RewriteAlu(m.IMul, false); break; case Mnemonic.mulscc: RewriteMulscc(); break; case Mnemonic.or: RewriteAlu(m.Or, false); break; case Mnemonic.orcc: RewriteAluCc(m.Or, false); break; case Mnemonic.orn: RewriteAlu(m.Or, true); break; case Mnemonic.orncc: RewriteAlu(m.Or, true); break; case Mnemonic.restore: RewriteRestore(); break; case Mnemonic.rett: RewriteRett(); break; case Mnemonic.@return: RewriteReturn(); break; case Mnemonic.save: RewriteSave(); break; case Mnemonic.sethi: RewriteSethi(); break; case Mnemonic.sdiv: RewriteAlu(m.SDiv, false); break; case Mnemonic.sdivcc: RewriteAlu(m.SDiv, false); break; case Mnemonic.sll: RewriteAlu(m.Shl, false); break; case Mnemonic.sllx: RewriteAlu(m.Shl, false); break; case Mnemonic.smul: RewriteAlu(m.SMul, false); break; case Mnemonic.smulcc: RewriteAluCc(m.SMul, false); break; case Mnemonic.sra: RewriteAlu(m.Sar, false); break; case Mnemonic.srax: RewriteAlu(m.Sar, false); break; case Mnemonic.srl: RewriteAlu(m.Shr, false); break; case Mnemonic.srlx: RewriteAlu(m.Shr, false); break; case Mnemonic.st: RewriteStore(PrimitiveType.Word32); break; case Mnemonic.stb: RewriteStore(PrimitiveType.Byte); break; case Mnemonic.std: RewriteStore(PrimitiveType.Word64); break; case Mnemonic.stdf: RewriteStore(PrimitiveType.Real64); break; case Mnemonic.stf: RewriteStore(PrimitiveType.Real32); break; case Mnemonic.sth: RewriteStore(PrimitiveType.Word16); break; case Mnemonic.stw: RewriteStore(PrimitiveType.Word32); break; case Mnemonic.stx: RewriteStore(PrimitiveType.Word64); break; case Mnemonic.stfsr: RewriteStore(PrimitiveType.Word32); break; case Mnemonic.sub: RewriteAlu(m.ISub, false); break; case Mnemonic.subcc: RewriteAluCc(m.ISub, false); break; case Mnemonic.subx: RewriteAddxSubx(m.ISub, false); break; case Mnemonic.subxcc: RewriteAddxSubx(m.ISub, true); break; case Mnemonic.ta: RewriteTrap(Constant.True()); break; case Mnemonic.tn: RewriteTrap(Constant.False()); break; case Mnemonic.tne: RewriteTrap(m.Test(ConditionCode.NE, Grf(FlagM.ZF))); break; case Mnemonic.te: RewriteTrap(m.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break; case Mnemonic.udiv: RewriteAlu(m.UDiv, false); break; case Mnemonic.udivcc: RewriteAluCc(m.UDiv, false); break; case Mnemonic.umul: RewriteAlu(m.UMul, false); break; case Mnemonic.umulcc: RewriteAluCc(m.UMul, false); break; case Mnemonic.unimp: m.Invalid(); break; case Mnemonic.xor: RewriteAlu(m.Xor, false); break; case Mnemonic.xorcc: RewriteAlu(m.Xor, true); break; case Mnemonic.xnor: RewriteAlu(XNor, false); break; case Mnemonic.xnorcc: RewriteAlu(XNor, true); break; } yield return(m.MakeCluster(addr, 4, iclass)); } }
public void Rewrite(AvrInstruction instr) { this.instr = instr; this.rtlInstructions = new List <RtlInstruction>(); this.iclass = instr.InstructionClass; this.m = new RtlEmitter(rtlInstructions); switch (instr.Mnemonic) { case Mnemonic.adc: RewriteAdcSbc(m.IAdd); break; case Mnemonic.add: RewriteBinOp(m.IAdd, CmpFlags); break; case Mnemonic.adiw: RewriteAddSubIW(m.IAdd); break; case Mnemonic.and: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Mnemonic.andi: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Mnemonic.asr: RewriteAsr(); break; case Mnemonic.brcc: RewriteBranch(ConditionCode.UGE, FlagM.CF); break; case Mnemonic.brcs: RewriteBranch(ConditionCode.ULT, FlagM.CF); break; case Mnemonic.breq: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.brge: RewriteBranch(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Mnemonic.brid: RewriteBranch(FlagM.IF, false); break; case Mnemonic.brne: RewriteBranch(ConditionCode.NE, FlagM.ZF); break; case Mnemonic.brpl: RewriteBranch(ConditionCode.GE, FlagM.NF); break; case Mnemonic.call: RewriteCall(); break; case Mnemonic.cli: RewriteCli(); break; case Mnemonic.com: RewriteUnary(m.Comp, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF, FlagM.CF); break; case Mnemonic.cp: RewriteCp(); break; case Mnemonic.cpi: RewriteCp(); break; case Mnemonic.cpc: RewriteCpc(); break; case Mnemonic.cpse: SkipIf(m.Eq); break; case Mnemonic.dec: RewriteIncDec(m.ISub); break; case Mnemonic.des: RewriteDes(); break; case Mnemonic.eor: RewriteBinOp(m.Xor, LogicalFlags, FlagM.VF); break; case Mnemonic.icall: RewriteIcall(); break; case Mnemonic.@in: RewriteIn(); break; case Mnemonic.inc: RewriteIncDec(m.IAdd); break; case Mnemonic.ijmp: RewriteIjmp(); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.ld: RewriteLd(); break; case Mnemonic.ldd: RewriteLd(); break; case Mnemonic.ldi: RewriteLdi(); break; case Mnemonic.lds: RewriteLds(); break; case Mnemonic.lpm: RewriteLpm(); break; case Mnemonic.lsr: RewriteLsr(); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.movw: RewriteMovw(); break; case Mnemonic.muls: RewriteMuls(); break; case Mnemonic.neg: RewriteUnary(m.Neg, CmpFlags); break; case Mnemonic.@out: RewriteOut(); break; case Mnemonic.or: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Mnemonic.ori: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.rcall: RewriteCall(); break; case Mnemonic.ror: RewriteRor(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.reti: RewriteRet(); break; //$TODO: more to indicate interrupt return? case Mnemonic.rjmp: RewriteJmp(); break; case Mnemonic.sbc: RewriteAdcSbc(m.ISub); break; case Mnemonic.sbci: RewriteAdcSbc(m.ISub); break; case Mnemonic.sbis: RewriteSbis(); return; // We've already added ourself to clusters. case Mnemonic.sbiw: RewriteAddSubIW(m.ISub); break; case Mnemonic.sbrc: SkipIf(Sbrc); break; case Mnemonic.sbrs: SkipIf(Sbrs); break; case Mnemonic.sec: RewriteSetBit(FlagM.CF, true); break; case Mnemonic.sei: RewriteSei(); break; case Mnemonic.st: RewriteSt(); break; case Mnemonic.std: RewriteSt(); break; case Mnemonic.sts: RewriteSts(); break; case Mnemonic.sub: RewriteBinOp(m.ISub, CmpFlags); break; case Mnemonic.subi: RewriteBinOp(m.ISub, CmpFlags); break; case Mnemonic.swap: RewriteSwap(); break; default: host.Error(instr.Address, string.Format("AVR8 instruction '{0}' is not supported yet.", instr.Mnemonic)); EmitUnitTest(); m.Invalid(); break; } clusters.Add(m.MakeCluster(instr.Address, instr.Length, iclass)); }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; var cluster = new List <RtlInstruction>(); m = new RtlEmitter(cluster); iclass = instr.InstructionClass; switch (instr.Mnemonic) { default: EmitUnitTest(); host.Warn( instr.Address, "AArch64 instruction {0} is not supported yet.", instr); goto case Mnemonic.Invalid; case Mnemonic.Invalid: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.add: RewriteMaybeSimdBinary(m.IAdd, "__add_{0}"); break; case Mnemonic.adds: RewriteBinary(m.IAdd, this.NZCV); break; case Mnemonic.addv: RewriteAddv(); break; case Mnemonic.adr: RewriteUnary(n => n); break; case Mnemonic.asrv: RewriteBinary(m.Sar); break; case Mnemonic.bic: RewriteBinary((a, b) => m.And(a, m.Comp(b))); break; case Mnemonic.adrp: RewriteAdrp(); break; case Mnemonic.and: RewriteBinary(m.And); break; case Mnemonic.ands: RewriteBinary(m.And, this.NZ00); break; case Mnemonic.asr: RewriteBinary(m.Sar); break; case Mnemonic.b: RewriteB(); break; case Mnemonic.bfm: RewriteBfm(); break; case Mnemonic.bl: RewriteBl(); break; case Mnemonic.blr: RewriteBlr(); break; case Mnemonic.br: RewriteBr(); break; case Mnemonic.cbnz: RewriteCb(m.Ne0); break; case Mnemonic.cbz: RewriteCb(m.Eq0); break; case Mnemonic.ccmn: RewriteCcmn(); break; case Mnemonic.ccmp: RewriteCcmp(); break; case Mnemonic.clz: RewriteClz(); break; case Mnemonic.cmp: RewriteCmp(); break; case Mnemonic.cmeq: RewriteCmeq(); break; case Mnemonic.csel: RewriteCsel(); break; case Mnemonic.csinc: RewriteCsinc(); break; case Mnemonic.csinv: RewriteCsinv(); break; case Mnemonic.csneg: RewriteCsneg(); break; case Mnemonic.dsb: RewriteDsb(); break; case Mnemonic.dup: RewriteDup(); break; case Mnemonic.eor: RewriteBinary(m.Xor); break; case Mnemonic.fabs: RewriteFabs(); break; case Mnemonic.fadd: RewriteFadd(); break; case Mnemonic.fcmp: RewriteFcmp(); break; case Mnemonic.fcsel: RewriteFcsel(); break; case Mnemonic.fcvt: RewriteFcvt(); break; case Mnemonic.fcvtms: RewriteFcvtms(); break; case Mnemonic.fcvtps: RewriteFcvtps(); break; case Mnemonic.fcvtzs: RewriteFcvtzs(); break; case Mnemonic.fdiv: RewriteMaybeSimdBinary(m.FDiv, "__fdiv_{0}", Domain.Real); break; case Mnemonic.fmadd: RewriteIntrinsicFTernary("__fmaddf", "__fmadd"); break; case Mnemonic.fmsub: RewriteIntrinsicFTernary("__fmsubf", "__fmsub"); break; case Mnemonic.fmax: RewriteIntrinsicFBinary("fmaxf", "fmax"); break; case Mnemonic.fmin: RewriteIntrinsicFBinary("fminf", "fmin"); break; case Mnemonic.fmov: RewriteFmov(); break; case Mnemonic.fmul: RewriteFmul(); break; case Mnemonic.fneg: RewriteUnary(m.FNeg); break; case Mnemonic.fnmul: RewriteFnmul(); break; case Mnemonic.fsqrt: RewriteFsqrt(); break; case Mnemonic.fsub: RewriteMaybeSimdBinary(m.FSub, "__fsub_{0}", Domain.Real); break; case Mnemonic.isb: RewriteIsb(); break; case Mnemonic.ld1r: RewriteLdNr("__ld1r"); break; case Mnemonic.ld2: RewriteLdN("__ld2"); break; case Mnemonic.ld3: RewriteLdN("__ld3"); break; case Mnemonic.ld4: RewriteLdN("__ld4"); break; case Mnemonic.ldp: RewriteLoadStorePair(true); break; case Mnemonic.ldpsw: RewriteLoadStorePair(true, PrimitiveType.Int32, PrimitiveType.Int64); break; case Mnemonic.ldr: RewriteLdr(null); break; case Mnemonic.ldrb: RewriteLdr(PrimitiveType.Byte); break; case Mnemonic.ldrh: RewriteLdr(PrimitiveType.Word16); break; case Mnemonic.ldrsb: RewriteLdr(PrimitiveType.SByte); break; case Mnemonic.ldrsh: RewriteLdr(PrimitiveType.Int16); break; case Mnemonic.ldrsw: RewriteLdr(PrimitiveType.Int32); break; case Mnemonic.lslv: RewriteBinary(m.Shl); break; case Mnemonic.lsrv: RewriteBinary(m.Shr); break; case Mnemonic.ldur: RewriteLdr(null); break; case Mnemonic.ldurb: RewriteLdr(PrimitiveType.Byte); break; case Mnemonic.ldurh: RewriteLdr(PrimitiveType.Word16); break; case Mnemonic.ldursb: RewriteLdr(PrimitiveType.SByte); break; case Mnemonic.ldursh: RewriteLdr(PrimitiveType.Int16); break; case Mnemonic.ldursw: RewriteLdr(PrimitiveType.Int32); break; case Mnemonic.lsl: RewriteBinary(m.Shl); break; case Mnemonic.lsr: RewriteBinary(m.Shr); break; case Mnemonic.madd: RewriteMaddSub(m.IAdd); break; case Mnemonic.mneg: RewriteBinary((a, b) => m.Neg(m.IMul(a, b))); break; case Mnemonic.msub: RewriteMaddSub(m.ISub); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.movi: RewriteMovi(); break; case Mnemonic.movk: RewriteMovk(); break; case Mnemonic.movn: RewriteMovn(); break; case Mnemonic.movz: RewriteMovz(); break; case Mnemonic.mrs: RewriteMrs(); break; case Mnemonic.msr: RewriteMsr(); break; case Mnemonic.mul: RewriteMaybeSimdBinary(m.IMul, "__mul_{0}"); break; case Mnemonic.mvn: RewriteUnary(m.Comp); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.not: RewriteMaybeSimdUnary(m.Comp, "__not_{0}"); break; case Mnemonic.orr: RewriteBinary(m.Or); break; case Mnemonic.orn: RewriteBinary((a, b) => m.Or(a, m.Comp(b))); break; case Mnemonic.prfm: RewritePrfm(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.rev16: RewriteRev16(); break; case Mnemonic.ror: RewriteRor(); break; case Mnemonic.rorv: RewriteRor(); break; case Mnemonic.sbfiz: RewriteSbfiz(); break; case Mnemonic.sbfm: RewriteUSbfm("__sbfm"); break; case Mnemonic.scvtf: RewriteScvtf(); break; case Mnemonic.sdiv: RewriteBinary(m.SDiv); break; case Mnemonic.shrn: RewriteShrn(); break; case Mnemonic.smaddl: RewriteMaddl(PrimitiveType.Int64, m.SMul); break; case Mnemonic.smax: RewriteSmax(); break; case Mnemonic.smaxv: RewriteSmaxv(); break; case Mnemonic.smc: RewriteSmc(); break; case Mnemonic.smull: RewriteMull(PrimitiveType.Int64, m.SMul); break; case Mnemonic.st1: RewriteStN("__st1"); break; case Mnemonic.st2: RewriteStN("__st2"); break; case Mnemonic.st3: RewriteStN("__st3"); break; case Mnemonic.st4: RewriteStN("__st4"); break; case Mnemonic.stlr: RewriteStlr(); break; case Mnemonic.stp: RewriteLoadStorePair(false); break; case Mnemonic.str: RewriteStr(null); break; case Mnemonic.strb: RewriteStr(PrimitiveType.Byte); break; case Mnemonic.strh: RewriteStr(PrimitiveType.Word16); break; case Mnemonic.stur: RewriteStr(null); break; case Mnemonic.sturb: RewriteStr(PrimitiveType.Byte); break; case Mnemonic.sturh: RewriteStr(PrimitiveType.Word16); break; case Mnemonic.sub: RewriteBinary(m.ISub); break; case Mnemonic.subs: RewriteBinary(m.ISub, NZCV); break; case Mnemonic.svc: RewriteSvc(); break; case Mnemonic.sxtb: RewriteUSxt(Domain.SignedInt, 8); break; case Mnemonic.sxth: RewriteUSxt(Domain.SignedInt, 16); break; case Mnemonic.sxtl: RewriteSimdUnary("__sxtl_{0}", Domain.SignedInt); break; case Mnemonic.sxtw: RewriteUSxt(Domain.SignedInt, 32); break; case Mnemonic.tbnz: RewriteTb(m.Ne0); break; case Mnemonic.tbz: RewriteTb(m.Eq0); break; case Mnemonic.test: RewriteTest(); break; case Mnemonic.uaddw: RewriteUaddw(); break; case Mnemonic.ubfm: RewriteUSbfm("__ubfm"); break; case Mnemonic.ucvtf: RewriteIcvt(Domain.UnsignedInt); break; case Mnemonic.udiv: RewriteBinary(m.UDiv); break; case Mnemonic.umaddl: RewriteMaddl(PrimitiveType.UInt64, m.UMul); break; case Mnemonic.umlal: RewriteUmlal(); break; case Mnemonic.umull: RewriteMull(PrimitiveType.UInt64, m.UMul); break; case Mnemonic.umulh: RewriteMulh(PrimitiveType.UInt64, m.UMul); break; case Mnemonic.uxtb: RewriteUSxt(Domain.UnsignedInt, 8); break; case Mnemonic.uxth: RewriteUSxt(Domain.UnsignedInt, 16); break; case Mnemonic.uxtl: RewriteSimdUnary("__uxtl_{0}", Domain.UnsignedInt); break; case Mnemonic.uxtw: RewriteUSxt(Domain.UnsignedInt, 32); break; case Mnemonic.xtn: RewriteSimdUnary("__xtn_{0}", Domain.None); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
/// <summary> /// Iterator that yields one RtlIntructionCluster for each x86 instruction. /// </summary> /// <returns></returns> public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { instrCur = dasm.Current; var addr = instrCur.Address; this.rtlInstructions = new List <RtlInstruction>(); this.rtlc = instrCur.InstructionClass; m = new RtlEmitter(rtlInstructions); orw = arch.ProcessorMode.CreateOperandRewriter(arch, m, binder, host); switch (instrCur.code) { default: EmitUnitTest(); host.Warn( dasm.Current.Address, "x86 instruction '{0}' is not supported yet.", instrCur.code); goto case Opcode.illegal; case Opcode.illegal: rtlc = InstrClass.Invalid; m.Invalid(); break; case Opcode.aaa: RewriteAaa(); break; case Opcode.aad: RewriteAad(); break; case Opcode.aam: RewriteAam(); break; case Opcode.aas: RewriteAas(); break; case Opcode.adc: RewriteAdcSbb(m.IAdd); break; case Opcode.add: RewriteAddSub(Operator.IAdd); break; case Opcode.addss: RewriteScalarBinop(m.FAdd, PrimitiveType.Real32); break; case Opcode.addsd: case Opcode.vaddsd: RewriteScalarBinop(m.FAdd, PrimitiveType.Real64); break; case Opcode.addps: RewritePackedBinop("__addps", PrimitiveType.Real32); break; case Opcode.addpd: RewritePackedBinop("__addpd", PrimitiveType.Real64); break; case Opcode.aesimc: RewriteAesimc(); break; case Opcode.and: RewriteLogical(Operator.And); break; case Opcode.andnps: RewriteAndnps(); break; case Opcode.andpd: RewritePackedBinop("__andpd", PrimitiveType.Real64); break; case Opcode.andps: RewritePackedBinop("__andps", PrimitiveType.Real32); break; case Opcode.arpl: RewriteArpl(); break; case Opcode.bound: RewriteBound(); break; case Opcode.bsf: RewriteBsf(); break; case Opcode.bsr: RewriteBsr(); break; case Opcode.bswap: RewriteBswap(); break; case Opcode.bt: RewriteBt(); break; case Opcode.btc: RewriteBtc(); break; case Opcode.btr: RewriteBtr(); break; case Opcode.bts: RewriteBts(); break; case Opcode.call: RewriteCall(instrCur.op1, instrCur.op1.Width); break; case Opcode.cbw: RewriteCbw(); break; case Opcode.clc: RewriteSetFlag(FlagM.CF, Constant.False()); break; case Opcode.cld: RewriteSetFlag(FlagM.DF, Constant.False()); break; case Opcode.cli: RewriteCli(); break; case Opcode.clts: RewriteClts(); break; case Opcode.cmc: m.Assign(orw.FlagGroup(FlagM.CF), m.Not(orw.FlagGroup(FlagM.CF))); break; case Opcode.cmova: RewriteConditionalMove(ConditionCode.UGT, instrCur.op1, instrCur.op2); break; case Opcode.cmovbe: RewriteConditionalMove(ConditionCode.ULE, instrCur.op1, instrCur.op2); break; case Opcode.cmovc: RewriteConditionalMove(ConditionCode.ULT, instrCur.op1, instrCur.op2); break; case Opcode.cmovge: RewriteConditionalMove(ConditionCode.GE, instrCur.op1, instrCur.op2); break; case Opcode.cmovg: RewriteConditionalMove(ConditionCode.GT, instrCur.op1, instrCur.op2); break; case Opcode.cmovl: RewriteConditionalMove(ConditionCode.LT, instrCur.op1, instrCur.op2); break; case Opcode.cmovle: RewriteConditionalMove(ConditionCode.LE, instrCur.op1, instrCur.op2); break; case Opcode.cmovnc: RewriteConditionalMove(ConditionCode.UGE, instrCur.op1, instrCur.op2); break; case Opcode.cmovno: RewriteConditionalMove(ConditionCode.NO, instrCur.op1, instrCur.op2); break; case Opcode.cmovns: RewriteConditionalMove(ConditionCode.NS, instrCur.op1, instrCur.op2); break; case Opcode.cmovnz: RewriteConditionalMove(ConditionCode.NE, instrCur.op1, instrCur.op2); break; case Opcode.cmovo: RewriteConditionalMove(ConditionCode.OV, instrCur.op1, instrCur.op2); break; case Opcode.cmovpe: RewriteConditionalMove(ConditionCode.PE, instrCur.op1, instrCur.op2); break; case Opcode.cmovpo: RewriteConditionalMove(ConditionCode.PO, instrCur.op1, instrCur.op2); break; case Opcode.cmovs: RewriteConditionalMove(ConditionCode.SG, instrCur.op1, instrCur.op2); break; case Opcode.cmovz: RewriteConditionalMove(ConditionCode.EQ, instrCur.op1, instrCur.op2); break; case Opcode.cmpxchg: RewriteCmpxchg(); break; case Opcode.cmp: RewriteCmp(); break; case Opcode.cmps: RewriteStringInstruction(); break; case Opcode.cmppd: RewriteCmpp("__cmppd", PrimitiveType.Real64); break; case Opcode.cmpps: RewriteCmpp("__cmpps", PrimitiveType.Real32); break; case Opcode.cmpsb: RewriteStringInstruction(); break; case Opcode.comisd: RewriteComis(PrimitiveType.Real64); break; case Opcode.comiss: RewriteComis(PrimitiveType.Real32); break; case Opcode.cpuid: RewriteCpuid(); break; case Opcode.cvtpi2ps: RewriteCvtPackedToReal(PrimitiveType.Real32); break; case Opcode.cvtps2pi: RewriteCvtps2pi("__cvtps2pi", PrimitiveType.Real32, PrimitiveType.Int32); break; case Opcode.cvtps2pd: RewriteCvtps2pi("__cvtps2pd", PrimitiveType.Real32, PrimitiveType.Real64); break; case Opcode.cvtdq2ps: RewriteCvtps2pi("__cvtdq2ps", PrimitiveType.Int64, PrimitiveType.Real32); break; case Opcode.cvtsd2si: RewriteCvts2si(PrimitiveType.Real64); break; case Opcode.cvtsd2ss: RewriteCvtToReal(PrimitiveType.Real32); break; case Opcode.cvtsi2ss: case Opcode.vcvtsi2ss: RewriteCvtToReal(PrimitiveType.Real32); break; case Opcode.cvtsi2sd: case Opcode.vcvtsi2sd: RewriteCvtToReal(PrimitiveType.Real64); break; case Opcode.cvtss2sd: RewriteCvtToReal(PrimitiveType.Real64); break; case Opcode.cvtss2si: RewriteCvts2si(PrimitiveType.Real32); break; case Opcode.cvttsd2si: RewriteCvtts2si(PrimitiveType.Real64); break; case Opcode.cvttss2si: RewriteCvtts2si(PrimitiveType.Real32); break; case Opcode.cvttps2pi: RewriteCvttps2pi(); break; case Opcode.cwd: RewriteCwd(); break; case Opcode.daa: EmitDaaDas("__daa"); break; case Opcode.das: EmitDaaDas("__das"); break; case Opcode.dec: RewriteIncDec(-1); break; case Opcode.div: RewriteDivide(m.UDiv, Domain.UnsignedInt); break; case Opcode.divps: RewritePackedBinop("__divps", PrimitiveType.Real32); break; case Opcode.divsd: RewriteScalarBinop(m.FDiv, PrimitiveType.Real64); break; case Opcode.divss: RewriteScalarBinop(m.FDiv, PrimitiveType.Real32); break; case Opcode.f2xm1: RewriteF2xm1(); break; case Opcode.emms: RewriteEmms(); break; case Opcode.enter: RewriteEnter(); break; case Opcode.fabs: RewriteFabs(); break; case Opcode.fadd: EmitCommonFpuInstruction(m.FAdd, false, false); break; case Opcode.faddp: EmitCommonFpuInstruction(m.FAdd, false, true); break; case Opcode.fbld: RewriteFbld(); break; case Opcode.fbstp: RewriteFbstp(); break; case Opcode.fchs: EmitFchs(); break; case Opcode.fclex: RewriteFclex(); break; case Opcode.fcmovb: RewriteFcmov(FlagM.CF, ConditionCode.GE); break; case Opcode.fcmovbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GT); break; case Opcode.fcmove: RewriteFcmov(FlagM.ZF, ConditionCode.NE); break; case Opcode.fcmovnb: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GE); break; case Opcode.fcmovnbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.LE); break; case Opcode.fcmovne: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break; case Opcode.fcmovnu: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break; case Opcode.fcmovu: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break; case Opcode.fcom: RewriteFcom(0); break; case Opcode.fcomi: RewrteFcomi(false); break; case Opcode.fcomip: RewrteFcomi(true); break; case Opcode.fcomp: RewriteFcom(1); break; case Opcode.fcompp: RewriteFcom(2); break; case Opcode.fcos: RewriteFUnary("cos"); break; case Opcode.fdecstp: RewriteFdecstp(); break; case Opcode.fdiv: EmitCommonFpuInstruction(m.FDiv, false, false); break; case Opcode.fdivp: EmitCommonFpuInstruction(m.FDiv, false, true); break; case Opcode.ffree: RewriteFfree(); break; case Opcode.fiadd: EmitCommonFpuInstruction(m.FAdd, false, false, PrimitiveType.Real64); break; case Opcode.ficom: RewriteFicom(false); break; case Opcode.ficomp: RewriteFicom(true); break; case Opcode.fimul: EmitCommonFpuInstruction(m.FMul, false, false, PrimitiveType.Real64); break; case Opcode.fisub: EmitCommonFpuInstruction(m.FSub, false, false, PrimitiveType.Real64); break; case Opcode.fisubr: EmitCommonFpuInstruction(m.FSub, true, false, PrimitiveType.Real64); break; case Opcode.fidiv: EmitCommonFpuInstruction(m.FDiv, false, false, PrimitiveType.Real64); break; case Opcode.fidivr: EmitCommonFpuInstruction(m.FDiv, true, false, PrimitiveType.Real64); break; case Opcode.fdivr: EmitCommonFpuInstruction(m.FDiv, true, false); break; case Opcode.fdivrp: EmitCommonFpuInstruction(m.FDiv, true, true); break; case Opcode.fild: RewriteFild(); break; case Opcode.fincstp: RewriteFincstp(); break; case Opcode.fist: RewriteFist(false); break; case Opcode.fistp: RewriteFist(true); break; case Opcode.fisttp: RewriteFistt(true); break; case Opcode.fld: RewriteFld(); break; case Opcode.fld1: RewriteFldConst(1.0); break; case Opcode.fldcw: RewriteFldcw(); break; case Opcode.fldenv: RewriteFldenv(); break; case Opcode.fldl2e: RewriteFldConst(Constant.LgE()); break; case Opcode.fldl2t: RewriteFldConst(Constant.Lg10()); break; case Opcode.fldlg2: RewriteFldConst(Constant.Log2()); break; case Opcode.fldln2: RewriteFldConst(Constant.Ln2()); break; case Opcode.fldpi: RewriteFldConst(Constant.Pi()); break; case Opcode.fldz: RewriteFldConst(0.0); break; case Opcode.fmul: EmitCommonFpuInstruction(m.FMul, false, false); break; case Opcode.fmulp: EmitCommonFpuInstruction(m.FMul, false, true); break; case Opcode.fninit: RewriteFninit(); break; case Opcode.fnop: m.Nop(); break; case Opcode.fpatan: RewriteFpatan(); break; case Opcode.fprem: RewriteFprem(); break; case Opcode.fprem1: RewriteFprem1(); break; case Opcode.fptan: RewriteFptan(); break; case Opcode.frndint: RewriteFUnary("__rndint"); break; case Opcode.frstor: RewriteFrstor(); break; case Opcode.fsave: RewriteFsave(); break; case Opcode.fscale: RewriteFscale(); break; case Opcode.fsin: RewriteFUnary("sin"); break; case Opcode.fsincos: RewriteFsincos(); break; case Opcode.fsqrt: RewriteFUnary("sqrt"); break; case Opcode.fst: RewriteFst(false); break; case Opcode.fstenv: RewriteFstenv(); break; case Opcode.fstcw: RewriterFstcw(); break; case Opcode.fstp: RewriteFst(true); break; case Opcode.fstsw: RewriteFstsw(); break; case Opcode.fsub: EmitCommonFpuInstruction(m.FSub, false, false); break; case Opcode.fsubp: EmitCommonFpuInstruction(m.FSub, false, true); break; case Opcode.fsubr: EmitCommonFpuInstruction(m.FSub, true, false); break; case Opcode.fsubrp: EmitCommonFpuInstruction(m.FSub, true, true); break; case Opcode.ftst: RewriteFtst(); break; case Opcode.fucom: RewriteFcom(0); break; case Opcode.fucomp: RewriteFcom(1); break; case Opcode.fucompp: RewriteFcom(2); break; case Opcode.fucomi: RewrteFcomi(false); break; case Opcode.fucomip: RewrteFcomi(true); break; case Opcode.fxam: RewriteFxam(); break; case Opcode.fxch: RewriteExchange(); break; case Opcode.fxtract: RewriteFxtract(); break; case Opcode.fyl2x: RewriteFyl2x(); break; case Opcode.fyl2xp1: RewriteFyl2xp1(); break; case Opcode.getsec: RewriteGetsec(); break; case Opcode.hlt: RewriteHlt(); break; case Opcode.idiv: RewriteDivide(m.SDiv, Domain.SignedInt); break; case Opcode.@in: RewriteIn(); break; case Opcode.imul: RewriteMultiply(Operator.SMul, Domain.SignedInt); break; case Opcode.inc: RewriteIncDec(1); break; case Opcode.insb: RewriteStringInstruction(); break; case Opcode.ins: RewriteStringInstruction(); break; case Opcode.@int: RewriteInt(); break; case Opcode.into: RewriteInto(); break; case Opcode.invd: RewriteInvd(); break; case Opcode.iret: RewriteIret(); break; case Opcode.jmp: RewriteJmp(); break; case Opcode.ja: RewriteConditionalGoto(ConditionCode.UGT, instrCur.op1); break; case Opcode.jbe: RewriteConditionalGoto(ConditionCode.ULE, instrCur.op1); break; case Opcode.jc: RewriteConditionalGoto(ConditionCode.ULT, instrCur.op1); break; case Opcode.jcxz: RewriteJcxz(); break; case Opcode.jge: RewriteConditionalGoto(ConditionCode.GE, instrCur.op1); break; case Opcode.jg: RewriteConditionalGoto(ConditionCode.GT, instrCur.op1); break; case Opcode.jl: RewriteConditionalGoto(ConditionCode.LT, instrCur.op1); break; case Opcode.jle: RewriteConditionalGoto(ConditionCode.LE, instrCur.op1); break; case Opcode.jnc: RewriteConditionalGoto(ConditionCode.UGE, instrCur.op1); break; case Opcode.jno: RewriteConditionalGoto(ConditionCode.NO, instrCur.op1); break; case Opcode.jns: RewriteConditionalGoto(ConditionCode.NS, instrCur.op1); break; case Opcode.jnz: RewriteConditionalGoto(ConditionCode.NE, instrCur.op1); break; case Opcode.jo: RewriteConditionalGoto(ConditionCode.OV, instrCur.op1); break; case Opcode.jpe: RewriteConditionalGoto(ConditionCode.PE, instrCur.op1); break; case Opcode.jpo: RewriteConditionalGoto(ConditionCode.PO, instrCur.op1); break; case Opcode.js: RewriteConditionalGoto(ConditionCode.SG, instrCur.op1); break; case Opcode.jz: RewriteConditionalGoto(ConditionCode.EQ, instrCur.op1); break; case Opcode.lahf: RewriteLahf(); break; case Opcode.lar: RewriteLar(); break; case Opcode.lds: RewriteLxs(Registers.ds); break; case Opcode.ldmxcsr: RewriteLdmxcsr(); break; case Opcode.stmxcsr: RewriteStmxcsr(); break; case Opcode.lea: RewriteLea(); break; case Opcode.leave: RewriteLeave(); break; case Opcode.les: RewriteLxs(Registers.es); break; case Opcode.lfence: RewriteLfence(); break; case Opcode.lfs: RewriteLxs(Registers.fs); break; case Opcode.lgs: RewriteLxs(Registers.gs); break; case Opcode.lgdt: RewriteLxdt("__lgdt"); break; case Opcode.lidt: RewriteLxdt("__lidt"); break; case Opcode.lldt: RewriteLxdt("__lldt"); break; case Opcode.@lock: RewriteLock(); break; case Opcode.lods: RewriteStringInstruction(); break; case Opcode.lodsb: RewriteStringInstruction(); break; case Opcode.loop: RewriteLoop(0, ConditionCode.EQ); break; case Opcode.loope: RewriteLoop(FlagM.ZF, ConditionCode.EQ); break; case Opcode.loopne: RewriteLoop(FlagM.ZF, ConditionCode.NE); break; case Opcode.lsl: RewriteLsl(); break; case Opcode.lss: RewriteLxs(Registers.ss); break; case Opcode.maskmovq: RewriteMaskmovq(); break; case Opcode.maxps: RewritePackedBinop("__maxps", PrimitiveType.Real32); break; case Opcode.mfence: RewriteMfence(); break; case Opcode.minpd: RewritePackedBinop("__minpd", PrimitiveType.Real64); break; case Opcode.minps: RewritePackedBinop("__minps", PrimitiveType.Real32); break; case Opcode.mov: RewriteMov(); break; case Opcode.movapd: case Opcode.movaps: case Opcode.vmovapd: case Opcode.vmovaps: RewriteMov(); break; case Opcode.movd: RewriteMovzx(); break; case Opcode.movdqa: RewriteMov(); break; case Opcode.movhpd: RewritePackedUnaryop("__movhpd", PrimitiveType.Real64, PrimitiveType.Real64); break; case Opcode.movhps: RewritePackedUnaryop("__movhps", PrimitiveType.Real32, PrimitiveType.Real64); break; case Opcode.movlpd: RewritePackedUnaryop("__movlpd", PrimitiveType.Real64, PrimitiveType.Real64); break; case Opcode.movlps: RewritePackedUnaryop("__movlps", PrimitiveType.Real32, PrimitiveType.Real64); break; case Opcode.movlhps: RewriteMovlhps(); break; case Opcode.movmskpd: RewriteMovmsk("__movmskpd", PrimitiveType.Real64); break; case Opcode.movmskps: RewriteMovmsk("__movmskps", PrimitiveType.Real32); break; case Opcode.movnti: RewriteMov(); break; case Opcode.movntps: RewriteMov(); break; case Opcode.movntq: RewriteMov(); break; case Opcode.movq: RewriteMov(); break; case Opcode.movs: RewriteStringInstruction(); break; case Opcode.movsb: RewriteStringInstruction(); break; case Opcode.movsd: case Opcode.vmovsd: RewriteMovssd(PrimitiveType.Real64); break; case Opcode.movss: case Opcode.vmovss: RewriteMovssd(PrimitiveType.Real32); break; case Opcode.movsx: RewriteMovsx(); break; case Opcode.movups: RewriteMov(); break; case Opcode.movupd: RewriteMov(); break; case Opcode.movzx: RewriteMovzx(); break; case Opcode.mul: RewriteMultiply(Operator.UMul, Domain.UnsignedInt); break; case Opcode.mulpd: RewritePackedBinop("__mulpd", PrimitiveType.Real64); break; case Opcode.mulps: RewritePackedBinop("__mulps", PrimitiveType.Real32); break; case Opcode.mulss: RewriteScalarBinop(m.FMul, PrimitiveType.Real32); break; case Opcode.mulsd: RewriteScalarBinop(m.FMul, PrimitiveType.Real64); break; case Opcode.neg: RewriteNeg(); break; case Opcode.nop: m.Nop(); break; case Opcode.not: RewriteNot(); break; case Opcode.or: RewriteLogical(BinaryOperator.Or); break; case Opcode.orpd: RewritePackedBinop("__orpd", PrimitiveType.Real64); break; case Opcode.orps: RewritePackedBinop("__orps", PrimitiveType.Real32); break; case Opcode.@out: RewriteOut(); break; case Opcode.@outs: RewriteStringInstruction(); break; case Opcode.@outsb: RewriteStringInstruction(); break; case Opcode.packssdw: RewritePackedBinop("__packssdw", PrimitiveType.Int32, new ArrayType(PrimitiveType.Int16, 0)); break; case Opcode.packuswb: RewritePackedBinop("__packuswb", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt8, 0)); break; case Opcode.paddb: RewritePackedBinop("__paddb", PrimitiveType.Byte); break; case Opcode.paddd: RewritePackedBinop("__paddd", PrimitiveType.Word32); break; case Opcode.paddq: case Opcode.vpaddq: RewritePackedBinop("__paddq", PrimitiveType.Word64); break; case Opcode.paddsw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break; case Opcode.paddsb: RewritePackedBinop("__paddsb", PrimitiveType.SByte); break; case Opcode.paddusb: RewritePackedBinop("__paddusb", PrimitiveType.Byte); break; case Opcode.paddusw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break; case Opcode.paddw: RewritePackedBinop("__paddw", PrimitiveType.Word16); break; case Opcode.pand: case Opcode.vpand: RewritePackedLogical("__pand"); break; case Opcode.pandn: case Opcode.vpandn: RewritePackedLogical("__pandn"); break; case Opcode.pause: RewritePause(); break; case Opcode.palignr: RewritePalignr(); break; case Opcode.pavgb: RewritePavg("__pavgb", PrimitiveType.Byte); break; case Opcode.pavgw: RewritePavg("__pavgw", PrimitiveType.Byte); break; case Opcode.pcmpeqb: RewritePcmp("__pcmpeqb", PrimitiveType.Byte); break; case Opcode.pcmpeqd: RewritePcmp("__pcmpeqd", PrimitiveType.Word32); break; case Opcode.pcmpeqw: RewritePcmp("__pcmpeqw", PrimitiveType.Word16); break; case Opcode.pcmpgtb: RewritePcmp("__pcmpgtb", PrimitiveType.Byte); break; case Opcode.pcmpgtd: RewritePcmp("__pcmpgtd", PrimitiveType.Word32); break; case Opcode.pcmpgtw: RewritePcmp("__pcmpgtw", PrimitiveType.Word16); break; case Opcode.pextrw: case Opcode.vextrw: RewritePextrw(); break; case Opcode.pinsrw: case Opcode.vpinsrw: RewritePinsrw(); break; case Opcode.pmaddwd: RewritePackedBinop("__pmaddwd", PrimitiveType.Word16, new ArrayType(PrimitiveType.Word32, 0)); break; case Opcode.pmaxsw: RewritePackedBinop("__pmaxsw", PrimitiveType.Int16); break; case Opcode.pmaxub: RewritePackedBinop("__pmaxub", PrimitiveType.UInt8); break; case Opcode.pminsw: RewritePackedBinop("__pminsw", PrimitiveType.Int16); break; case Opcode.pminub: RewritePackedBinop("__pminub", PrimitiveType.UInt8); break; case Opcode.pmovmskb: RewriteMovmsk("__pmovmskb", PrimitiveType.Byte); break; case Opcode.pmulhuw: RewritePackedBinop("__pmulhuw", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt16, 8)); break; case Opcode.pmulhw: RewritePackedBinop("__pmulhw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break; case Opcode.pmullw: case Opcode.vpmullw: RewritePackedBinop("__pmullw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break; case Opcode.pmuludq: RewritePackedBinop("__pmuludq", PrimitiveType.UInt32, new ArrayType(PrimitiveType.UInt64, 0)); break; case Opcode.prefetchw: RewritePrefetch("__prefetchw"); break; case Opcode.psadbw: RewritePackedBinop("__psadbw", PrimitiveType.Byte, PrimitiveType.Word16); break; case Opcode.pslld: RewritePackedBinop("__pslld", PrimitiveType.Word32); break; case Opcode.psllq: case Opcode.vpsllq: RewritePackedBinop("__psllq", PrimitiveType.Word64); break; case Opcode.psllw: RewritePackedBinop("__psllw", PrimitiveType.Word16); break; case Opcode.psrad: RewritePackedBinop("__psrad", PrimitiveType.Int32); break; case Opcode.psraw: RewritePackedBinop("__psraw", PrimitiveType.Int16); break; case Opcode.psrlq: RewritePackedBinop("__psrlq", PrimitiveType.Word64); break; case Opcode.pop: RewritePop(); break; case Opcode.popa: RewritePopa(); break; case Opcode.popf: RewritePopf(); break; case Opcode.por: RewritePackedLogical("__por"); break; case Opcode.prefetchnta: RewritePrefetch("__prefetchnta"); break; case Opcode.prefetcht0: RewritePrefetch("__prefetcht0"); break; case Opcode.prefetcht1: RewritePrefetch("__prefetcht1"); break; case Opcode.prefetcht2: RewritePrefetch("__prefetcht2"); break; case Opcode.pshufd: RewritePshuf("__pshufd", PrimitiveType.Word32); break; case Opcode.pshufw: RewritePshuf("__pshufw", PrimitiveType.Word16); break; case Opcode.psrld: RewritePackedShift("__psrld", PrimitiveType.Word32); break; case Opcode.psrlw: RewritePackedShift("__psrlw", PrimitiveType.Word16); break; case Opcode.psubb: RewritePackedBinop("__psubb", PrimitiveType.Byte); break; case Opcode.psubd: case Opcode.vpsubd: RewritePackedBinop("__psubd", PrimitiveType.Word32); break; case Opcode.psubq: RewritePackedBinop("__psubq", PrimitiveType.Word64); break; case Opcode.psubsb: RewritePackedBinop("__psubsb", PrimitiveType.SByte); break; case Opcode.psubsw: RewritePackedBinop("__psubsw", PrimitiveType.Word16); break; case Opcode.psubusb: RewritePackedBinop("__psubusb", PrimitiveType.UInt8); break; case Opcode.psubusw: RewritePackedBinop("__psubusw", PrimitiveType.UInt16); break; case Opcode.psubw: RewritePackedBinop("__psubw", PrimitiveType.Word16); break; case Opcode.punpckhbw: RewritePunpckhbw(); break; case Opcode.punpckhdq: RewritePunpckhdq(); break; case Opcode.punpckhwd: RewritePunpckhwd(); break; case Opcode.punpcklbw: RewritePunpcklbw(); break; case Opcode.punpckldq: RewritePunpckldq(); break; case Opcode.punpcklwd: RewritePunpcklwd(); break; case Opcode.push: RewritePush(); break; case Opcode.pusha: RewritePusha(); break; case Opcode.pushf: RewritePushf(); break; case Opcode.pxor: case Opcode.vpxor: RewritePxor(); break; case Opcode.rcl: RewriteRotation(PseudoProcedure.RolC, true, true); break; case Opcode.rcpps: RewritePackedUnaryop("__rcpps", PrimitiveType.Real32); break; case Opcode.rcr: RewriteRotation(PseudoProcedure.RorC, true, false); break; case Opcode.rol: RewriteRotation(PseudoProcedure.Rol, false, true); break; case Opcode.ror: RewriteRotation(PseudoProcedure.Ror, false, false); break; case Opcode.rdmsr: RewriteRdmsr(); break; case Opcode.rdpmc: RewriteRdpmc(); break; case Opcode.rdtsc: RewriteRdtsc(); break; case Opcode.ret: RewriteRet(); break; case Opcode.retf: RewriteRet(); break; case Opcode.rsqrtps: RewritePackedUnaryop("__rsqrtps", PrimitiveType.Real32); break; case Opcode.sahf: m.Assign(orw.FlagGroup(X86Instruction.DefCc(instrCur.code)), orw.AluRegister(Registers.ah)); break; case Opcode.sar: RewriteBinOp(Operator.Sar); break; case Opcode.sbb: RewriteAdcSbb(m.ISub); break; case Opcode.scas: RewriteStringInstruction(); break; case Opcode.scasb: RewriteStringInstruction(); break; case Opcode.seta: RewriteSet(ConditionCode.UGT); break; case Opcode.setc: RewriteSet(ConditionCode.ULT); break; case Opcode.setbe: RewriteSet(ConditionCode.ULE); break; case Opcode.setg: RewriteSet(ConditionCode.GT); break; case Opcode.setge: RewriteSet(ConditionCode.GE); break; case Opcode.setl: RewriteSet(ConditionCode.LT); break; case Opcode.setle: RewriteSet(ConditionCode.LE); break; case Opcode.setnc: RewriteSet(ConditionCode.UGE); break; case Opcode.setno: RewriteSet(ConditionCode.NO); break; case Opcode.setns: RewriteSet(ConditionCode.NS); break; case Opcode.setnz: RewriteSet(ConditionCode.NE); break; case Opcode.setpe: RewriteSet(ConditionCode.PE); break; case Opcode.setpo: RewriteSet(ConditionCode.PO); break; case Opcode.seto: RewriteSet(ConditionCode.OV); break; case Opcode.sets: RewriteSet(ConditionCode.SG); break; case Opcode.setz: RewriteSet(ConditionCode.EQ); break; case Opcode.sfence: RewriteSfence(); break; case Opcode.sgdt: RewriteSxdt("__sgdt"); break; case Opcode.sha1msg2: RewriteSha1msg2(); break; case Opcode.shl: RewriteBinOp(BinaryOperator.Shl); break; case Opcode.shld: RewriteShxd("__shld"); break; case Opcode.shr: RewriteBinOp(BinaryOperator.Shr); break; case Opcode.shrd: RewriteShxd("__shrd"); break; case Opcode.sidt: RewriteSxdt("__sidt"); break; case Opcode.vshufps: RewritePackedTernaryop("__vshufps", PrimitiveType.Real32); break; case Opcode.sldt: RewriteSxdt("__sldt"); break; case Opcode.sqrtps: RewritePackedUnaryop("__sqrtps", PrimitiveType.Real32); break; case Opcode.sqrtsd: RewriteSqrtsd(); break; case Opcode.stc: RewriteSetFlag(FlagM.CF, Constant.True()); break; case Opcode.std: RewriteSetFlag(FlagM.DF, Constant.True()); break; case Opcode.sti: RewriteSti(); break; case Opcode.stos: RewriteStringInstruction(); break; case Opcode.stosb: RewriteStringInstruction(); break; case Opcode.sub: RewriteAddSub(BinaryOperator.ISub); break; case Opcode.subsd: RewriteScalarBinop(m.FSub, PrimitiveType.Real64); break; case Opcode.subss: RewriteScalarBinop(m.FSub, PrimitiveType.Real32); break; case Opcode.subpd: RewritePackedBinop("__subpd", PrimitiveType.Real64); break; case Opcode.subps: RewritePackedBinop("__subps", PrimitiveType.Real32); break; case Opcode.syscall: RewriteSyscall(); break; case Opcode.sysenter: RewriteSysenter(); break; case Opcode.sysexit: RewriteSysexit(); break; case Opcode.sysret: RewriteSysret(); break; case Opcode.ucomiss: RewriteComis(PrimitiveType.Real32); break; case Opcode.ucomisd: RewriteComis(PrimitiveType.Real64); break; case Opcode.ud2: rtlc = InstrClass.Invalid; m.Invalid(); break; case Opcode.unpcklpd: RewritePackedBinop("__unpcklpd", PrimitiveType.Real64); break; case Opcode.unpcklps: RewritePackedBinop("__unpcklps", PrimitiveType.Real32); break; case Opcode.test: RewriteTest(); break; case Opcode.wait: RewriteWait(); break; case Opcode.wbinvd: RewriteWbinvd(); break; case Opcode.wrmsr: RewriteWrsmr(); break; case Opcode.xadd: RewriteXadd(); break; case Opcode.xchg: RewriteExchange(); break; case Opcode.xgetbv: RewriteXgetbv(); break; case Opcode.xsetbv: RewriteXsetbv(); break; case Opcode.xlat: RewriteXlat(); break; case Opcode.xor: RewriteLogical(BinaryOperator.Xor); break; case Opcode.xorpd: case Opcode.vxorpd: RewritePackedBinop("__xorpd", PrimitiveType.Word64); break; case Opcode.xorps: RewritePackedBinop("__xorps", PrimitiveType.Word32); break; case Opcode.BOR_exp: RewriteFUnary("exp"); break; case Opcode.BOR_ln: RewriteFUnary("log"); break; } var len = (int)(dasm.Current.Address - addr) + dasm.Current.Length; yield return(new RtlInstructionCluster(addr, len, rtlInstructions.ToArray()) { Class = rtlc }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instrCur = dasm.Current; this.iclass = instrCur.InstructionClass; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); switch (instrCur.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.Invalid; case Mnemonic.Invalid: this.iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.add: RewriteAdd(true); break; case Mnemonic.addc: RewriteAddc(true); break; case Mnemonic.addk: RewriteAdd(false); break; case Mnemonic.addi: RewriteAddi(true); break; case Mnemonic.addik: RewriteAddi(false); break; case Mnemonic.and: RewriteLogical(m.And); break; case Mnemonic.andi: RewriteLogicalImm(m.And); break; case Mnemonic.beqi: RewriteBranch(ConditionCode.EQ); break; case Mnemonic.beqid: RewriteBranch(ConditionCode.EQ); break; case Mnemonic.bgei: RewriteBranch(ConditionCode.GE); break; case Mnemonic.bgeid: RewriteBranch(ConditionCode.GE); break; case Mnemonic.bgti: RewriteBranch(ConditionCode.GT); break; case Mnemonic.bgtid: RewriteBranch(ConditionCode.GT); break; case Mnemonic.blei: RewriteBranch(ConditionCode.LE); break; case Mnemonic.bleid: RewriteBranch(ConditionCode.LE); break; case Mnemonic.blti: RewriteBranch(ConditionCode.LT); break; case Mnemonic.bltid: RewriteBranch(ConditionCode.LT); break; case Mnemonic.bnei: RewriteBranch(ConditionCode.NE); break; case Mnemonic.bneid: RewriteBranch(ConditionCode.NE); break; case Mnemonic.br: RewriteJump(false, false); break; case Mnemonic.bra: RewriteJump(false, true); break; case Mnemonic.brad: RewriteJump(false, true); break; case Mnemonic.brai: RewriteJumpAddr(false); break; case Mnemonic.brald: RewriteJump(true, false); break; case Mnemonic.bri: RewriteJumpAddr(false); break; case Mnemonic.brid: RewriteJumpAddr(false); break; case Mnemonic.brlid: RewriteJumpAddr(true); break; case Mnemonic.cmp: RewriteCmp(m.ISub); break; case Mnemonic.cmpu: RewriteCmp(m.USub); break; case Mnemonic.imm: CaptureImmState(); continue; // <- don't emit code! case Mnemonic.lbu: RewriteLoadIdx(PrimitiveType.Byte); break; case Mnemonic.lbui: RewriteLoadOffset(PrimitiveType.Byte); break; case Mnemonic.lhu: RewriteLoadIdx(PrimitiveType.Word16); break; case Mnemonic.lhui: RewriteLoadOffset(PrimitiveType.Word16); break; case Mnemonic.lw: RewriteLoadIdx(PrimitiveType.Word32); break; case Mnemonic.lwi: RewriteLoadOffset(PrimitiveType.Word32); break; case Mnemonic.mul: RewriteMul(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.or: RewriteOr(); break; case Mnemonic.ori: RewriteOri(); break; case Mnemonic.rsub: RewriteRsub(true); break; case Mnemonic.rsubi: RewriteRsubi(true); break; case Mnemonic.rsubk: RewriteRsub(false); break; case Mnemonic.rsubik: RewriteRsubi(false); break; case Mnemonic.rtsd: RewriteRtsd(); break; case Mnemonic.sb: RewriteStoreIdx(PrimitiveType.Byte); break; case Mnemonic.sbi: RewriteStoreOffset(PrimitiveType.Byte); break; case Mnemonic.sext8: RewriteSext(PrimitiveType.SByte); break; case Mnemonic.sext16: RewriteSext(PrimitiveType.Int16); break; case Mnemonic.sh: RewriteStoreIdx(PrimitiveType.Word16); break; case Mnemonic.shi: RewriteStoreOffset(PrimitiveType.Word16); break; case Mnemonic.sra: RewriteShift1(m.Sar); break; case Mnemonic.src: RewriteShift1(RorC); break; case Mnemonic.srl: RewriteShift1(m.Shr); break; case Mnemonic.sw: RewriteStoreIdx(PrimitiveType.Word32); break; case Mnemonic.swi: RewriteStoreOffset(PrimitiveType.Word32); break; case Mnemonic.xor: RewriteLogical(m.Xor); break; case Mnemonic.xori: RewriteLogicalImm(m.Xor); break; } var addr = addrInstr ?? instrCur.Address; var length = (int)(rdr.Address - addr); this.addrInstr = null !; yield return(m.MakeCluster(addr, length, iclass)); this.immHiBits = 0; addrInstr = null !; } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.rtlInstructions = new List <RtlInstruction>(); this.rtlc = RtlClass.Linear; m = new RtlEmitter(this.rtlInstructions); switch (instr.Opcode) { default: host.Warn( instr.Address, "PDP-11 instruction {0} is not supported yet.", instr.Opcode); rtlc = RtlClass.Invalid; m.Invalid(); break; case Opcode.illegal: rtlc = RtlClass.Invalid; m.Invalid(); break; case Opcode.adc: RewriteAdcSbc(m.IAdd); break; case Opcode.add: RewriteAdd(); break; case Opcode.addb: RewriteAdd(); break; case Opcode.ash: RewriteShift(); break; case Opcode.ashc: RewriteAshc(); break; case Opcode.asl: RewriteAsl(); break; case Opcode.asr: RewriteAsr(); break; case Opcode.bcc: RewriteBxx(ConditionCode.UGE, FlagM.CF); break; case Opcode.bcs: RewriteBxx(ConditionCode.ULT, FlagM.CF); break; case Opcode.beq: RewriteBxx(ConditionCode.EQ, FlagM.ZF); break; case Opcode.bge: RewriteBxx(ConditionCode.GE, FlagM.VF | FlagM.NF); break; case Opcode.bgt: RewriteBxx(ConditionCode.GT, FlagM.ZF | FlagM.NF | FlagM.VF); break; case Opcode.bhi: RewriteBxx(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break; case Opcode.bvs: RewriteBxx(ConditionCode.OV, FlagM.VF); break; case Opcode.bic: RewriteBic(); break; case Opcode.bis: RewriteBis(); break; case Opcode.bisb: RewriteBis(); break; case Opcode.bit: RewriteBit(); break; case Opcode.bitb: RewriteBit(); break; case Opcode.ble: RewriteBxx(ConditionCode.LE, FlagM.ZF | FlagM.NF | FlagM.VF); break; case Opcode.blos: RewriteBxx(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break; case Opcode.blt: RewriteBxx(ConditionCode.LT, FlagM.NF | FlagM.VF); break; case Opcode.bmi: RewriteBxx(ConditionCode.LT, FlagM.NF); break; case Opcode.bne: RewriteBxx(ConditionCode.NE, FlagM.ZF); break; case Opcode.bpl: RewriteBxx(ConditionCode.GT, FlagM.NF); break; case Opcode.bpt: RewriteBpt(); break; case Opcode.br: RewriteBr(); break; case Opcode.clr: RewriteClr(instr, m.Word16(0)); break; case Opcode.clrb: RewriteClr(instr, m.Byte(0)); break; case Opcode.clrflags: RewriteClrSetFlags(Constant.False); break; case Opcode.cmp: RewriteCmp(); break; case Opcode.com: RewriteCom(); break; case Opcode.dec: RewriteIncDec(m.ISub); break; case Opcode.div: RewriteDiv(); break; case Opcode.emt: RewriteEmt(); break; case Opcode.halt: RewriteHalt(); break; case Opcode.iot: RewriteIot(); break; case Opcode.inc: RewriteIncDec(m.IAdd); break; case Opcode.jmp: RewriteJmp(); break; case Opcode.jsr: RewriteJsr(); break; case Opcode.mark: RewriteMark(); break; case Opcode.mfpd: RewriteMfpd(); break; case Opcode.mfpi: RewriteMfpi(); break; case Opcode.mov: RewriteMov(); break; case Opcode.movb: RewriteMov(); break; case Opcode.mtpi: RewriteMtpi(); break; case Opcode.mul: RewriteMul(); break; case Opcode.neg: RewriteNeg(); break; case Opcode.nop: m.Nop(); break; case Opcode.reset: RewriteReset(); break; case Opcode.rol: RewriteRotate(PseudoProcedure.Rol); break; case Opcode.ror: RewriteRotate(PseudoProcedure.Ror); break; case Opcode.rti: RewriteRti(); break; case Opcode.rts: RewriteRts(); break; case Opcode.rtt: RewriteRtt(); break; case Opcode.sbc: RewriteAdcSbc(m.ISub); break; case Opcode.setflags: RewriteClrSetFlags(Constant.True); break; case Opcode.stcdi: RewriteStcdi(); break; case Opcode.sob: RewriteSob(); break; case Opcode.stexp: RewriteStexp(); break; case Opcode.sub: RewriteSub(); break; case Opcode.swab: RewriteSwab(); break; case Opcode.sxt: RewriteSxt(); break; case Opcode.trap: RewriteTrap(); break; case Opcode.tst: RewriteTst(); break; case Opcode.tstb: RewriteTst(); break; case Opcode.wait: RewriteWait(); break; case Opcode.xor: RewriteXor(); break; } yield return(new RtlInstructionCluster(instr.Address, instr.Length, this.rtlInstructions.ToArray()) { Class = rtlc }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var addr = dasm.Current.Address; var len = dasm.Current.Length; var rtlInstructions = new List <RtlInstruction>(); iclass = InstrClass.Linear; m = new RtlEmitter(rtlInstructions); this.instr = dasm.Current; switch (instr.Mnemonic) { default: host.Error(instr.Address, $"Rewriting of Xtensa instruction '{instr}' not implemented yet."); EmitUnitTest(); goto case Mnemonic.invalid; case Mnemonic.invalid: case Mnemonic.reserved: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.abs: RewritePseudoFn("abs"); break; case Mnemonic.add: case Mnemonic.add_n: RewriteBinOp(m.IAdd); break; case Mnemonic.add_s: RewriteBinOp(m.FAdd); break; case Mnemonic.addi: RewriteAddi(); break; case Mnemonic.addi_n: RewriteAddi(); break; case Mnemonic.addmi: RewriteBinOp(m.IAdd); break; case Mnemonic.addx2: RewriteAddx(2); break; case Mnemonic.addx4: RewriteAddx(4); break; case Mnemonic.addx8: RewriteAddx(8); break; case Mnemonic.all4: RewriteAll(4, m.And); break; case Mnemonic.all8: RewriteAll(8, m.And); break; case Mnemonic.and: RewriteBinOp(m.And); break; case Mnemonic.andb: RewriteBinOp(m.And); break; case Mnemonic.andbc: RewriteBinOp((a, b) => m.And(a, m.Not(b))); break; case Mnemonic.any4: RewriteAll(4, m.Or); break; case Mnemonic.any8: RewriteAll(8, m.Or); break; case Mnemonic.ball: RewriteBall(); break; case Mnemonic.bany: RewriteBany(); break; case Mnemonic.bbc: case Mnemonic.bbci: RewriteBbx(m.Eq0); break; case Mnemonic.bbs: case Mnemonic.bbsi: RewriteBbx(m.Ne0); break; case Mnemonic.beq: case Mnemonic.beqi: RewriteBranch(m.Eq); break; case Mnemonic.beqz: case Mnemonic.beqz_n: RewriteBranchZ(m.Eq0); break; case Mnemonic.bf: RewriteBranchZ(m.Not); break; case Mnemonic.bge: case Mnemonic.bgei: RewriteBranch(m.Ge); break; case Mnemonic.bgeu: case Mnemonic.bgeui: RewriteBranch(m.Uge); break; case Mnemonic.bgez: RewriteBranchZ(m.Ge0); break; case Mnemonic.blt: RewriteBranch(m.Lt); break; case Mnemonic.blti: RewriteBranch(m.Lt); break; case Mnemonic.bltu: case Mnemonic.bltui: RewriteBranch(m.Ult); break; case Mnemonic.bltz: RewriteBranchZ(m.Lt0); break; case Mnemonic.bnall: RewriteBnall(); break; case Mnemonic.bne: RewriteBranch(m.Ne); break; case Mnemonic.bnei: RewriteBranch(m.Ne); break; case Mnemonic.bnez: case Mnemonic.bnez_n: RewriteBranchZ(m.Ne0); break; case Mnemonic.bnone: RewriteBnone(); break; case Mnemonic.@break: RewriteBreak(); break; case Mnemonic.call0: RewriteCall0(); break; case Mnemonic.call4: RewriteCallW(4); break; case Mnemonic.call8: RewriteCallW(8); break; case Mnemonic.call12: RewriteCallW(12); break; case Mnemonic.callx0: RewriteCall0(); break; case Mnemonic.callx4: RewriteCallW(4); break; case Mnemonic.callx8: RewriteCallW(8); break; case Mnemonic.callx12: RewriteCallW(12); break; case Mnemonic.ceil_s: RewriteCvtFloatToIntegral("__ceil", PrimitiveType.Int32); break; case Mnemonic.clamps: RewriteClamps(); break; case Mnemonic.cust0: RewritePseudoProc("__cust0"); break; case Mnemonic.cust1: RewritePseudoProc("__cust1"); break; case Mnemonic.dhi: RewriteCacheFn("__dhi"); break; case Mnemonic.dhu: RewriteCacheFn("__dhu"); break; case Mnemonic.dhwb: RewriteCacheFn("__dhwb"); break; case Mnemonic.dhwbi: RewriteCacheFn("__dhwbi"); break; case Mnemonic.dii: RewriteCacheFn("__dii"); break; case Mnemonic.diu: RewriteCacheFn("__diu"); break; case Mnemonic.dpfr: RewriteCacheFn("__dpfr"); break; case Mnemonic.dpfro: RewriteCacheFn("__dpfro"); break; case Mnemonic.dpfw: RewriteCacheFn("__dpfw"); break; case Mnemonic.dpfwo: RewriteCacheFn("__dpfwo"); break; case Mnemonic.dsync: RewritePseudoProc("__dsync"); break; case Mnemonic.esync: RewritePseudoProc("__esync"); break; case Mnemonic.excw: RewritePseudoProc("__excw"); break; case Mnemonic.extui: RewriteExtui(); break; case Mnemonic.entry: RewriteEntry(); break; case Mnemonic.float_s: RewriteFloat_s(PrimitiveType.Int32); break; case Mnemonic.floor_s: RewritePseudoFn("__floor"); break; case Mnemonic.iii: RewriteCacheFn("__iii"); break; case Mnemonic.iitlb: RewritePseudoProc("__iitlb"); break; case Mnemonic.ipf: RewriteCacheFn("__ipf"); break; case Mnemonic.isync: RewritePseudoProc("__isync"); break; case Mnemonic.j: case Mnemonic.jx: RewriteJ(); break; case Mnemonic.ill: RewriteIll(); break; case Mnemonic.l16si: RewriteLsi(PrimitiveType.Int16); break; case Mnemonic.l16ui: RewriteLui(PrimitiveType.UInt16); break; case Mnemonic.l32ai: RewriteL32ai(); break; case Mnemonic.l32i: RewriteL32i(); break; case Mnemonic.l32e: RewriteL32e(); break; case Mnemonic.l32i_n: RewriteL32i(); break; case Mnemonic.l32r: RewriteCopy(); break; case Mnemonic.l8ui: RewriteLui(PrimitiveType.Byte); break; case Mnemonic.lddec: RewriteLddecinc(m.ISub); break; case Mnemonic.ldinc: RewriteLddecinc(m.IAdd); break; case Mnemonic.ldpte: RewritePseudoProc("__ldpte"); break; case Mnemonic.loop: RewriteLoop(); break; case Mnemonic.lsiu: RewriteLsiu(); break; case Mnemonic.madd_s: RewriteMaddSub(m.FAdd); break; case Mnemonic.memw: RewriteNop(); break; /// memory sync barriers? case Mnemonic.max: RewriteMax(); break; case Mnemonic.maxu: RewriteMaxu(); break; case Mnemonic.min: RewriteMin(); break; case Mnemonic.minu: RewriteMinu(); break; case Mnemonic.mov_n: RewriteCopy(); break; case Mnemonic.mov_s: RewriteCopy(); break; case Mnemonic.movf: case Mnemonic.movf_s: RewriteMovft(e => e); break; case Mnemonic.movi: RewriteCopy(); break; case Mnemonic.movi_n: RewriteMovi_n(); break; case Mnemonic.movsp: RewriteCopy(); break; case Mnemonic.moveqz: case Mnemonic.moveqz_s: RewriteMovcc(m.Eq); break; case Mnemonic.movltz: case Mnemonic.movltz_s: RewriteMovcc(m.Lt); break; case Mnemonic.movgez: case Mnemonic.movgez_s: RewriteMovcc(m.Ge); break; case Mnemonic.movnez: case Mnemonic.movnez_s: RewriteMovcc(m.Ne); break; case Mnemonic.movt: case Mnemonic.movt_s: RewriteMovft(m.Not); break; case Mnemonic.msub_s: RewriteMaddSub(m.FSub); break; case Mnemonic.mul_aa_hh: RewriteMul("__mul_hh", Int40); break; case Mnemonic.mul_aa_hl: RewriteMul("__mul_hl", Int40); break; case Mnemonic.mul_aa_lh: RewriteMul("__mul_lh", Int40); break; case Mnemonic.mul_aa_ll: RewriteMul("__mul_ll", Int40); break; case Mnemonic.mul_ad_hh: RewriteMul("__mul_hh", Int40); break; case Mnemonic.mul_ad_hl: RewriteMul("__mul_hl", Int40); break; case Mnemonic.mul_ad_lh: RewriteMul("__mul_lh", Int40); break; case Mnemonic.mul_ad_ll: RewriteMul("__mul_ll", Int40); break; case Mnemonic.mul_da_hh: RewriteMul("__mul_hh", Int40); break; case Mnemonic.mul_da_hl: RewriteMul("__mul_hl", Int40); break; case Mnemonic.mul_da_lh: RewriteMul("__mul_lh", Int40); break; case Mnemonic.mul_da_ll: RewriteMul("__mul_ll", Int40); break; case Mnemonic.mul_dd_hh: RewriteMul("__mul_hh", Int40); break; case Mnemonic.mul_dd_hl: RewriteMul("__mul_hl", Int40); break; case Mnemonic.mul_dd_lh: RewriteMul("__mul_lh", Int40); break; case Mnemonic.mul_dd_ll: RewriteMul("__mul_ll", Int40); break; case Mnemonic.mula_aa_hh: RewriteMula("__mul_hh", Int40); break; case Mnemonic.mula_aa_hl: RewriteMula("__mul_hl", Int40); break; case Mnemonic.mula_aa_lh: RewriteMula("__mul_lh", Int40); break; case Mnemonic.mula_aa_ll: RewriteMula("__mul_ll", Int40); break; case Mnemonic.mula_ad_hh: RewriteMula("__mul_hh", Int40); break; case Mnemonic.mula_ad_hl: RewriteMula("__mul_hl", Int40); break; case Mnemonic.mula_ad_lh: RewriteMula("__mul_lh", Int40); break; case Mnemonic.mula_ad_ll: RewriteMula("__mul_ll", Int40); break; case Mnemonic.mula_da_hh: RewriteMula("__mul_hh", Int40); break; case Mnemonic.mula_da_hh_lddec: RewriteMulaIncDec("__mul_hh", Int40, -4); break; case Mnemonic.mula_da_hh_ldinc: RewriteMulaIncDec("__mul_hh", Int40, 4); break; case Mnemonic.mula_da_hl: RewriteMula("__mul_hl", Int40); break; case Mnemonic.mula_da_hl_lddec: RewriteMulaIncDec("__mul_hl", Int40, -4); break; case Mnemonic.mula_da_hl_ldinc: RewriteMulaIncDec("__mul_hl", Int40, 4); break; case Mnemonic.mula_da_lh: RewriteMula("__mul_lh", Int40); break; case Mnemonic.mula_da_lh_lddec: RewriteMulaIncDec("__mul_lh", Int40, -4); break; case Mnemonic.mula_da_lh_ldinc: RewriteMulaIncDec("__mul_lh", Int40, 4); break; case Mnemonic.mula_da_ll: RewriteMula("__mul_ll", Int40); break; case Mnemonic.mula_da_ll_lddec: RewriteMulaIncDec("__mul_ll", Int40, -4); break; case Mnemonic.mula_da_ll_ldinc: RewriteMulaIncDec("__mul_ll", Int40, 4); break; case Mnemonic.mula_dd_hh: RewriteMula("__mul_hh", Int40); break; case Mnemonic.mula_dd_hh_lddec: RewriteMulaIncDec("__mul_hh", Int40, -4); break; case Mnemonic.mula_dd_hl: RewriteMula("__mul_hl", Int40); break; case Mnemonic.mula_dd_lh: RewriteMula("__mul_lh", Int40); break; case Mnemonic.mula_dd_ll: RewriteMula("__mul_ll", Int40); break; case Mnemonic.mula_dd_ll_lddec: RewriteMulaIncDec("__mul_ll", Int40, -4); break; case Mnemonic.muls_aa_hh: RewriteMuls("__mul_hh", Int40); break; case Mnemonic.muls_aa_hl: RewriteMuls("__mul_hl", Int40); break; case Mnemonic.muls_aa_lh: RewriteMuls("__mul_lh", Int40); break; case Mnemonic.muls_aa_ll: RewriteMuls("__mul_ll", Int40); break; case Mnemonic.muls_ad_hh: RewriteMuls("__mul_hh", Int40); break; case Mnemonic.muls_ad_hl: RewriteMuls("__mul_hl", Int40); break; case Mnemonic.muls_ad_lh: RewriteMuls("__mul_lh", Int40); break; case Mnemonic.muls_ad_ll: RewriteMuls("__mul_ll", Int40); break; case Mnemonic.muls_da_hh: RewriteMuls("__mul_hh", Int40); break; case Mnemonic.muls_da_hl: RewriteMuls("__mul_hl", Int40); break; case Mnemonic.muls_da_lh: RewriteMuls("__mul_lh", Int40); break; case Mnemonic.muls_da_ll: RewriteMuls("__mul_ll", Int40); break; case Mnemonic.muls_dd_hh: RewriteMuls("__mul_hh", Int40); break; case Mnemonic.muls_dd_hl: RewriteMuls("__mul_hl", Int40); break; case Mnemonic.muls_dd_lh: RewriteMuls("__mul_lh", Int40); break; case Mnemonic.muls_dd_ll: RewriteMuls("__mul_ll", Int40); break; case Mnemonic.mul_s: RewriteBinOp(m.FMul); break; case Mnemonic.mul16s: RewriteMul16(m.SMul, Domain.SignedInt); break; case Mnemonic.mul16u: RewriteMul16(m.UMul, Domain.UnsignedInt); break; case Mnemonic.mull: RewriteBinOp(m.IMul); break; case Mnemonic.mulsh: RewriteMulh("__mulsh", PrimitiveType.Int32); break; case Mnemonic.muluh: RewriteMulh("__muluh", PrimitiveType.UInt32); break; case Mnemonic.neg: RewriteUnaryOp(m.Neg); break; case Mnemonic.nsa: RewritePseudoFn("__nsa"); break; case Mnemonic.nsau: RewritePseudoFn("__nsau"); break; case Mnemonic.oeq_s: RewriteBinOp(m.FEq); break; //$REVIEW: what to do about 'ordered' and 'unordered' case Mnemonic.ole_s: RewriteBinOp(m.FLe); break; //$REVIEW: what to do about 'ordered' and 'unordered' case Mnemonic.olt_s: RewriteBinOp(m.FLt); break; //$REVIEW: what to do about 'ordered' and 'unordered' case Mnemonic.or: RewriteOr(); break; case Mnemonic.orb: RewriteOr(); break; case Mnemonic.orbc: RewriteBinOp((a, b) => m.Or(a, m.Not(b))); break; case Mnemonic.pitlb: RewritePseudoFn("__pitlb"); break; case Mnemonic.quos: RewriteBinOp(m.SDiv); break; case Mnemonic.quou: RewriteBinOp(m.UDiv); break; case Mnemonic.rdtlb0: RewritePseudoFn("__rdtlb0"); break; case Mnemonic.rdtlb1: RewritePseudoFn("__rdtlb1"); break; case Mnemonic.rems: RewriteBinOp(m.Mod); break; case Mnemonic.remu: RewriteBinOp(m.Mod); break; case Mnemonic.ret: case Mnemonic.ret_n: RewriteRet(); break; case Mnemonic.rfe: RewriteRet(); break; //$REVIEW: emit some hint this is a return from exception? case Mnemonic.rfi: RewriteRet(); break; //$REVIEW: emit some hint this is a return from interrupt? case Mnemonic.ritlb0: RewritePseudoFn("__ritlb0"); break; case Mnemonic.ritlb1: RewritePseudoFn("__ritlb1"); break; case Mnemonic.rotw: RewritePseudoProc("__rotw"); break; case Mnemonic.round_s: RewriteCvtFloatToIntegral("__round", PrimitiveType.Int32); break; case Mnemonic.rsil: RewritePseudoFn("__rsil"); break; case Mnemonic.rer: RewriteRer(); break; case Mnemonic.rfr: RewriteCopy(); break; case Mnemonic.rsr: RewriteCopy(); break; case Mnemonic.rsync: RewriteRsync(); break; case Mnemonic.rur: RewriteCopy(); break; case Mnemonic.s16i: RewriteSi(PrimitiveType.Word16); break; case Mnemonic.s32c1i: RewriteS32c1i(); break; case Mnemonic.s32e: RewriteS32e(); break; case Mnemonic.s32i: case Mnemonic.s32i_n: RewriteSi(PrimitiveType.Word32); break; case Mnemonic.s32ri: RewriteSi(PrimitiveType.Word32); break; //$REVIEW: what about concurrency semantics case Mnemonic.s8i: RewriteSi(PrimitiveType.Byte); break; case Mnemonic.sext: RewriteSext(); break; case Mnemonic.sll: RewriteShift(m.Shl); break; case Mnemonic.slli: RewriteShiftI(m.Shl); break; case Mnemonic.sra: RewriteShift(m.Sar); break; case Mnemonic.srai: RewriteShiftI(m.Sar); break; case Mnemonic.src: RewriteSrc(); break; case Mnemonic.srl: RewriteShift(m.Sar); break; case Mnemonic.srli: RewriteShiftI(m.Shr); break; case Mnemonic.ssa8b: RewriteSsa8b(); break; case Mnemonic.ssa8l: RewriteSsa8l(); break; case Mnemonic.ssi: RewriteSi(PrimitiveType.Real32); break; case Mnemonic.ssl: RewriteSsl(); break; case Mnemonic.ssr: case Mnemonic.ssai: RewriteSsa(); break; case Mnemonic.sub: RewriteBinOp(m.ISub); break; case Mnemonic.sub_s: RewriteBinOp(m.FSub); break; case Mnemonic.subx2: RewriteSubx(2); break; case Mnemonic.subx4: RewriteSubx(4); break; case Mnemonic.subx8: RewriteSubx(8); break; case Mnemonic.syscall: RewriteSyscall(); break; case Mnemonic.trunc_s: RewriteCvtFloatToIntegral("__trunc", PrimitiveType.Int32); break; case Mnemonic.ueq_s: RewriteBinOp(m.Eq); break; //$REVIEW: what to do about 'ordered' and 'unordered' case Mnemonic.ufloat_s: RewriteFloat_s(PrimitiveType.UInt32); break; case Mnemonic.ule_s: RewriteBinOp(m.FLe); break; //$REVIEW: what to do about 'ordered' and 'unordered' case Mnemonic.ult_s: RewriteBinOp(m.FLt); break; //$REVIEW: what to do about 'ordered' and 'unordered' case Mnemonic.umul_aa_hh: RewriteMul("__umul_hh", UInt40); break; case Mnemonic.umul_aa_hl: RewriteMul("__umul_hl", UInt40); break; case Mnemonic.umul_aa_lh: RewriteMul("__umul_lh", UInt40); break; case Mnemonic.umul_aa_ll: RewriteMul("__umul_ll", UInt40); break; case Mnemonic.un_s: RewritePseudoFn("isunordered"); break; case Mnemonic.utrunc_s: RewriteCvtFloatToIntegral("__utrunc", PrimitiveType.UInt32); break; case Mnemonic.waiti: RewritePseudoProc("__waiti"); break; case Mnemonic.wdtlb: RewritePseudoProc("__wdtlb"); break; case Mnemonic.witlb: RewritePseudoProc("__witlb"); break; case Mnemonic.wer: RewriteWer(); break; case Mnemonic.wsr: RewriteWsr(); break; case Mnemonic.wur: RewriteInverseCopy(); break; case Mnemonic.xor: RewriteBinOp(m.Xor); break; case Mnemonic.xorb: RewriteBinOp(m.Xor); break; case Mnemonic.xsr: RewriteXsr(); break; } CheckForLoopExit(); yield return(m.MakeCluster(addr, len, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.iclass = instr.InstructionClass; var instrs = new List <RtlInstruction>(); m = new RtlEmitter(instrs); switch (instr.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.invalid; case Mnemonic.invalid: m.Invalid(); break; case Mnemonic.add: RewriteAdd(true); break; case Mnemonic.add_c: RewriteAdd_c(); break; case Mnemonic.add_l: RewriteAdd(false); break; case Mnemonic.addb: RewriteAddb(); break; case Mnemonic.addi: RewriteAddi(false); break; case Mnemonic.addi_tc: RewriteAddi(true); break; case Mnemonic.addib: RewriteAddb(); break; case Mnemonic.addil: RewriteAddi(false); break; case Mnemonic.and: RewriteLogical(m.And); break; case Mnemonic.andcm: RewriteLogical((a, b) => m.And(a, m.Comp(b))); break; case Mnemonic.b_l: RewriteBranch(); break; case Mnemonic.be: RewriteBe(); break; case Mnemonic.be_l: RewriteBe(); break; case Mnemonic.bv: RewriteBv(); break; case Mnemonic.cmpb: RewriteCmpb(0, 1); break; case Mnemonic.cmpib: RewriteCmpb(1, 0); break; case Mnemonic.@break: RewriteBreak(); break; case Mnemonic.depwi: RewriteDepwi(); break; case Mnemonic.diag: RewriteDiag(); break; case Mnemonic.extrw: RewriteExtrw(); break; case Mnemonic.fadd: RewriteFpArithmetic(m.FAdd); break; case Mnemonic.fcpy: RewriteFcpy(); break; case Mnemonic.fid: RewriteFid(); break; case Mnemonic.fldd: RewriteFld(PrimitiveType.Real64); break; case Mnemonic.fldw: RewriteFld(PrimitiveType.Real32); break; case Mnemonic.fmpy: RewriteFpArithmetic(m.FMul); break; case Mnemonic.fstd: RewriteFst(PrimitiveType.Real64); break; case Mnemonic.fstw: RewriteFst(PrimitiveType.Real32); break; case Mnemonic.fsub: RewriteFpArithmetic(m.FSub); break; case Mnemonic.ldb: RewriteLd(PrimitiveType.Byte); break; case Mnemonic.ldd: RewriteLd(PrimitiveType.Word64); break; case Mnemonic.ldh: RewriteLd(PrimitiveType.Word16); break; case Mnemonic.ldil: RewriteLdil(); break; case Mnemonic.ldo: RewriteLdo(); break; case Mnemonic.ldsid: RewriteLdsid(); break; case Mnemonic.ldw: RewriteLd(PrimitiveType.Word32); break; case Mnemonic.ldwa: RewriteLd(PrimitiveType.Word32); break; case Mnemonic.mfctl: RewriteMfctl(); break; case Mnemonic.mfctl_w: RewriteMfctl(); break; case Mnemonic.mtctl: RewriteMtctl(); break; case Mnemonic.mtsm: RewriteMtsm(); break; case Mnemonic.mtsp: RewriteMtsp(); break; case Mnemonic.or: RewriteOr(); break; case Mnemonic.rfi: RewriteRfi("__rfi"); break; case Mnemonic.rfi_r: RewriteRfi("__rfi_r"); break; case Mnemonic.shladd: RewriteShladd(); break; case Mnemonic.shrpd: RewriteShrp(PrimitiveType.Word64, PrimitiveType.Word128); break; case Mnemonic.shrpw: RewriteShrp(PrimitiveType.Word32, PrimitiveType.Word64); break; case Mnemonic.stb: RewriteSt(PrimitiveType.Byte); break; case Mnemonic.std: RewriteSt(PrimitiveType.Word64); break; case Mnemonic.stda: RewriteSt(PrimitiveType.Word64); break; case Mnemonic.sth: RewriteSt(PrimitiveType.Word16); break; case Mnemonic.stw: RewriteSt(PrimitiveType.Word32); break; case Mnemonic.sub: RewriteSub(); break; case Mnemonic.subi: RewriteSubi(); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; var rtlInstrs = new List <RtlInstruction>(); this.m = new RtlEmitter(rtlInstrs); this.rtlc = RtlClass.Linear; switch (instr.Opcode) { case Opcode.mov: case Opcode.rev: case Opcode.revw: case Opcode.tbl: host.Warn( instr.Address, "M6812 instruction '{0}' is not supported yet.", instr.Opcode); goto case Opcode.invalid; case Opcode.invalid: this.rtlc = RtlClass.Invalid; m.Invalid(); break; case Opcode.aba: RewriteAba(); break; case Opcode.adca: RewriteAdcSbc(Registers.a, m.IAdd); break; case Opcode.adcb: RewriteAdcSbc(Registers.b, m.IAdd); break; case Opcode.adda: RewriteArithmetic(Registers.a, m.IAdd); break; case Opcode.addb: RewriteArithmetic(Registers.b, m.IAdd); break; case Opcode.addd: RewriteArithmetic(Registers.d, m.IAdd); break; case Opcode.anda: RewriteLogical(Registers.a, m.And); break; case Opcode.andb: RewriteLogical(Registers.b, m.And); break; case Opcode.andcc: RewriteAndcc(); break; case Opcode.asr: RewriteShiftMem(m.Sar); break; case Opcode.asra: RewriteArithmetic(Registers.a, m.Sar); break; case Opcode.asrb: RewriteArithmetic(Registers.b, m.Sar); break; case Opcode.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break; case Opcode.bclr: RewriteBclr(); break; case Opcode.bcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break; case Opcode.beq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break; case Opcode.bge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Opcode.bgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.bhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Opcode.ble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.blt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break; case Opcode.bls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break; case Opcode.bmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break; case Opcode.bne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break; case Opcode.bpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break; case Opcode.bvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break; case Opcode.bvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break; case Opcode.bgnd: RewriteBgnd(); break; case Opcode.bita: RewriteBit(Registers.a); break; case Opcode.bitb: RewriteBit(Registers.b); break; case Opcode.bra: RewriteBra(); break; case Opcode.brclr: RewriteBrclr(); break; case Opcode.brn: m.Nop(); break; case Opcode.brset: RewriteBrset(); break; case Opcode.bset: RewriteBset(); break; case Opcode.bsr: RewriteBsr(); break; case Opcode.call: RewriteCall(); break; case Opcode.cba: RewriteCba(); break; case Opcode.clr: RewriteClr(); break; case Opcode.clra: RewriteClr(Registers.a); break; case Opcode.clrb: RewriteClr(Registers.b); break; case Opcode.cmpa: RewriteCmp(Registers.a); break; case Opcode.cmpb: RewriteCmp(Registers.b); break; case Opcode.com: RewriteCom(); break; case Opcode.coma: RewriteCom(Registers.a); break; case Opcode.comb: RewriteCom(Registers.b); break; case Opcode.cpd: RewriteCmp(Registers.d); break; case Opcode.cps: RewriteCmp(Registers.sp); break; case Opcode.cpx: RewriteCmp(Registers.x); break; case Opcode.cpy: RewriteCmp(Registers.y); break; case Opcode.daa: RewriteDaa(); break; case Opcode.dbeq: RewriteDb(m.Eq0); break; case Opcode.dbne: RewriteDb(m.Ne0); break; case Opcode.dec: RewriteIncDec(m.ISub); break; case Opcode.deca: RewriteIncDec(Registers.a, m.ISub); break; case Opcode.decb: RewriteIncDec(Registers.b, m.ISub); break; case Opcode.dex: RewriteIncDecXY(Registers.x, m.ISub); break; case Opcode.dey: RewriteIncDecXY(Registers.y, m.ISub); break; case Opcode.ediv: RewriteEdiv(m.UDiv, m.Remainder); break; case Opcode.edivs: RewriteEdiv(m.SDiv, m.Remainder); break; case Opcode.emacs: RewriteEmacs(); break; case Opcode.emaxd: RewriteEmaxmind("__umax"); break; case Opcode.emaxm: RewriteEmaxminm("__umax"); break; case Opcode.emind: RewriteEmaxmind("__umin"); break; case Opcode.eminm: RewriteEmaxminm("__umin"); break; case Opcode.emul: RewriteEmul(m.UMul); break; case Opcode.emuls: RewriteEmul(m.SMul); break; case Opcode.eora: RewriteLogical(Registers.a, m.Xor); break; case Opcode.eorb: RewriteLogical(Registers.b, m.Xor); break; case Opcode.etbl: RewriteEtbl(); break; case Opcode.fdiv: RewriteFdiv(); break; case Opcode.ibeq: RewriteIb(m.Eq0); break; case Opcode.ibne: RewriteIb(m.Ne0); break; case Opcode.idiv: RewriteIdiv(m.UDiv); break; case Opcode.idivs: RewriteIdiv(m.SDiv); break; case Opcode.inc: RewriteIncDec(m.IAdd); break; case Opcode.inca: RewriteIncDec(Registers.a, m.IAdd); break; case Opcode.incb: RewriteIncDec(Registers.b, m.IAdd); break; case Opcode.inx: RewriteIncDecXY(Registers.x, m.IAdd); break; case Opcode.iny: RewriteIncDecXY(Registers.y, m.IAdd); break; case Opcode.jmp: RewriteJmp(); break; case Opcode.jsr: RewriteJsr(); break; case Opcode.lbcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break; case Opcode.lbcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break; case Opcode.lbeq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break; case Opcode.lbge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Opcode.lbgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.lbhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Opcode.lble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.lblt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break; case Opcode.lbls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break; case Opcode.lbmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break; case Opcode.lbne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break; case Opcode.lbpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break; case Opcode.lbra: RewriteBra(); break; case Opcode.lbrn: m.Nop(); break; case Opcode.lbvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break; case Opcode.lbvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break; case Opcode.ldaa: RewriteLd(Registers.a); break; case Opcode.ldab: RewriteLd(Registers.b); break; case Opcode.ldd: RewriteLd(Registers.d); break; case Opcode.lds: RewriteLd(Registers.sp); break; case Opcode.ldx: RewriteLd(Registers.x); break; case Opcode.ldy: RewriteLd(Registers.y); break; case Opcode.leas: RewriteLea(Registers.sp); break; case Opcode.leax: RewriteLea(Registers.x); break; case Opcode.leay: RewriteLea(Registers.y); break; case Opcode.lsl: RewriteShiftMem(m.Shl); break; case Opcode.lsla: RewriteArithmetic(Registers.a, m.Shl); break; case Opcode.lslb: RewriteArithmetic(Registers.b, m.Shl); break; case Opcode.lsld: RewriteArithmetic(Registers.d, m.Shl); break; case Opcode.lsr: RewriteShiftMem(m.Shr); break; case Opcode.lsra: RewriteArithmetic(Registers.a, m.Shr); break; case Opcode.lsrb: RewriteArithmetic(Registers.b, m.Shr); break; case Opcode.lsrd: RewriteArithmetic(Registers.d, m.Shr); break; case Opcode.maxa: RewriteMaxmina("__umax_b"); break; case Opcode.maxm: RewriteMaxminm("__umax_b"); break; case Opcode.mem: RewriteMem(); break; case Opcode.mina: RewriteMaxmina("__umin_b"); break; case Opcode.minm: RewriteMaxminm("__umin_b"); break; case Opcode.mul: RewriteMul(); break; case Opcode.neg: RewriteNeg(); break; case Opcode.nega: RewriteNeg(Registers.a); break; case Opcode.negb: RewriteNeg(Registers.b); break; case Opcode.nop: m.Nop(); break; case Opcode.oraa: RewriteLogical(Registers.a, m.Or); break; case Opcode.orab: RewriteLogical(Registers.b, m.Or); break; case Opcode.orcc: RewriteOrcc(); break; case Opcode.psha: RewritePsh(Registers.a); break; case Opcode.pshb: RewritePsh(Registers.b); break; case Opcode.pshc: RewritePsh(Registers.ccr); break; case Opcode.pshd: RewritePsh(Registers.d); break; case Opcode.pshx: RewritePsh(Registers.x); break; case Opcode.pshy: RewritePsh(Registers.y); break; case Opcode.pula: RewritePul(Registers.a); break; case Opcode.pulb: RewritePul(Registers.b); break; case Opcode.pulc: RewritePul(Registers.ccr); break; case Opcode.puld: RewritePul(Registers.d); break; case Opcode.pulx: RewritePul(Registers.x); break; case Opcode.puly: RewritePul(Registers.y); break; case Opcode.rol: RewriteShiftMem(Rol); break; case Opcode.rola: RewriteArithmetic(Registers.a, Rol); break; case Opcode.rolb: RewriteArithmetic(Registers.b, Rol); break; case Opcode.ror: RewriteShiftMem(Ror); break; case Opcode.rora: RewriteArithmetic(Registers.a, Ror); break; case Opcode.rorb: RewriteArithmetic(Registers.a, Ror); break; case Opcode.rtc: RewriteRtc(); break; case Opcode.rti: RewriteRti(); break; case Opcode.rts: RewriteRts(); break; case Opcode.sba: RewriteSba(); break; case Opcode.sbca: RewriteAdcSbc(Registers.a, m.ISub); break; case Opcode.sbcb: RewriteAdcSbc(Registers.b, m.ISub); break; case Opcode.sex: RewriteSex(); break; case Opcode.staa: RewriteSt(Registers.a); break; case Opcode.stab: RewriteSt(Registers.b); break; case Opcode.std: RewriteSt(Registers.d); break; case Opcode.stop: RewriteStop(); break; case Opcode.sts: RewriteSt(Registers.sp); break; case Opcode.stx: RewriteSt(Registers.x); break; case Opcode.sty: RewriteSt(Registers.y); break; case Opcode.suba: RewriteSub(Registers.a); break; case Opcode.subb: RewriteSub(Registers.b); break; case Opcode.subd: RewriteSub(Registers.d); break; case Opcode.swi: RewriteSwi(); break; case Opcode.tab: RewriteTab(); break; case Opcode.tba: RewriteTba(); break; case Opcode.tbeq: RewriteTb(m.Eq0); break; case Opcode.tbne: RewriteTb(m.Ne0); break; case Opcode.tfr: RewriteTfr(); break; case Opcode.trap: RewriteTrap(); break; case Opcode.tst: RewriteTst(); break; case Opcode.tsta: RewriteTst(Registers.a); break; case Opcode.tstb: RewriteTst(Registers.b); break; case Opcode.wai: RewriteWai(); break; case Opcode.wav: RewriteWav(); break; } yield return(new RtlInstructionCluster( instr.Address, instr.Length, rtlInstrs.ToArray()) { Class = rtlc }); } }
private void Invalid() { m.Invalid(); rtlc = InstrClass.Invalid; }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var instr = dasm.Current; var rtlInstructions = new List <RtlInstruction>(); this.iclass = instr.InstructionClass; this.m = new RtlEmitter(rtlInstructions); switch (instr.Mnemonic) { default: host.Warn( instr.Address, string.Format("MIPS instruction '{0}' is not supported yet.", instr)); EmitUnitTest(instr); goto case Mnemonic.illegal; case Mnemonic.illegal: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.addi: RewriteBinary(instr, m.IAdd); break; case Mnemonic.addiu: RewriteBinary(instr, m.IAdd); break; case Mnemonic.addu: RewriteBinary(instr, m.IAdd); break; case Mnemonic.b: RewriteB(instr); break; case Mnemonic.beqz: RewriteBeqz(instr); break; case Mnemonic.bnez: RewriteBnez(instr); break; case Mnemonic.cmpi: RewriteCmp(instr); break; case Mnemonic.jal: RewriteJal(instr); break; case Mnemonic.jalx: RewriteJalx(instr); break; case Mnemonic.lb: RewriteLoad(instr, PrimitiveType.SByte); break; case Mnemonic.lbu: RewriteLoad(instr, PrimitiveType.Byte); break; case Mnemonic.lh: RewriteLoad(instr, PrimitiveType.Int16); break; case Mnemonic.lhu: RewriteLoad(instr, PrimitiveType.UInt16); break; case Mnemonic.la: RewriteMove(instr); break; case Mnemonic.li: RewriteMove(instr); break; case Mnemonic.lw: RewriteLoad(instr, PrimitiveType.Word32); break; case Mnemonic.mfhi: RewriteMf(instr, arch.hi); break; case Mnemonic.mflo: RewriteMf(instr, arch.lo); break; case Mnemonic.move: RewriteMove(instr); break; case Mnemonic.neg: RewriteUnary(instr, m.Neg); break; case Mnemonic.save: RewriteSave(instr); break; case Mnemonic.sb: RewriteStore(instr); break; case Mnemonic.sh: RewriteStore(instr); break; case Mnemonic.sll: RewriteBinary(instr, m.Shl); break; case Mnemonic.sllv: RewriteBinary(instr, m.Shl); break; case Mnemonic.slt: RewriteScc(instr, m.Lt); break; case Mnemonic.slti: RewriteScc(instr, m.Lt); break; case Mnemonic.sltiu: RewriteScc(instr, m.Ult); break; case Mnemonic.sra: RewriteBinary(instr, m.Sar); break; case Mnemonic.srav: RewriteBinary(instr, m.Sar); break; case Mnemonic.srl: RewriteBinary(instr, m.Shr); break; case Mnemonic.srlv: RewriteBinary(instr, m.Shr); break; case Mnemonic.subu: RewriteBinary(instr, m.ISub); break; case Mnemonic.sw: RewriteStore(instr); break; case Mnemonic.xor: RewriteBinary(instr, m.Xor); break; } yield return(new RtlInstructionCluster(instr.Address, instr.Length, rtlInstructions.ToArray()) { Class = iclass, }); } }
private void Invalid() { this.iclass = InstrClass.Invalid; m.Invalid(); }
private void Invalid() { m.Invalid(); rtlc = RtlClass.Invalid; }
private void EmitInvalid() { rtlInstructions.Clear(); rtlc = InstrClass.Invalid; m.Invalid(); }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var addr = dasm.Current.Address; var len = dasm.Current.Length; this.iclass = dasm.Current.InstructionClass; var rtlInstructions = new List <RtlInstruction>(); m = new RtlEmitter(rtlInstructions); switch (dasm.Current.Mnemonic) { default: throw new AddressCorrelatedException( dasm.Current.Address, "Z80 instruction '{0}' is not supported yet.", dasm.Current.Mnemonic); case Mnemonic.illegal: m.Invalid(); break; case Mnemonic.adc: RewriteAdc(); break; case Mnemonic.add: RewriteAdd(); break; case Mnemonic.and: RewriteAnd(); break; case Mnemonic.bit: RewriteBit(); break; case Mnemonic.call: RewriteCall(dasm.Current); break; case Mnemonic.ccf: RewriteCcf(); break; case Mnemonic.cp: RewriteCp(); break; case Mnemonic.cpd: RewriteCp(m.ISub, false); break; case Mnemonic.cpdr: RewriteCp(m.ISub, true); break; case Mnemonic.cpi: RewriteCp(m.IAdd, false); break; case Mnemonic.cpir: RewriteCp(m.IAdd, true); break; case Mnemonic.cpl: RewriteCpl(); break; case Mnemonic.di: RewriteDi(); break; case Mnemonic.daa: RewriteDaa(); break; case Mnemonic.dec: RewriteDec(); break; case Mnemonic.djnz: RewriteDjnz(dasm.Current.Operands[0]); break; case Mnemonic.ei: RewriteEi(); break; case Mnemonic.ex: RewriteEx(); break; case Mnemonic.ex_af: RewriteExAf(); break; case Mnemonic.exx: RewriteExx(); break; case Mnemonic.hlt: RewriteHlt(); break; case Mnemonic.@in: RewriteIn(); break; case Mnemonic.ind: RewriteIn(m.ISub, false); break; case Mnemonic.indr: RewriteIn(m.ISub, true); break; case Mnemonic.ini: RewriteIn(m.IAdd, false); break; case Mnemonic.inir: RewriteIn(m.IAdd, true); break; case Mnemonic.im: m.SideEffect(host.PseudoProcedure("__im", VoidType.Instance, RewriteOp(dasm.Current.Operands[0]))); break; case Mnemonic.inc: RewriteInc(); break; case Mnemonic.jp: RewriteJp(dasm.Current); break; case Mnemonic.jr: RewriteJr(); break; case Mnemonic.ld: RewriteLd(); break; case Mnemonic.rl: RewriteRotation(PseudoProcedure.RolC, true); break; case Mnemonic.rla: RewriteRotation(PseudoProcedure.RolC, true); break; case Mnemonic.rlc: RewriteRotation(PseudoProcedure.Rol, false); break; case Mnemonic.rlca: RewriteRotation(PseudoProcedure.Rol, false); break; case Mnemonic.rr: RewriteRotation(PseudoProcedure.RorC, true); break; case Mnemonic.rra: RewriteRotation(PseudoProcedure.RorC, true); break; case Mnemonic.rrc: RewriteRotation(PseudoProcedure.Ror, true); break; case Mnemonic.rrca: RewriteRotation(PseudoProcedure.Ror, true); break; case Mnemonic.ldd: RewriteBlockInstruction(m.ISub, false); break; case Mnemonic.lddr: RewriteBlockInstruction(m.ISub, true); break; case Mnemonic.ldi: RewriteBlockInstruction(m.IAdd, false); break; case Mnemonic.ldir: RewriteBlockInstruction(m.IAdd, true); break; case Mnemonic.neg: RewriteNeg(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.or: RewriteOr(); break; case Mnemonic.@out: RewriteOut(); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.push: RewritePush(dasm.Current); break; case Mnemonic.res: RewriteResSet("__res"); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.rst: RewriteRst(); break; case Mnemonic.sbc: RewriteSbc(); break; case Mnemonic.scf: RewriteScf(); break; case Mnemonic.set: RewriteResSet("__set"); break; case Mnemonic.sla: RewriteShift(dasm.Current, m.Shl); break; case Mnemonic.sra: RewriteShift(dasm.Current, m.Sar); break; case Mnemonic.srl: RewriteShift(dasm.Current, m.Shr); break; case Mnemonic.sub: RewriteSub(); break; case Mnemonic.xor: RewriteXor(); break; //$TODO: Not implemented yet; feel free to implement these! case Mnemonic.otdr: goto default; case Mnemonic.otir: goto default; case Mnemonic.outd: goto default; case Mnemonic.outi: goto default; case Mnemonic.outr: goto default; case Mnemonic.reti: goto default; case Mnemonic.retn: goto default; case Mnemonic.rld: goto default; case Mnemonic.rrd: goto default; case Mnemonic.swap: goto default; } yield return(m.MakeCluster(addr, len, iclass)); } }