public InstructionDecoder(InstrClass iclass, Mnemonic mnemonic, params Mutator <M6809Disassembler> [] mutators) { this.iclass = iclass; this.mnemonic = mnemonic; this.mutators = mutators; }
private static Decoder Instr(Mnemonic opcode, InstrClass iclass, params Mutator <Avr8Disassembler>[] mutators) { return(new InstrDecoder <Avr8Disassembler, Mnemonic, AvrInstruction>(iclass, opcode, mutators)); }
private void Invalid() { rtlInstructions.Clear(); iclass = InstrClass.Invalid; m.Invalid(); }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { instrCur = dasm.Current; var addr = instrCur.Address; var rtlInstructions = new List <RtlInstruction>(); iclass = instrCur.InstructionClass; m = new RtlEmitter(rtlInstructions); switch (instrCur.Mnemonic) { default: EmitUnitTest(); host.Warn( instrCur.Address, "SPARC instruction '{0}' is not supported yet.", instrCur.Mnemonic); goto case Mnemonic.illegal; case Mnemonic.illegal: iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.add: RewriteAlu(m.IAdd, false); break; case Mnemonic.addcc: RewriteAluCc(m.IAdd, false); break; case Mnemonic.addx: RewriteAddxSubx(m.IAdd, false); break; case Mnemonic.addxcc: RewriteAddxSubx(m.IAdd, true); break; case Mnemonic.and: RewriteAlu(m.And, false); break; case Mnemonic.andcc: RewriteAluCc(m.And, false); break; case Mnemonic.andn: RewriteAlu(m.And, true); break; case Mnemonic.ba: RewriteBranch(Constant.True()); break; case Mnemonic.bn: RewriteBranch(Constant.False()); break; case Mnemonic.bne: RewriteBranch(m.Test(ConditionCode.NE, Grf(FlagM.ZF))); break; case Mnemonic.be: RewriteBranch(m.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break; case Mnemonic.bg: RewriteBranch(m.Test(ConditionCode.GT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Mnemonic.bge: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.NF | FlagM.VF))); break; case Mnemonic.bgu: RewriteBranch(m.Test(ConditionCode.UGE, Grf(FlagM.CF | FlagM.ZF))); break; case Mnemonic.bl: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Mnemonic.ble: RewriteBranch(m.Test(ConditionCode.LE, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break; case Mnemonic.bleu: RewriteBranch(m.Test(ConditionCode.ULE, Grf(FlagM.CF | FlagM.ZF))); break; case Mnemonic.bcc: RewriteBranch(m.Test(ConditionCode.UGE, Grf(FlagM.CF))); break; case Mnemonic.bcs: RewriteBranch(m.Test(ConditionCode.ULT, Grf(FlagM.CF))); break; case Mnemonic.bneg: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.NF))); break; case Mnemonic.bpos: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.NF))); break; case Mnemonic.brgz: RewriteBranchReg(m.Gt0); break; case Mnemonic.brgez: RewriteBranchReg(m.Ge0); break; case Mnemonic.brlz: RewriteBranchReg(m.Lt0); break; case Mnemonic.brlez: RewriteBranchReg(m.Le0); break; case Mnemonic.brnz: RewriteBranchReg(m.Ne0); break; case Mnemonic.brz: RewriteBranchReg(m.Eq0); break; // Z //case Mnemonic.bgu not (C or Z) //case Mnemonic.bleu (C or Z) //case Mnemonic.bcc not C //case Mnemonic.bcs C //case Mnemonic.bpos not N //case Mnemonic.bneg N //case Mnemonic.bvc not V //case Mnemonic.bvs V case Mnemonic.call: RewriteCall(); break; case Mnemonic.fabss: RewriteFabss(); break; case Mnemonic.fadds: RewriteFadds(); break; case Mnemonic.fbne: RewriteBranch(m.Test(ConditionCode.NE, Grf(FlagM.LF | FlagM.GF))); break; case Mnemonic.fba: RewriteBranch(Constant.True()); break; case Mnemonic.fbn: RewriteBranch(Constant.False()); break; case Mnemonic.fbu: RewriteBranch(m.Test(ConditionCode.NE, Grf(FlagM.UF))); break; case Mnemonic.fbg: RewriteBranch(m.Test(ConditionCode.GT, Grf(FlagM.GF))); break; case Mnemonic.fbug: RewriteBranch(m.Test(ConditionCode.GT, Grf(FlagM.GF | FlagM.UF))); break; //case Mnemonic.fbug : on Unordered or Greater G or U //case Mnemonic.fbl : on Less L case Mnemonic.fbul: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.GF | FlagM.UF))); break; //case Mnemonic.fbul : on Unordered or Less L or U //case Mnemonic.fblg : on Less or Greater L or G //case Mnemonic.fbne : on Not Equal L or G or U case Mnemonic.fbe: RewriteBranch(m.Test(ConditionCode.EQ, Grf(FlagM.EF))); break; case Mnemonic.fbue: RewriteBranch(m.Test(ConditionCode.EQ, Grf(FlagM.EF | FlagM.UF))); break; case Mnemonic.fbuge: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.EF | FlagM.GF | FlagM.UF))); break; case Mnemonic.fble: RewriteBranch(m.Test(ConditionCode.LE, Grf(FlagM.EF | FlagM.LF))); break; //case Mnemonic.fbule : on Unordered or Less or Equal E or L or U case Mnemonic.fbule: RewriteBranch(m.Test(ConditionCode.LE, Grf(FlagM.EF | FlagM.LF | FlagM.UF))); break; case Mnemonic.fbge: RewriteBranch(m.Test(ConditionCode.GE, Grf(FlagM.EF | FlagM.GF))); break; // case Mnemonic.FBO : on Ordered E or L or G case Mnemonic.fcmpes: RewriteFcmpes(); break; case Mnemonic.fcmped: RewriteFcmped(); break; case Mnemonic.fcmpd: RewriteFcmpd(); break; case Mnemonic.fcmpq: RewriteFcmpq(); break; case Mnemonic.fcmps: RewriteFcmps(); break; case Mnemonic.fdivd: RewriteFdivs(); break; case Mnemonic.fdivs: RewriteFdivd(); break; case Mnemonic.fdtos: RewriteFdtos(); break; case Mnemonic.fitod: RewriteFitod(); break; case Mnemonic.fitoq: RewriteFitoq(); break; case Mnemonic.fitos: RewriteFitos(); break; case Mnemonic.fmovs: RewriteFmovs(); break; case Mnemonic.fmuld: RewriteFmuld(); break; case Mnemonic.fmuls: RewriteFmuls(); break; case Mnemonic.fnegs: RewriteFmovs(); break; case Mnemonic.fstod: RewriteFstod(); break; case Mnemonic.fsubs: RewriteFsubs(); break; case Mnemonic.jmpl: RewriteJmpl(); break; case Mnemonic.ld: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.lddf: RewriteLoad(PrimitiveType.Real64); break; case Mnemonic.ldf: RewriteLoad(PrimitiveType.Real32); break; case Mnemonic.ldd: RewriteLoad(PrimitiveType.Word64); break; case Mnemonic.ldsb: RewriteLoad(PrimitiveType.SByte); break; case Mnemonic.ldsh: RewriteLoad(PrimitiveType.Int16); break; case Mnemonic.ldsw: RewriteLoad(PrimitiveType.Int32); break; case Mnemonic.ldstub: RewriteLdstub(); break; case Mnemonic.ldub: RewriteLoad(PrimitiveType.Byte); break; case Mnemonic.lduh: RewriteLoad(PrimitiveType.Word16); break; case Mnemonic.lduw: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.ldx: RewriteLoad(PrimitiveType.Word64); break; case Mnemonic.ldfsr: RewriteLoad(PrimitiveType.Word32); break; case Mnemonic.mulx: RewriteAlu(m.IMul, false); break; case Mnemonic.mulscc: RewriteMulscc(); break; case Mnemonic.or: RewriteAlu(m.Or, false); break; case Mnemonic.orcc: RewriteAluCc(m.Or, false); break; case Mnemonic.orn: RewriteAlu(m.Or, true); break; case Mnemonic.orncc: RewriteAlu(m.Or, true); break; case Mnemonic.restore: RewriteRestore(); break; case Mnemonic.rett: RewriteRett(); break; case Mnemonic.@return: RewriteReturn(); break; case Mnemonic.save: RewriteSave(); break; case Mnemonic.sethi: RewriteSethi(); break; case Mnemonic.sdiv: RewriteAlu(m.SDiv, false); break; case Mnemonic.sdivcc: RewriteAlu(m.SDiv, false); break; case Mnemonic.sll: RewriteAlu(m.Shl, false); break; case Mnemonic.sllx: RewriteAlu(m.Shl, false); break; case Mnemonic.smul: RewriteAlu(m.SMul, false); break; case Mnemonic.smulcc: RewriteAluCc(m.SMul, false); break; case Mnemonic.sra: RewriteAlu(m.Sar, false); break; case Mnemonic.srax: RewriteAlu(m.Sar, false); break; case Mnemonic.srl: RewriteAlu(m.Shr, false); break; case Mnemonic.srlx: RewriteAlu(m.Shr, false); break; case Mnemonic.st: RewriteStore(PrimitiveType.Word32); break; case Mnemonic.stb: RewriteStore(PrimitiveType.Byte); break; case Mnemonic.std: RewriteStore(PrimitiveType.Word64); break; case Mnemonic.stdf: RewriteStore(PrimitiveType.Real64); break; case Mnemonic.stf: RewriteStore(PrimitiveType.Real32); break; case Mnemonic.sth: RewriteStore(PrimitiveType.Word16); break; case Mnemonic.stw: RewriteStore(PrimitiveType.Word32); break; case Mnemonic.stx: RewriteStore(PrimitiveType.Word64); break; case Mnemonic.stfsr: RewriteStore(PrimitiveType.Word32); break; case Mnemonic.sub: RewriteAlu(m.ISub, false); break; case Mnemonic.subcc: RewriteAluCc(m.ISub, false); break; case Mnemonic.subx: RewriteAddxSubx(m.ISub, false); break; case Mnemonic.subxcc: RewriteAddxSubx(m.ISub, true); break; case Mnemonic.ta: RewriteTrap(Constant.True()); break; case Mnemonic.tn: RewriteTrap(Constant.False()); break; case Mnemonic.tne: RewriteTrap(m.Test(ConditionCode.NE, Grf(FlagM.ZF))); break; case Mnemonic.te: RewriteTrap(m.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break; case Mnemonic.udiv: RewriteAlu(m.UDiv, false); break; case Mnemonic.udivcc: RewriteAluCc(m.UDiv, false); break; case Mnemonic.umul: RewriteAlu(m.UMul, false); break; case Mnemonic.umulcc: RewriteAluCc(m.UMul, false); break; case Mnemonic.unimp: m.Invalid(); break; case Mnemonic.xor: RewriteAlu(m.Xor, false); break; case Mnemonic.xorcc: RewriteAlu(m.Xor, true); break; case Mnemonic.xnor: RewriteAlu(XNor, false); break; case Mnemonic.xnorcc: RewriteAlu(XNor, true); break; } yield return(m.MakeCluster(addr, 4, iclass)); } }
public 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); 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.lhu: RewriteLoad(instr, PrimitiveType.UInt16); 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.sh: RewriteStore(instr); break; case Mnemonic.sll: case Mnemonic.sllv: RewriteSll(instr); break; case Mnemonic.slt: RewriteSxx(instr, m.Lt); break; case Mnemonic.slti: RewriteSxx(instr, m.Lt); break; case Mnemonic.sltiu: RewriteSxx(instr, m.Ult); break; case Mnemonic.sltu: RewriteSxx(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; case Mnemonic.rdhwr: RewriteReadHardwareRegister(instr); break; // Nano instructions case Mnemonic.addiupc: RewriteAddiupc(instr); break; case Mnemonic.aluipc: RewriteAluipc(instr); break; case Mnemonic.balc: RewriteJump(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.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.ext: RewriteExt(instr); break; case Mnemonic.ins: RewriteIns(instr); break; case Mnemonic.jalrc: RewriteJalr(instr); break; case Mnemonic.jrc: RewriteJr(instr); break; case Mnemonic.lbux: RewriteLx(instr, PrimitiveType.Byte); break; case Mnemonic.lwx: RewriteLx(instr, PrimitiveType.Word32); 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.move: RewriteMove(instr); break; case Mnemonic.move_balc: RewriteMoveBalc(instr); break; case Mnemonic.movep: RewriteMovep(instr); break; case Mnemonic.not: RewriteNot(instr); break; case Mnemonic.restore: RewriteRestore(instr, false); break; case Mnemonic.restore_jrc: RewriteRestore(instr, true); break; case Mnemonic.save: RewriteSave(instr); break; case Mnemonic.sigrie: RewriteSigrie(instr); break; case Mnemonic.swxs: RewriteSwxs(instr); break; case Mnemonic.ualwm: RewriteLwm(instr); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
private void RewriteReturn() { iclass = InstrClass.Transfer; m.Return(2, 0); }
public readonly Mutator <X86Disassembler>[] mutators; // mutators for decoding operands to this instruction public InstructionDecoder(Mnemonic mnemonic, InstrClass icl, params Mutator <X86Disassembler> [] mutators) { this.iclass = icl; this.mnemonic = mnemonic; this.mutators = mutators; }
private void RewriteRet() { rtlc = InstrClass.Transfer; m.Return(2, 0); }
public void Rewrite(AvrInstruction instr) { this.instr = instr; this.rtlInstructions = new List <RtlInstruction>(); this.rtlc = instr.iclass; 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()) { this.instr = dasm.Current; this.rtlc = InstrClass.Linear; var rtls = new List <RtlInstruction>(); this.m = new RtlEmitter(rtls); switch (instr.Mnemonic) { default: host.Error(instr.Address, "Rewriting x86 opcode '{0}' is not supported yet.", instr); rtlc = InstrClass.Invalid; break; case Mnemonic.adc: RewriteAdcSbb(m.IAdd); break; case Mnemonic.add: RewriteArithmetic(m.IAdd); break; case Mnemonic.and: RewriteLogical(m.And); break; case Mnemonic.andp: RewriteLogical(m.And); break; case Mnemonic.btjo: RewriteBtj(a => a); break; case Mnemonic.btjop: RewriteBtj(a => a); break; case Mnemonic.btjz: RewriteBtj(m.Comp); break; case Mnemonic.btjzp: RewriteBtj(m.Comp); break; case Mnemonic.br: RewriteBr(); break; case Mnemonic.call: RewriteCall(); break; case Mnemonic.clr: RewriteClr(); break; case Mnemonic.tsta: RewriteTst(arch.a); break; case Mnemonic.dac: RewriteDacDsb("__dac"); break; case Mnemonic.dec: RewriteIncDec(m.ISub); break; case Mnemonic.decd: RewriteIncdDecd(m.ISub); break; case Mnemonic.dint: RewriteDint(); break; case Mnemonic.djnz: RewriteDjnz(); break; case Mnemonic.dsb: RewriteDacDsb("__dsb"); break; case Mnemonic.eint: RewriteEint(); break; case Mnemonic.idle: RewriteIdle(); break; case Mnemonic.inc: RewriteIncDec(m.IAdd); break; case Mnemonic.inv: RewriteInv(); break; case Mnemonic.jmp: RewriteJmp(); break; case Mnemonic.jeq: RewriteJcc(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.jge: RewriteJcc(ConditionCode.GE, FlagM.NZ); break; case Mnemonic.jgt: RewriteJcc(ConditionCode.GT, FlagM.NZ); break; case Mnemonic.jhs: RewriteJcc(ConditionCode.UGE, FlagM.CF); break; case Mnemonic.jl: RewriteJcc(ConditionCode.ULT, FlagM.CF); break; case Mnemonic.jne: RewriteJcc(ConditionCode.EQ, FlagM.ZF); break; case Mnemonic.lda: RewriteLda(); break; case Mnemonic.ldsp: RewriteLdsp(); break; case Mnemonic.mov: RewriteMov(); break; case Mnemonic.movd: RewriteMovd(); break; case Mnemonic.movp: RewriteMov(); break; case Mnemonic.mpy: RewriteMpy(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.or: RewriteLogical(m.Or); break; case Mnemonic.orp: RewriteLogical(m.Or); break; case Mnemonic.pop: RewritePop(); break; case Mnemonic.push: RewritePush(); break; case Mnemonic.reti: RewriteReti(); break; case Mnemonic.rets: RewriteRets(); break; case Mnemonic.rl: RewriteRotate(PseudoProcedure.Rol); break; case Mnemonic.rlc: RewriteRotateC(PseudoProcedure.RolC); break; case Mnemonic.rr: RewriteRotate(PseudoProcedure.Ror); break; case Mnemonic.rrc: RewriteRotateC(PseudoProcedure.RorC); break; case Mnemonic.sbb: RewriteAdcSbb(m.ISub); break; case Mnemonic.setc: RewriteSetc(); break; case Mnemonic.sta: RewriteSta(); break; case Mnemonic.stsp: RewriteStsp(); break; case Mnemonic.sub: RewriteArithmetic(m.ISub); break; case Mnemonic.trap_0: RewriteTrap(0); break; case Mnemonic.trap_1: RewriteTrap(1); break; case Mnemonic.trap_2: RewriteTrap(2); break; case Mnemonic.trap_3: RewriteTrap(3); break; case Mnemonic.trap_4: RewriteTrap(4); break; case Mnemonic.trap_5: RewriteTrap(5); break; case Mnemonic.trap_6: RewriteTrap(6); break; case Mnemonic.trap_7: RewriteTrap(7); break; case Mnemonic.trap_8: RewriteTrap(8); break; case Mnemonic.trap_9: RewriteTrap(9); break; case Mnemonic.trap_10: RewriteTrap(10); break; case Mnemonic.trap_11: RewriteTrap(11); break; case Mnemonic.trap_12: RewriteTrap(12); break; case Mnemonic.trap_13: RewriteTrap(13); break; case Mnemonic.trap_14: RewriteTrap(14); break; case Mnemonic.trap_15: RewriteTrap(15); break; case Mnemonic.trap_16: RewriteTrap(16); break; case Mnemonic.trap_17: RewriteTrap(17); break; case Mnemonic.trap_18: RewriteTrap(18); break; case Mnemonic.trap_19: RewriteTrap(19); break; case Mnemonic.trap_20: RewriteTrap(20); break; case Mnemonic.trap_21: RewriteTrap(21); break; case Mnemonic.trap_22: RewriteTrap(22); break; case Mnemonic.trap_23: RewriteTrap(23); break; case Mnemonic.tstb: RewriteTst(arch.b); break; case Mnemonic.xchb: RewriteXchb(); break; case Mnemonic.xor: RewriteLogical(m.Xor); break; case Mnemonic.xorp: RewriteLogical(m.Xor); break; } yield return(new RtlInstructionCluster(instr.Address, instr.Length, rtls.ToArray()) { Class = rtlc, }); } }
private void RewriteCall() { rtlc = InstrClass.Transfer | InstrClass.Call; m.Call(RewriteOp(0), 2); //$TODO: 3-byte mode in architecture. }
private void RewriteJmp() { rtlc = InstrClass.Transfer; m.Goto(Operand(instr.Operands[0])); }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { var addr = dasm.Current.Address; var len = dasm.Current.Length; var rtlInstructions = new List <RtlInstruction>(); rtlc = InstrClass.Linear; m = new RtlEmitter(rtlInstructions); this.instr = dasm.Current; switch (instr.Opcode) { default: throw new AddressCorrelatedException( instr.Address, "Rewriting of Xtensa instruction '{0}' not implemented yet.", instr.Opcode); case Opcodes.abs: RewritePseudoFn("abs"); break; case Opcodes.add: case Opcodes.add_n: RewriteBinOp(m.IAdd); break; case Opcodes.add_s: RewriteBinOp(m.FAdd); break; case Opcodes.addi: RewriteAddi(); break; case Opcodes.addi_n: RewriteAddi(); break; case Opcodes.addmi: RewriteBinOp(m.IAdd); break; case Opcodes.addx2: RewriteAddx(2); break; case Opcodes.addx4: RewriteAddx(4); break; case Opcodes.addx8: RewriteAddx(8); break; case Opcodes.and: RewriteBinOp(m.And); break; case Opcodes.andb: RewriteBinOp(m.And); break; case Opcodes.andbc: RewriteBinOp((a, b) => m.And(a, m.Not(b))); break; case Opcodes.ball: RewriteBall(); break; case Opcodes.bany: RewriteBany(); break; case Opcodes.bbc: case Opcodes.bbci: RewriteBbx(m.Eq0); break; case Opcodes.bbs: case Opcodes.bbsi: RewriteBbx(m.Ne0); break; case Opcodes.beq: case Opcodes.beqi: RewriteBranch(m.Eq); break; case Opcodes.beqz: case Opcodes.beqz_n: RewriteBranchZ(m.Eq0); break; case Opcodes.bge: case Opcodes.bgei: RewriteBranch(m.Ge); break; case Opcodes.bgeu: case Opcodes.bgeui: RewriteBranch(m.Uge); break; case Opcodes.bgez: RewriteBranchZ(m.Ge0); break; case Opcodes.blt: RewriteBranch(m.Lt); break; case Opcodes.blti: RewriteBranch(m.Lt); break; case Opcodes.bltu: case Opcodes.bltui: RewriteBranch(m.Ult); break; case Opcodes.bltz: RewriteBranchZ(m.Lt0); break; case Opcodes.bnall: RewriteBnall(); break; case Opcodes.bne: RewriteBranch(m.Ne); break; case Opcodes.bnei: RewriteBranch(m.Ne); break; case Opcodes.bnez: case Opcodes.bnez_n: RewriteBranchZ(m.Ne0); break; case Opcodes.bnone: RewriteBnone(); break; case Opcodes.@break: RewriteBreak(); break; case Opcodes.call0: case Opcodes.callx0: RewriteCall0(); break; case Opcodes.extui: RewriteExtui(); break; case Opcodes.floor_s: RewritePseudoFn("__floor"); break; case Opcodes.isync: RewritePseudoProc("__isync"); break; case Opcodes.j: case Opcodes.jx: RewriteJ(); break; case Opcodes.ill: RewriteIll(); break; case Opcodes.l16si: RewriteLsi(PrimitiveType.Int16); break; case Opcodes.l16ui: RewriteLui(PrimitiveType.UInt16); break; case Opcodes.l32i: RewriteL32i(); break; case Opcodes.l32e: RewriteL32e(); break; case Opcodes.l32i_n: RewriteL32i(); break; case Opcodes.l32r: RewriteCopy(); break; case Opcodes.l8ui: RewriteLui(PrimitiveType.Byte); break; case Opcodes.ldpte: RewritePseudoProc("__ldpte"); break; case Opcodes.lsiu: RewriteLsiu(); break; case Opcodes.memw: RewriteNop(); break; /// memory sync barriers? case Opcodes.mov_n: RewriteCopy(); break; case Opcodes.movi: RewriteCopy(); break; case Opcodes.movi_n: RewriteMovi_n(); break; case Opcodes.moveqz: case Opcodes.moveqz_s: RewriteMovcc(m.Eq); break; case Opcodes.movltz: RewriteMovcc(m.Lt); break; case Opcodes.movgez: RewriteMovcc(m.Ge); break; case Opcodes.movnez: RewriteMovcc(m.Ne); break; case Opcodes.mul_s: RewriteBinOp(m.FMul); break; case Opcodes.mul16s: RewriteMul16(m.SMul, Domain.SignedInt); break; case Opcodes.mul16u: RewriteMul16(m.UMul, Domain.UnsignedInt); break; case Opcodes.mull: RewriteBinOp(m.IMul); break; case Opcodes.neg: RewriteUnaryOp(m.Neg); break; case Opcodes.nsa: RewritePseudoFn("__nsa"); break; case Opcodes.nsau: RewritePseudoFn("__nsau"); break; case Opcodes.or: RewriteOr(); break; case Opcodes.orbc: RewriteBinOp((a, b) => m.Or(a, m.Not(b))); break; case Opcodes.quos: RewriteBinOp(m.SDiv); break; case Opcodes.quou: RewriteBinOp(m.UDiv); break; case Opcodes.rems: RewriteBinOp(m.Mod); break; case Opcodes.remu: RewriteBinOp(m.Mod); break; case Opcodes.reserved: RewriteReserved(); break; case Opcodes.ret: case Opcodes.ret_n: RewriteRet(); break; case Opcodes.rfe: RewriteRet(); break; //$REVIEW: emit some hint this is a return from exception? case Opcodes.rfi: RewriteRet(); break; //$REVIEW: emit some hint this is a return from interrupt? case Opcodes.rsil: RewritePseudoFn("__rsil"); break; case Opcodes.rsr: RewriteCopy(); break; case Opcodes.s16i: RewriteSi(PrimitiveType.Word16); break; case Opcodes.s32e: RewriteS32e(); break; case Opcodes.s32i: case Opcodes.s32i_n: RewriteSi(PrimitiveType.Word32); break; case Opcodes.s32ri: RewriteSi(PrimitiveType.Word32); break; //$REVIEW: what about concurrency semantics case Opcodes.s8i: RewriteSi(PrimitiveType.Byte); break; case Opcodes.sll: RewriteShift(m.Shl); break; case Opcodes.slli: RewriteShiftI(m.Shl); break; case Opcodes.sra: RewriteShift(m.Sar); break; case Opcodes.srai: RewriteShiftI(m.Sar); break; case Opcodes.src: RewriteSrc(); break; case Opcodes.srl: RewriteShift(m.Sar); break; case Opcodes.srli: RewriteShiftI(m.Shr); break; case Opcodes.ssa8l: RewriteSsa8l(); break; case Opcodes.ssi: RewriteSi(PrimitiveType.Real32); break; case Opcodes.ssl: RewriteSsl(); break; case Opcodes.ssr: case Opcodes.ssai: RewriteSsa(); break; case Opcodes.sub: RewriteBinOp(m.ISub); break; case Opcodes.sub_s: RewriteBinOp(m.FSub); break; case Opcodes.subx2: RewriteSubx(2); break; case Opcodes.subx4: RewriteSubx(4); break; case Opcodes.subx8: RewriteSubx(8); break; case Opcodes.ueq_s: RewriteBinOp(m.Eq); break; case Opcodes.wsr: RewriteWsr(); break; case Opcodes.xor: RewriteBinOp(m.Xor); break; } yield return(new RtlInstructionCluster(addr, len, rtlInstructions.ToArray()) { Class = rtlc, }); } }
private static Decoder Instr(Mnemonic mnemonic, InstrClass iclass, params Mutator <M6809Disassembler>[] mutators) { return(new InstructionDecoder(iclass, mnemonic, mutators)); }
private void MaybeAnnulNextInstruction(InstrClass iclass, Expression e) { var addrNext = instr.Address + 8; MaybeConditionalJump(InstrClass.ConditionalTransfer, addrNext, false, e); }
private void Invalid() { iclass = InstrClass.Invalid; m.Invalid(); }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; this.iclass = instr.InstructionClass; var instrs = new List <RtlInstruction>(); m = new RtlEmitter(instrs); switch (instr.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.invalid; case Mnemonic.invalid: m.Invalid(); break; case Mnemonic.add: RewriteAdd(true); break; case Mnemonic.add_c: RewriteAdd_c(); break; case Mnemonic.add_l: RewriteAdd(false); break; case Mnemonic.addb: RewriteAddb(); break; case Mnemonic.addi: RewriteAddi(false); break; case Mnemonic.addi_tc: RewriteAddi(true); break; case Mnemonic.addib: RewriteAddb(); break; case Mnemonic.addil: RewriteAddi(false); break; case Mnemonic.and: RewriteLogical(m.And); break; case Mnemonic.andcm: RewriteLogical((a, b) => m.And(a, m.Comp(b))); break; case Mnemonic.b_l: RewriteBranch(); break; case Mnemonic.be: RewriteBe(); break; case Mnemonic.be_l: RewriteBe(); break; case Mnemonic.bv: RewriteBv(); break; case Mnemonic.cmpb: RewriteCmpb(0, 1); break; case Mnemonic.cmpib: RewriteCmpb(1, 0); break; case Mnemonic.@break: RewriteBreak(); break; case Mnemonic.depwi: RewriteDepwi(); break; case Mnemonic.diag: RewriteDiag(); break; case Mnemonic.extrw: RewriteExtrw(); break; case Mnemonic.fadd: RewriteFpArithmetic(m.FAdd); break; case Mnemonic.fcpy: RewriteFcpy(); break; case Mnemonic.fid: RewriteFid(); break; case Mnemonic.fldd: RewriteFld(PrimitiveType.Real64); break; case Mnemonic.fldw: RewriteFld(PrimitiveType.Real32); break; case Mnemonic.fmpy: RewriteFpArithmetic(m.FMul); break; case Mnemonic.fstd: RewriteFst(PrimitiveType.Real64); break; case Mnemonic.fstw: RewriteFst(PrimitiveType.Real32); break; case Mnemonic.fsub: RewriteFpArithmetic(m.FSub); break; case Mnemonic.ldb: RewriteLd(PrimitiveType.Byte); break; case Mnemonic.ldd: RewriteLd(PrimitiveType.Word64); break; case Mnemonic.ldh: RewriteLd(PrimitiveType.Word16); break; case Mnemonic.ldil: RewriteLdil(); break; case Mnemonic.ldo: RewriteLdo(); break; case Mnemonic.ldsid: RewriteLdsid(); break; case Mnemonic.ldw: RewriteLd(PrimitiveType.Word32); break; case Mnemonic.ldwa: RewriteLd(PrimitiveType.Word32); break; case Mnemonic.mfctl: RewriteMfctl(); break; case Mnemonic.mfctl_w: RewriteMfctl(); break; case Mnemonic.mtctl: RewriteMtctl(); break; case Mnemonic.mtsm: RewriteMtsm(); break; case Mnemonic.mtsp: RewriteMtsp(); break; case Mnemonic.or: RewriteOr(); break; case Mnemonic.rfi: RewriteRfi("__rfi"); break; case Mnemonic.rfi_r: RewriteRfi("__rfi_r"); break; case Mnemonic.shladd: RewriteShladd(); break; case Mnemonic.shrpd: RewriteShrp(PrimitiveType.Word64, PrimitiveType.Word128); break; case Mnemonic.shrpw: RewriteShrp(PrimitiveType.Word32, PrimitiveType.Word64); break; case Mnemonic.stb: RewriteSt(PrimitiveType.Byte); break; case Mnemonic.std: RewriteSt(PrimitiveType.Word64); break; case Mnemonic.stda: RewriteSt(PrimitiveType.Word64); break; case Mnemonic.sth: RewriteSt(PrimitiveType.Word16); break; case Mnemonic.stw: RewriteSt(PrimitiveType.Word32); break; case Mnemonic.sub: RewriteSub(); break; case Mnemonic.subi: RewriteSubi(); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { 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(new RtlInstructionCluster(instr.Address, instr.Length, instrs.ToArray()) { Class = iclass }); } }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instr = dasm.Current; var rtls = new List <RtlInstruction>(); m = new RtlEmitter(rtls); this.iclass = instr.InstructionClass; switch (instr.Mnemonic) { default: host.Error(instr.Address, $"WE32100 instruction '{instr}' is not supported yet."); EmitUnitTest(); goto case Mnemonic.invalid; case Mnemonic.invalid: m.Invalid(); iclass = InstrClass.Invalid; break; case Mnemonic.addb2: RewriteArithmetic2(m.IAdd, PrimitiveType.Byte); break; case Mnemonic.addh2: RewriteArithmetic2(m.IAdd, PrimitiveType.Word16); break; case Mnemonic.addw2: RewriteArithmetic2(m.IAdd, PrimitiveType.Word32); break; case Mnemonic.addb3: RewriteArithmetic3(m.IAdd, PrimitiveType.Byte); break; case Mnemonic.addh3: RewriteArithmetic3(m.IAdd, PrimitiveType.Word16); break; case Mnemonic.addw3: RewriteArithmetic3(m.IAdd, PrimitiveType.Word32); break; case Mnemonic.andb2: RewriteLogical2(m.And, PrimitiveType.Byte); break; case Mnemonic.andh2: RewriteLogical2(m.And, PrimitiveType.Word16); break; case Mnemonic.andw2: RewriteLogical2(m.And, PrimitiveType.Word32); break; case Mnemonic.andb3: RewriteLogical3(m.And, PrimitiveType.Byte); break; case Mnemonic.andh3: RewriteLogical3(m.And, PrimitiveType.Word16); break; case Mnemonic.andw3: RewriteLogical3(m.And, PrimitiveType.Word32); break; case Mnemonic.dech: RewriteUnary(e => m.ISub(e, 1), PrimitiveType.Word16, NZVC); break; case Mnemonic.movb: RewriteMov(PrimitiveType.Byte); break; case Mnemonic.subb2: RewriteArithmetic2(m.ISub, PrimitiveType.Byte); break; case Mnemonic.subh2: RewriteArithmetic2(m.ISub, PrimitiveType.Word16); break; case Mnemonic.subw2: RewriteArithmetic2(m.ISub, PrimitiveType.Word32); break; case Mnemonic.xorb2: RewriteLogical2(m.Xor, PrimitiveType.Byte); break; case Mnemonic.xorh2: RewriteLogical2(m.Xor, PrimitiveType.Word16); break; case Mnemonic.xorw2: RewriteLogical2(m.Xor, PrimitiveType.Word32); break; } yield return(m.MakeCluster(instr.Address, instr.Length, iclass)); } }
public InstrDecoder(Mnemonic opcode, InstrClass iclass, params Mutator <i8051Disassembler>[] mutators) { this.opcode = opcode; this.iclass = iclass; this.mutators = mutators; }
public IEnumerator <RtlInstructionCluster> GetEnumerator() { while (dasm.MoveNext()) { this.instrCur = dasm.Current; this.iclass = instrCur.InstructionClass; var instrs = new List <RtlInstruction>(); this.m = new RtlEmitter(instrs); switch (instrCur.Mnemonic) { default: EmitUnitTest(); goto case Mnemonic.Invalid; case Mnemonic.Invalid: this.iclass = InstrClass.Invalid; m.Invalid(); break; case Mnemonic.add: RewriteAdd(true); break; case Mnemonic.addc: RewriteAddc(true); break; case Mnemonic.addk: RewriteAdd(false); break; case Mnemonic.addi: RewriteAddi(true); break; case Mnemonic.addik: RewriteAddi(false); break; case Mnemonic.and: RewriteLogical(m.And); break; case Mnemonic.andi: RewriteLogicalImm(m.And); break; case Mnemonic.beqi: RewriteBranch(ConditionCode.EQ); break; case Mnemonic.beqid: RewriteBranch(ConditionCode.EQ); break; case Mnemonic.bgei: RewriteBranch(ConditionCode.GE); break; case Mnemonic.bgeid: RewriteBranch(ConditionCode.GE); break; case Mnemonic.bgti: RewriteBranch(ConditionCode.GT); break; case Mnemonic.bgtid: RewriteBranch(ConditionCode.GT); break; case Mnemonic.blei: RewriteBranch(ConditionCode.LE); break; case Mnemonic.bleid: RewriteBranch(ConditionCode.LE); break; case Mnemonic.blti: RewriteBranch(ConditionCode.LT); break; case Mnemonic.bltid: RewriteBranch(ConditionCode.LT); break; case Mnemonic.bnei: RewriteBranch(ConditionCode.NE); break; case Mnemonic.bneid: RewriteBranch(ConditionCode.NE); break; case Mnemonic.br: RewriteJump(false, false); break; case Mnemonic.bra: RewriteJump(false, true); break; case Mnemonic.brad: RewriteJump(false, true); break; case Mnemonic.brai: RewriteJumpAddr(false); break; case Mnemonic.brald: RewriteJump(true, false); break; case Mnemonic.bri: RewriteJumpAddr(false); break; case Mnemonic.brid: RewriteJumpAddr(false); break; case Mnemonic.brlid: RewriteJumpAddr(true); break; case Mnemonic.cmp: RewriteCmp(m.ISub); break; case Mnemonic.cmpu: RewriteCmp(m.USub); break; case Mnemonic.imm: CaptureImmState(); continue; // <- don't emit code! case Mnemonic.lbu: RewriteLoadIdx(PrimitiveType.Byte); break; case Mnemonic.lbui: RewriteLoadOffset(PrimitiveType.Byte); break; case Mnemonic.lhu: RewriteLoadIdx(PrimitiveType.Word16); break; case Mnemonic.lhui: RewriteLoadOffset(PrimitiveType.Word16); break; case Mnemonic.lw: RewriteLoadIdx(PrimitiveType.Word32); break; case Mnemonic.lwi: RewriteLoadOffset(PrimitiveType.Word32); break; case Mnemonic.mul: RewriteMul(); break; case Mnemonic.nop: m.Nop(); break; case Mnemonic.or: RewriteOr(); break; case Mnemonic.ori: RewriteOri(); break; case Mnemonic.rsub: RewriteRsub(true); break; case Mnemonic.rsubi: RewriteRsubi(true); break; case Mnemonic.rsubk: RewriteRsub(false); break; case Mnemonic.rsubik: RewriteRsubi(false); break; case Mnemonic.rtsd: RewriteRtsd(); break; case Mnemonic.sb: RewriteStoreIdx(PrimitiveType.Byte); break; case Mnemonic.sbi: RewriteStoreOffset(PrimitiveType.Byte); break; case Mnemonic.sext8: RewriteSext(PrimitiveType.SByte); break; case Mnemonic.sext16: RewriteSext(PrimitiveType.Int16); break; case Mnemonic.sh: RewriteStoreIdx(PrimitiveType.Word16); break; case Mnemonic.shi: RewriteStoreOffset(PrimitiveType.Word16); break; case Mnemonic.sra: RewriteShift1(m.Sar); break; case Mnemonic.src: RewriteShift1(RorC); break; case Mnemonic.srl: RewriteShift1(m.Shr); break; case Mnemonic.sw: RewriteStoreIdx(PrimitiveType.Word32); break; case Mnemonic.swi: RewriteStoreOffset(PrimitiveType.Word32); break; case Mnemonic.xor: RewriteLogical(m.Xor); break; case Mnemonic.xori: RewriteLogicalImm(m.Xor); break; } var addr = addrInstr ?? instrCur.Address; var length = (int)(rdr.Address - addr); this.addrInstr = null; yield return(m.MakeCluster(addr, length, iclass)); this.immHiBits = 0; addrInstr = null; } }
private static InstrDecoder Instr(Mnemonic opcode, InstrClass iclass, params Mutator <i8051Disassembler>[] mutators) { return(new InstrDecoder(opcode, iclass, mutators)); }
private static Decoder Instr(InstrClass iclass, Mnemonic mnemonic, params Mutator <Disassembler>[] mutators) { return(new InstrDecoder <Disassembler, Mnemonic, Instruction>(iclass, mnemonic, mutators)); }
public RtlGoto(Expression target, InstrClass rtlClass) : base(target, rtlClass) { }
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() { while (dasm.MoveNext()) { this.instr = dasm.Current; var rtlInstrs = new List <RtlInstruction>(); this.m = new RtlEmitter(rtlInstrs); this.rtlc = instr.InstructionClass; switch (instr.Mnemonic) { case Mnemonic.mov: case Mnemonic.rev: case Mnemonic.revw: case Mnemonic.tbl: host.Warn( instr.Address, "M6812 instruction '{0}' is not supported yet.", instr.Mnemonic); goto case Mnemonic.invalid; case Mnemonic.invalid: this.rtlc = 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(new RtlInstructionCluster( instr.Address, instr.Length, rtlInstrs.ToArray()) { Class = 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(IntrinsicProcedure.RolC, 0x8000); break; case Mnemonic.rolb: RewriteRotate(IntrinsicProcedure.RolC, 0x80); break; case Mnemonic.ror: RewriteRotate(IntrinsicProcedure.RorC, 0x1); break; case Mnemonic.rorb: RewriteRotate(IntrinsicProcedure.RorC, 0x1); 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 static Decoder Instr(Mnemonic mnemonic, InstrClass iclass, params Mutator <VaxDisassembler>[] mutators) { return(new InstrDecoder <VaxDisassembler, Mnemonic, VaxInstruction>(iclass, mnemonic, mutators)); }
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_msync: RewriteMsync(); 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(m.MakeCluster(instrCur.Address, instrCur.Length, iclass)); } }
protected static Decoder <TDasm, TMnemonic, TInstr> Instr <TDasm>(TMnemonic mnemonic, InstrClass iclass, params Mutator <TDasm>[] mutators) where TDasm : DisassemblerBase <TInstr, TMnemonic> { return(new InstrDecoder <TDasm, TMnemonic, TInstr>(iclass, mnemonic, mutators)); }