示例#1
0
 public Tms7000Rewriter(Tms7000Architecture arch, EndianImageReader rdr, Tms7000State state, IStorageBinder binder, IRewriterHost host)
 {
     this.arch   = arch;
     this.rdr    = rdr;
     this.host   = host;
     this.binder = binder;
     this.dasm   = new Tms7000Disassembler(arch, rdr).GetEnumerator();
     this.instr  = null !;
     this.m      = null !;
 }
示例#2
0
            public override Tms7000Instruction Decode(uint b, Tms7000Disassembler dasm)
            {
                foreach (var m in mutators)
                {
                    if (!m(b, dasm))
                    {
                        return(dasm.CreateInvalidInstruction());
                    }
                }
                var instr = new Tms7000Instruction
                {
                    Mnemonic         = opcode,
                    InstructionClass = iclass,
                    Operands         = dasm.ops.ToArray()
                };

                return(instr);
            }
示例#3
0
            public Tms7000Instruction Decode(byte b, Tms7000Disassembler dasm)
            {
                foreach (var m in mutators)
                {
                    if (!m(b, dasm))
                    {
                        return(Invalid());
                    }
                }
                var instr = new Tms7000Instruction
                {
                    Opcode           = opcode,
                    InstructionClass = iclass,
                    op1 = dasm.ops.Count > 0 ? dasm.ops[0] : null,
                    op2 = dasm.ops.Count > 1 ? dasm.ops[1] : null,
                    op3 = dasm.ops.Count > 2 ? dasm.ops[2] : null,
                };

                return(instr);
            }
示例#4
0
        public IEnumerator <RtlInstructionCluster> GetEnumerator()
        {
            while (dasm.MoveNext())
            {
                this.instr  = dasm.Current;
                this.iclass = InstrClass.Linear;
                var rtls = new List <RtlInstruction>();
                this.m = new RtlEmitter(rtls);
                switch (instr.Mnemonic)
                {
                default:
                    host.Error(instr.Address, "Rewriting TMS7000 instruction '{0}' is not supported yet.", instr);
                    iclass = 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(m.MakeCluster(instr.Address, instr.Length, iclass));
            }
        }