Пример #1
0
 public MicroBlazeRewriter(MicroBlazeArchitecture arch, EndianImageReader rdr, ProcessorState state, IStorageBinder binder, IRewriterHost host)
 {
     this.arch      = arch;
     this.rdr       = rdr;
     this.state     = state;
     this.binder    = binder;
     this.host      = host;
     this.dasm      = new MicroBlazeDisassembler(arch, rdr).GetEnumerator();
     this.instrCur  = null !;
     this.addrInstr = null !;
     this.m         = null !;
 }
Пример #2
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 !;
            }
        }