Ejemplo n.º 1
0
 public OpenRISCRewriter(OpenRISCArchitecture 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 OpenRISCDisassembler(arch, rdr).GetEnumerator();
     this.instrCur = null !;
     this.m        = null !;
 }
Ejemplo n.º 2
0
            public override OpenRISCInstruction Decode(uint wInstr, OpenRISCDisassembler dasm)
            {
                foreach (var m in mutators)
                {
                    if (!m(wInstr, dasm))
                    {
                        return(dasm.CreateInvalidInstruction());
                    }
                }
                var instr = new OpenRISCInstruction
                {
                    InstructionClass = iclass,
                    Mnemonic         = mnemonic,
                    Operands         = dasm.ops.ToArray()
                };

                return(instr);
            }
Ejemplo n.º 3
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));
            }
        }