public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, Frame frame, PrimitiveType dataWidth) { this.arch = arch; this.m = emitter; this.frame = frame; this.DataWidth = dataWidth; }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.rtlc = new RtlInstructionCluster(dasm.Current.Address, dasm.Current.Length); this.rtlc.Class = RtlClass.Linear; this.m = new RtlEmitter(rtlc.Instructions); switch (instr.opcode) { default: throw new AddressCorrelatedException( instr.Address, "Rewriting of Risc-V instruction '{0}' not implemented yet.", instr.opcode); 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.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.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(rtlc); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var addr = dasm.Current.Address; var len = dasm.Current.Length; this.rtlc = RtlClass.Linear; this.rtlInstructions = new List <RtlInstruction>(); m = new RtlEmitter(rtlInstructions); switch (dasm.Current.Code) { default: throw new AddressCorrelatedException( dasm.Current.Address, "Rewriting of Z80 instruction '{0}' not implemented yet.", dasm.Current.Code); case Opcode.illegal: m.Invalid(); break; case Opcode.adc: RewriteAdc(); break; case Opcode.add: RewriteAdd(); break; case Opcode.and: RewriteAnd(); break; case Opcode.bit: RewriteBit(); break; case Opcode.call: RewriteCall(dasm.Current); break; case Opcode.ccf: RewriteCcf(); break; case Opcode.cp: RewriteCp(); break; case Opcode.cpd: RewriteCp(m.ISub, false); break; case Opcode.cpdr: RewriteCp(m.ISub, true); break; case Opcode.cpi: RewriteCp(m.IAdd, false); break; case Opcode.cpir: RewriteCp(m.IAdd, true); break; case Opcode.cpl: RewriteCpl(); break; case Opcode.di: RewriteDi(); break; case Opcode.daa: RewriteDaa(); break; case Opcode.dec: RewriteDec(); break; case Opcode.djnz: RewriteDjnz(dasm.Current.Op1); break; case Opcode.ei: RewriteEi(); break; case Opcode.ex: RewriteEx(); break; case Opcode.ex_af: RewriteExAf(); break; case Opcode.exx: RewriteExx(); break; case Opcode.hlt: RewriteHlt(); break; case Opcode.@in: RewriteIn(); break; case Opcode.ind: RewriteIn(m.ISub, false); break; case Opcode.indr: RewriteIn(m.ISub, true); break; case Opcode.ini: RewriteIn(m.IAdd, false); break; case Opcode.inir: RewriteIn(m.IAdd, true); break; case Opcode.im: m.SideEffect(host.PseudoProcedure("__im", VoidType.Instance, RewriteOp(dasm.Current.Op1))); break; case Opcode.inc: RewriteInc(); break; case Opcode.jp: RewriteJp(dasm.Current); break; case Opcode.jr: RewriteJr(); break; case Opcode.ld: RewriteLd(); break; case Opcode.rl: RewriteRotation(PseudoProcedure.RolC, true); break; case Opcode.rla: RewriteRotation(PseudoProcedure.Rol, false); break; case Opcode.rlc: RewriteRotation(PseudoProcedure.RolC, false); break; case Opcode.rlca: RewriteRotation(PseudoProcedure.RolC, false); break; case Opcode.rr: RewriteRotation(PseudoProcedure.RorC, true); break; case Opcode.rra: RewriteRotation(PseudoProcedure.Ror, true); break; case Opcode.rrc: RewriteRotation(PseudoProcedure.RorC, true); break; case Opcode.rrca: RewriteRotation(PseudoProcedure.RorC, true); break; case Opcode.ldd: RewriteBlockInstruction(m.ISub, false); break; case Opcode.lddr: RewriteBlockInstruction(m.ISub, true); break; case Opcode.ldi: RewriteBlockInstruction(m.IAdd, false); break; case Opcode.ldir: RewriteBlockInstruction(m.IAdd, true); break; case Opcode.neg: RewriteNeg(); break; case Opcode.nop: m.Nop(); break; case Opcode.or: RewriteOr(); break; case Opcode.@out: RewriteOut(); break; case Opcode.pop: RewritePop(); break; case Opcode.push: RewritePush(dasm.Current); break; case Opcode.res: RewriteResSet("__res"); break; case Opcode.ret: RewriteRet(); break; case Opcode.rst: RewriteRst(); break; case Opcode.sbc: RewriteSbc(); break; case Opcode.scf: RewriteScf(); break; case Opcode.set: RewriteResSet("__set"); break; case Opcode.sla: RewriteShift(dasm.Current, m.Shl); break; case Opcode.sra: RewriteShift(dasm.Current, m.Sar); break; case Opcode.srl: RewriteShift(dasm.Current, m.Shr); break; case Opcode.sub: RewriteSub(); break; case Opcode.xor: RewriteXor(); break; //$TODO: Not implemented yet; feel free to implement these! case Opcode.otdr: goto default; case Opcode.otir: goto default; case Opcode.outd: goto default; case Opcode.outi: goto default; case Opcode.outr: goto default; case Opcode.reti: goto default; case Opcode.retn: goto default; case Opcode.rld: goto default; case Opcode.rrd: goto default; case Opcode.swap: goto default; } yield return(new RtlInstructionCluster(addr, len, rtlInstructions.ToArray()) { Class = rtlc }); } }
public void Rewrite(AvrInstruction instr) { this.instr = instr; this.rtlInstructions = new List <RtlInstruction>(); this.rtlc = instr.InstructionClass; this.m = new RtlEmitter(rtlInstructions); switch (instr.opcode) { case Opcode.adc: RewriteAdcSbc(m.IAdd); break; case Opcode.add: RewriteBinOp(m.IAdd, CmpFlags); break; case Opcode.adiw: RewriteAddSubIW(m.IAdd); break; case Opcode.and: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Opcode.andi: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Opcode.asr: RewriteAsr(); break; case Opcode.brcc: RewriteBranch(ConditionCode.UGE, FlagM.CF); break; case Opcode.brcs: RewriteBranch(ConditionCode.ULT, FlagM.CF); break; case Opcode.breq: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break; case Opcode.brge: RewriteBranch(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Opcode.brid: RewriteBranch(FlagM.IF, false); break; case Opcode.brne: RewriteBranch(ConditionCode.NE, FlagM.ZF); break; case Opcode.brpl: RewriteBranch(ConditionCode.GE, FlagM.NF); break; case Opcode.call: RewriteCall(); break; case Opcode.cli: RewriteCli(); break; case Opcode.com: RewriteUnary(m.Comp, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF, FlagM.CF); break; case Opcode.cp: RewriteCp(); break; case Opcode.cpi: RewriteCp(); break; case Opcode.cpc: RewriteCpc(); break; case Opcode.cpse: SkipIf(m.Eq); break; case Opcode.dec: RewriteIncDec(m.ISub); break; case Opcode.des: RewriteDes(); break; case Opcode.eor: RewriteBinOp(m.Xor, LogicalFlags, FlagM.VF); break; case Opcode.icall: RewriteIcall(); break; case Opcode.@in: RewriteIn(); break; case Opcode.inc: RewriteIncDec(m.IAdd); break; case Opcode.ijmp: RewriteIjmp(); break; case Opcode.jmp: RewriteJmp(); break; case Opcode.ld: RewriteLd(); break; case Opcode.ldd: RewriteLd(); break; case Opcode.ldi: RewriteLdi(); break; case Opcode.lds: RewriteLds(); break; case Opcode.lpm: RewriteLpm(); break; case Opcode.lsr: RewriteLsr(); break; case Opcode.mov: RewriteMov(); break; case Opcode.movw: RewriteMovw(); break; case Opcode.muls: RewriteMuls(); break; case Opcode.neg: RewriteUnary(m.Neg, CmpFlags); break; case Opcode.@out: RewriteOut(); break; case Opcode.or: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Opcode.ori: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break; case Opcode.pop: RewritePop(); break; case Opcode.push: RewritePush(); break; case Opcode.rcall: RewriteCall(); break; case Opcode.ror: RewriteRor(); break; case Opcode.ret: RewriteRet(); break; case Opcode.reti: RewriteRet(); break; //$TODO: more to indicate interrupt return? case Opcode.rjmp: RewriteJmp(); break; case Opcode.sbc: RewriteAdcSbc(m.ISub); break; case Opcode.sbci: RewriteAdcSbc(m.ISub); break; case Opcode.sbis: RewriteSbis(); return; // We've already added ourself to clusters. case Opcode.sbiw: RewriteAddSubIW(m.ISub); break; case Opcode.sbrc: SkipIf(Sbrc); break; case Opcode.sbrs: SkipIf(Sbrs); break; case Opcode.sec: RewriteSetBit(FlagM.CF, true); break; case Opcode.sei: RewriteSei(); break; case Opcode.st: RewriteSt(); break; case Opcode.std: RewriteSt(); break; case Opcode.sts: RewriteSts(); break; case Opcode.sub: RewriteBinOp(m.ISub, CmpFlags); break; case Opcode.subi: RewriteBinOp(m.ISub, CmpFlags); break; case Opcode.swap: RewriteSwap(); break; default: host.Error(instr.Address, string.Format("AVR8 instruction '{0}' is not supported yet.", instr.opcode)); EmitUnitTest(); m.Invalid(); break; } clusters.Add(new RtlInstructionCluster( instr.Address, instr.Length, rtlInstructions.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, IntrinsicProcedure.RolC); break; case Mnemonic.rotxr: RewriteRotationX(instr, IntrinsicProcedure.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; 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 }); } }
/// <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.Mnemonic) { default: EmitUnitTest(); host.Warn( dasm.Current.Address, "x86 instruction '{0}' is not supported yet.", instrCur.Mnemonic); goto case Mnemonic.illegal; case Mnemonic.illegal: rtlc = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.aaa: RewriteAaa(); break; case Mnemonic.aad: RewriteAad(); break; case Mnemonic.aam: RewriteAam(); break; case Mnemonic.aas: RewriteAas(); break; case Mnemonic.adc: RewriteAdcSbb(m.IAdd); break; case Mnemonic.add: RewriteAddSub(Operator.IAdd); break; case Mnemonic.addss: RewriteScalarBinop(m.FAdd, PrimitiveType.Real32); break; case Mnemonic.addsd: case Mnemonic.vaddsd: RewriteScalarBinop(m.FAdd, PrimitiveType.Real64); break; case Mnemonic.addps: RewritePackedBinop("__addps", PrimitiveType.Real32); break; case Mnemonic.addpd: RewritePackedBinop("__addpd", PrimitiveType.Real64); break; case Mnemonic.aesimc: RewriteAesimc(); break; case Mnemonic.and: RewriteLogical(Operator.And); break; case Mnemonic.andnps: RewriteAndnps(); break; case Mnemonic.andpd: RewritePackedBinop("__andpd", PrimitiveType.Real64); break; case Mnemonic.andps: RewritePackedBinop("__andps", PrimitiveType.Real32); break; case Mnemonic.arpl: RewriteArpl(); break; case Mnemonic.bound: RewriteBound(); break; case Mnemonic.bsf: RewriteBsf(); break; case Mnemonic.bsr: RewriteBsr(); break; case Mnemonic.bswap: RewriteBswap(); break; case Mnemonic.bt: RewriteBt(); break; case Mnemonic.btc: RewriteBtc(); break; case Mnemonic.btr: RewriteBtr(); break; case Mnemonic.bts: RewriteBts(); break; case Mnemonic.call: RewriteCall(instrCur.Operands[0], instrCur.Operands[0].Width); break; case Mnemonic.cbw: RewriteCbw(); break; case Mnemonic.clc: RewriteSetFlag(FlagM.CF, Constant.False()); break; case Mnemonic.cld: RewriteSetFlag(FlagM.DF, Constant.False()); break; case Mnemonic.cli: RewriteCli(); break; case Mnemonic.clts: RewriteClts(); break; case Mnemonic.cmc: m.Assign(orw.FlagGroup(FlagM.CF), m.Not(orw.FlagGroup(FlagM.CF))); break; case Mnemonic.cmova: RewriteConditionalMove(ConditionCode.UGT, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovbe: RewriteConditionalMove(ConditionCode.ULE, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovc: RewriteConditionalMove(ConditionCode.ULT, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovge: RewriteConditionalMove(ConditionCode.GE, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovg: RewriteConditionalMove(ConditionCode.GT, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovl: RewriteConditionalMove(ConditionCode.LT, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovle: RewriteConditionalMove(ConditionCode.LE, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovnc: RewriteConditionalMove(ConditionCode.UGE, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovno: RewriteConditionalMove(ConditionCode.NO, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovns: RewriteConditionalMove(ConditionCode.NS, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovnz: RewriteConditionalMove(ConditionCode.NE, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovo: RewriteConditionalMove(ConditionCode.OV, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovpe: RewriteConditionalMove(ConditionCode.PE, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovpo: RewriteConditionalMove(ConditionCode.PO, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovs: RewriteConditionalMove(ConditionCode.SG, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmovz: RewriteConditionalMove(ConditionCode.EQ, instrCur.Operands[0], instrCur.Operands[1]); break; case Mnemonic.cmpxchg: RewriteCmpxchg(); break; case Mnemonic.cmp: RewriteCmp(); break; case Mnemonic.cmps: RewriteStringInstruction(); break; case Mnemonic.cmppd: RewriteCmpp("__cmppd", PrimitiveType.Real64); break; case Mnemonic.cmpps: RewriteCmpp("__cmpps", PrimitiveType.Real32); break; case Mnemonic.cmpsb: RewriteStringInstruction(); break; case Mnemonic.comisd: RewriteComis(PrimitiveType.Real64); break; case Mnemonic.comiss: RewriteComis(PrimitiveType.Real32); break; case Mnemonic.cpuid: RewriteCpuid(); break; case Mnemonic.cvtpi2ps: RewriteCvtPackedToReal(PrimitiveType.Real32); break; case Mnemonic.cvtps2pi: RewriteCvtps2pi("__cvtps2pi", PrimitiveType.Real32, PrimitiveType.Int32); break; case Mnemonic.cvtps2pd: RewriteCvtps2pi("__cvtps2pd", PrimitiveType.Real32, PrimitiveType.Real64); break; case Mnemonic.cvtdq2ps: RewriteCvtps2pi("__cvtdq2ps", PrimitiveType.Int64, PrimitiveType.Real32); break; case Mnemonic.cvtsd2si: RewriteCvts2si(PrimitiveType.Real64); break; case Mnemonic.cvtsd2ss: RewriteCvtToReal(PrimitiveType.Real32); break; case Mnemonic.cvtsi2ss: case Mnemonic.vcvtsi2ss: RewriteCvtToReal(PrimitiveType.Real32); break; case Mnemonic.cvtsi2sd: case Mnemonic.vcvtsi2sd: RewriteCvtToReal(PrimitiveType.Real64); break; case Mnemonic.cvtss2sd: RewriteCvtToReal(PrimitiveType.Real64); break; case Mnemonic.cvtss2si: RewriteCvts2si(PrimitiveType.Real32); break; case Mnemonic.cvttsd2si: RewriteCvtts2si(PrimitiveType.Real64); break; case Mnemonic.cvttss2si: RewriteCvtts2si(PrimitiveType.Real32); break; case Mnemonic.cvttps2pi: RewriteCvttps2pi(); break; case Mnemonic.cwd: RewriteCwd(); break; case Mnemonic.daa: EmitDaaDas("__daa"); break; case Mnemonic.das: EmitDaaDas("__das"); break; case Mnemonic.dec: RewriteIncDec(-1); break; case Mnemonic.div: RewriteDivide(m.UDiv, Domain.UnsignedInt); break; case Mnemonic.divps: RewritePackedBinop("__divps", PrimitiveType.Real32); break; case Mnemonic.divsd: RewriteScalarBinop(m.FDiv, PrimitiveType.Real64); break; case Mnemonic.divss: RewriteScalarBinop(m.FDiv, PrimitiveType.Real32); break; case Mnemonic.f2xm1: RewriteF2xm1(); break; case Mnemonic.emms: RewriteEmms(); break; case Mnemonic.enter: RewriteEnter(); break; case Mnemonic.fabs: RewriteFabs(); break; case Mnemonic.fadd: EmitCommonFpuInstruction(m.FAdd, false, false); break; case Mnemonic.faddp: EmitCommonFpuInstruction(m.FAdd, false, true); break; case Mnemonic.fbld: RewriteFbld(); break; case Mnemonic.fbstp: RewriteFbstp(); break; case Mnemonic.fchs: EmitFchs(); break; case Mnemonic.fclex: RewriteFclex(); break; case Mnemonic.fcmovb: RewriteFcmov(FlagM.CF, ConditionCode.GE); break; case Mnemonic.fcmovbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GT); break; case Mnemonic.fcmove: RewriteFcmov(FlagM.ZF, ConditionCode.NE); break; case Mnemonic.fcmovnb: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GE); break; case Mnemonic.fcmovnbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.LE); break; case Mnemonic.fcmovne: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break; case Mnemonic.fcmovnu: RewriteFcmov(FlagM.PF, ConditionCode.IS_NAN); break; case Mnemonic.fcmovu: RewriteFcmov(FlagM.PF, ConditionCode.NOT_NAN); break; case Mnemonic.fcom: RewriteFcom(0); break; case Mnemonic.fcomi: RewriteFcomi(false); break; case Mnemonic.fcomip: RewriteFcomi(true); break; case Mnemonic.fcomp: RewriteFcom(1); break; case Mnemonic.fcompp: RewriteFcom(2); break; case Mnemonic.fcos: RewriteFUnary("cos"); break; case Mnemonic.fdecstp: RewriteFdecstp(); break; case Mnemonic.fdiv: EmitCommonFpuInstruction(m.FDiv, false, false); break; case Mnemonic.fdivp: EmitCommonFpuInstruction(m.FDiv, false, true); break; case Mnemonic.ffree: RewriteFfree(); break; case Mnemonic.fiadd: EmitCommonFpuInstruction(m.FAdd, false, false, PrimitiveType.Real64); break; case Mnemonic.ficom: RewriteFicom(false); break; case Mnemonic.ficomp: RewriteFicom(true); break; case Mnemonic.fimul: EmitCommonFpuInstruction(m.FMul, false, false, PrimitiveType.Real64); break; case Mnemonic.fisub: EmitCommonFpuInstruction(m.FSub, false, false, PrimitiveType.Real64); break; case Mnemonic.fisubr: EmitCommonFpuInstruction(m.FSub, true, false, PrimitiveType.Real64); break; case Mnemonic.fidiv: EmitCommonFpuInstruction(m.FDiv, false, false, PrimitiveType.Real64); break; case Mnemonic.fidivr: EmitCommonFpuInstruction(m.FDiv, true, false, PrimitiveType.Real64); break; case Mnemonic.fdivr: EmitCommonFpuInstruction(m.FDiv, true, false); break; case Mnemonic.fdivrp: EmitCommonFpuInstruction(m.FDiv, true, true); break; case Mnemonic.fild: RewriteFild(); break; case Mnemonic.fincstp: RewriteFincstp(); break; case Mnemonic.fist: RewriteFist(false); break; case Mnemonic.fistp: RewriteFist(true); break; case Mnemonic.fisttp: RewriteFistt(true); break; case Mnemonic.fld: RewriteFld(); break; case Mnemonic.fld1: RewriteFldConst(1.0); break; case Mnemonic.fldcw: RewriteFldcw(); break; case Mnemonic.fldenv: RewriteFldenv(); break; case Mnemonic.fldl2e: RewriteFldConst(Constant.LgE()); break; case Mnemonic.fldl2t: RewriteFldConst(Constant.Lg10()); break; case Mnemonic.fldlg2: RewriteFldConst(Constant.Log2()); break; case Mnemonic.fldln2: RewriteFldConst(Constant.Ln2()); break; case Mnemonic.fldpi: RewriteFldConst(Constant.Pi()); break; case Mnemonic.fldz: RewriteFldConst(0.0); break; case Mnemonic.fmul: EmitCommonFpuInstruction(m.FMul, false, false); break; case Mnemonic.fmulp: EmitCommonFpuInstruction(m.FMul, false, true); break; case Mnemonic.fninit: RewriteFninit(); break; case Mnemonic.fnop: m.Nop(); break; case Mnemonic.fpatan: RewriteFpatan(); break; case Mnemonic.fprem: RewriteFprem(); break; case Mnemonic.fprem1: RewriteFprem1(); break; case Mnemonic.fptan: RewriteFptan(); break; case Mnemonic.frndint: RewriteFUnary("__rndint"); break; case Mnemonic.frstor: RewriteFrstor(); break; case Mnemonic.fsave: RewriteFsave(); break; case Mnemonic.fscale: RewriteFscale(); break; case Mnemonic.fsin: RewriteFUnary("sin"); break; case Mnemonic.fsincos: RewriteFsincos(); break; case Mnemonic.fsqrt: RewriteFUnary("sqrt"); break; case Mnemonic.fst: RewriteFst(false); break; case Mnemonic.fstenv: RewriteFstenv(); break; case Mnemonic.fstcw: RewriterFstcw(); break; case Mnemonic.fstp: RewriteFst(true); break; case Mnemonic.fstsw: RewriteFstsw(); break; case Mnemonic.fsub: EmitCommonFpuInstruction(m.FSub, false, false); break; case Mnemonic.fsubp: EmitCommonFpuInstruction(m.FSub, false, true); break; case Mnemonic.fsubr: EmitCommonFpuInstruction(m.FSub, true, false); break; case Mnemonic.fsubrp: EmitCommonFpuInstruction(m.FSub, true, true); break; case Mnemonic.ftst: RewriteFtst(); break; case Mnemonic.fucom: RewriteFcom(0); break; case Mnemonic.fucomp: RewriteFcom(1); break; case Mnemonic.fucompp: RewriteFcom(2); break; case Mnemonic.fucomi: RewriteFcomi(false); break; case Mnemonic.fucomip: RewriteFcomi(true); break; case Mnemonic.fxam: RewriteFxam(); break; case Mnemonic.fxch: RewriteExchange(); break; case Mnemonic.fxtract: RewriteFxtract(); break; case Mnemonic.fyl2x: RewriteFyl2x(); break; case Mnemonic.fyl2xp1: RewriteFyl2xp1(); break; case Mnemonic.getsec: RewriteGetsec(); break; case Mnemonic.hlt: RewriteHlt(); break; case Mnemonic.idiv: RewriteDivide(m.SDiv, Domain.SignedInt); break; case Mnemonic.@in: RewriteIn(); break; case Mnemonic.imul: RewriteMultiply(Operator.SMul, Domain.SignedInt); break; case Mnemonic.inc: RewriteIncDec(1); break; case Mnemonic.insb: RewriteStringInstruction(); break; case Mnemonic.ins: RewriteStringInstruction(); break; case Mnemonic.@int: RewriteInt(); break; case Mnemonic.into: RewriteInto(); break; case Mnemonic.invd: RewriteInvd(); break; case Mnemonic.iret: RewriteIret(); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.ja: RewriteConditionalGoto(ConditionCode.UGT, instrCur.Operands[0]); break; case Mnemonic.jbe: RewriteConditionalGoto(ConditionCode.ULE, instrCur.Operands[0]); break; case Mnemonic.jc: RewriteConditionalGoto(ConditionCode.ULT, instrCur.Operands[0]); break; case Mnemonic.jcxz: RewriteJcxz(); break; case Mnemonic.jge: RewriteConditionalGoto(ConditionCode.GE, instrCur.Operands[0]); break; case Mnemonic.jg: RewriteConditionalGoto(ConditionCode.GT, instrCur.Operands[0]); break; case Mnemonic.jl: RewriteConditionalGoto(ConditionCode.LT, instrCur.Operands[0]); break; case Mnemonic.jle: RewriteConditionalGoto(ConditionCode.LE, instrCur.Operands[0]); break; case Mnemonic.jnc: RewriteConditionalGoto(ConditionCode.UGE, instrCur.Operands[0]); break; case Mnemonic.jno: RewriteConditionalGoto(ConditionCode.NO, instrCur.Operands[0]); break; case Mnemonic.jns: RewriteConditionalGoto(ConditionCode.NS, instrCur.Operands[0]); break; case Mnemonic.jnz: RewriteConditionalGoto(ConditionCode.NE, instrCur.Operands[0]); break; case Mnemonic.jo: RewriteConditionalGoto(ConditionCode.OV, instrCur.Operands[0]); break; case Mnemonic.jpe: RewriteConditionalGoto(ConditionCode.PE, instrCur.Operands[0]); break; case Mnemonic.jpo: RewriteConditionalGoto(ConditionCode.PO, instrCur.Operands[0]); break; case Mnemonic.js: RewriteConditionalGoto(ConditionCode.SG, instrCur.Operands[0]); break; case Mnemonic.jz: RewriteConditionalGoto(ConditionCode.EQ, instrCur.Operands[0]); break; case Mnemonic.lahf: RewriteLahf(); break; case Mnemonic.lar: RewriteLar(); break; case Mnemonic.lds: RewriteLxs(Registers.ds); break; case Mnemonic.ldmxcsr: RewriteLdmxcsr(); break; case Mnemonic.stmxcsr: RewriteStmxcsr(); break; case Mnemonic.lea: RewriteLea(); break; case Mnemonic.leave: RewriteLeave(); break; case Mnemonic.les: RewriteLxs(Registers.es); break; case Mnemonic.lfence: RewriteLfence(); break; case Mnemonic.lfs: RewriteLxs(Registers.fs); break; case Mnemonic.lgs: RewriteLxs(Registers.gs); break; case Mnemonic.lgdt: RewriteLxdt("__lgdt"); break; case Mnemonic.lidt: RewriteLxdt("__lidt"); break; case Mnemonic.lldt: RewriteLxdt("__lldt"); break; case Mnemonic.@lock: RewriteLock(); break; case Mnemonic.lods: RewriteStringInstruction(); break; case Mnemonic.lodsb: RewriteStringInstruction(); break; case Mnemonic.loop: RewriteLoop(0, ConditionCode.EQ); break; case Mnemonic.loope: RewriteLoop(FlagM.ZF, ConditionCode.EQ); break; case Mnemonic.loopne: RewriteLoop(FlagM.ZF, ConditionCode.NE); break; case Mnemonic.lsl: RewriteLsl(); break; case Mnemonic.lss: RewriteLxs(Registers.ss); break; case Mnemonic.maskmovq: RewriteMaskmovq(); break; case Mnemonic.maxps: RewritePackedBinop("__maxps", PrimitiveType.Real32); break; case Mnemonic.mfence: RewriteMfence(); break; case Mnemonic.minpd: RewritePackedBinop("__minpd", PrimitiveType.Real64); break; case Mnemonic.minps: RewritePackedBinop("__minps", PrimitiveType.Real32); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.movapd: case Mnemonic.movaps: case Mnemonic.vmovapd: case Mnemonic.vmovaps: RewriteMov(); break; case Mnemonic.vmread: RewriteVmread(); break; case Mnemonic.vmwrite: RewriteVmwrite(); break; case Mnemonic.movd: RewriteMovzx(); break; case Mnemonic.movdqa: RewriteMov(); break; case Mnemonic.movhpd: RewritePackedUnaryop("__movhpd", PrimitiveType.Real64, PrimitiveType.Real64); break; case Mnemonic.movhps: RewritePackedUnaryop("__movhps", PrimitiveType.Real32, PrimitiveType.Real64); break; case Mnemonic.movlpd: RewritePackedUnaryop("__movlpd", PrimitiveType.Real64, PrimitiveType.Real64); break; case Mnemonic.movlps: RewritePackedUnaryop("__movlps", PrimitiveType.Real32, PrimitiveType.Real64); break; case Mnemonic.movlhps: RewriteMovlhps(); break; case Mnemonic.movmskpd: RewriteMovmsk("__movmskpd", PrimitiveType.Real64); break; case Mnemonic.movmskps: RewriteMovmsk("__movmskps", PrimitiveType.Real32); break; case Mnemonic.movnti: RewriteMov(); break; case Mnemonic.movntps: RewriteMov(); break; case Mnemonic.movntq: RewriteMov(); break; case Mnemonic.movq: RewriteMov(); break; case Mnemonic.movs: RewriteStringInstruction(); break; case Mnemonic.movsb: RewriteStringInstruction(); break; case Mnemonic.movsd: case Mnemonic.vmovsd: RewriteMovssd(PrimitiveType.Real64); break; case Mnemonic.movss: case Mnemonic.vmovss: RewriteMovssd(PrimitiveType.Real32); break; case Mnemonic.movsx: RewriteMovsx(); break; case Mnemonic.movups: RewriteMov(); break; case Mnemonic.movupd: RewriteMov(); break; case Mnemonic.movzx: RewriteMovzx(); break; case Mnemonic.mul: RewriteMultiply(Operator.UMul, Domain.UnsignedInt); break; case Mnemonic.mulpd: RewritePackedBinop("__mulpd", PrimitiveType.Real64); break; case Mnemonic.mulps: RewritePackedBinop("__mulps", PrimitiveType.Real32); break; case Mnemonic.mulss: RewriteScalarBinop(m.FMul, PrimitiveType.Real32); break; case Mnemonic.mulsd: RewriteScalarBinop(m.FMul, PrimitiveType.Real64); break; case Mnemonic.neg: RewriteNeg(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.not: RewriteNot(); break; case Mnemonic.or: RewriteLogical(BinaryOperator.Or); break; case Mnemonic.orpd: RewritePackedBinop("__orpd", PrimitiveType.Real64); break; case Mnemonic.orps: RewritePackedBinop("__orps", PrimitiveType.Real32); break; case Mnemonic.@out: RewriteOut(); break; case Mnemonic.@outs: RewriteStringInstruction(); break; case Mnemonic.@outsb: RewriteStringInstruction(); break; case Mnemonic.packssdw: RewritePackedBinop("__packssdw", PrimitiveType.Int32, new ArrayType(PrimitiveType.Int16, 0)); break; case Mnemonic.packuswb: RewritePackedBinop("__packuswb", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt8, 0)); break; case Mnemonic.paddb: RewritePackedBinop("__paddb", PrimitiveType.Byte); break; case Mnemonic.paddd: RewritePackedBinop("__paddd", PrimitiveType.Word32); break; case Mnemonic.paddq: case Mnemonic.vpaddq: RewritePackedBinop("__paddq", PrimitiveType.Word64); break; case Mnemonic.paddsw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break; case Mnemonic.paddsb: RewritePackedBinop("__paddsb", PrimitiveType.SByte); break; case Mnemonic.paddusb: RewritePackedBinop("__paddusb", PrimitiveType.Byte); break; case Mnemonic.paddusw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break; case Mnemonic.paddw: RewritePackedBinop("__paddw", PrimitiveType.Word16); break; case Mnemonic.pand: case Mnemonic.vpand: RewritePackedLogical("__pand"); break; case Mnemonic.pandn: case Mnemonic.vpandn: RewritePackedLogical("__pandn"); break; case Mnemonic.pause: RewritePause(); break; case Mnemonic.palignr: RewritePalignr(); break; case Mnemonic.pavgb: RewritePavg("__pavgb", PrimitiveType.Byte); break; case Mnemonic.pavgw: RewritePavg("__pavgw", PrimitiveType.Byte); break; case Mnemonic.pcmpeqb: RewritePcmp("__pcmpeqb", PrimitiveType.Byte); break; case Mnemonic.pcmpeqd: RewritePcmp("__pcmpeqd", PrimitiveType.Word32); break; case Mnemonic.pcmpeqw: RewritePcmp("__pcmpeqw", PrimitiveType.Word16); break; case Mnemonic.pcmpgtb: RewritePcmp("__pcmpgtb", PrimitiveType.Byte); break; case Mnemonic.pcmpgtd: RewritePcmp("__pcmpgtd", PrimitiveType.Word32); break; case Mnemonic.pcmpgtw: RewritePcmp("__pcmpgtw", PrimitiveType.Word16); break; case Mnemonic.pextrw: case Mnemonic.vextrw: RewritePextrw(); break; case Mnemonic.pinsrw: case Mnemonic.vpinsrw: RewritePinsrw(); break; case Mnemonic.pmaddwd: RewritePackedBinop("__pmaddwd", PrimitiveType.Word16, new ArrayType(PrimitiveType.Word32, 0)); break; case Mnemonic.pmaxsw: RewritePackedBinop("__pmaxsw", PrimitiveType.Int16); break; case Mnemonic.pmaxub: RewritePackedBinop("__pmaxub", PrimitiveType.UInt8); break; case Mnemonic.pminsw: RewritePackedBinop("__pminsw", PrimitiveType.Int16); break; case Mnemonic.pminub: RewritePackedBinop("__pminub", PrimitiveType.UInt8); break; case Mnemonic.pmovmskb: RewriteMovmsk("__pmovmskb", PrimitiveType.Byte); break; case Mnemonic.pmulhuw: RewritePackedBinop("__pmulhuw", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt16, 8)); break; case Mnemonic.pmulhw: RewritePackedBinop("__pmulhw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break; case Mnemonic.pmullw: case Mnemonic.vpmullw: RewritePackedBinop("__pmullw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break; case Mnemonic.pmuludq: RewritePackedBinop("__pmuludq", PrimitiveType.UInt32, new ArrayType(PrimitiveType.UInt64, 0)); break; case Mnemonic.prefetchw: RewritePrefetch("__prefetchw"); break; case Mnemonic.psadbw: RewritePackedBinop("__psadbw", PrimitiveType.Byte, PrimitiveType.Word16); break; case Mnemonic.pslld: RewritePackedBinop("__pslld", PrimitiveType.Word32); break; case Mnemonic.psllq: case Mnemonic.vpsllq: RewritePackedBinop("__psllq", PrimitiveType.Word64); break; case Mnemonic.psllw: RewritePackedBinop("__psllw", PrimitiveType.Word16); break; case Mnemonic.psrad: RewritePackedBinop("__psrad", PrimitiveType.Int32); break; case Mnemonic.psraw: RewritePackedBinop("__psraw", PrimitiveType.Int16); break; case Mnemonic.psrlq: RewritePackedBinop("__psrlq", PrimitiveType.Word64); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.popa: RewritePopa(); break; case Mnemonic.popf: RewritePopf(); break; case Mnemonic.por: RewritePackedLogical("__por"); break; case Mnemonic.prefetchnta: RewritePrefetch("__prefetchnta"); break; case Mnemonic.prefetcht0: RewritePrefetch("__prefetcht0"); break; case Mnemonic.prefetcht1: RewritePrefetch("__prefetcht1"); break; case Mnemonic.prefetcht2: RewritePrefetch("__prefetcht2"); break; case Mnemonic.pshufd: RewritePshuf("__pshufd", PrimitiveType.Word32); break; case Mnemonic.pshufw: RewritePshuf("__pshufw", PrimitiveType.Word16); break; case Mnemonic.psrld: RewritePackedShift("__psrld", PrimitiveType.Word32); break; case Mnemonic.psrlw: RewritePackedShift("__psrlw", PrimitiveType.Word16); break; case Mnemonic.psubb: RewritePackedBinop("__psubb", PrimitiveType.Byte); break; case Mnemonic.psubd: case Mnemonic.vpsubd: RewritePackedBinop("__psubd", PrimitiveType.Word32); break; case Mnemonic.psubq: RewritePackedBinop("__psubq", PrimitiveType.Word64); break; case Mnemonic.psubsb: RewritePackedBinop("__psubsb", PrimitiveType.SByte); break; case Mnemonic.psubsw: RewritePackedBinop("__psubsw", PrimitiveType.Word16); break; case Mnemonic.psubusb: RewritePackedBinop("__psubusb", PrimitiveType.UInt8); break; case Mnemonic.psubusw: RewritePackedBinop("__psubusw", PrimitiveType.UInt16); break; case Mnemonic.psubw: RewritePackedBinop("__psubw", PrimitiveType.Word16); break; case Mnemonic.punpckhbw: RewritePunpckhbw(); break; case Mnemonic.punpckhdq: RewritePunpckhdq(); break; case Mnemonic.punpckhwd: RewritePunpckhwd(); break; case Mnemonic.punpcklbw: RewritePunpcklbw(); break; case Mnemonic.punpckldq: RewritePunpckldq(); break; case Mnemonic.punpcklwd: RewritePunpcklwd(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.pusha: RewritePusha(); break; case Mnemonic.pushf: RewritePushf(); break; case Mnemonic.pxor: case Mnemonic.vpxor: RewritePxor(); break; case Mnemonic.rcl: RewriteRotation(PseudoProcedure.RolC, true, true); break; case Mnemonic.rcpps: RewritePackedUnaryop("__rcpps", PrimitiveType.Real32); break; case Mnemonic.rcr: RewriteRotation(PseudoProcedure.RorC, true, false); break; case Mnemonic.rol: RewriteRotation(PseudoProcedure.Rol, false, true); break; case Mnemonic.ror: RewriteRotation(PseudoProcedure.Ror, false, false); break; case Mnemonic.rdmsr: RewriteRdmsr(); break; case Mnemonic.rdpmc: RewriteRdpmc(); break; case Mnemonic.rdtsc: RewriteRdtsc(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.retf: RewriteRet(); break; case Mnemonic.rsqrtps: RewritePackedUnaryop("__rsqrtps", PrimitiveType.Real32); break; case Mnemonic.sahf: m.Assign(orw.FlagGroup(X86Instruction.DefCc(instrCur.Mnemonic)), orw.AluRegister(Registers.ah)); break; case Mnemonic.sar: RewriteBinOp(Operator.Sar); break; case Mnemonic.sbb: RewriteAdcSbb(m.ISub); break; case Mnemonic.scas: RewriteStringInstruction(); break; case Mnemonic.scasb: RewriteStringInstruction(); break; case Mnemonic.seta: RewriteSet(ConditionCode.UGT); break; case Mnemonic.setc: RewriteSet(ConditionCode.ULT); break; case Mnemonic.setbe: RewriteSet(ConditionCode.ULE); break; case Mnemonic.setg: RewriteSet(ConditionCode.GT); break; case Mnemonic.setge: RewriteSet(ConditionCode.GE); break; case Mnemonic.setl: RewriteSet(ConditionCode.LT); break; case Mnemonic.setle: RewriteSet(ConditionCode.LE); break; case Mnemonic.setnc: RewriteSet(ConditionCode.UGE); break; case Mnemonic.setno: RewriteSet(ConditionCode.NO); break; case Mnemonic.setns: RewriteSet(ConditionCode.NS); break; case Mnemonic.setnz: RewriteSet(ConditionCode.NE); break; case Mnemonic.setpe: RewriteSet(ConditionCode.PE); break; case Mnemonic.setpo: RewriteSet(ConditionCode.PO); break; case Mnemonic.seto: RewriteSet(ConditionCode.OV); break; case Mnemonic.sets: RewriteSet(ConditionCode.SG); break; case Mnemonic.setz: RewriteSet(ConditionCode.EQ); break; case Mnemonic.sfence: RewriteSfence(); break; case Mnemonic.sgdt: RewriteSxdt("__sgdt"); break; case Mnemonic.sha1msg2: RewriteSha1msg2(); break; case Mnemonic.shl: RewriteBinOp(BinaryOperator.Shl); break; case Mnemonic.shld: RewriteShxd("__shld"); break; case Mnemonic.shr: RewriteBinOp(BinaryOperator.Shr); break; case Mnemonic.shrd: RewriteShxd("__shrd"); break; case Mnemonic.sidt: RewriteSxdt("__sidt"); break; case Mnemonic.vshufps: RewritePackedTernaryop("__vshufps", PrimitiveType.Real32); break; case Mnemonic.sldt: RewriteSxdt("__sldt"); break; case Mnemonic.sqrtps: RewritePackedUnaryop("__sqrtps", PrimitiveType.Real32); break; case Mnemonic.sqrtsd: RewriteSqrtsd(); break; case Mnemonic.stc: RewriteSetFlag(FlagM.CF, Constant.True()); break; case Mnemonic.std: RewriteSetFlag(FlagM.DF, Constant.True()); break; case Mnemonic.sti: RewriteSti(); break; case Mnemonic.stos: RewriteStringInstruction(); break; case Mnemonic.stosb: RewriteStringInstruction(); break; case Mnemonic.sub: RewriteAddSub(BinaryOperator.ISub); break; case Mnemonic.subsd: RewriteScalarBinop(m.FSub, PrimitiveType.Real64); break; case Mnemonic.subss: RewriteScalarBinop(m.FSub, PrimitiveType.Real32); break; case Mnemonic.subpd: RewritePackedBinop("__subpd", PrimitiveType.Real64); break; case Mnemonic.subps: RewritePackedBinop("__subps", PrimitiveType.Real32); break; case Mnemonic.syscall: RewriteSyscall(); break; case Mnemonic.sysenter: RewriteSysenter(); break; case Mnemonic.sysexit: RewriteSysexit(); break; case Mnemonic.sysret: RewriteSysret(); break; case Mnemonic.ucomiss: RewriteComis(PrimitiveType.Real32); break; case Mnemonic.ucomisd: RewriteComis(PrimitiveType.Real64); break; case Mnemonic.ud0: rtlc = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.ud1: rtlc = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.ud2: rtlc = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.unpcklpd: RewritePackedBinop("__unpcklpd", PrimitiveType.Real64); break; case Mnemonic.unpcklps: RewritePackedBinop("__unpcklps", PrimitiveType.Real32); break; case Mnemonic.test: RewriteTest(); break; case Mnemonic.wait: RewriteWait(); break; case Mnemonic.wbinvd: RewriteWbinvd(); break; case Mnemonic.wrmsr: RewriteWrsmr(); break; case Mnemonic.xadd: RewriteXadd(); break; case Mnemonic.xchg: RewriteExchange(); break; case Mnemonic.xgetbv: RewriteXgetbv(); break; case Mnemonic.xsetbv: RewriteXsetbv(); break; case Mnemonic.xlat: RewriteXlat(); break; case Mnemonic.xor: RewriteLogical(BinaryOperator.Xor); break; case Mnemonic.xorpd: case Mnemonic.vxorpd: RewritePackedBinop("__xorpd", PrimitiveType.Word64); break; case Mnemonic.xorps: RewritePackedBinop("__xorps", PrimitiveType.Word32); break; case Mnemonic.BOR_exp: RewriteFUnary("exp"); break; case Mnemonic.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 rtls = new List <RtlInstruction>(); this.m = new RtlEmitter(rtls); switch (instrCur.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.Invalid; case Mnemonic.Invalid: m.Invalid(); iclass = InstrClass.Invalid; break; case Mnemonic.l_add: RewriteAluCV(m.IAdd); break; case Mnemonic.l_addc: RewriteAddc(); break; case Mnemonic.l_addi: RewriteAddi(); break; case Mnemonic.l_addic: RewriteAddic(); break; case Mnemonic.l_adrp: RewriteAdrp(); break; case Mnemonic.l_and: RewriteBinOp(m.And); break; case Mnemonic.l_andi: RewriteBinOpImm(m.And); break; case Mnemonic.l_bf: RewriteBranch(false); break; case Mnemonic.l_bnf: RewriteBranch(true); break; case Mnemonic.l_cmov: RewriteCmov(); break; case Mnemonic.l_csync: RewriteCsync(); break; case Mnemonic.l_j: RewriteJ(); break; case Mnemonic.l_jal: RewriteJal(); break; case Mnemonic.l_jalr: RewriteJalr(); break; case Mnemonic.l_jr: RewriteJr(); break; case Mnemonic.l_lbs: RewriteLoad(arch.SignedWordWidth); break; case Mnemonic.l_lbz: RewriteLoad(arch.WordWidth); break; case Mnemonic.l_lf: RewriteLoad(arch.WordWidth); break; case Mnemonic.l_lhs: RewriteLoad(arch.SignedWordWidth); break; case Mnemonic.l_lhz: RewriteLoad(arch.WordWidth); break; case Mnemonic.l_lwa: RewriteLwa(); break; case Mnemonic.l_lws: RewriteLoad(arch.SignedWordWidth); break; case Mnemonic.l_lwz: RewriteLoad(arch.WordWidth); break; case Mnemonic.l_ld: RewriteLoad(arch.WordWidth); break; case Mnemonic.l_maci: RewriteMaci(); break; case Mnemonic.l_macrc: RewriteMacrc(); break; case Mnemonic.l_movhi: RewriteMovhi(); break; case Mnemonic.l_mfspr: RewriteMfspr(); break; case Mnemonic.l_mtspr: RewriteMtspr(); break; case Mnemonic.l_mul: RewriteAluV(m.SMul); break; case Mnemonic.l_nop: m.Nop(); break; case Mnemonic.l_or: RewriteBinOp(m.Or); break; case Mnemonic.l_ori: RewriteBinOpImm(m.Or); break; case Mnemonic.l_psync: RewritePsync(); break; case Mnemonic.l_rfe: RewriteRfe(); break; case Mnemonic.l_sb: RewriteStore(); break; case Mnemonic.l_sh: RewriteStore(); break; case Mnemonic.l_sw: RewriteStore(); break; case Mnemonic.l_sfeq: RewriteSf(m.Eq); break; case Mnemonic.l_sfeqi: RewriteSfi(m.Eq); break; case Mnemonic.l_sfges: RewriteSf(m.Ge); break; case Mnemonic.l_sfgesi: RewriteSfi(m.Ge); break; case Mnemonic.l_sfgeu: RewriteSf(m.Uge); break; case Mnemonic.l_sfgtsi: RewriteSfi(m.Gt); break; case Mnemonic.l_sfgtu: RewriteSf(m.Ugt); break; case Mnemonic.l_sfgtui: RewriteSfi(m.Ugt); break; case Mnemonic.l_sfles: RewriteSf(m.Le); break; case Mnemonic.l_sflesi: RewriteSfi(m.Le); break; case Mnemonic.l_sfleu: RewriteSf(m.Ule); break; case Mnemonic.l_sfleui: RewriteSfi(m.Ule); break; case Mnemonic.l_sflts: RewriteSf(m.Lt); break; case Mnemonic.l_sfltsi: RewriteSfi(m.Lt); break; case Mnemonic.l_sfltu: RewriteSf(m.Ult); break; case Mnemonic.l_sfltui: RewriteSfi(m.Ult); break; case Mnemonic.l_sfne: RewriteSf(m.Ne); break; case Mnemonic.l_sfnei: RewriteSfi(m.Ne); break; case Mnemonic.l_sll: RewriteBinOp(m.Shl); break; case Mnemonic.l_slli: RewriteBinOpImm(m.Shl); break; case Mnemonic.l_sra: RewriteBinOp(m.Sar); break; case Mnemonic.l_srai: RewriteBinOpImm(m.Sar); break; case Mnemonic.l_srl: RewriteBinOp(m.Shr); break; case Mnemonic.l_srli: RewriteBinOpImm(m.Shr); break; case Mnemonic.l_sub: RewriteAluCV(m.ISub); break; case Mnemonic.l_sys: RewriteSys(); break; case Mnemonic.l_xor: RewriteBinOp(m.Xor); break; case Mnemonic.l_xori: RewriteBinOpImm(m.Xor); break; } yield return(new RtlInstructionCluster(instrCur.Address, instrCur.Length, rtls.ToArray()) { Class = this.iclass }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { iclass = InstrClass.Linear; var instrs = new List <RtlInstruction>(); m = new RtlEmitter(instrs); this.instr = dasm.Current; switch (instr.Mnemonic) { default: host.Warn( instr.Address, string.Format( "TLCS-900 instruction '{0}' not supported yet.", instr.Mnemonic)); EmitUnitTest(); Invalid(); break; case Mnemonic.invalid: Invalid(); break; case Mnemonic.adc: RewriteAdcSbc(m.IAdd, "****0*"); break; case Mnemonic.add: RewriteBinOp(m.IAdd, "***V0*"); break; case Mnemonic.and: RewriteBinOp(m.And, "**1*00"); break; case Mnemonic.bit: RewriteBit(); break; case Mnemonic.bs1b: RewriteBs1b(); break; case Mnemonic.call: RewriteCall(); break; case Mnemonic.calr: RewriteCall(); break; case Mnemonic.ccf: RewriteCcf(); break; case Mnemonic.chg: RewriteChg(); break; case Mnemonic.cp: RewriteCp("SZHV1C"); break; case Mnemonic.daa: RewriteDaa("****-*"); break; case Mnemonic.dec: RewriteIncDec(m.ISub, "****1-"); break; case Mnemonic.decf: RewriteDecf(); break; case Mnemonic.div: RewriteDiv(m.UDiv, "---V--"); break; case Mnemonic.divs: RewriteDiv(m.SDiv, "---V--"); break; case Mnemonic.djnz: RewriteDjnz(); break; case Mnemonic.ei: RewriteEi(); break; case Mnemonic.ex: RewriteEx(); break; case Mnemonic.halt: RewriteHalt(); break; case Mnemonic.inc: RewriteIncDec(m.IAdd, "****0-"); break; case Mnemonic.incf: RewriteIncf(); break; case Mnemonic.lda: RewriteLda(); break; case Mnemonic.jp: RewriteJp(); break; case Mnemonic.jr: RewriteJp(); break; case Mnemonic.ld: RewriteLd(); break; case Mnemonic.ldf: RewriteLdf(); break; case Mnemonic.ldir: RewriteLdir(PrimitiveType.Byte, "--000-"); break; case Mnemonic.ldirw: RewriteLdir(PrimitiveType.Word16, "--000-"); break; case Mnemonic.mul: RewriteMul(m.UMul); break; case Mnemonic.muls: RewriteMul(m.SMul); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.or: RewriteBinOp(m.Or, "**0*00"); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.rcf: RewriteRcf(); break; case Mnemonic.res: RewriteRes(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.retd: RewriteRetd(); break; case Mnemonic.reti: RewriteReti(); break; case Mnemonic.sbc: RewriteAdcSbc(m.ISub, "****1*"); break; case Mnemonic.scc: RewriteScc(); break; case Mnemonic.scf: RewriteScf(); break; case Mnemonic.set: RewriteSet(); break; case Mnemonic.sla: RewriteShift(m.Shl, "**0*0*"); break; case Mnemonic.sll: RewriteShift(m.Shl, "**0*0*"); break; case Mnemonic.srl: RewriteShift(m.Shr, "**0*0*"); break; case Mnemonic.sub: RewriteBinOp(m.ISub, "***V1*"); break; case Mnemonic.swi: RewriteSwi(); break; case Mnemonic.xor: RewriteBinOp(m.Xor, "**0*00"); break; case Mnemonic.zcf: RewriteZcf(); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var rtlc = new RtlInstructionCluster(dasm.Current.Address, dasm.Current.Length); emitter = new RtlEmitter(rtlc.Instructions); switch (dasm.Current.Code) { default: throw new AddressCorrelatedException( dasm.Current.Address, "Rewriting of Z80 instruction {0} not implemented yet.", dasm.Current.Code); case Opcode.adc: RewriteAdc(); break; case Opcode.add: RewriteAdd(); break; case Opcode.call: RewriteCall(dasm.Current); break; case Opcode.cp: RewriteCp(); break; case Opcode.cpl: RewriteCpl(); break; case Opcode.dec: RewriteDec(); break; case Opcode.djnz: RewriteDjnz(dasm.Current.Op1); break; case Opcode.inc: RewriteInc(); break; case Opcode.jp: RewriteJp(dasm.Current); break; case Opcode.jr: RewriteJr(); break; case Opcode.ld: emitter.Assign( RewriteOp(dasm.Current.Op1), RewriteOp(dasm.Current.Op2)); break; case Opcode.rla: RewriteRotation(PseudoProcedure.Rol, false); break; case Opcode.rlc: RewriteRotation(PseudoProcedure.RolC, false); break; case Opcode.rra: RewriteRotation(PseudoProcedure.Ror, true); break; case Opcode.rrc: RewriteRotation(PseudoProcedure.RorC, true); break; case Opcode.ldir: RewriteBlockInstruction(); break; case Opcode.neg: RewriteNeg(); break; case Opcode.or: RewriteOr(); break; case Opcode.pop: RewritePop(); break; case Opcode.push: RewritePush(dasm.Current); break; case Opcode.ret: RewriteRet(); break; case Opcode.sbc: RewriteSbc(); break; case Opcode.sub: RewriteSub(); break; } yield return(rtlc); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.rtlInstructions = new List <RtlInstruction>(); this.iclass = instr.InstructionClass; m = new RtlEmitter(this.rtlInstructions); switch (instr.Mnemonic) { default: host.Warn( instr.Address, "PDP-11 instruction {0} is not supported yet.", instr.Mnemonic); iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.illegal: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.adc: RewriteAdcSbc(m.IAdd); break; case Mnemonic.add: RewriteAdd(); break; case Mnemonic.addb: RewriteAdd(); break; case Mnemonic.ash: RewriteShift(); break; case Mnemonic.ashc: RewriteAshc(); break; case Mnemonic.asl: RewriteAsl(); break; case Mnemonic.aslb: RewriteAsl(); break; case Mnemonic.asr: RewriteAsr(); break; case Mnemonic.asrb: RewriteAsr(); break; case Mnemonic.bcc: RewriteBxx(ConditionCode.UGE, FlagM.CF); break; case Mnemonic.bcs: RewriteBxx(ConditionCode.ULT, FlagM.CF); break; case Mnemonic.beq: RewriteBxx(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.bge: RewriteBxx(ConditionCode.GE, FlagM.VF | FlagM.NF); break; case Mnemonic.bgt: RewriteBxx(ConditionCode.GT, FlagM.ZF | FlagM.NF | FlagM.VF); break; case Mnemonic.bhi: RewriteBxx(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break; case Mnemonic.bvs: RewriteBxx(ConditionCode.OV, FlagM.VF); break; case Mnemonic.bic: RewriteBic(); break; case Mnemonic.bicb: RewriteBic(); break; case Mnemonic.bis: RewriteBis(); break; case Mnemonic.bisb: RewriteBis(); break; case Mnemonic.bit: RewriteBit(); break; case Mnemonic.bitb: RewriteBit(); break; case Mnemonic.ble: RewriteBxx(ConditionCode.LE, FlagM.ZF | FlagM.NF | FlagM.VF); break; case Mnemonic.blos: RewriteBxx(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break; case Mnemonic.blt: RewriteBxx(ConditionCode.LT, FlagM.NF | FlagM.VF); break; case Mnemonic.bmi: RewriteBxx(ConditionCode.LT, FlagM.NF); break; case Mnemonic.bne: RewriteBxx(ConditionCode.NE, FlagM.ZF); break; case Mnemonic.bpl: RewriteBxx(ConditionCode.GT, FlagM.NF); break; case Mnemonic.bpt: RewriteBpt(); break; case Mnemonic.br: RewriteBr(); break; case Mnemonic.clr: RewriteClr(instr, m.Word16(0)); break; case Mnemonic.clrb: RewriteClr(instr, m.Byte(0)); break; case Mnemonic.clrflags: RewriteClrSetFlags(Constant.False); break; case Mnemonic.cmp: RewriteCmp(); break; case Mnemonic.cmpb: RewriteCmp(); break; case Mnemonic.com: RewriteCom(); break; case Mnemonic.comb: RewriteCom(); break; case Mnemonic.dec: RewriteIncDec(m.ISub); break; case Mnemonic.decb: RewriteIncDec(m.ISub); break; case Mnemonic.div: RewriteDiv(); break; case Mnemonic.emt: RewriteEmt(); break; case Mnemonic.halt: RewriteHalt(); break; case Mnemonic.iot: RewriteIot(); break; case Mnemonic.inc: RewriteIncDec(m.IAdd); break; case Mnemonic.incb: RewriteIncDec(m.IAdd); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.jsr: RewriteJsr(); break; case Mnemonic.mark: RewriteMark(); break; case Mnemonic.mfpd: RewriteMfpd(); break; case Mnemonic.mfpi: RewriteMfpi(); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.movb: RewriteMov(); break; case Mnemonic.mtpi: RewriteMtpi(); break; case Mnemonic.mul: RewriteMul(); break; case Mnemonic.neg: RewriteNeg(); break; case Mnemonic.negb: RewriteNeg(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.reset: RewriteReset(); break; case Mnemonic.rol: RewriteRotate(PseudoProcedure.Rol); break; case Mnemonic.rolb: RewriteRotate(PseudoProcedure.Rol); break; case Mnemonic.ror: RewriteRotate(PseudoProcedure.Ror); break; case Mnemonic.rorb: RewriteRotate(PseudoProcedure.Ror); break; case Mnemonic.rti: RewriteRti(); break; case Mnemonic.rts: RewriteRts(); break; case Mnemonic.rtt: RewriteRtt(); break; case Mnemonic.sbc: RewriteAdcSbc(m.ISub); break; case Mnemonic.sbcb: RewriteAdcSbc(m.ISub); break; case Mnemonic.setflags: RewriteClrSetFlags(Constant.True); break; case Mnemonic.stcdi: RewriteStcdi(); break; case Mnemonic.sob: RewriteSob(); break; case Mnemonic.stexp: RewriteStexp(); break; case Mnemonic.sub: RewriteSub(); break; case Mnemonic.swab: RewriteSwab(); break; case Mnemonic.sxt: RewriteSxt(); break; case Mnemonic.trap: RewriteTrap(); break; case Mnemonic.tst: RewriteTst(); break; case Mnemonic.tstb: RewriteTst(); break; case Mnemonic.wait: RewriteWait(); break; case Mnemonic.xor: RewriteXor(); break; } yield return(m.MakeCluster(instr.Address, instr.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.Code) { default: EmitUnitTest(); rtlc = InstrClass.Invalid; m.Invalid(); break; case Opcode.illegal: m.Invalid(); break; case Opcode.adc: Adc(); break; case Opcode.and: And(); break; case Opcode.asl: Asl(); break; case Opcode.bcc: Branch(ConditionCode.UGE, FlagM.CF); break; case Opcode.bcs: Branch(ConditionCode.ULT, FlagM.CF); break; case Opcode.beq: Branch(ConditionCode.EQ, FlagM.ZF); break; case Opcode.bit: Bit(); break; case Opcode.bmi: Branch(ConditionCode.SG, FlagM.NF); break; case Opcode.bne: Branch(ConditionCode.NE, FlagM.ZF); break; case Opcode.bpl: Branch(ConditionCode.NS, FlagM.NF); break; case Opcode.brk: Brk(); break; case Opcode.bvc: Branch(ConditionCode.NO, FlagM.VF); break; case Opcode.bvs: Branch(ConditionCode.OV, FlagM.VF); break; case Opcode.clc: SetFlag(FlagM.CF, false); break; case Opcode.cld: SetFlag(FlagM.DF, false); break; case Opcode.cli: SetFlag(FlagM.IF, false); break; case Opcode.clv: SetFlag(FlagM.VF, false); break; case Opcode.cmp: Cmp(Registers.a); break; case Opcode.cpx: Cmp(Registers.x); break; case Opcode.cpy: Cmp(Registers.y); break; case Opcode.dec: Dec(); break; case Opcode.dex: Dec(Registers.x); break; case Opcode.dey: Dec(Registers.y); break; case Opcode.eor: Eor(); break; case Opcode.inc: Inc(); break; case Opcode.inx: Inc(Registers.x); break; case Opcode.iny: Inc(Registers.y); break; case Opcode.jmp: Jmp(); break; case Opcode.jsr: Jsr(); break; case Opcode.lda: Ld(Registers.a); break; case Opcode.ldx: Ld(Registers.x); break; case Opcode.ldy: Ld(Registers.y); break; case Opcode.lsr: Lsr(); break; case Opcode.nop: m.Nop(); break; case Opcode.ora: Ora(); break; case Opcode.pha: Push(Registers.a); break; case Opcode.php: Push(AllFlags()); break; case Opcode.pla: Pull(Registers.a); break; case Opcode.plp: Plp(); break; case Opcode.rol: Rotate(PseudoProcedure.Rol); break; case Opcode.ror: Rotate(PseudoProcedure.Ror); break; case Opcode.rti: Rti(); break; case Opcode.rts: Rts(); break; case Opcode.sbc: Sbc(); break; case Opcode.sec: SetFlag(FlagM.CF, true); break; case Opcode.sed: SetFlag(FlagM.DF, true); break; case Opcode.sei: SetFlag(FlagM.IF, true); break; case Opcode.sta: St(Registers.a); break; case Opcode.stx: St(Registers.x); break; case Opcode.sty: St(Registers.y); break; case Opcode.tax: Copy(Registers.x, Registers.a); break; case Opcode.tay: Copy(Registers.y, Registers.a); break; case Opcode.tsx: Copy(Registers.x, Registers.s); break; case Opcode.txa: Copy(Registers.a, Registers.x); break; case Opcode.txs: Copy(Registers.s, Registers.x); break; case Opcode.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()) { this.instr = dasm.Current; var rtls = new List<RtlInstruction>(); this.m = new RtlEmitter(rtls); this.iclass = InstrClass.Linear; switch (instr.Mnemonic) { default: host.Warn( instr.Address, string.Format( "i8051 instruction '{0}' not supported yet.", instr.Mnemonic)); goto case Mnemonic.Invalid; case Mnemonic.Invalid: case Mnemonic.reserved: Invalid(); break; case Mnemonic.acall: RewriteCall(); break; case Mnemonic.add: RewriteBinop(m.IAdd, FlagM.C | FlagM.AC | FlagM.OV | FlagM.P); break; case Mnemonic.addc: RewriteAddcSubb(m.IAdd); break; case Mnemonic.ajmp: RewriteJump(); break; case Mnemonic.anl: RewriteLogical(m.And); break; case Mnemonic.cjne: RewriteCjne(); break; case Mnemonic.clr: RewriteClr(); break; case Mnemonic.dec: RewriteIncDec(m.ISub); break; case Mnemonic.djnz: RewriteDjnz(); break; case Mnemonic.inc: RewriteIncDec(m.IAdd); break; case Mnemonic.jb: RewriteJb(m.Ne0); break; case Mnemonic.jbc: RewriteJbc(); break; case Mnemonic.jc: RewriteJc(e => e); break; case Mnemonic.jmp: RewriteJump(); break; case Mnemonic.jnb: RewriteJb(m.Eq0); break; case Mnemonic.jnc: RewriteJc(m.Not); break; case Mnemonic.jnz: RewriteJz(m.Ne0); break; case Mnemonic.jz: RewriteJz(m.Eq0); break; case Mnemonic.lcall: RewriteCall(); break; case Mnemonic.ljmp: RewriteJump(); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.movc: RewriteMovc(); break; case Mnemonic.movx: RewriteMovx(); break; case Mnemonic.mul: RewriteMul(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.orl: RewriteLogical(m.Or); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.reti: RewriteRet(); break; case Mnemonic.rl: RewriteRotate(PseudoProcedure.Rol); break; case Mnemonic.rr: RewriteRotate(PseudoProcedure.Ror); break; case Mnemonic.setb: RewriteSetb(); break; case Mnemonic.sjmp: RewriteJump(); break; case Mnemonic.subb: RewriteAddcSubb(m.ISub); break; case Mnemonic.swap: RewriteSwap(); break; case Mnemonic.xrl: RewriteLogical(m.Xor); break; case Mnemonic.xch: RewriteXch(); break; case Mnemonic.cpl: case Mnemonic.da: case Mnemonic.div: case Mnemonic.rrc: case Mnemonic.rlc: case Mnemonic.xchd: EmitUnitTest(); Invalid(); break; } yield return m.MakeCluster(instr.Address, instr.Length, iclass); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var instr = dasm.Current; this.cluster = new RtlInstructionCluster(instr.Address, 4); cluster.Class = RtlClass.Linear; this.emitter = new RtlEmitter(cluster.Instructions); switch (instr.opcode) { default: throw new AddressCorrelatedException( instr.Address, "Rewriting of MIPS instruction {0} not implemented yet.", instr.opcode); case Opcode.add: case Opcode.addi: case Opcode.addiu: case Opcode.addu: RewriteAdd(instr, PrimitiveType.Word32); break; case Opcode.and: case Opcode.andi: RewriteAnd(instr); break; case Opcode.beq: RewriteBranch(instr, Operator.Eq, false); break; case Opcode.beql: RewriteBranch(instr, Operator.Eq, true); break; case Opcode.bgez: RewriteBranch0(instr, Operator.Ge, false); break; case Opcode.bgezl: RewriteBranch0(instr, Operator.Ge, true); break; case Opcode.bgezal: RewriteBranch0(instr, Operator.Ge, false); break; case Opcode.bgezall: RewriteBranch0(instr, Operator.Ge, true); break; case Opcode.bgtz: RewriteBranch0(instr, Operator.Gt, false); break; case Opcode.bgtzl: RewriteBranch0(instr, Operator.Gt, true); break; case Opcode.blez: RewriteBranch0(instr, Operator.Le, false); break; case Opcode.blezl: RewriteBranch0(instr, Operator.Le, true); break; case Opcode.bltz: RewriteBranch0(instr, Operator.Lt, false); break; case Opcode.bltzl: RewriteBranch0(instr, Operator.Lt, true); break; case Opcode.bltzal: RewriteBranch0(instr, Operator.Lt, false); break; case Opcode.bltzall: RewriteBranch0(instr, Operator.Lt, true); break; case Opcode.bne: RewriteBranch(instr, Operator.Ne, false); break; case Opcode.bnel: RewriteBranch(instr, Operator.Ne, true); break; case Opcode.@break: RewriteBreak(instr); break; case Opcode.dadd: case Opcode.daddi: RewriteAdd(instr, PrimitiveType.Word64); break; case Opcode.daddiu: case Opcode.daddu: case Opcode.ddiv: case Opcode.ddivu: case Opcode.div: RewriteDiv(instr, emitter.SDiv); break; case Opcode.divu: RewriteDiv(instr, emitter.UDiv); break; case Opcode.dmult: case Opcode.dmultu: case Opcode.dsll: case Opcode.dsll32: case Opcode.dsllv: case Opcode.dsra: case Opcode.dsra32: case Opcode.dsrav: case Opcode.dsrl: case Opcode.dsrl32: case Opcode.dsrlv: case Opcode.dsub: case Opcode.dsubu: goto default; case Opcode.j: RewriteJump(instr); break; case Opcode.jal: RewriteJal(instr); break; case Opcode.jalr: RewriteJalr(instr); break; case Opcode.jr: RewriteJr(instr); break; case Opcode.lb: case Opcode.lbu: RewriteLoad(instr); break; case Opcode.ld: case Opcode.ldl: case Opcode.ldr: goto default; case Opcode.lh: case Opcode.lhu: RewriteLoad(instr); break; case Opcode.ll: case Opcode.lld: goto default; case Opcode.lui: RewriteLui(instr); break; case Opcode.lw: RewriteLoad(instr); break; case Opcode.lwl: RewriteLwl(instr); break; case Opcode.lwr: RewriteLwr(instr); break; case Opcode.lwu: goto default; case Opcode.mfc0: RewriteMfc0(instr); break; case Opcode.mfhi: RewriteMf(instr, Registers.hi); break; case Opcode.mflo: RewriteMf(instr, Registers.lo); break; case Opcode.mthi: RewriteMt(instr, Registers.hi); break; case Opcode.mtlo: RewriteMt(instr, Registers.lo); break; case Opcode.movn: case Opcode.movz: case Opcode.mult: RewriteMul(instr, emitter.SMul, PrimitiveType.Int64); break; case Opcode.multu: RewriteMul(instr, emitter.UMul, PrimitiveType.UInt64); break; goto default; case Opcode.nop: break; case Opcode.nor: RewriteNor(instr); break; case Opcode.or: case Opcode.ori: RewriteOr(instr); break; case Opcode.pref: goto default; case Opcode.sb: RewriteStore(instr); break; case Opcode.sc: case Opcode.scd: case Opcode.sd: case Opcode.sdl: case Opcode.sdr: goto default; case Opcode.sh: RewriteStore(instr); break; case Opcode.sll: case Opcode.sllv: RewriteSll(instr); break; case Opcode.slt: RewriteSxx(instr, Operator.Lt); break; case Opcode.slti: RewriteSxx(instr, Operator.Lt); break; case Opcode.sltiu: RewriteSxx(instr, Operator.Ult); break; case Opcode.sltu: RewriteSxx(instr, Operator.Ult); break; case Opcode.sra: RewriteSra(instr); break; case Opcode.srl: RewriteSrl(instr); break; case Opcode.sub: case Opcode.subu: RewriteSub(instr); break; case Opcode.sw: RewriteStore(instr); break; case Opcode.swl: RewriteSwl(instr); break; case Opcode.swr: RewriteSwr(instr); break; case Opcode.swu: goto default; case Opcode.xor: case Opcode.xori: RewriteXor(instr); break; } yield return(cluster); } }
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, }); } }
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; var addr = dasm.Current.Address; var len = dasm.Current.Length; this.rtlInstructions = new List <RtlInstruction>(); this.rtlc = InstrClass.Linear; this.m = new RtlEmitter(rtlInstructions); switch (instr.opcode) { default: host.Warn( instr.Address, "Risc-V instruction '{0}' not supported yet.", instr.opcode); rtlc = InstrClass.Invalid; m.Invalid(); break; case Opcode.invalid: rtlc = InstrClass.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()) { instr = dasm.Current; var addr = this.instr.Address; var len = this.instr.Length; this.rtlInstructions = new List <RtlInstruction>(); this.iclass = this.instr.InstructionClass; this.m = new RtlEmitter(rtlInstructions); switch (this.instr.Mnemonic) { default: EmitUnitTest(); //emitter.SideEffect(Constant.String( // this.instr.ToString(), // StringType.NullTerminated(PrimitiveType.Char))); //host.Warn( // this.instr.Address, // "VAX instruction {0} not supported yet.", // this.instr.Mnemonic); m.Invalid(); break; case Mnemonic.Invalid: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.Reserved: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.acbb: RewriteAcbi(PrimitiveType.Byte); break; case Mnemonic.acbd: RewriteAcbf(PrimitiveType.Real64); break; case Mnemonic.acbf: RewriteAcbf(PrimitiveType.Real32); break; case Mnemonic.acbg: RewriteAcbf(PrimitiveType.Real64); break; case Mnemonic.acbh: RewriteAcbf(PrimitiveType.Real128); break; case Mnemonic.acbl: RewriteAcbi(PrimitiveType.Word32); break; case Mnemonic.acbw: RewriteAcbi(PrimitiveType.Word16); break; case Mnemonic.adawi: RewriteAlu2(PrimitiveType.Word16, Adawi, AllFlags); break; case Mnemonic.addb2: RewriteAlu2(PrimitiveType.Byte, m.IAdd, AllFlags); break; case Mnemonic.addb3: RewriteAlu3(PrimitiveType.Byte, m.IAdd, AllFlags); break; case Mnemonic.addd2: RewriteFpu2(PrimitiveType.Real64, m.FAdd, NZ00); break; case Mnemonic.addd3: RewriteFpu3(PrimitiveType.Real64, m.FAdd, NZ00); break; case Mnemonic.addf2: RewriteFpu2(PrimitiveType.Real32, m.FAdd, NZ00); break; case Mnemonic.addf3: RewriteFpu3(PrimitiveType.Real32, m.FAdd, NZ00); break; case Mnemonic.addl2: RewriteAlu2(PrimitiveType.Word32, m.IAdd, AllFlags); break; case Mnemonic.addl3: RewriteAlu3(PrimitiveType.Word32, m.IAdd, AllFlags); break; case Mnemonic.addp4: RewriteP4("vax_addp4"); break; case Mnemonic.addp6: RewriteP6("vax_addp6"); break; case Mnemonic.addw2: RewriteAlu2(PrimitiveType.Word16, m.IAdd, AllFlags); break; case Mnemonic.addw3: RewriteAlu3(PrimitiveType.Word16, m.IAdd, AllFlags); break; case Mnemonic.adwc: RewriteAdwc(); break; case Mnemonic.aobleq: RewriteAob(m.Le); break; case Mnemonic.aoblss: RewriteAob(m.Lt); break; case Mnemonic.ashl: RewriteAsh(PrimitiveType.Word32); break; case Mnemonic.ashp: RewriteAshp(); break; case Mnemonic.ashq: RewriteAsh(PrimitiveType.Word64); break; case Mnemonic.bbc: RewriteBb(false); break; case Mnemonic.bbcc: RewriteBbxx(false, false); break; case Mnemonic.bbcci: RewriteBbxxi(false); break; case Mnemonic.bbcs: RewriteBbxx(false, true); break; case Mnemonic.bbs: RewriteBb(true); break; case Mnemonic.bbsc: RewriteBbxx(true, false); break; case Mnemonic.bbss: RewriteBbxx(true, true); break; case Mnemonic.bbssi: RewriteBbxxi(true); break; case Mnemonic.beql: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.bgeq: RewriteBranch(ConditionCode.GE, FlagM.NF); break; case Mnemonic.bgequ: RewriteBranch(ConditionCode.UGE, FlagM.CF); break; case Mnemonic.bgtr: RewriteBranch(ConditionCode.GT, FlagM.ZF | FlagM.NF); break; case Mnemonic.bgtru: RewriteBranch(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break; case Mnemonic.bleq: RewriteBranch(ConditionCode.LE, FlagM.ZF | FlagM.NF); break; case Mnemonic.blequ: RewriteBranch(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break; case Mnemonic.blss: RewriteBranch(ConditionCode.LT, FlagM.NF); break; case Mnemonic.blssu: RewriteBranch(ConditionCode.ULT, FlagM.CF); break; case Mnemonic.bneq: RewriteBranch(ConditionCode.NE, FlagM.ZF); break; case Mnemonic.bvc: RewriteBranch(ConditionCode.NO, FlagM.VF); break; case Mnemonic.bvs: RewriteBranch(ConditionCode.OV, FlagM.VF); break; case Mnemonic.bicb2: RewriteAlu2(PrimitiveType.Byte, Bic, NZ00); break; case Mnemonic.bicb3: RewriteAlu3(PrimitiveType.Byte, Bic, NZ00); break; case Mnemonic.bicl2: RewriteAlu2(PrimitiveType.Word32, Bic, NZ00); break; case Mnemonic.bicl3: RewriteAlu3(PrimitiveType.Word32, Bic, NZ00); break; case Mnemonic.bicpsw: RewriteBicpsw(); break; case Mnemonic.bicw2: RewriteAlu2(PrimitiveType.Word16, Bic, NZ00); break; case Mnemonic.bicw3: RewriteAlu3(PrimitiveType.Word16, Bic, NZ00); break; case Mnemonic.bisb2: RewriteAlu2(PrimitiveType.Byte, m.Or, NZ00); break; case Mnemonic.bisb3: RewriteAlu3(PrimitiveType.Byte, m.Or, NZ00); break; case Mnemonic.bispsw: RewriteBispsw(); break; case Mnemonic.bisl2: RewriteAlu2(PrimitiveType.Word32, m.Or, NZ00); break; case Mnemonic.bisl3: RewriteAlu3(PrimitiveType.Word32, m.Or, NZ00); break; case Mnemonic.bisw2: RewriteAlu2(PrimitiveType.Word16, m.Or, NZ00); break; case Mnemonic.bisw3: RewriteAlu3(PrimitiveType.Word16, m.Or, NZ00); break; case Mnemonic.bitb: RewriteBit(PrimitiveType.Byte); break; case Mnemonic.bitw: RewriteBit(PrimitiveType.Byte); break; case Mnemonic.bitl: RewriteBit(PrimitiveType.Byte); break; case Mnemonic.blbc: RewriteBlb(m.Eq0); break; case Mnemonic.blbs: RewriteBlb(m.Ne0); break; case Mnemonic.bpt: RewriteBpt(); break; case Mnemonic.brb: RewriteBranch(); break; case Mnemonic.brw: RewriteBranch(); break; case Mnemonic.bsbb: RewriteBsb(); break; case Mnemonic.bsbw: RewriteBsb(); break; case Mnemonic.callg: RewriteCallg(); break; case Mnemonic.calls: RewriteCalls(); break; case Mnemonic.caseb: RewriteCase(PrimitiveType.Byte); break; case Mnemonic.casel: RewriteCase(PrimitiveType.Word32); break; case Mnemonic.casew: RewriteCase(PrimitiveType.Word16); break; case Mnemonic.chme: RewriteChm("vax_chme"); break; case Mnemonic.chmk: RewriteChm("vax_chmk"); break; case Mnemonic.chms: RewriteChm("vax_chms"); break; case Mnemonic.chmu: RewriteChm("vax_chmu"); break; case Mnemonic.clrb: RewriteClr(PrimitiveType.Byte); break; case Mnemonic.clrh: RewriteClr(PrimitiveType.Word128); break; case Mnemonic.clrl: RewriteClr(PrimitiveType.Word32); break; case Mnemonic.clrq: RewriteClr(PrimitiveType.Word64); break; case Mnemonic.clrw: RewriteClr(PrimitiveType.Word16); break; case Mnemonic.cmpb: RewriteCmp(PrimitiveType.Byte); break; case Mnemonic.cmpd: RewriteCmp(PrimitiveType.Real64); break; case Mnemonic.cmpf: RewriteCmp(PrimitiveType.Real32); break; case Mnemonic.cmpg: RewriteCmp(PrimitiveType.Real64); break; case Mnemonic.cmph: RewriteCmp(PrimitiveType.Real128); break; case Mnemonic.cmpl: RewriteCmp(PrimitiveType.Word32); break; case Mnemonic.cmpw: RewriteCmp(PrimitiveType.Word16); break; case Mnemonic.cmpp3: RewriteCmpp3(); break; case Mnemonic.cmpp4: RewriteCmpp4(); break; case Mnemonic.cmpv: goto default; case Mnemonic.cmpzv: goto default; case Mnemonic.cvtbd: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break; case Mnemonic.cvtbf: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real32); break; case Mnemonic.cvtbg: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break; case Mnemonic.cvtbh: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real128); break; case Mnemonic.cvtbl: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int32); break; case Mnemonic.cvtbw: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int16); break; case Mnemonic.cvtdb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break; case Mnemonic.cvtdf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break; case Mnemonic.cvtdh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break; case Mnemonic.cvtdl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break; case Mnemonic.cvtdw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break; case Mnemonic.cvtfb: RewriteCvt(PrimitiveType.Real32, PrimitiveType.SByte); break; case Mnemonic.cvtfd: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break; case Mnemonic.cvtfg: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break; case Mnemonic.cvtfh: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real128); break; case Mnemonic.cvtfl: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int32); break; case Mnemonic.cvtfw: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int16); break; case Mnemonic.cvtgb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break; case Mnemonic.cvtgf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break; case Mnemonic.cvtgh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break; case Mnemonic.cvtgl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break; case Mnemonic.cvtgw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break; case Mnemonic.cvthb: RewriteCvt(PrimitiveType.Real128, PrimitiveType.SByte); break; case Mnemonic.cvthd: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break; case Mnemonic.cvthf: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real32); break; case Mnemonic.cvthg: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break; case Mnemonic.cvthl: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int32); break; case Mnemonic.cvthw: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int16); break; case Mnemonic.cvtps: RewriteCvtComplex("__cvtps"); break; case Mnemonic.cvtrdl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break; case Mnemonic.cvtrfl: RewriteCvtr(PrimitiveType.Real32, PrimitiveType.Int32); break; case Mnemonic.cvtrgl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break; case Mnemonic.cvtrhl: RewriteCvtr(PrimitiveType.Real128, PrimitiveType.Int32); break; case Mnemonic.cvtlb: RewriteCvt(PrimitiveType.Int32, PrimitiveType.SByte); break; case Mnemonic.cvtld: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break; case Mnemonic.cvtlf: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real32); break; case Mnemonic.cvtlg: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break; case Mnemonic.cvtlh: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real128); break; case Mnemonic.cvtlp: goto default; case Mnemonic.cvtlw: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Int16); break; case Mnemonic.cvtpl: goto default; case Mnemonic.cvtpt: goto default; case Mnemonic.cvtsp: RewriteCvtComplex("__cvtsp"); break; case Mnemonic.cvttp: goto default; case Mnemonic.cvtwb: RewriteCvt(PrimitiveType.Int16, PrimitiveType.SByte); break; case Mnemonic.cvtwd: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break; case Mnemonic.cvtwf: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real32); break; case Mnemonic.cvtwg: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break; case Mnemonic.cvtwh: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real128); break; case Mnemonic.cvtwl: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Int32); break;; case Mnemonic.decb: RewriteIncDec(PrimitiveType.Byte, Dec); break; case Mnemonic.decl: RewriteIncDec(PrimitiveType.Word32, Dec); break; case Mnemonic.decw: RewriteIncDec(PrimitiveType.Word16, Dec); break; case Mnemonic.divb2: RewriteAlu2(PrimitiveType.Byte, m.SDiv, AllFlags); break; case Mnemonic.divb3: RewriteAlu3(PrimitiveType.Byte, m.SDiv, AllFlags); break; case Mnemonic.divd2: RewriteFpu2(PrimitiveType.Real64, m.FDiv, AllFlags); break; case Mnemonic.divd3: RewriteFpu3(PrimitiveType.Real64, m.FDiv, AllFlags); break; case Mnemonic.divf2: RewriteFpu2(PrimitiveType.Real32, m.FDiv, AllFlags); break; case Mnemonic.divf3: RewriteFpu3(PrimitiveType.Real32, m.FDiv, AllFlags); break; case Mnemonic.divl2: RewriteAlu2(PrimitiveType.Word32, m.SDiv, AllFlags); break; case Mnemonic.divl3: RewriteAlu3(PrimitiveType.Word32, m.SDiv, AllFlags); break; case Mnemonic.divp: RewriteDivp(); break; case Mnemonic.divw2: RewriteAlu2(PrimitiveType.Word16, m.SDiv, AllFlags); break; case Mnemonic.divw3: RewriteAlu3(PrimitiveType.Word16, m.SDiv, AllFlags); break; case Mnemonic.emodd: RewriteEmod("emodd", PrimitiveType.Real64, PrimitiveType.Byte); break; //$TODO: VAX floating point types case Mnemonic.emodf: RewriteEmod("emodf", PrimitiveType.Real32, PrimitiveType.Byte); break; //$TODO: VAX floating point types case Mnemonic.emodg: RewriteEmod("emodg", PrimitiveType.Real64, PrimitiveType.Word16); break; //$TODO: VAX floating point types case Mnemonic.emodh: RewriteEmod("emodh", PrimitiveType.Real128, PrimitiveType.Word16); break; //$TODO: VAX floating point types case Mnemonic.extv: RewriteExtv(Domain.SignedInt); break; case Mnemonic.extzv: RewriteExtv(Domain.UnsignedInt); break; case Mnemonic.ffc: RewriteFfx("__ffc"); break; case Mnemonic.ffs: RewriteFfx("__ffs"); break; case Mnemonic.halt: RewriteHalt(); break; case Mnemonic.incb: RewriteIncDec(PrimitiveType.Byte, Inc); break; case Mnemonic.incl: RewriteIncDec(PrimitiveType.Word32, Inc); break; case Mnemonic.incw: RewriteIncDec(PrimitiveType.Word16, Inc); break; case Mnemonic.insque: RewriteInsque(); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.jsb: RewriteJsb(); break; case Mnemonic.mcomb: RewriteAluUnary2(PrimitiveType.Byte, m.Comp, NZ00); break; case Mnemonic.mcoml: RewriteAluUnary2(PrimitiveType.Word32, m.Comp, NZ00); break; case Mnemonic.mcomw: RewriteAluUnary2(PrimitiveType.Word16, m.Comp, NZ00); break; case Mnemonic.mnegb: RewriteAluUnary2(PrimitiveType.Byte, m.Neg, AllFlags); break; case Mnemonic.mnegd: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break; case Mnemonic.mnegf: RewriteAluUnary2(PrimitiveType.Real32, m.FNeg, NZ00); break; case Mnemonic.mnegg: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break; case Mnemonic.mnegh: RewriteAluUnary2(PrimitiveType.Word128, m.FNeg, NZ00); break; case Mnemonic.mnegl: RewriteAluUnary2(PrimitiveType.Word32, m.Neg, AllFlags); break; case Mnemonic.mnegw: RewriteAluUnary2(PrimitiveType.Word16, m.Neg, AllFlags); break; case Mnemonic.movab: RewriteMova(PrimitiveType.Byte); break; case Mnemonic.movah: RewriteMova(PrimitiveType.Real128); break; case Mnemonic.moval: RewriteMova(PrimitiveType.Word32); break; case Mnemonic.movaq: RewriteMova(PrimitiveType.Word64); break; case Mnemonic.movaw: RewriteMova(PrimitiveType.Word16); break; case Mnemonic.movb: RewriteAluUnary2(PrimitiveType.Byte, Copy, NZ00); break; case Mnemonic.movc3: goto default; case Mnemonic.movc5: goto default; case Mnemonic.movd: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break; case Mnemonic.movf: RewriteAluUnary2(PrimitiveType.Real32, Copy, NZ00); break; case Mnemonic.movg: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break; case Mnemonic.movh: RewriteAluUnary2(PrimitiveType.Real128, Copy, NZ00); break; case Mnemonic.movl: RewriteAluUnary2(PrimitiveType.Word32, Copy, NZ00); break; case Mnemonic.movo: RewriteAluUnary2(PrimitiveType.Word128, Copy, NZ00); break; case Mnemonic.movp: RewriteMovp(); break; case Mnemonic.movq: RewriteAluUnary2(PrimitiveType.Word64, Copy, NZ00); break; case Mnemonic.movw: RewriteAluUnary2(PrimitiveType.Word16, Copy, NZ00); break; case Mnemonic.movzbl: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt32); break; case Mnemonic.movzbw: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt16); break; case Mnemonic.movzwl: RewriteMovz(PrimitiveType.Word16, PrimitiveType.UInt32); break; case Mnemonic.mulb2: RewriteAlu2(PrimitiveType.Byte, m.IMul, AllFlags); break; case Mnemonic.mulb3: RewriteAlu3(PrimitiveType.Byte, m.IMul, AllFlags); break; case Mnemonic.muld2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break; case Mnemonic.muld3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break; case Mnemonic.mulf2: RewriteAlu2(PrimitiveType.Real32, m.FMul, AllFlags); break; case Mnemonic.mulf3: RewriteAlu3(PrimitiveType.Real32, m.FMul, AllFlags); break; case Mnemonic.mulg2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break; case Mnemonic.mulg3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break; case Mnemonic.mulh2: RewriteAlu2(PrimitiveType.Real128, m.FMul, AllFlags); break; case Mnemonic.mulh3: RewriteAlu3(PrimitiveType.Real128, m.FMul, AllFlags); break; case Mnemonic.mull2: RewriteAlu2(PrimitiveType.Word32, m.IMul, AllFlags); break; case Mnemonic.mull3: RewriteAlu3(PrimitiveType.Word32, m.IMul, AllFlags); break; case Mnemonic.mulp: RewriteMulp(); break; case Mnemonic.mulw2: RewriteAlu2(PrimitiveType.Word16, m.IMul, AllFlags); break; case Mnemonic.mulw3: RewriteAlu3(PrimitiveType.Word16, m.IMul, AllFlags); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.polyd: RewritePoly(PrimitiveType.Real64); break; case Mnemonic.polyf: RewritePoly(PrimitiveType.Real32); break; case Mnemonic.polyg: RewritePoly(PrimitiveType.Real64); break; case Mnemonic.polyh: RewritePoly(PrimitiveType.Real128); break; case Mnemonic.popr: goto default; case Mnemonic.prober: RewriteProber(); break; case Mnemonic.probew: goto default; case Mnemonic.pushr: goto default; case Mnemonic.pushab: RewritePusha(); break; case Mnemonic.pushal: RewritePusha(); break; case Mnemonic.pushah: RewritePusha(); break; case Mnemonic.pushaw: RewritePusha(); break; case Mnemonic.pushaq: RewritePusha(); break; case Mnemonic.pushl: RewritePush(PrimitiveType.Word32); break; case Mnemonic.rei: RewriteRei(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.rotl: RewriteAlu3(PrimitiveType.Word32, Rotl, NZ00); break; case Mnemonic.rsb: RewriteRsb(); break; case Mnemonic.sbwc: RewriteSbwc(); break; case Mnemonic.scanc: RewriteScanc(); break; case Mnemonic.sobgeq: RewriteSob(m.Ge); break; case Mnemonic.sobgtr: RewriteSob(m.Gt); break; case Mnemonic.subb2: RewriteAlu2(PrimitiveType.Byte, m.ISub, AllFlags); break; case Mnemonic.subb3: RewriteAlu3(PrimitiveType.Byte, m.ISub, AllFlags); break; case Mnemonic.subd2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break; case Mnemonic.subd3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break; case Mnemonic.subf2: RewriteAlu2(PrimitiveType.Real32, m.FSub, NZ00); break; case Mnemonic.subf3: RewriteAlu3(PrimitiveType.Real32, m.FSub, NZ00); break; case Mnemonic.subg2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break; case Mnemonic.subg3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break; case Mnemonic.subh2: RewriteAlu2(PrimitiveType.Real128, m.FSub, NZ00); break; case Mnemonic.subh3: RewriteAlu3(PrimitiveType.Real128, m.FSub, NZ00); break; case Mnemonic.subl2: RewriteAlu2(PrimitiveType.Word32, m.ISub, AllFlags); break; case Mnemonic.subl3: RewriteAlu3(PrimitiveType.Word32, m.ISub, AllFlags); break; case Mnemonic.subp4: RewriteP4("vax_subp4"); break; case Mnemonic.subp6: RewriteP6("vax_subp6"); break; case Mnemonic.subw2: RewriteAlu2(PrimitiveType.Word16, m.ISub, AllFlags); break; case Mnemonic.subw3: RewriteAlu3(PrimitiveType.Word16, m.ISub, AllFlags); break; case Mnemonic.tstb: RewriteTst(PrimitiveType.Byte, ICmp0); break; case Mnemonic.tstd: RewriteTst(PrimitiveType.Real64, FCmp0); break; case Mnemonic.tstf: RewriteTst(PrimitiveType.Real32, FCmp0); break; case Mnemonic.tstg: RewriteTst(PrimitiveType.Real64, FCmp0); break; case Mnemonic.tsth: RewriteTst(PrimitiveType.Real128, FCmp0); break; case Mnemonic.tstl: RewriteTst(PrimitiveType.Word32, ICmp0); break; case Mnemonic.tstw: RewriteTst(PrimitiveType.Word16, ICmp0); break; case Mnemonic.xorb2: RewriteAlu2(PrimitiveType.Byte, m.Xor, NZ00); break; case Mnemonic.xorb3: RewriteAlu3(PrimitiveType.Byte, m.Xor, NZ00); break; case Mnemonic.xorl2: RewriteAlu2(PrimitiveType.Word32, m.Xor, NZ00); break; case Mnemonic.xorl3: RewriteAlu3(PrimitiveType.Word32, m.Xor, NZ00); break; case Mnemonic.xorw2: RewriteAlu2(PrimitiveType.Word16, m.Xor, NZ00); break; case Mnemonic.xorw3: RewriteAlu3(PrimitiveType.Word16, m.Xor, NZ00); break; case Mnemonic.ldpctx: goto default; case Mnemonic.svpctx: goto default; case Mnemonic.editpc: goto default; case Mnemonic.matchc: goto default; case Mnemonic.index: goto default; case Mnemonic.locc: goto default; case Mnemonic.crc: goto default; case Mnemonic.skpc: goto default; case Mnemonic.remque: goto default; case Mnemonic.spanc: goto default; case Mnemonic.insqhi: goto default; case Mnemonic.insqti: goto default; case Mnemonic.movtc: goto default; case Mnemonic.remqhi: goto default; case Mnemonic.movtuc: goto default; case Mnemonic.remqti: goto default; case Mnemonic.emul: goto default; case Mnemonic.ediv: goto default; case Mnemonic.insv: goto default; case Mnemonic.mtpr: goto default; case Mnemonic.mfpr: goto default; case Mnemonic.movpsl: goto default; case Mnemonic.xfc: goto default; case Mnemonic.mfvp: goto default; case Mnemonic.vldl: goto default; case Mnemonic.vgathl: goto default; case Mnemonic.vldq: goto default; case Mnemonic.vgathq: goto default; case Mnemonic.addg2: goto default; case Mnemonic.addg3: goto default; case Mnemonic.divg2: goto default; case Mnemonic.divg3: goto default; case Mnemonic.addh2: goto default; case Mnemonic.addh3: goto default; case Mnemonic.divh2: goto default; case Mnemonic.divh3: goto default; case Mnemonic.vstl: goto default; case Mnemonic.vscatl: goto default; case Mnemonic.vstq: goto default; case Mnemonic.vscatq: goto default; case Mnemonic.vvmull: goto default; case Mnemonic.vsmull: goto default; case Mnemonic.vvmulg: goto default; case Mnemonic.vsmulg: goto default; case Mnemonic.vvmulf: goto default; case Mnemonic.vsmulf: goto default; case Mnemonic.vvmuld: goto default; case Mnemonic.vsmuld: goto default; case Mnemonic.vsync: goto default; case Mnemonic.mtvp: goto default; case Mnemonic.vvdivg: goto default; case Mnemonic.vsdivg: goto default; case Mnemonic.vvdivf: goto default; case Mnemonic.vsdivf: goto default; case Mnemonic.vvdivd: goto default; case Mnemonic.vsdivd: goto default; case Mnemonic.vvaddl: goto default; case Mnemonic.vsaddl: goto default; case Mnemonic.vvaddg: goto default; case Mnemonic.vsaddg: goto default; case Mnemonic.vvaddf: goto default; case Mnemonic.vsaddf: goto default; case Mnemonic.vvaddd: goto default; case Mnemonic.vsaddd: goto default; case Mnemonic.vvsubl: goto default; case Mnemonic.vssubl: goto default; case Mnemonic.vvsubg: goto default; case Mnemonic.vssubg: goto default; case Mnemonic.vvsubf: goto default; case Mnemonic.vssubf: goto default; case Mnemonic.vvsubd: goto default; case Mnemonic.vssubd: goto default; case Mnemonic.vvcmpl: goto default; case Mnemonic.vvsrll: goto default; case Mnemonic.vscmpl: goto default; case Mnemonic.vssrll: goto default; case Mnemonic.vvcmpg: goto default; case Mnemonic.vscmpg: goto default; case Mnemonic.vvcmpf: goto default; case Mnemonic.vvslll: goto default; case Mnemonic.vscmpf: goto default; case Mnemonic.vsslll: goto default; case Mnemonic.vvcmpd: goto default; case Mnemonic.vscmpd: goto default; case Mnemonic.vvbisl: goto default; case Mnemonic.vvxorl: goto default; case Mnemonic.vsbisl: goto default; case Mnemonic.vsxorl: goto default; case Mnemonic.vvbicl: goto default; case Mnemonic.vvcvt: goto default; case Mnemonic.vsbicl: goto default; case Mnemonic.iota: goto default; case Mnemonic.vvmerge: goto default; case Mnemonic.vsmerge: goto default; case Mnemonic.bugl: goto default; case Mnemonic.bugw: goto default; } yield return(m.MakeCluster(addr, len, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); this.iclass = dasm.Current.InstructionClass; switch (instr.Mnemonic) { case Mnemonic.invalid: m.Invalid(); break; case Mnemonic.brk: case Mnemonic.cmps: case Mnemonic.movs: case Mnemonic.retb: case Mnemonic.stop: default: EmitUnitTest(); this.iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.add: RewriteAdd(); break; case Mnemonic.addc: RewriteAddcSubc(m.IAdd); break; case Mnemonic.addw: RewriteAddw(); break; case Mnemonic.and: RewriteLogical(m.And); break; case Mnemonic.and1: RewriteLogical1(m.And); break; case Mnemonic.bc: RewriteBranch(ConditionCode.ULT, C()); break; case Mnemonic.bf: RewriteBf(); break; case Mnemonic.bh: RewriteBranch(ConditionCode.UGT, CZ()); break; case Mnemonic.bnc: RewriteBranch(ConditionCode.UGE, C()); break; case Mnemonic.bnh: RewriteBranch(ConditionCode.ULE, CZ()); break; case Mnemonic.bnz: RewriteBranch(ConditionCode.NE, Z()); break; case Mnemonic.br: RewriteBr(); break; case Mnemonic.bt: RewriteBt(); break; case Mnemonic.btclr: RewriteBtclr(); break; case Mnemonic.bz: RewriteBranch(ConditionCode.EQ, Z()); break; case Mnemonic.call: RewriteCall(); break; case Mnemonic.callt: RewriteCall(); break; case Mnemonic.clr1: RewriteClr1(); break; case Mnemonic.clrb: RewriteClr(PrimitiveType.Byte); break; case Mnemonic.clrw: RewriteClr(PrimitiveType.Word16); break; case Mnemonic.cmp: RewriteCmp(); break; case Mnemonic.cmp0: RewriteCmp0(); break; case Mnemonic.cmpw: RewriteCmp(); break; case Mnemonic.dec: RewriteIncDec((a, b) => m.ISubS(a, 1)); break; case Mnemonic.decw: RewriteIncwDecw((a, b) => m.ISubS(a, 1)); break; case Mnemonic.halt: RewriteHalt(); break; case Mnemonic.inc: RewriteIncDec((a, b) => m.IAddS(a, 1)); break; case Mnemonic.incw: RewriteIncwDecw((a, b) => m.IAddS(a, 1)); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.mov1: RewriteMov1(); break; case Mnemonic.movw: RewriteMov(); break; case Mnemonic.mulu: RewriteMulu(); break; case Mnemonic.oneb: RewriteOne(PrimitiveType.Byte); break; case Mnemonic.onew: RewriteOne(PrimitiveType.Word16); break; case Mnemonic.or: RewriteLogical(m.Or); break; case Mnemonic.or1: RewriteLogical1(m.Or); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.not1: RewriteNot1(); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.reti: RewriteRet(); break; case Mnemonic.rol: RewriteRotate(IntrinsicProcedure.Rol); break; case Mnemonic.rolc: RewriteRotateC(IntrinsicProcedure.RolC); break; case Mnemonic.rolwc: RewriteRotateC(IntrinsicProcedure.RolC); break; case Mnemonic.ror: RewriteRotate(IntrinsicProcedure.Ror); break; case Mnemonic.rorc: RewriteRotate(IntrinsicProcedure.RorC); break; case Mnemonic.sar: RewriteShift(m.Sar); break; case Mnemonic.sarw: RewriteShiftw(m.Sar); break; case Mnemonic.sel: RewriteSel(); break; case Mnemonic.set1: RewriteSet1(); break; case Mnemonic.shl: RewriteShift(m.Shl); break; case Mnemonic.shlw: RewriteShiftw(m.Shl); break; case Mnemonic.shr: RewriteShift(m.Shr); break; case Mnemonic.shrw: RewriteShiftw(m.Shr); break; case Mnemonic.skc: RewriteSkip(ConditionCode.ULT, C()); break; case Mnemonic.skh: RewriteSkip(ConditionCode.UGT, CZ()); break; case Mnemonic.sknc: RewriteSkip(ConditionCode.UGE, C()); break; case Mnemonic.sknh: RewriteSkip(ConditionCode.ULE, CZ()); break; case Mnemonic.sknz: RewriteSkip(ConditionCode.NE, Z()); break; case Mnemonic.skz: RewriteSkip(ConditionCode.EQ, Z()); break; case Mnemonic.sub: RewriteSub(); break; case Mnemonic.subc: RewriteAddcSubc(m.ISub); break; case Mnemonic.subw: RewriteSubw(); break; case Mnemonic.xch: RewriteXch(); break; case Mnemonic.xchw: RewriteXch(); break; case Mnemonic.xor: RewriteLogical(m.Xor); break; case Mnemonic.xor1: RewriteLogical1(m.Xor); break; } yield return(m.MakeCluster(instr.Address, instr.Length, 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) { case Mnemonic.abs: case Mnemonic.abss: case Mnemonic.abssw: case Mnemonic.adds: case Mnemonic.asls: case Mnemonic.asrs: case Mnemonic.ex: case Mnemonic.jcc: case Mnemonic.jcs: case Mnemonic.jge: case Mnemonic.jgt: case Mnemonic.jhi: case Mnemonic.jle: case Mnemonic.jls: case Mnemonic.jlt: case Mnemonic.jmi: case Mnemonic.jne: case Mnemonic.jpl: case Mnemonic.jpnz: case Mnemonic.jvc: case Mnemonic.jvs: case Mnemonic.negs: case Mnemonic.negsw: case Mnemonic.norm: case Mnemonic.normw: case Mnemonic.rlc: case Mnemonic.rnd16: case Mnemonic.rrc: case Mnemonic.sat16: case Mnemonic.subs: case Mnemonic.swap: case Mnemonic.abs_s: case Mnemonic.not_s: case Mnemonic.unimp_s: default: EmitUnitTest(this.instr); goto case Mnemonic.Invalid; case Mnemonic.Invalid: this.iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.adc: RewriteAluOp(Adc, ZNCV); break; case Mnemonic.add: case Mnemonic.add_s: RewriteAluOp(m.IAdd, ZNCV); break; case Mnemonic.add1: case Mnemonic.add1_s: RewriteAluOp(Add1, ZNCV); break; case Mnemonic.add2: case Mnemonic.add2_s: RewriteAluOp(Add2, ZNCV); break; case Mnemonic.add3: case Mnemonic.add3_s: RewriteAluOp(Add3, ZNCV); break; case Mnemonic.addsdw: RewriteAddSubsdw("__addsdw"); break; case Mnemonic.and: case Mnemonic.and_s: RewriteAluOp(m.And, ZN); break; case Mnemonic.asl: case Mnemonic.asl_s: RewriteShift(m.Shl, ZNCV); break; case Mnemonic.asr: case Mnemonic.asr_s: RewriteShift(m.Sar, ZNCV); break; case Mnemonic.b: case Mnemonic.b_s: RewriteB(ArcCondition.AL); break; case Mnemonic.bcc: case Mnemonic.bhs_s: RewriteB(ArcCondition.CC); break; case Mnemonic.bcs: case Mnemonic.blo_s: RewriteB(ArcCondition.CS); break; case Mnemonic.beq: case Mnemonic.beq_s: RewriteB(ArcCondition.EQ); break; case Mnemonic.bge: case Mnemonic.bge_s: RewriteB(ArcCondition.GE); break; case Mnemonic.bgt: case Mnemonic.bgt_s: RewriteB(ArcCondition.GT); break; case Mnemonic.bhi: case Mnemonic.bhi_s: RewriteB(ArcCondition.HI); break; case Mnemonic.ble: case Mnemonic.ble_s: RewriteB(ArcCondition.LE); break; case Mnemonic.bls: case Mnemonic.bls_s: RewriteB(ArcCondition.LS); break; case Mnemonic.blt: case Mnemonic.blt_s: RewriteB(ArcCondition.LT); break; case Mnemonic.bmi: RewriteB(ArcCondition.MI); break; case Mnemonic.bne: case Mnemonic.bne_s: RewriteB(ArcCondition.NE); break; case Mnemonic.bpl: RewriteB(ArcCondition.PL); break; case Mnemonic.bpnz: RewriteB(ArcCondition.PNZ); break; case Mnemonic.bvc: RewriteB(ArcCondition.VC); break; case Mnemonic.bvs: RewriteB(ArcCondition.VS); break; case Mnemonic.bsc: RewriteB(ArcCondition.SC); break; case Mnemonic.bss: RewriteB(ArcCondition.SS); break; case Mnemonic.bbit0: RewriteBbit(false); break; case Mnemonic.bbit1: RewriteBbit(true); break; case Mnemonic.bclr: case Mnemonic.bclr_s: RewriteAluOp(Bclr, ZN); break; case Mnemonic.bl: case Mnemonic.bl_s: RewriteBl(ArcCondition.AL); break; case Mnemonic.blal: RewriteBl(ArcCondition.AL); break; case Mnemonic.blcc: RewriteBl(ArcCondition.CC); break; case Mnemonic.blcs: RewriteBl(ArcCondition.CS); break; case Mnemonic.bleq: RewriteBl(ArcCondition.EQ); break; case Mnemonic.blge: RewriteBl(ArcCondition.GE); break; case Mnemonic.blgt: RewriteBl(ArcCondition.GT); break; case Mnemonic.blhi: RewriteBl(ArcCondition.HI); break; case Mnemonic.blle: RewriteBl(ArcCondition.LE); break; case Mnemonic.blls: RewriteBl(ArcCondition.LS); break; case Mnemonic.bllt: RewriteBl(ArcCondition.LT); break; case Mnemonic.blmi: RewriteBl(ArcCondition.MI); break; case Mnemonic.blne: RewriteBl(ArcCondition.NE); break; case Mnemonic.blpl: RewriteBl(ArcCondition.PL); break; case Mnemonic.blpnz: RewriteBl(ArcCondition.PNZ); break; case Mnemonic.blvc: RewriteBl(ArcCondition.VC); break; case Mnemonic.blvs: RewriteBl(ArcCondition.VS); break; case Mnemonic.breq: case Mnemonic.breq_s: RewriteBr(m.Eq); break; case Mnemonic.brge: RewriteBr(m.Ge); break; case Mnemonic.brhs: RewriteBr(m.Uge); break; case Mnemonic.brlo: RewriteBr(m.Ult); break; case Mnemonic.brlt: RewriteBr(m.Lt); break; case Mnemonic.brne: case Mnemonic.brne_s: RewriteBr(m.Ne); break; case Mnemonic.brk: case Mnemonic.brk_s: RewriteBrk(); break; case Mnemonic.bic: case Mnemonic.bic_s: RewriteAluOp(AndNot, ZN); break; case Mnemonic.bmsk: case Mnemonic.bmsk_s: RewriteAluOp(Bmsk, ZN); break; case Mnemonic.bset: case Mnemonic.bset_s: RewriteAluOp(Bset, ZN); break; case Mnemonic.btst: case Mnemonic.btst_s: RewriteCondInstr(Btst, ZN); break; case Mnemonic.bxor: RewriteAluOp(Bxor, ZN); break; case Mnemonic.cmp: case Mnemonic.cmp_s: RewriteCondInstr(m.ISub, ZNCV); break; case Mnemonic.divaw: RewriteDivaw(); break; case Mnemonic.extb: case Mnemonic.extb_s: RewriteExt(PrimitiveType.Byte, PrimitiveType.Word32); break; case Mnemonic.extw: case Mnemonic.extw_s: RewriteExt(PrimitiveType.Word16, PrimitiveType.Word32); break; case Mnemonic.flag: RewriteFlag(); break; case Mnemonic.j: case Mnemonic.j_s: RewriteJ(ArcCondition.AL); break; case Mnemonic.jeq: RewriteJ(ArcCondition.EQ); break; case Mnemonic.jl: case Mnemonic.jl_s: RewriteJl(); break; case Mnemonic.ld: case Mnemonic.ld_s: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.ldb: case Mnemonic.ldb_s: RewriteLoad(PrimitiveType.Byte); break; case Mnemonic.ldw: case Mnemonic.ldw_s: RewriteLoad(PrimitiveType.Word16); break; case Mnemonic.lp: RewriteLp(ArcCondition.AL); break; case Mnemonic.lpcc: RewriteLp(ArcCondition.CC); break; case Mnemonic.lpcs: RewriteLp(ArcCondition.CS); break; case Mnemonic.lpeq: RewriteLp(ArcCondition.EQ); break; case Mnemonic.lpge: RewriteLp(ArcCondition.GE); break; case Mnemonic.lpgt: RewriteLp(ArcCondition.GT); break; case Mnemonic.lphi: RewriteLp(ArcCondition.HI); break; case Mnemonic.lple: RewriteLp(ArcCondition.LE); break; case Mnemonic.lpls: RewriteLp(ArcCondition.LS); break; case Mnemonic.lplt: RewriteLp(ArcCondition.LT); break; case Mnemonic.lpmi: RewriteLp(ArcCondition.MI); break; case Mnemonic.lpne: RewriteLp(ArcCondition.NE); break; case Mnemonic.lppl: RewriteLp(ArcCondition.PL); break; case Mnemonic.lppnz: RewriteLp(ArcCondition.PNZ); break; case Mnemonic.lpvc: RewriteLp(ArcCondition.VC); break; case Mnemonic.lpvs: RewriteLp(ArcCondition.VS); break; case Mnemonic.lr: RewriteLr(); break; case Mnemonic.lsr: case Mnemonic.lsr_s: RewriteShift(m.Shr, ZNC); break; case Mnemonic.max: RewriteAluOp(Max, ZNCV); break; case Mnemonic.min: RewriteAluOp(Min, ZNCV); break; case Mnemonic.mov: case Mnemonic.mov_s: RewriteMov(); break; case Mnemonic.mul64: case Mnemonic.mul64_s: RewriteMul(m.SMul, PrimitiveType.Int64); break; case Mnemonic.mulu64: RewriteMul(m.UMul, PrimitiveType.UInt64); break; case Mnemonic.neg_s: RewriteAluOp(m.Neg, ZNCV); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.not: RewriteAluOp(m.Comp, ZN); break; case Mnemonic.or: case Mnemonic.or_s: RewriteAluOp(m.Or, ZN); break; case Mnemonic.pop_s: RewritePop(); break; case Mnemonic.push_s: RewritePush(); break; case Mnemonic.rcmp: RewriteCondInstr(Rsub, ZNCV); break; case Mnemonic.ror: RewriteShift(Ror, ZNC); break; case Mnemonic.rsub: RewriteAluOp(Rsub, ZNCV); break; case Mnemonic.sbc: RewriteAluOp(Sbc, ZNCV); break; case Mnemonic.sexb: case Mnemonic.sexb_s: RewriteExt(PrimitiveType.SByte, PrimitiveType.Int32); break; case Mnemonic.sexw: case Mnemonic.sexw_s: RewriteExt(PrimitiveType.Int16, PrimitiveType.Int32); break; case Mnemonic.sr: RewriteSr(); break; case Mnemonic.st: case Mnemonic.st_s: RewriteStore(PrimitiveType.Word32); break; case Mnemonic.stb: case Mnemonic.stb_s: RewriteStore(PrimitiveType.Byte); break; case Mnemonic.stw: case Mnemonic.stw_s: RewriteStore(PrimitiveType.Word16); break; case Mnemonic.sub: case Mnemonic.sub_s: RewriteAluOp(m.ISub, ZNCV); break; case Mnemonic.sub1: RewriteAluOp(Sub1, ZNCV); break; case Mnemonic.sub2: RewriteAluOp(Sub2, ZNCV); break; case Mnemonic.sub3: RewriteAluOp(Sub3, ZNCV); break; case Mnemonic.subsdw: RewriteAddSubsdw("__subsdw"); break; case Mnemonic.trap_s: case Mnemonic.trap0: RewriteTrap(); break; case Mnemonic.tst: case Mnemonic.tst_s: RewriteCondInstr(m.And, ZN); break; case Mnemonic.xor: case Mnemonic.xor_s: RewriteAluOp(m.Xor, ZN); break; } TryHandlingZeroOverheadLoop(); 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; 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(new RtlInstructionCluster(instr.Address, instr.Length, instrs.ToArray()) { Class = iclass, }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; var rtlInstrs = new List <RtlInstruction>(); this.m = new RtlEmitter(rtlInstrs); this.iclass = instr.InstructionClass; switch (instr.Mnemonic) { case Mnemonic.mov: case Mnemonic.rev: case Mnemonic.revw: case Mnemonic.tbl: EmitUnitTest(); host.Warn( instr.Address, "M6812 instruction '{0}' is not supported yet.", instr.Mnemonic); goto case Mnemonic.invalid; case Mnemonic.invalid: this.iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.aba: RewriteAba(); break; case Mnemonic.adca: RewriteAdcSbc(Registers.a, m.IAdd); break; case Mnemonic.adcb: RewriteAdcSbc(Registers.b, m.IAdd); break; case Mnemonic.adda: RewriteArithmetic(Registers.a, m.IAdd); break; case Mnemonic.addb: RewriteArithmetic(Registers.b, m.IAdd); break; case Mnemonic.addd: RewriteArithmetic(Registers.d, m.IAdd); break; case Mnemonic.anda: RewriteLogical(Registers.a, m.And); break; case Mnemonic.andb: RewriteLogical(Registers.b, m.And); break; case Mnemonic.andcc: RewriteAndcc(); break; case Mnemonic.asr: RewriteShiftMem(m.Sar); break; case Mnemonic.asra: RewriteArithmetic(Registers.a, m.Sar); break; case Mnemonic.asrb: RewriteArithmetic(Registers.b, m.Sar); break; case Mnemonic.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break; case Mnemonic.bclr: RewriteBclr(); break; case Mnemonic.bcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break; case Mnemonic.beq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.bge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Mnemonic.bgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Mnemonic.bhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Mnemonic.ble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Mnemonic.blt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break; case Mnemonic.bls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break; case Mnemonic.bmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break; case Mnemonic.bne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break; case Mnemonic.bpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break; case Mnemonic.bvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break; case Mnemonic.bvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break; case Mnemonic.bgnd: RewriteBgnd(); break; case Mnemonic.bita: RewriteBit(Registers.a); break; case Mnemonic.bitb: RewriteBit(Registers.b); break; case Mnemonic.bra: RewriteBra(); break; case Mnemonic.brclr: RewriteBrclr(); break; case Mnemonic.brn: m.Nop(); break; case Mnemonic.brset: RewriteBrset(); break; case Mnemonic.bset: RewriteBset(); break; case Mnemonic.bsr: RewriteBsr(); break; case Mnemonic.call: RewriteCall(); break; case Mnemonic.cba: RewriteCba(); break; case Mnemonic.clr: RewriteClr(); break; case Mnemonic.clra: RewriteClr(Registers.a); break; case Mnemonic.clrb: RewriteClr(Registers.b); break; case Mnemonic.cmpa: RewriteCmp(Registers.a); break; case Mnemonic.cmpb: RewriteCmp(Registers.b); break; case Mnemonic.com: RewriteCom(); break; case Mnemonic.coma: RewriteCom(Registers.a); break; case Mnemonic.comb: RewriteCom(Registers.b); break; case Mnemonic.cpd: RewriteCmp(Registers.d); break; case Mnemonic.cps: RewriteCmp(Registers.sp); break; case Mnemonic.cpx: RewriteCmp(Registers.x); break; case Mnemonic.cpy: RewriteCmp(Registers.y); break; case Mnemonic.daa: RewriteDaa(); break; case Mnemonic.dbeq: RewriteDb(m.Eq0); break; case Mnemonic.dbne: RewriteDb(m.Ne0); break; case Mnemonic.dec: RewriteIncDec(m.ISub); break; case Mnemonic.deca: RewriteIncDec(Registers.a, m.ISub); break; case Mnemonic.decb: RewriteIncDec(Registers.b, m.ISub); break; case Mnemonic.dex: RewriteIncDecXY(Registers.x, m.ISub); break; case Mnemonic.dey: RewriteIncDecXY(Registers.y, m.ISub); break; case Mnemonic.ediv: RewriteEdiv(m.UDiv, m.Remainder); break; case Mnemonic.edivs: RewriteEdiv(m.SDiv, m.Remainder); break; case Mnemonic.emacs: RewriteEmacs(); break; case Mnemonic.emaxd: RewriteEmaxmind("__umax"); break; case Mnemonic.emaxm: RewriteEmaxminm("__umax"); break; case Mnemonic.emind: RewriteEmaxmind("__umin"); break; case Mnemonic.eminm: RewriteEmaxminm("__umin"); break; case Mnemonic.emul: RewriteEmul(m.UMul); break; case Mnemonic.emuls: RewriteEmul(m.SMul); break; case Mnemonic.eora: RewriteLogical(Registers.a, m.Xor); break; case Mnemonic.eorb: RewriteLogical(Registers.b, m.Xor); break; case Mnemonic.etbl: RewriteEtbl(); break; case Mnemonic.fdiv: RewriteFdiv(); break; case Mnemonic.ibeq: RewriteIb(m.Eq0); break; case Mnemonic.ibne: RewriteIb(m.Ne0); break; case Mnemonic.idiv: RewriteIdiv(m.UDiv); break; case Mnemonic.idivs: RewriteIdiv(m.SDiv); break; case Mnemonic.inc: RewriteIncDec(m.IAdd); break; case Mnemonic.inca: RewriteIncDec(Registers.a, m.IAdd); break; case Mnemonic.incb: RewriteIncDec(Registers.b, m.IAdd); break; case Mnemonic.inx: RewriteIncDecXY(Registers.x, m.IAdd); break; case Mnemonic.iny: RewriteIncDecXY(Registers.y, m.IAdd); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.jsr: RewriteJsr(); break; case Mnemonic.lbcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break; case Mnemonic.lbcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break; case Mnemonic.lbeq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.lbge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Mnemonic.lbgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Mnemonic.lbhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Mnemonic.lble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Mnemonic.lblt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break; case Mnemonic.lbls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break; case Mnemonic.lbmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break; case Mnemonic.lbne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break; case Mnemonic.lbpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break; case Mnemonic.lbra: RewriteBra(); break; case Mnemonic.lbrn: m.Nop(); break; case Mnemonic.lbvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break; case Mnemonic.lbvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break; case Mnemonic.ldaa: RewriteLd(Registers.a); break; case Mnemonic.ldab: RewriteLd(Registers.b); break; case Mnemonic.ldd: RewriteLd(Registers.d); break; case Mnemonic.lds: RewriteLd(Registers.sp); break; case Mnemonic.ldx: RewriteLd(Registers.x); break; case Mnemonic.ldy: RewriteLd(Registers.y); break; case Mnemonic.leas: RewriteLea(Registers.sp); break; case Mnemonic.leax: RewriteLea(Registers.x); break; case Mnemonic.leay: RewriteLea(Registers.y); break; case Mnemonic.lsl: RewriteShiftMem(m.Shl); break; case Mnemonic.lsla: RewriteArithmetic(Registers.a, m.Shl); break; case Mnemonic.lslb: RewriteArithmetic(Registers.b, m.Shl); break; case Mnemonic.lsld: RewriteArithmetic(Registers.d, m.Shl); break; case Mnemonic.lsr: RewriteShiftMem(m.Shr); break; case Mnemonic.lsra: RewriteArithmetic(Registers.a, m.Shr); break; case Mnemonic.lsrb: RewriteArithmetic(Registers.b, m.Shr); break; case Mnemonic.lsrd: RewriteArithmetic(Registers.d, m.Shr); break; case Mnemonic.maxa: RewriteMaxmina("__umax_b"); break; case Mnemonic.maxm: RewriteMaxminm("__umax_b"); break; case Mnemonic.mem: RewriteMem(); break; case Mnemonic.mina: RewriteMaxmina("__umin_b"); break; case Mnemonic.minm: RewriteMaxminm("__umin_b"); break; case Mnemonic.mul: RewriteMul(); break; case Mnemonic.neg: RewriteNeg(); break; case Mnemonic.nega: RewriteNeg(Registers.a); break; case Mnemonic.negb: RewriteNeg(Registers.b); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.oraa: RewriteLogical(Registers.a, m.Or); break; case Mnemonic.orab: RewriteLogical(Registers.b, m.Or); break; case Mnemonic.orcc: RewriteOrcc(); break; case Mnemonic.psha: RewritePsh(Registers.a); break; case Mnemonic.pshb: RewritePsh(Registers.b); break; case Mnemonic.pshc: RewritePsh(Registers.ccr); break; case Mnemonic.pshd: RewritePsh(Registers.d); break; case Mnemonic.pshx: RewritePsh(Registers.x); break; case Mnemonic.pshy: RewritePsh(Registers.y); break; case Mnemonic.pula: RewritePul(Registers.a); break; case Mnemonic.pulb: RewritePul(Registers.b); break; case Mnemonic.pulc: RewritePul(Registers.ccr); break; case Mnemonic.puld: RewritePul(Registers.d); break; case Mnemonic.pulx: RewritePul(Registers.x); break; case Mnemonic.puly: RewritePul(Registers.y); break; case Mnemonic.rol: RewriteShiftMem(Rol); break; case Mnemonic.rola: RewriteArithmetic(Registers.a, Rol); break; case Mnemonic.rolb: RewriteArithmetic(Registers.b, Rol); break; case Mnemonic.ror: RewriteShiftMem(Ror); break; case Mnemonic.rora: RewriteArithmetic(Registers.a, Ror); break; case Mnemonic.rorb: RewriteArithmetic(Registers.a, Ror); break; case Mnemonic.rtc: RewriteRtc(); break; case Mnemonic.rti: RewriteRti(); break; case Mnemonic.rts: RewriteRts(); break; case Mnemonic.sba: RewriteSba(); break; case Mnemonic.sbca: RewriteAdcSbc(Registers.a, m.ISub); break; case Mnemonic.sbcb: RewriteAdcSbc(Registers.b, m.ISub); break; case Mnemonic.sex: RewriteSex(); break; case Mnemonic.staa: RewriteSt(Registers.a); break; case Mnemonic.stab: RewriteSt(Registers.b); break; case Mnemonic.std: RewriteSt(Registers.d); break; case Mnemonic.stop: RewriteStop(); break; case Mnemonic.sts: RewriteSt(Registers.sp); break; case Mnemonic.stx: RewriteSt(Registers.x); break; case Mnemonic.sty: RewriteSt(Registers.y); break; case Mnemonic.suba: RewriteSub(Registers.a); break; case Mnemonic.subb: RewriteSub(Registers.b); break; case Mnemonic.subd: RewriteSub(Registers.d); break; case Mnemonic.swi: RewriteSwi(); break; case Mnemonic.tab: RewriteTab(); break; case Mnemonic.tba: RewriteTba(); break; case Mnemonic.tbeq: RewriteTb(m.Eq0); break; case Mnemonic.tbne: RewriteTb(m.Ne0); break; case Mnemonic.tfr: RewriteTfr(); break; case Mnemonic.trap: RewriteTrap(); break; case Mnemonic.tst: RewriteTst(); break; case Mnemonic.tsta: RewriteTst(Registers.a); break; case Mnemonic.tstb: RewriteTst(Registers.b); break; case Mnemonic.wai: RewriteWai(); break; case Mnemonic.wav: RewriteWav(); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { instrCur = dasm.Current; ric = new RtlInstructionCluster(instrCur.Address, 4); ric.Class = RtlClass.Linear; emitter = new RtlEmitter(ric.Instructions); switch (instrCur.Opcode) { default: throw new AddressCorrelatedException( instrCur.Address, "Rewriting SPARC opcode '{0}' is not supported yet.", instrCur.Opcode); case Opcode.add: RewriteAlu(emitter.IAdd, false); break; case Opcode.addcc: RewriteAluCc(emitter.IAdd, false); break; case Opcode.addx: RewriteAddxSubx(emitter.IAdd, false); break; case Opcode.addxcc: RewriteAddxSubx(emitter.IAdd, true); break; case Opcode.and: RewriteAlu(emitter.And, false); break; case Opcode.andcc: RewriteAluCc(emitter.And, false); break; case Opcode.andn: RewriteAlu(emitter.And, true); break; case Opcode.ba: RewriteBranch(Constant.True()); break; case Opcode.bn: RewriteBranch(Constant.False()); break; case Opcode.bne: RewriteBranch(emitter.Test(ConditionCode.NE, Grf(FlagM.ZF))); break; case Opcode.be: RewriteBranch(emitter.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break; case Opcode.bg: RewriteBranch(emitter.Test(ConditionCode.GT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Opcode.bge: RewriteBranch(emitter.Test(ConditionCode.GE, Grf(FlagM.NF | FlagM.VF))); break; case Opcode.bgu: RewriteBranch(emitter.Test(ConditionCode.UGE, Grf(FlagM.CF | FlagM.ZF))); break; case Opcode.bl: RewriteBranch(emitter.Test(ConditionCode.LT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Opcode.ble: RewriteBranch(emitter.Test(ConditionCode.LE, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Opcode.bleu: RewriteBranch(emitter.Test(ConditionCode.ULE, Grf(FlagM.CF | FlagM.ZF))); break; case Opcode.bcc: RewriteBranch(emitter.Test(ConditionCode.UGE, Grf(FlagM.CF))); break; case Opcode.bcs: RewriteBranch(emitter.Test(ConditionCode.ULT, Grf(FlagM.CF))); break; case Opcode.bneg: RewriteBranch(emitter.Test(ConditionCode.LT, Grf(FlagM.NF))); break; case Opcode.bpos: RewriteBranch(emitter.Test(ConditionCode.GE, Grf(FlagM.NF))); break; // Z //case Opcode.bgu not (C or Z) //case Opcode.bleu (C or Z) //case Opcode.bcc not C //case Opcode.bcs C //case Opcode.bpos not N //case Opcode.bneg N //case Opcode.bvc not V //case Opcode.bvs V case Opcode.call: RewriteCall(); break; case Opcode.fabss: RewriteFabss(); break; case Opcode.fadds: RewriteFadds(); break; case Opcode.fbne: RewriteBranch(emitter.Test(ConditionCode.NE, Grf(FlagM.LF | FlagM.GF))); break; case Opcode.fba: RewriteBranch(Constant.True()); break; case Opcode.fbn: RewriteBranch(Constant.False()); break; case Opcode.fbu: RewriteBranch(emitter.Test(ConditionCode.NE, Grf(FlagM.UF))); break; case Opcode.fbg: RewriteBranch(emitter.Test(ConditionCode.GT, Grf(FlagM.GF))); break; case Opcode.fbug: RewriteBranch(emitter.Test(ConditionCode.GT, Grf(FlagM.GF | FlagM.UF))); break; //case Opcode.fbug : on Unordered or Greater G or U //case Opcode.fbl : on Less L case Opcode.fbul: RewriteBranch(emitter.Test(ConditionCode.LT, Grf(FlagM.GF | FlagM.UF))); break; //case Opcode.fbul : on Unordered or Less L or U //case Opcode.fblg : on Less or Greater L or G //case Opcode.fbne : on Not Equal L or G or U //case Opcode.fbe : on Equal E //case Opcode.fbue : on Unordered or Equal E or U //case Opcode.fbge : on Greater or Equal E or G //case Opcode.fbuge : on Unordered or Greater or Equal E or G or U case Opcode.fbuge: RewriteBranch(emitter.Test(ConditionCode.GE, Grf(FlagM.EF | FlagM.GF | FlagM.UF))); break; //case Opcode.fble : on Less or Equal E or L //case Opcode.fbule : on Unordered or Less or Equal E or L or U case Opcode.fbule: RewriteBranch(emitter.Test(ConditionCode.LE, Grf(FlagM.EF | FlagM.LF | FlagM.UF))); break; // case Opcode.FBO : on Ordered E or L or G case Opcode.fcmpes: RewriteFcmpes(); break; case Opcode.fdivs: RewriteFdivs(); break; case Opcode.fitod: RewriteFitod(); break; case Opcode.fitoq: RewriteFitoq(); break; case Opcode.fitos: RewriteFitos(); break; case Opcode.fmovs: RewriteFmovs(); break; case Opcode.fmuls: RewriteFmuls(); break; case Opcode.fnegs: RewriteFmovs(); break; case Opcode.fsubs: RewriteFsubs(); break; case Opcode.jmpl: RewriteJmpl(); break; case Opcode.ld: RewriteLoad(PrimitiveType.Word32); break; case Opcode.lddf: RewriteDLoad(PrimitiveType.Real64); break; case Opcode.ldf: RewriteLoad(PrimitiveType.Real32); break; case Opcode.ldd: RewriteLoad(PrimitiveType.Word64); break; case Opcode.ldsb: RewriteLoad(PrimitiveType.SByte); break; case Opcode.ldsh: RewriteLoad(PrimitiveType.Int16); break; case Opcode.ldub: RewriteLoad(PrimitiveType.Byte); break; case Opcode.lduh: RewriteLoad(PrimitiveType.Word16); break; case Opcode.mulscc: RewriteMulscc(); break; case Opcode.or: RewriteAlu(emitter.Or, false); break; case Opcode.orcc: RewriteAluCc(emitter.Or, false); break; case Opcode.restore: RewriteRestore(); break; case Opcode.rett: RewriteRett(); break; case Opcode.save: RewriteSave(); break; case Opcode.sethi: RewriteSethi(); break; case Opcode.sdiv: RewriteAlu(emitter.SDiv, false); break; case Opcode.sdivcc: RewriteAlu(emitter.SDiv, false); break; case Opcode.sll: RewriteAlu(emitter.Shl, false); break; case Opcode.smul: RewriteAlu(emitter.SMul, false); break; case Opcode.smulcc: RewriteAluCc(emitter.SMul, false); break; case Opcode.sra: RewriteAlu(emitter.Sar, false); break; case Opcode.srl: RewriteAlu(emitter.Shr, false); break; case Opcode.st: RewriteStore(PrimitiveType.Word32); break; case Opcode.stb: RewriteStore(PrimitiveType.Byte); break; case Opcode.std: RewriteStore(PrimitiveType.Word64); break; case Opcode.stf: RewriteStore(PrimitiveType.Real32); break; case Opcode.sth: RewriteStore(PrimitiveType.Word16); break; case Opcode.sub: RewriteAlu(emitter.ISub, false); break; case Opcode.subcc: RewriteAluCc(emitter.ISub, false); break; case Opcode.subx: RewriteAddxSubx(emitter.ISub, false); break; case Opcode.subxcc: RewriteAddxSubx(emitter.ISub, true); break; case Opcode.ta: RewriteTrap(Constant.True()); break; case Opcode.tn: RewriteTrap(Constant.False()); break; case Opcode.tne: RewriteTrap(emitter.Test(ConditionCode.NE, Grf(FlagM.ZF))); break; case Opcode.te: RewriteTrap(emitter.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break; case Opcode.udiv: RewriteAlu(emitter.UDiv, false); break; case Opcode.udivcc: RewriteAluCc(emitter.UDiv, false); break; case Opcode.umul: RewriteAlu(emitter.UMul, false); break; case Opcode.umulcc: RewriteAluCc(emitter.UMul, false); break; case Opcode.unimp: emitter.Invalid(); break; case Opcode.xor: RewriteAlu(emitter.Xor, false); break; } yield return(ric); } }
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()) { di = dasm.Current; var addr = di.Address; var len = di.Length; rtlInstructions = new List <RtlInstruction>(); rtlc = RtlClass.Linear; m = new RtlEmitter(rtlInstructions); orw = new OperandRewriter(arch, this.m, this.binder, di.dataWidth); switch (di.code) { default: host.Warn( di.Address, "M68k instruction '{0}' is not supported yet.", di.code); m.Invalid(); break; case Opcode.illegal: RewriteIllegal(); break; case Opcode.abcd: RewriteAbcd(); break; case Opcode.add: RewriteBinOp((s, d) => m.IAdd(d, s), FlagM.CVZNX); break; case Opcode.adda: RewriteBinOp((s, d) => m.IAdd(d, s)); break; case Opcode.addi: RewriteArithmetic((s, d) => m.IAdd(d, s)); break; case Opcode.addq: RewriteAddSubq((s, d) => m.IAdd(d, s)); break; case Opcode.addx: RewriteAddSubx(m.IAdd); break; case Opcode.and: RewriteLogical((s, d) => m.And(d, s)); break; case Opcode.andi: RewriteLogical((s, d) => m.And(d, s)); break; case Opcode.asl: RewriteArithmetic((s, d) => m.Shl(d, s)); break; case Opcode.asr: RewriteShift((s, d) => m.Sar(d, s)); break; /* * * Mnemonic Condition Encoding Test * T* True 0000 1 * F* False 0001 0 * HI High 0010 C L Z * LS Low or Same 0011 C V Z * VC Overflow Clear 1000 V * VS Overflow Set 1001 V */ case Opcode.bclr: RewriteBclrBset("__bclr"); break; case Opcode.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); 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.bchg: RewriteBchg(); break; case Opcode.bkpt: RewriteBkpt(); break; case Opcode.bra: RewriteBra(); break; case Opcode.bset: RewriteBclrBset("__bset"); break; case Opcode.bsr: RewriteBsr(); break; case Opcode.btst: RewriteBtst(); break; case Opcode.callm: RewriteCallm(); break; case Opcode.cas: RewriteCas(); break; case Opcode.clr: RewriteClr(); break; case Opcode.chk: RewriteChk(); break; case Opcode.chk2: RewriteChk2(); break; case Opcode.cmp: RewriteCmp(); break; case Opcode.cmp2: RewriteCmp2(); break; case Opcode.cmpa: RewriteCmp(); break; case Opcode.cmpi: RewriteCmp(); break; case Opcode.cmpm: RewriteCmp(); break; case Opcode.dbcc: RewriteDbcc(ConditionCode.UGE, FlagM.CF); break; case Opcode.dbcs: RewriteDbcc(ConditionCode.ULT, FlagM.CF); break; case Opcode.dbeq: RewriteDbcc(ConditionCode.EQ, FlagM.ZF); break; case Opcode.dbge: RewriteDbcc(ConditionCode.GE, FlagM.NF | FlagM.ZF); break; case Opcode.dble: RewriteDbcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.dbls: RewriteDbcc(ConditionCode.ULE, FlagM.CF | FlagM.ZF); break; case Opcode.dbhi: RewriteDbcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Opcode.dbpl: RewriteDbcc(ConditionCode.GT, FlagM.NF); break; case Opcode.dbne: RewriteDbcc(ConditionCode.NE, FlagM.ZF); break; case Opcode.dbt: RewriteDbcc(ConditionCode.ALWAYS, 0); break; case Opcode.dbra: RewriteDbcc(ConditionCode.None, 0); break; case Opcode.divs: RewriteDiv(m.SDiv, PrimitiveType.Int16); break; case Opcode.divsl: RewriteDiv(m.SDiv, PrimitiveType.Int32); break; case Opcode.divu: RewriteDiv(m.UDiv, PrimitiveType.UInt16); break; case Opcode.divul: RewriteDiv(m.UDiv, PrimitiveType.UInt32); break; case Opcode.eor: RewriteLogical((s, d) => m.Xor(d, s)); break; case Opcode.eori: RewriteLogical((s, d) => m.Xor(d, s)); break; case Opcode.exg: RewriteExg(); break; case Opcode.ext: RewriteExt(); break; case Opcode.extb: RewriteExtb(); break; case Opcode.fadd: RewriteFBinOp((s, d) => m.FAdd(d, s)); break; //$REVIEW: the following don't respect NaN, but NaN typically doesn't exist in HLLs. case Opcode.fbf: m.Nop(); break; case Opcode.fblt: RewriteFbcc(ConditionCode.LT); break; case Opcode.fbgl: RewriteFbcc(ConditionCode.NE); break; case Opcode.fbgt: RewriteFbcc(ConditionCode.GT); break; case Opcode.fbgle: RewriteFbcc(ConditionCode.NE); break; //$BUG: should be !is_nan case Opcode.fbne: RewriteFbcc(ConditionCode.NE); break; case Opcode.fbnge: RewriteFbcc(ConditionCode.LT); break; case Opcode.fbngl: RewriteFbcc(ConditionCode.EQ); break; case Opcode.fbngle: RewriteFbcc(ConditionCode.EQ); break; //$BUG: should be is_nan case Opcode.fbnlt: RewriteFbcc(ConditionCode.GE); break; case Opcode.fbnle: RewriteFbcc(ConditionCode.GT); break; case Opcode.fbogl: RewriteFbcc(ConditionCode.NE); break; case Opcode.fbole: RewriteFbcc(ConditionCode.LE); break; case Opcode.fbolt: RewriteFbcc(ConditionCode.LT); break; case Opcode.fbogt: RewriteFbcc(ConditionCode.GT); break; case Opcode.fbor: RewriteFbcc(ConditionCode.EQ); break; //$REVIEW: is this correct? case Opcode.fbseq: RewriteFbcc(ConditionCode.EQ); break; case Opcode.fbsf: RewriteFbcc(ConditionCode.NEVER); break; case Opcode.fbsne: RewriteFbcc(ConditionCode.NE); break; case Opcode.fbst: RewriteFbcc(ConditionCode.ALWAYS); break; case Opcode.fbuge: RewriteFbcc(ConditionCode.GE); break; case Opcode.fbugt: RewriteFbcc(ConditionCode.GT); break; case Opcode.fbult: RewriteFbcc(ConditionCode.LT); break; case Opcode.fbun: RewriteFbcc(ConditionCode.IS_NAN); break; case Opcode.fasin: RewriteFasin(); break; case Opcode.fintrz: RewriteFintrz(); break; case Opcode.fcmp: RewriteFcmp(); break; case Opcode.fdiv: RewriteFBinOp((s, d) => m.FDiv(d, s)); break; case Opcode.fmove: RewriteFmove(); break; case Opcode.fmovecr: RewriteFmovecr(); break; case Opcode.fmovem: RewriteMovem(i => arch.GetRegister(i + Registers.fp0.Number)); break; case Opcode.fmul: RewriteFBinOp((s, d) => m.FMul(d, s)); break; case Opcode.fneg: RewriteFUnaryOp(m.Neg); break; case Opcode.fsqrt: RewriteFsqrt(); break; case Opcode.fsub: RewriteFBinOp((s, d) => m.FSub(d, s)); break; case Opcode.ftan: RewriteFtan(); break; case Opcode.jmp: RewriteJmp(); break; case Opcode.jsr: RewriteJsr(); break; case Opcode.lea: RewriteLea(); break; case Opcode.link: RewriteLink(); break; case Opcode.lsl: RewriteShift((s, d) => m.Shl(d, s)); break; case Opcode.lsr: RewriteShift((s, d) => m.Shr(d, s)); break; case Opcode.move: RewriteMove(true); break; case Opcode.move16: RewriteMove16(); break; case Opcode.movea: RewriteMove(false); break; case Opcode.movep: RewriteMovep(); break; case Opcode.moveq: RewriteMoveq(); break; case Opcode.moves: RewriteMoves(); break; case Opcode.movem: RewriteMovem(arch.GetRegister); break; case Opcode.muls: RewriteMul((s, d) => m.SMul(d, s)); break; case Opcode.mulu: RewriteMul((s, d) => m.UMul(d, s)); break; case Opcode.nbcd: RewriteNbcd(); break; case Opcode.neg: RewriteUnary(s => m.Neg(s), AllConditions); break; case Opcode.negx: RewriteUnary(RewriteNegx, AllConditions); break; case Opcode.nop: m.Nop(); break; case Opcode.not: RewriteUnary(s => m.Comp(s), LogicalConditions); break; case Opcode.or: RewriteLogical((s, d) => m.Or(d, s)); break; case Opcode.ori: RewriteLogical((s, d) => m.Or(d, s)); break; case Opcode.pack: RewritePack(); break; case Opcode.pea: RewritePea(); break; case Opcode.pflushr: RewritePflushr(); break; case Opcode.ptest: RewritePtest(); break; case Opcode.rol: RewriteRotation(PseudoProcedure.Rol); break; case Opcode.ror: RewriteRotation(PseudoProcedure.Ror); break; case Opcode.roxl: RewriteRotationX(PseudoProcedure.RolC); break; case Opcode.roxr: RewriteRotationX(PseudoProcedure.RorC); break; case Opcode.rte: RewriteRte(); break; case Opcode.rtm: RewriteRtm(); break; case Opcode.rts: RewriteRts(); break; case Opcode.sbcd: RewriteSbcd(); break; case Opcode.scc: RewriteScc(ConditionCode.UGE, FlagM.CF); break; case Opcode.scs: RewriteScc(ConditionCode.ULT, FlagM.CF); break; case Opcode.seq: RewriteScc(ConditionCode.EQ, FlagM.ZF); break; case Opcode.sge: RewriteScc(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Opcode.sgt: RewriteScc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.shi: RewriteScc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Opcode.sle: RewriteScc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.slt: RewriteScc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break; case Opcode.sls: RewriteScc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break; case Opcode.smi: RewriteScc(ConditionCode.LT, FlagM.NF); break; case Opcode.sne: RewriteScc(ConditionCode.NE, FlagM.ZF); break; case Opcode.spl: RewriteScc(ConditionCode.GT, FlagM.NF); break; case Opcode.svc: RewriteScc(ConditionCode.NO, FlagM.VF); break; case Opcode.svs: RewriteScc(ConditionCode.OV, FlagM.VF); break; case Opcode.st: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.True()); break; case Opcode.sf: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.False()); break; case Opcode.stop: RewriteStop(); break; case Opcode.sub: RewriteArithmetic((s, d) => m.ISub(d, s)); break; case Opcode.suba: RewriteArithmetic((s, d) => m.ISub(d, s)); break; case Opcode.subi: RewriteArithmetic((s, d) => m.ISub(d, s)); break; case Opcode.subq: RewriteAddSubq((s, d) => m.ISub(d, s)); break; case Opcode.subx: RewriteArithmetic((s, d) => m.ISub(m.ISub(d, s), binder.EnsureFlagGroup(Registers.ccr, (uint)FlagM.XF, "X", PrimitiveType.Bool))); break; case Opcode.swap: RewriteSwap(); break; case Opcode.trap: RewriteTrap(); break; case Opcode.trapeq: RewriteTrapCc(ConditionCode.EQ, FlagM.ZF); break; case Opcode.trapf: RewriteTrapCc(ConditionCode.NEVER, 0); break; case Opcode.traphi: RewriteTrapCc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Opcode.trapls: RewriteTrapCc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break; case Opcode.traplt: RewriteTrapCc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break; case Opcode.tas: RewriteTas(); break; case Opcode.tst: RewriteTst(); break; case Opcode.unlk: RewriteUnlk(); break; case Opcode.unpk: RewriteUnpk(); break; } yield return(new RtlInstructionCluster( addr, len, rtlInstructions.ToArray()) { Class = rtlc }); } yield break; }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; iclass = instr.InstructionClass; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); switch (instr.Mnemonic) { default: EmitUnitTest(); Invalid(); host.Warn( instr.Address, string.Format( "TLCS-90 instruction '{0}' not supported yet.", instr.Mnemonic)); break; case Mnemonic.invalid: m.Invalid(); break; case Mnemonic.adc: RewriteAdcSbc(m.IAdd, "**-**V0*"); break; case Mnemonic.add: RewriteBinOp(m.IAdd, "**-***0*"); break; case Mnemonic.and: RewriteBinOp(m.And, "**-10*00"); break; case Mnemonic.bit: RewriteBit("*--I**0-"); break; case Mnemonic.call: RewriteCall(); break; case Mnemonic.callr: RewriteCall(); break; case Mnemonic.ccf: RewriteCcf(); break; case Mnemonic.cp: RewriteCp(); break; case Mnemonic.cpl: RewriteCpl("---1--1-"); break; case Mnemonic.daa: RewriteDaa(); break; case Mnemonic.dec: RewriteIncDec(m.ISub, false); break; case Mnemonic.decx: RewriteIncDec(m.ISub, true); break; case Mnemonic.di: RewriteDi(); break; case Mnemonic.div: RewriteDiv(); break; case Mnemonic.djnz: RewriteDjnz(); break; case Mnemonic.ei: RewriteEi(); break; case Mnemonic.ex: RewriteEx(); break; case Mnemonic.exx: RewriteExx(); break; case Mnemonic.halt: RewriteHalt(); break; case Mnemonic.inc: RewriteIncDec(m.IAdd, false); break; case Mnemonic.incw: RewriteIncwDecw(m.IAdd); break; case Mnemonic.incx: RewriteIncDec(m.IAdd, true); break; case Mnemonic.jp: RewriteJp(); break; case Mnemonic.jr: RewriteJp(); break; case Mnemonic.ld: RewriteLd(); break; case Mnemonic.ldar: RewriteLdar(); break; case Mnemonic.ldir: RewriteLdir("---0-00-"); break; case Mnemonic.ldw: RewriteLd(); break; case Mnemonic.mul: RewriteMul(); break; case Mnemonic.neg: RewriteNeg(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.or: RewriteBinOp(m.Or, "**-00*00"); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.rcf: RewriteRcf(); break; case Mnemonic.res: RewriteSetRes(false); break; case Mnemonic.ret: RewriteRet(); break; case Mnemonic.reti: RewriteReti(); break; case Mnemonic.rl: RewriteRotation(CommonOps.RolC, true); break; case Mnemonic.rlc: RewriteRotation(CommonOps.Ror, false); break; case Mnemonic.rr: RewriteRotation(CommonOps.RorC, true); break; case Mnemonic.rrc: RewriteRotation(CommonOps.Ror, false); break; case Mnemonic.sbc: RewriteAdcSbc(m.ISub, "**-**V1*"); break; case Mnemonic.scf: RewriteScf(); break; case Mnemonic.set: RewriteSetRes(true); break; case Mnemonic.tset: RewriteTset("*--I**0-"); break; case Mnemonic.sla: RewriteShift(m.Shl); break; case Mnemonic.sll: RewriteShift(m.Shl); break; case Mnemonic.sra: RewriteShift(m.Sar); break; case Mnemonic.srl: RewriteShift(m.Shr); break; case Mnemonic.sub: RewriteBinOp(m.ISub, "**-**V1*"); break; case Mnemonic.swi: RewriteSwi(); break; case Mnemonic.xor: RewriteBinOp(m.Xor, "**-10*00"); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
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.Error( 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.add: case Mnemonic.addi: case Mnemonic.addiu: case Mnemonic.addu: RewriteAdd(instr, PrimitiveType.Word32); break; case Mnemonic.add_s: RewriteFpuBinopS(instr, m.FAdd); break; case Mnemonic.add_d: RewriteFpuBinopD(instr, m.FAdd); break; case Mnemonic.and: case Mnemonic.andi: RewriteAnd(instr); break; case Mnemonic.bc1f: RewriteBranchConditional1(instr, false); break; case Mnemonic.bc1t: RewriteBranchConditional1(instr, true); break; case Mnemonic.beq: RewriteBranch(instr, m.Eq, false); break; case Mnemonic.beql: RewriteBranchLikely(instr, m.Eq); break; case Mnemonic.bgez: RewriteBranch0(instr, m.Ge, false); break; case Mnemonic.bgezl: RewriteBranch0(instr, m.Ge, true); break; case Mnemonic.bgezal: RewriteBgezal(instr); break; case Mnemonic.bgezall: RewriteBranch0(instr, m.Ge, true); break; case Mnemonic.bgtz: RewriteBranch0(instr, m.Gt, false); break; case Mnemonic.bgtzl: RewriteBranch0(instr, m.Gt, true); break; case Mnemonic.blez: RewriteBranch0(instr, m.Le, false); break; case Mnemonic.blezl: RewriteBranch0(instr, m.Le, true); break; case Mnemonic.bltz: RewriteBranch0(instr, m.Lt, false); break; case Mnemonic.bltzl: RewriteBranch0(instr, m.Lt, true); break; case Mnemonic.bltzal: RewriteBranch0(instr, m.Lt, true); break; case Mnemonic.bltzall: RewriteBranch0(instr, m.Lt, true); break; case Mnemonic.bne: RewriteBranch(instr, m.Ne, false); break; case Mnemonic.bnel: RewriteBranchLikely(instr, m.Ne); break; case Mnemonic.@break: RewriteBreak(instr); break; case Mnemonic.c_le_d: RewriteFpuCmpD(instr, Operator.Fle); break; case Mnemonic.c_le_s: RewriteFpuCmpD(instr, Operator.Fle); break; case Mnemonic.c_lt_d: RewriteFpuCmpD(instr, Operator.Flt); break; case Mnemonic.c_lt_s: RewriteFpuCmpD(instr, Operator.Flt); break; case Mnemonic.c_eq_d: RewriteFpuCmpD(instr, Operator.Feq); break; case Mnemonic.c_eq_s: RewriteFpuCmpD(instr, Operator.Feq); break; case Mnemonic.cache: RewriteCache(instr, "__cache"); break; case Mnemonic.cfc1: RewriteCfc1(instr); break; case Mnemonic.ctc1: RewriteCtc1(instr); break; case Mnemonic.clo: RewriteClo(instr); break; case Mnemonic.clz: RewriteClz(instr); break; case Mnemonic.cvt_d_l: RewriteCvtToD(instr, PrimitiveType.Int32); break; case Mnemonic.cvt_s_d: RewriteCvtFromD(instr, PrimitiveType.Real32); break; case Mnemonic.cvt_w_d: RewriteCvtFromD(instr, PrimitiveType.Int32); break; case Mnemonic.dadd: case Mnemonic.daddi: RewriteAdd(instr, PrimitiveType.Word64); break; case Mnemonic.daddiu: case Mnemonic.daddu: RewriteAdd(instr, PrimitiveType.Word64); break; case Mnemonic.ddiv: RewriteDiv(instr, m.SDiv); break; case Mnemonic.ddivu: RewriteDiv(instr, m.UDiv); break; case Mnemonic.div: RewriteDiv(instr, m.SDiv); break; case Mnemonic.divu: RewriteDiv(instr, m.UDiv); break; case Mnemonic.div_d: RewriteFpuBinopD(instr, m.FDiv); break; case Mnemonic.dmfc0: RewriteMfc0(instr); break; case Mnemonic.dmfc1: RewriteMfc1(instr); break; case Mnemonic.dmtc0: RewriteMtc0(instr); break; case Mnemonic.dmtc1: RewriteMtc1(instr); break; case Mnemonic.dmult: RewriteMul(instr, m.SMul, PrimitiveType.Int128); break; case Mnemonic.dmultu: RewriteMul(instr, m.UMul, PrimitiveType.UInt128); break; case Mnemonic.dsll: RewriteSll(instr); break; case Mnemonic.dsll32: RewriteDshift32(instr, m.Shl); break; case Mnemonic.dsllv: RewriteSrl(instr); break; case Mnemonic.dsra: RewriteSra(instr); break; case Mnemonic.dsra32: RewriteDshift32(instr, m.Sar); break; case Mnemonic.dsrav: RewriteSra(instr); break; case Mnemonic.dsrl: RewriteSrl(instr); break; case Mnemonic.dsrl32: RewriteDshift32(instr, m.Shr); break; case Mnemonic.dsrlv: RewriteSrl(instr); break; case Mnemonic.dsub: case Mnemonic.dsubu: RewriteSub(instr, PrimitiveType.Word64); break; case Mnemonic.eret: RewriteEret(instr); break; case Mnemonic.j: RewriteJump(instr); break; case Mnemonic.jal: RewriteJal(instr); break; case Mnemonic.jalr: RewriteJalr(instr); break; case Mnemonic.jr: RewriteJr(instr); break; case Mnemonic.lb: RewriteLoad(instr, PrimitiveType.SByte); break; case Mnemonic.lbu: RewriteLoad(instr, PrimitiveType.Byte); break; case Mnemonic.ld: RewriteLoad(instr, PrimitiveType.Word64); break; case Mnemonic.ldl: RewriteLdl(instr); break; case Mnemonic.ldr: RewriteLdr(instr); break; case Mnemonic.ldc1: RewriteLcpr1(instr); break; case Mnemonic.ldc2: RewriteLdc2(instr); break; case Mnemonic.ldxc1: RewriteLcpr1(instr); break; case Mnemonic.luxc1: RewriteLcpr1(instr); break; case Mnemonic.lwxc1: RewriteLcpr1(instr); break; case Mnemonic.lh: RewriteLoad(instr, PrimitiveType.Int16); break; case Mnemonic.lhxs: RewriteLoadIndexed(instr, PrimitiveType.Int16, PrimitiveType.Int32, 2); break; case Mnemonic.lhu: RewriteLoad(instr, PrimitiveType.UInt16); break; case Mnemonic.lhuxs: RewriteLoadIndexed(instr, PrimitiveType.Word16, PrimitiveType.Word32, 2); break; case Mnemonic.ll: RewriteLoadLinked32(instr); break; case Mnemonic.lld: RewriteLoadLinked64(instr); break; case Mnemonic.lui: RewriteLui(instr); break; case Mnemonic.lw: RewriteLoad(instr, PrimitiveType.Word32, PrimitiveType.Int32); break; case Mnemonic.lwc1: RewriteLcpr1(instr); break; case Mnemonic.lwc2: RewriteLdc2(instr); break; case Mnemonic.lwl: RewriteLwl(instr); break; case Mnemonic.lwr: RewriteLwr(instr); break; case Mnemonic.lwu: RewriteLoad(instr, PrimitiveType.UInt32); break; case Mnemonic.madd: RewriteMac_int(instr, m.IAdd); break; case Mnemonic.madd_s: RewriteMac_real(instr, PrimitiveType.Real32, m.FAdd); break; case Mnemonic.madd_ps: RewriteMac_vec(instr, PrimitiveType.Real32, m.FAdd); break; case Mnemonic.mfc0: RewriteMfc0(instr); break; case Mnemonic.mfc1: RewriteMfc1(instr); break; case Mnemonic.mfhi: RewriteMf(instr, arch.hi); break; case Mnemonic.mflo: RewriteMf(instr, arch.lo); break; case Mnemonic.mtc0: RewriteMtc0(instr); break; case Mnemonic.mthi: RewriteMt(instr, arch.hi); break; case Mnemonic.mtlo: RewriteMt(instr, arch.lo); break; case Mnemonic.movf: RewriteMovft(instr, false); break; case Mnemonic.movn: RewriteMovCc(instr, m.Ne0); break; case Mnemonic.movt: RewriteMovft(instr, true); break; case Mnemonic.movz: RewriteMovCc(instr, m.Eq0); break; case Mnemonic.mov_d: RewriteCopy(instr); break; case Mnemonic.mov_s: RewriteCopy(instr); break; case Mnemonic.msub: RewriteMac_int(instr, m.ISub); break; case Mnemonic.msub_s: RewriteMac_real(instr, PrimitiveType.Real32, m.FSub); break; case Mnemonic.mtc1: RewriteMtc1(instr); break; case Mnemonic.mul: RewriteMul(instr, m.SMul, PrimitiveType.Int32); break; case Mnemonic.mult: RewriteMul(instr, m.SMul, PrimitiveType.Int64); break; case Mnemonic.multu: RewriteMul(instr, m.UMul, PrimitiveType.UInt64); break; case Mnemonic.mul_s: RewriteMul(instr, m.FMul, PrimitiveType.Real32); break; case Mnemonic.mul_d: RewriteMulD(instr); break; case Mnemonic.nmadd_d: RewriteNmac_real(instr, PrimitiveType.Real64, m.FAdd); break; case Mnemonic.nmadd_s: RewriteNmac_real(instr, PrimitiveType.Real32, m.FAdd); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.nor: RewriteNor(instr); break; case Mnemonic.nmsub_d: RewriteNmac_real(instr, PrimitiveType.Real64, m.FSub); break; case Mnemonic.nmsub_s: RewriteNmac_real(instr, PrimitiveType.Real32, m.FSub); break; case Mnemonic.nmsub_ps: RewriteNmac_vec(instr, PrimitiveType.Real32, m.FSub); break; case Mnemonic.or: case Mnemonic.ori: RewriteOr(instr); break; case Mnemonic.pref: case Mnemonic.prefx: RewritePrefx(instr); break; case Mnemonic.sb: RewriteStore(instr); break; case Mnemonic.sc: RewriteStoreConditional32(instr); break; case Mnemonic.scd: RewriteStoreConditional64(instr); break; case Mnemonic.sd: RewriteStore(instr); break; case Mnemonic.sdc1: RewriteStore(instr); break; case Mnemonic.sdc2: RewriteSdc2(instr); break; case Mnemonic.sdl: RewriteSdl(instr); break; case Mnemonic.sdr: RewriteSdr(instr); break; case Mnemonic.seb: RewriteSignExtend(instr, PrimitiveType.Byte); break; case Mnemonic.seh: RewriteSignExtend(instr, PrimitiveType.Word16); break; case Mnemonic.seqi: RewriteScc(instr, m.Eq); break; case Mnemonic.sh: RewriteStore(instr); break; case Mnemonic.sll: case Mnemonic.sllv: RewriteSll(instr); 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.sltu: RewriteScc(instr, m.Ult); break; case Mnemonic.sra: case Mnemonic.srav: RewriteSra(instr); break; case Mnemonic.srl: case Mnemonic.srlv: RewriteSrl(instr); break; case Mnemonic.sub: case Mnemonic.subu: RewriteSub(instr, PrimitiveType.Word32); break; case Mnemonic.sub_d: RewriteFpuBinopD(instr, m.FSub); break; case Mnemonic.sw: case Mnemonic.swc1: RewriteStore(instr); break; case Mnemonic.swc2: RewriteSdc2(instr); break; case Mnemonic.swl: RewriteSwl(instr); break; case Mnemonic.swr: RewriteSwr(instr); break; case Mnemonic.swxc1: RewriteStore(instr); break; case Mnemonic.sync: RewriteSync(instr); break; case Mnemonic.syscall: RewriteSyscall(instr); break; case Mnemonic.teq: RewriteTrap(instr, m.Eq); break; case Mnemonic.teqi: RewriteTrap(instr, m.Eq); break; case Mnemonic.tge: RewriteTrap(instr, m.Ge); break; case Mnemonic.tgeu: RewriteTrap(instr, m.Uge); break; case Mnemonic.tgei: RewriteTrapi(instr, m.Ge); break; case Mnemonic.tgeiu: RewriteTrapi(instr, m.Uge); break; case Mnemonic.tlbp: RewriteTlbp(instr); break; case Mnemonic.tlbr: RewriteTlbr(instr); break; case Mnemonic.tlbwi: RewriteTlbwi(instr); break; case Mnemonic.tlbwr: RewriteTlbwr(instr); break; case Mnemonic.tlt: RewriteTrap(instr, m.Lt); break; case Mnemonic.tlti: RewriteTrapi(instr, m.Lt); break; case Mnemonic.tltiu: RewriteTrapi(instr, m.Ult); break; case Mnemonic.tltu: RewriteTrap(instr, m.Ult); break; case Mnemonic.tne: RewriteTrap(instr, m.Ne); break; case Mnemonic.tnei: RewriteTrapi(instr, m.Ne); break; case Mnemonic.trunc_l_d: RewriteTrunc(instr, "trunc", PrimitiveType.Real64, PrimitiveType.Int64); break; case Mnemonic.wait: RewriteWait(instr); break; case Mnemonic.xor: case Mnemonic.xori: RewriteXor(instr); break; // Nano instructions case Mnemonic.addiupc: RewriteAddiupc(instr); break; case Mnemonic.aluipc: RewriteAluipc(instr); break; case Mnemonic.balc: RewriteBalc(instr); break; case Mnemonic.balrsc: RewriteBalrsc(instr); break; case Mnemonic.bbeqzc: RewriteBb(instr, e => e); break; case Mnemonic.bbnezc: RewriteBb(instr, m.Not); break; case Mnemonic.bc: RewriteJump(instr); break; case Mnemonic.beqc: RewriteBranch(instr, m.Eq, false); break; case Mnemonic.beqic: RewriteBranchImm(instr, m.Eq, false); break; case Mnemonic.beqzc: RewriteBranch0(instr, m.Eq, false); break; case Mnemonic.bgec: RewriteBranch(instr, m.Ge, false); break; case Mnemonic.bgeic: RewriteBranchImm(instr, m.Ge, false); break; case Mnemonic.bgeiuc: RewriteBranchImm(instr, m.Uge, false); break; case Mnemonic.bgeuc: RewriteBranch(instr, m.Uge, false); break; case Mnemonic.bltc: RewriteBranch(instr, m.Lt, false); break; case Mnemonic.bltic: RewriteBranchImm(instr, m.Lt, false); break; case Mnemonic.bltiuc: RewriteBranchImm(instr, m.Ult, false); break; case Mnemonic.bltuc: RewriteBranch(instr, m.Ult, false); break; case Mnemonic.bnec: RewriteBranch(instr, m.Ne, false); break; case Mnemonic.bneiuc: RewriteBranchImm(instr, m.Ne, false); break; case Mnemonic.bnezc: RewriteBranch0(instr, m.Ne, false); break; case Mnemonic.cachee: RewriteCache(instr, "__cache_EVA"); break; case Mnemonic.ext: RewriteExt(instr); break; case Mnemonic.ins: RewriteIns(instr); break; case Mnemonic.jalrc: RewriteJalr(instr); break; case Mnemonic.jalrc_hb: RewriteJalr_hb(instr); break; case Mnemonic.jrc: RewriteJr(instr); break; case Mnemonic.lbue: RewriteLe(instr, PrimitiveType.Byte, "__load_ub_EVA"); break; case Mnemonic.lbux: RewriteLx(instr, PrimitiveType.Byte, 1); break; case Mnemonic.lwx: RewriteLx(instr, PrimitiveType.Word32, 1); break; case Mnemonic.lwpc: RewriteLwpc(instr); break; case Mnemonic.li: RewriteMove(instr); break; case Mnemonic.lsa: RewriteLsa(instr); break; case Mnemonic.lwm: RewriteLwm(instr); break; case Mnemonic.lwxs: RewriteLwxs(instr); break; case Mnemonic.mod: RewriteMod(instr, m.Mod); break; case Mnemonic.modu: RewriteMod(instr, m.Mod); break; //$TODO: unsigned modulus. case Mnemonic.move: RewriteMove(instr); break; case Mnemonic.move_balc: RewriteMoveBalc(instr); break; case Mnemonic.movep: RewriteMovep(instr); break; case Mnemonic.muh: RewriteMuh(instr, PrimitiveType.Int64, m.SMul); break; case Mnemonic.muhu: RewriteMuh(instr, PrimitiveType.UInt64, m.UMul); break; case Mnemonic.not: RewriteNot(instr); break; case Mnemonic.rdhwr: RewriteReadHardwareRegister(instr); break; case Mnemonic.restore: RewriteRestore(instr, false); break; case Mnemonic.restore_jrc: RewriteRestore(instr, true); break; case Mnemonic.rotr: RewriteRotr(instr); break; case Mnemonic.rotx: RewriteRotx(instr); break; case Mnemonic.save: RewriteSave(instr); break; case Mnemonic.sdbbp: RewriteSdbbp(instr); break; case Mnemonic.sigrie: RewriteSigrie(instr); break; case Mnemonic.swm: RewriteSwm(instr); break; case Mnemonic.swpc: RewriteSwpc(instr); break; case Mnemonic.sbx: RewriteSxs(instr, PrimitiveType.Byte, 1); break; case Mnemonic.shxs: RewriteSxs(instr, PrimitiveType.Word16, 2); break; case Mnemonic.swx: RewriteSxs(instr, PrimitiveType.Word32, 1); break; case Mnemonic.swxs: RewriteSxs(instr, PrimitiveType.Word32, 4); break; case Mnemonic.ualwm: RewriteLwm(instr); 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>(); rtlc = 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: rtlc = 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; // Z //case Opcode.bgu not (C or Z) //case Opcode.bleu (C or Z) //case Opcode.bcc not C //case Opcode.bcs C //case Opcode.bpos not N //case Opcode.bneg N //case Opcode.bvc not V //case Opcode.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 Opcode.fbug : on Unordered or Greater G or U //case Opcode.fbl : on Less L case Mnemonic.fbul: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.GF | FlagM.UF))); break; //case Opcode.fbul : on Unordered or Less L or U //case Opcode.fblg : on Less or Greater L or G //case Opcode.fbne : on Not Equal L or G or U //case Opcode.fbe : on Equal E 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 Opcode.fble : on Less or Equal E or L //case Opcode.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 Opcode.FBO : on Ordered E or L or G case Mnemonic.fcmpes: RewriteFcmpes(); 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.ldstub: RewriteLdstub(); break; case Mnemonic.ldub: RewriteLoad(PrimitiveType.Byte); break; case Mnemonic.lduh: RewriteLoad(PrimitiveType.Word16); break; case Mnemonic.ldfsr: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.mulscc: RewriteMulscc(); break; case Mnemonic.or: RewriteAlu(m.Or, false); break; case Mnemonic.orcc: RewriteAluCc(m.Or, false); break; case Mnemonic.restore: RewriteRestore(); break; case Mnemonic.rett: RewriteRett(); 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.smul: RewriteAlu(m.SMul, false); break; case Mnemonic.smulcc: RewriteAluCc(m.SMul, false); break; case Mnemonic.sra: RewriteAlu(m.Sar, false); break; case Mnemonic.srl: 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.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(new RtlInstructionCluster(addr, 4, rtlInstructions.ToArray()) { Class = rtlc }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; rtlc = RtlClass.Linear; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); switch (instr.Opcode) { default: EmitUnitTest(); Invalid(); break; case Opcode.invalid: rtlc = RtlClass.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, }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { di = dasm.Current; ric = new RtlInstructionCluster(di.Address, di.Length); ric.Class = RtlClass.Linear; emitter = new RtlEmitter(ric.Instructions); orw = new OperandRewriter(arch, this.emitter, this.frame, di.dataWidth); switch (di.code) { case Opcode.add: RewriteBinOp((s, d) => emitter.IAdd(d, s), FlagM.CVZNX); break; case Opcode.adda: RewriteBinOp((s, d) => emitter.IAdd(d, s)); break; case Opcode.addi: RewriteArithmetic((s, d) => emitter.IAdd(d, s)); break; case Opcode.addq: RewriteAddSubq((s, d) => emitter.IAdd(d, s)); break; case Opcode.addx: RewriteAddSubx(Operator.IAdd); break; case Opcode.and: RewriteLogical((s, d) => emitter.And(d, s)); break; case Opcode.andi: RewriteLogical((s, d) => emitter.And(d, s)); break; case Opcode.asl: RewriteArithmetic((s, d) => emitter.Shl(d, s)); break; case Opcode.asr: RewriteShift((s, d) => emitter.Sar(d, s)); break; /* * * Mnemonic Condition Encoding Test * T* True 0000 1 * F* False 0001 0 * HI High 0010 C L Z * LS Low or Same 0011 C V Z * VC Overflow Clear 1000 V * VS Overflow Set 1001 V */ case Opcode.bclr: RewriteBclrBset("__bclr"); break; case Opcode.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); 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.bchg: RewriteBchg(); break; case Opcode.bra: RewriteBra(); break; case Opcode.bset: RewriteBclrBset("__bset"); break; case Opcode.bsr: RewriteBsr(); break; case Opcode.btst: RewriteBtst(); break; case Opcode.clr: RewriteClr(); break; case Opcode.cmp: RewriteCmp(); break; case Opcode.cmpa: RewriteCmp(); break; case Opcode.cmpi: RewriteCmp(); break; case Opcode.cmpm: RewriteCmp(); break; case Opcode.dbeq: RewriteDbcc(ConditionCode.EQ, FlagM.ZF); break; case Opcode.dble: RewriteDbcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.dbhi: RewriteDbcc(ConditionCode.ULE, FlagM.CF | FlagM.ZF); break; case Opcode.dbne: RewriteDbcc(ConditionCode.NE, FlagM.ZF); break; case Opcode.dbra: RewriteDbcc(ConditionCode.None, 0); break; case Opcode.divu: RewriteDiv(Operator.UDiv); break; case Opcode.eor: RewriteLogical((s, d) => emitter.Xor(d, s)); break; case Opcode.eori: RewriteLogical((s, d) => emitter.Xor(d, s)); break; case Opcode.exg: RewriteExg(); break; case Opcode.ext: RewriteExt(); break; case Opcode.extb: RewriteExtb(); break; case Opcode.illegal: if (!RewriteIllegal()) { goto default; } break; case Opcode.jmp: RewriteJmp(); break; case Opcode.jsr: RewriteJsr(); break; case Opcode.lea: RewriteLea(); break; case Opcode.link: RewriteLink(); break; case Opcode.lsl: RewriteShift((s, d) => emitter.Shl(d, s)); break; case Opcode.lsr: RewriteShift((s, d) => emitter.Shr(d, s)); break; case Opcode.move: RewriteMove(true); break; case Opcode.movea: RewriteMove(false); break; case Opcode.moveq: RewriteMoveq(); break; case Opcode.movem: RewriteMovem(); break; case Opcode.muls: RewriteMul((s, d) => emitter.SMul(d, s)); break; case Opcode.mulu: RewriteMul((s, d) => emitter.UMul(d, s)); break; case Opcode.neg: RewriteUnary(s => emitter.Neg(s), AllConditions); break; case Opcode.negx: RewriteUnary(RewriteNegx, AllConditions); break; case Opcode.nop: emitter.Nop(); break; case Opcode.not: RewriteUnary(s => emitter.Comp(s), LogicalConditions); break; case Opcode.or: RewriteLogical((s, d) => emitter.Or(d, s)); break; case Opcode.ori: RewriteLogical((s, d) => emitter.Or(d, s)); break; case Opcode.pea: RewritePea(); break; case Opcode.rol: RewriteRotation(PseudoProcedure.Rol); break; case Opcode.ror: RewriteRotation(PseudoProcedure.Ror); break; case Opcode.roxl: RewriteRotationX(PseudoProcedure.RolC); break; case Opcode.roxr: RewriteRotationX(PseudoProcedure.RorC); break; case Opcode.rts: RewriteRts(); break; case Opcode.scc: RewriteScc(ConditionCode.UGE, FlagM.CF); break; case Opcode.scs: RewriteScc(ConditionCode.ULT, FlagM.CF); break; case Opcode.seq: RewriteScc(ConditionCode.EQ, FlagM.ZF); break; case Opcode.sge: RewriteScc(ConditionCode.GE, FlagM.NF | FlagM.VF); break; case Opcode.sgt: RewriteScc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.shi: RewriteScc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break; case Opcode.sle: RewriteScc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break; case Opcode.slt: RewriteScc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break; case Opcode.sls: RewriteScc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break; case Opcode.smi: RewriteScc(ConditionCode.LT, FlagM.NF); break; case Opcode.sne: RewriteScc(ConditionCode.NE, FlagM.ZF); break; case Opcode.spl: RewriteScc(ConditionCode.GT, FlagM.NF); break; case Opcode.st: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.True()); break; case Opcode.sf: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.False()); break; case Opcode.sub: RewriteArithmetic((s, d) => emitter.ISub(d, s)); break; case Opcode.suba: RewriteArithmetic((s, d) => emitter.ISub(d, s)); break; case Opcode.subi: RewriteArithmetic((s, d) => emitter.ISub(d, s)); break; case Opcode.subq: RewriteAddSubq((s, d) => emitter.ISub(d, s)); break; case Opcode.subx: RewriteArithmetic((s, d) => emitter.ISub(emitter.ISub(d, s), frame.EnsureFlagGroup(Registers.ccr, (uint)FlagM.XF, "X", PrimitiveType.Bool))); break; case Opcode.swap: RewriteSwap(); break; case Opcode.tst: RewriteTst(); break; case Opcode.unlk: RewriteUnlk(); break; default: throw new AddressCorrelatedException( di.Address, "Rewriting M68k opcode '{0}' is not supported yet.", di.code); } yield return(ric); } yield break; }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); this.iclass = instr.InstructionClass; switch (instr.Mnemonic) { default: EmitUnitTest(); Invalid(); host.Warn( instr.Address, string.Format( "Alpha AXP instruction '{0}' not supported yet.", instr.Mnemonic)); break; case Mnemonic.invalid: Invalid(); break; case Mnemonic.addf_c: RewriteFpuOp(m.FAdd); break; case Mnemonic.adds: RewriteFpuOp(m.FAdd); break; case Mnemonic.adds_c: RewriteFpuOp(m.FAdd); break; case Mnemonic.addl: RewriteBin(addl); break; case Mnemonic.addl_v: RewriteBinOv(addl); break; case Mnemonic.addt: RewriteFpuOp(m.FAdd); break; case Mnemonic.addq: RewriteBin(addq); break; case Mnemonic.addq_v: RewriteBinOv(addq); break; case Mnemonic.and: RewriteBin(and); break; case Mnemonic.beq: RewriteBranch(m.Eq0); break; case Mnemonic.bge: RewriteBranch(m.Ge0); break; case Mnemonic.bgt: RewriteBranch(m.Gt0); break; case Mnemonic.bic: RewriteBin(bic); break; case Mnemonic.bis: RewriteBin(bis); break; case Mnemonic.blbc: RewriteBranch(lbc); break; case Mnemonic.blbs: RewriteBranch(lbs); break; case Mnemonic.ble: RewriteBranch(m.Le0); break; case Mnemonic.blt: RewriteBranch(m.Lt0); break; case Mnemonic.bne: RewriteBranch(m.Ne0); break; case Mnemonic.br: RewriteBr(); break; case Mnemonic.bsr: RewriteBr(); break; case Mnemonic.cmovlt: RewriteCmov(m.Lt0); break; case Mnemonic.cmovne: RewriteCmov(m.Ne0); break; case Mnemonic.cmovge: RewriteCmov(m.Ge0); break; case Mnemonic.cmovlbc: RewriteCmov(lbc); break; case Mnemonic.cmovlbs: RewriteCmov(lbs); break; case Mnemonic.cmpbge: RewriteInstrinsic("__cmpbge", false); break; case Mnemonic.cmpeq: RewriteCmp(m.Eq); break; case Mnemonic.cmple: RewriteCmp(m.Le); break; case Mnemonic.cmplt: RewriteCmp(m.Lt); break; case Mnemonic.cmpteq: RewriteCmpt(m.Eq); break; case Mnemonic.cmptle: RewriteCmpt(m.Le); break; case Mnemonic.cmptlt: RewriteCmpt(m.Lt); break; case Mnemonic.cmpule: RewriteCmp(m.Ule); break; case Mnemonic.cmpult: RewriteCmp(m.Ult); break; case Mnemonic.cpys: RewriteCpys("__cpys"); break; case Mnemonic.cpyse: RewriteCpys("__cpyse"); break; case Mnemonic.cpysn: RewriteCpys("__cpysn"); break; case Mnemonic.cvtlq: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Int64); break; case Mnemonic.cvtql: RewriteCvt(PrimitiveType.Int64, PrimitiveType.Int32); break; case Mnemonic.cvtqs: RewriteCvt(PrimitiveType.Int64, PrimitiveType.Real32); break; case Mnemonic.cvtqt: RewriteCvt(PrimitiveType.Int64, PrimitiveType.Real64); break; case Mnemonic.cvttq_c: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int64); break; case Mnemonic.cvtts: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break; case Mnemonic.divs: RewriteFpuOp(m.FDiv); break; case Mnemonic.divt: RewriteFpuOp(m.FDiv); break; case Mnemonic.extbl: RewriteInstrinsic("__extbl", true); break; case Mnemonic.extlh: RewriteInstrinsic("__extlh", true); break; case Mnemonic.extll: RewriteInstrinsic("__extll", true); break; case Mnemonic.extqh: RewriteInstrinsic("__extqh", true); break; case Mnemonic.extql: RewriteInstrinsic("__extql", true); break; case Mnemonic.extwh: RewriteInstrinsic("__extwh", true); break; case Mnemonic.extwl: RewriteInstrinsic("__extwl", true); break; case Mnemonic.fbeq: RewriteFBranch(Operator.Feq); break; case Mnemonic.fbge: RewriteFBranch(Operator.Fge); break; case Mnemonic.fbgt: RewriteFBranch(Operator.Fgt); break; case Mnemonic.fble: RewriteFBranch(Operator.Fle); break; case Mnemonic.fblt: RewriteFBranch(Operator.Flt); break; case Mnemonic.fbne: RewriteFBranch(Operator.Fne); break; case Mnemonic.fcmoveq: RewriteFCmov(Operator.Feq); break; case Mnemonic.fcmovle: RewriteFCmov(Operator.Fle); break; case Mnemonic.fcmovlt: RewriteFCmov(Operator.Flt); break; case Mnemonic.fcmovne: RewriteFCmov(Operator.Fne); break; case Mnemonic.halt: RewriteHalt(); break; case Mnemonic.implver: RewriteInstrinsic("__implver", true); break; case Mnemonic.insbl: RewriteInstrinsic("__insbl", true); break; case Mnemonic.inslh: RewriteInstrinsic("__inslh", true); break; case Mnemonic.insll: RewriteInstrinsic("__insll", true); break; case Mnemonic.insqh: RewriteInstrinsic("__insqh", true); break; case Mnemonic.insql: RewriteInstrinsic("__insql", true); break; case Mnemonic.inswl: RewriteInstrinsic("__inswl", true); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.jsr: RewriteJmp(); break; case Mnemonic.jsr_coroutine: RewriteJmp(); break; case Mnemonic.lda: RewriteLda(0); break; case Mnemonic.ldah: RewriteLda(16); break; case Mnemonic.ldbu: RewriteLd(PrimitiveType.Byte, PrimitiveType.Word64); break; case Mnemonic.ldf: RewriteLd(PrimitiveType.Real32, PrimitiveType.Real64); break; case Mnemonic.ldg: RewriteLd(PrimitiveType.Real64, PrimitiveType.Real64); break; case Mnemonic.ldl: RewriteLd(PrimitiveType.Int32, PrimitiveType.Word64); break; case Mnemonic.ldl_l: RewriteLoadInstrinsic("__ldl_l", true, PrimitiveType.Word32); break; case Mnemonic.ldq_l: RewriteLoadInstrinsic("__ldq_l", true, PrimitiveType.Word64); break; case Mnemonic.ldq: RewriteLd(PrimitiveType.Word64, PrimitiveType.Word64); break; case Mnemonic.ldq_u: RewriteLd(PrimitiveType.Word64, PrimitiveType.Word64); break; case Mnemonic.lds: RewriteLd(PrimitiveType.Real32, PrimitiveType.Real64); break; case Mnemonic.ldt: RewriteLd(PrimitiveType.Real64, PrimitiveType.Real64); break; case Mnemonic.ldwu: RewriteLd(PrimitiveType.UInt16, PrimitiveType.Word64); break; case Mnemonic.mskbl: RewriteInstrinsic("__mskbl", true); break; case Mnemonic.msklh: RewriteInstrinsic("__msklh", true); break; case Mnemonic.mskll: RewriteInstrinsic("__mskll", true); break; case Mnemonic.mskqh: RewriteInstrinsic("__mskqh", true); break; case Mnemonic.mskql: RewriteInstrinsic("__mskql", true); break; case Mnemonic.mskwl: RewriteInstrinsic("__mskwl", true); break; case Mnemonic.mull: RewriteBin(mull); break; case Mnemonic.mulq: RewriteBin(mulq); break; case Mnemonic.muls: RewriteFpuOp(m.FMul); break; case Mnemonic.mult: RewriteFpuOp(m.FMul); break; case Mnemonic.mult_c: RewriteFpuOp(m.FMul); break; case Mnemonic.ornot: RewriteBin(ornot); break; case Mnemonic.ret: RewriteJmp(); break; case Mnemonic.s4addl: RewriteBin(s4addl); break; case Mnemonic.s4addq: RewriteBin(s4addq); break; case Mnemonic.s8addl: RewriteBin(s8addl); break; case Mnemonic.s8addq: RewriteBin(s8addq); break; case Mnemonic.s4subl: RewriteBin(s4subl); break; case Mnemonic.s4subq: RewriteBin(s4subq); break; case Mnemonic.s8subl: RewriteBin(s8subl); break; case Mnemonic.s8subq: RewriteBin(s8subq); break; case Mnemonic.sll: RewriteBin(sll); break; case Mnemonic.src: RewriteInstrinsic("__src", true); break; case Mnemonic.srl: RewriteBin(srl); break; case Mnemonic.stb: RewriteSt(PrimitiveType.Byte); break; case Mnemonic.stf: RewriteSt(PrimitiveType.Real64, PrimitiveType.Real32); break; case Mnemonic.stl: RewriteSt(PrimitiveType.Word32); break; case Mnemonic.stl_c: RewriteStoreInstrinsic("__stl_c", PrimitiveType.Word32); break; case Mnemonic.stq_c: RewriteStoreInstrinsic("__stq_c", PrimitiveType.Word64); break; case Mnemonic.stq_u: RewriteStoreInstrinsic("__stq_u", PrimitiveType.Word64); break; case Mnemonic.stg: RewriteSt(PrimitiveType.Real64); break; case Mnemonic.stw: RewriteSt(PrimitiveType.Word16); break; case Mnemonic.sts: RewriteSt(PrimitiveType.Real32); break; case Mnemonic.stt: RewriteSt(PrimitiveType.Real64); break; case Mnemonic.stq: RewriteSt(PrimitiveType.Word64); break; case Mnemonic.subf_s: RewriteFpuOp(m.FSub); break; case Mnemonic.subf_uc: RewriteFpuOp(m.FSub); break; case Mnemonic.subl: RewriteBin(subl); break; case Mnemonic.subl_v: RewriteBinOv(subl); break; case Mnemonic.subq: RewriteBin(subq); break; case Mnemonic.subq_v: RewriteBinOv(subq); break; case Mnemonic.subs: RewriteFpuOp(m.FSub); break; case Mnemonic.subt: RewriteFpuOp(m.FSub); break; case Mnemonic.trapb: RewriteTrapb(); break; case Mnemonic.umulh: RewriteBin(umulh); break; case Mnemonic.xor: RewriteBin(xor); break; case Mnemonic.zap: RewriteInstrinsic("__zap", true); break; case Mnemonic.zapnot: RewriteInstrinsic("__zapnot", true); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }