Пример #1
0
 public InstructionDecoder(InstrClass iclass, Mnemonic mnemonic, params Mutator <M6809Disassembler> [] mutators)
 {
     this.iclass   = iclass;
     this.mnemonic = mnemonic;
     this.mutators = mutators;
 }
Пример #2
0
 private static Decoder Instr(Mnemonic opcode, InstrClass iclass, params Mutator <Avr8Disassembler>[] mutators)
 {
     return(new InstrDecoder <Avr8Disassembler, Mnemonic, AvrInstruction>(iclass, opcode, mutators));
 }
Пример #3
0
 private void Invalid()
 {
     rtlInstructions.Clear();
     iclass = InstrClass.Invalid;
     m.Invalid();
 }
Пример #4
0
        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));
            }
        }
Пример #5
0
        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));
            }
        }
Пример #6
0
 private void RewriteReturn()
 {
     iclass = InstrClass.Transfer;
     m.Return(2, 0);
 }
Пример #7
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;
            }
Пример #8
0
 private void RewriteRet()
 {
     rtlc = InstrClass.Transfer;
     m.Return(2, 0);
 }
Пример #9
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
            });
        }
Пример #10
0
        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,
                });
            }
        }
Пример #11
0
 private void RewriteCall()
 {
     rtlc = InstrClass.Transfer | InstrClass.Call;
     m.Call(RewriteOp(0), 2);    //$TODO: 3-byte mode in architecture.
 }
Пример #12
0
 private void RewriteJmp()
 {
     rtlc = InstrClass.Transfer;
     m.Goto(Operand(instr.Operands[0]));
 }
Пример #13
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,
                });
            }
        }
Пример #14
0
 private static Decoder Instr(Mnemonic mnemonic, InstrClass iclass, params Mutator <M6809Disassembler>[] mutators)
 {
     return(new InstructionDecoder(iclass, mnemonic, mutators));
 }
Пример #15
0
        private void MaybeAnnulNextInstruction(InstrClass iclass, Expression e)
        {
            var addrNext = instr.Address + 8;

            MaybeConditionalJump(InstrClass.ConditionalTransfer, addrNext, false, e);
        }
Пример #16
0
 private void Invalid()
 {
     iclass = InstrClass.Invalid;
     m.Invalid();
 }
Пример #17
0
        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));
            }
        }
Пример #18
0
        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
                });
            }
        }
Пример #19
0
        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));
            }
        }
Пример #20
0
 public InstrDecoder(Mnemonic opcode, InstrClass iclass, params Mutator <i8051Disassembler>[] mutators)
 {
     this.opcode   = opcode;
     this.iclass   = iclass;
     this.mutators = mutators;
 }
Пример #21
0
        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;
            }
        }
Пример #22
0
 private static InstrDecoder Instr(Mnemonic opcode, InstrClass iclass, params Mutator <i8051Disassembler>[] mutators)
 {
     return(new InstrDecoder(opcode, iclass, mutators));
 }
Пример #23
0
 private static Decoder Instr(InstrClass iclass, Mnemonic mnemonic, params Mutator <Disassembler>[] mutators)
 {
     return(new InstrDecoder <Disassembler, Mnemonic, Instruction>(iclass, mnemonic, mutators));
 }
Пример #24
0
 public RtlGoto(Expression target, InstrClass rtlClass) : base(target, rtlClass)
 {
 }
Пример #25
0
        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,
                });
            }
        }
Пример #26
0
        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
                });
            }
        }
Пример #27
0
        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));
            }
        }
Пример #28
0
 public static Decoder Instr(Mnemonic mnemonic, InstrClass iclass, params Mutator <VaxDisassembler>[] mutators)
 {
     return(new InstrDecoder <VaxDisassembler, Mnemonic, VaxInstruction>(iclass, mnemonic, mutators));
 }
Пример #29
0
        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));
            }
        }
Пример #30
0
 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));
 }