public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
rtlc = instr.InstructionClass;
var instrs = new List <RtlInstruction>();
this.m = new RtlEmitter(instrs);
switch (instr.Opcode)
{
default:
EmitUnitTest();
Invalid();
host.Warn(
instr.Address,
string.Format(
"TLCS-90 instruction '{0}' not supported yet.",
instr.Opcode));
break;
case Opcode.invalid: m.Invalid(); break;
case Opcode.adc: RewriteAdcSbc(m.IAdd, "**-**V0*"); break;
case Opcode.add: RewriteBinOp(m.IAdd, "**-***0*"); break;
case Opcode.and: RewriteBinOp(m.And, "**-10*00"); break;
case Opcode.bit: RewriteBit("*--I**0-"); break;
case Opcode.call: RewriteCall(); break;
case Opcode.callr: RewriteCall(); break;
case Opcode.ccf: RewriteCcf(); break;
case Opcode.cp: RewriteCp(); break;
case Opcode.cpl: RewriteCpl("---1--1-"); break;
case Opcode.daa: RewriteDaa(); break;
case Opcode.dec: RewriteIncDec(m.ISub, false); break;
case Opcode.decx: RewriteIncDec(m.ISub, true); break;
case Opcode.di: RewriteDi(); break;
case Opcode.div: RewriteDiv(); break;
case Opcode.djnz: RewriteDjnz(); break;
case Opcode.ei: RewriteEi(); break;
case Opcode.ex: RewriteEx(); break;
case Opcode.exx: RewriteExx(); break;
case Opcode.halt: RewriteHalt(); break;
case Opcode.inc: RewriteIncDec(m.IAdd, false); break;
case Opcode.incw: RewriteIncwDecw(m.IAdd); break;
case Opcode.incx: RewriteIncDec(m.IAdd, true); break;
case Opcode.jp: RewriteJp(); break;
case Opcode.jr: RewriteJp(); break;
case Opcode.ld: RewriteLd(); break;
case Opcode.ldar: RewriteLdar(); break;
case Opcode.ldir: RewriteLdir("---0-00-"); break;
case Opcode.ldw: RewriteLd(); break;
case Opcode.mul: RewriteMul(); break;
case Opcode.neg: RewriteNeg(); break;
case Opcode.nop: m.Nop(); break;
case Opcode.or: RewriteBinOp(m.Or, "**-00*00"); break;
case Opcode.pop: RewritePop(); break;
case Opcode.push: RewritePush(); break;
case Opcode.rcf: RewriteRcf(); break;
case Opcode.res: RewriteSetRes(false); break;
case Opcode.ret: RewriteRet(); break;
case Opcode.reti: RewriteReti(); break;
case Opcode.rl: RewriteRotation(PseudoProcedure.RolC, true); break;
case Opcode.rlc: RewriteRotation(PseudoProcedure.Rol, false); break;
case Opcode.rr: RewriteRotation(PseudoProcedure.RorC, true); break;
case Opcode.rrc: RewriteRotation(PseudoProcedure.Ror, false); break;
case Opcode.sbc: RewriteAdcSbc(m.ISub, "**-**V1*"); break;
case Opcode.scf: RewriteScf(); break;
case Opcode.set: RewriteSetRes(true); break;
case Opcode.tset: RewriteTset("*--I**0-"); break;
case Opcode.sla: RewriteShift(m.Shl); break;
case Opcode.sll: RewriteShift(m.Shl); break;
case Opcode.sra: RewriteShift(m.Sar); break;
case Opcode.srl: RewriteShift(m.Shr); break;
case Opcode.sub: RewriteBinOp(m.ISub, "**-**V1*"); break;
case Opcode.swi: RewriteSwi(); break;
case Opcode.xor: RewriteBinOp(m.Xor, "**-10*00"); break;
}
yield return(new RtlInstructionCluster(instr.Address, instr.Length, instrs.ToArray())
{
Class = rtlc,
});
}
}
private void Invalid()
{
rtlc = InstrClass.Invalid;
m.Invalid();
}
private void Invalid()
{
m.Invalid();
iclass = InstrClass.Invalid;
}
private void Invalid()
{
rtlInstructions.Clear();
rtlc = RtlClass.Invalid;
m.Invalid();
}
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();
this.iclass = InstrClass.Invalid;
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
m.Invalid();
break;
case Mnemonic.j: RewriteJ(); break;
case Mnemonic.jan: RewriteJxx(Registers.ARegs[0], m.Ne0); break;
case Mnemonic.jam: RewriteJxx(Registers.ARegs[0], m.Lt0); break;
case Mnemonic.jap: RewriteJxx(Registers.ARegs[0], m.Ge0); break;
case Mnemonic.jaz: RewriteJxx(Registers.ARegs[0], m.Eq0); break;
case Mnemonic.jsn: RewriteJxx(Registers.SRegs[0], m.Ne0); break;
case Mnemonic.jsm: RewriteJxx(Registers.SRegs[0], m.Lt0); break;
case Mnemonic.jsp: RewriteJxx(Registers.SRegs[0], m.Ge0); break;
case Mnemonic.jsz: RewriteJxx(Registers.SRegs[0], m.Eq0); break;
case Mnemonic.r: RewriteR(); break;
case Mnemonic._and: Rewrite3(m.And); break;
case Mnemonic._clz: RewriteIntrinsic("__clz", false); break;
case Mnemonic._popcnt: RewriteIntrinsic("__popcnt", false); break;
case Mnemonic._fmul: Rewrite3(m.FMul); break;
case Mnemonic._iadd: Rewrite3(m.IAdd); break;
case Mnemonic._isub: Rewrite3(m.ISub); break;
case Mnemonic._mov: RewriteMov(); break;
case Mnemonic._movz: RewriteMovz(); break;
case Mnemonic._lmask: RewriteLmask(); break;
case Mnemonic._load: RewriteLoad(); break;
case Mnemonic._lsl: RewriteShift(m.Shl); break;
case Mnemonic._lsr: RewriteShift(m.Shr); break;
case Mnemonic._vor: Rewrite3(m.Or); break;
case Mnemonic._store: RewriteStore(); break;
case Mnemonic._xor: Rewrite3(m.Xor); break;
}
yield return(m.MakeCluster(instrCur.Address, instrCur.Length, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instrCur = dasm.Current;
var instrs = new List <RtlInstruction>();
this.rtlc = instrCur.InstructionClass;
this.m = new RtlEmitter(instrs);
switch (instrCur.Mnemonic)
{
default:
EmitUnitTest();
rtlc = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.illegal: m.Invalid(); break;
case Mnemonic.adc: Adc(); break;
case Mnemonic.and: And(); break;
case Mnemonic.asl: Asl(); break;
case Mnemonic.bcc: Branch(ConditionCode.UGE, FlagM.CF); break;
case Mnemonic.bcs: Branch(ConditionCode.ULT, FlagM.CF); break;
case Mnemonic.beq: Branch(ConditionCode.EQ, FlagM.ZF); break;
case Mnemonic.bit: Bit(); break;
case Mnemonic.bmi: Branch(ConditionCode.SG, FlagM.NF); break;
case Mnemonic.bne: Branch(ConditionCode.NE, FlagM.ZF); break;
case Mnemonic.bpl: Branch(ConditionCode.NS, FlagM.NF); break;
case Mnemonic.brk: Brk(); break;
case Mnemonic.bvc: Branch(ConditionCode.NO, FlagM.VF); break;
case Mnemonic.bvs: Branch(ConditionCode.OV, FlagM.VF); break;
case Mnemonic.clc: SetFlag(FlagM.CF, false); break;
case Mnemonic.cld: SetFlag(FlagM.DF, false); break;
case Mnemonic.cli: SetFlag(FlagM.IF, false); break;
case Mnemonic.clv: SetFlag(FlagM.VF, false); break;
case Mnemonic.cmp: Cmp(Registers.a); break;
case Mnemonic.cpx: Cmp(Registers.x); break;
case Mnemonic.cpy: Cmp(Registers.y); break;
case Mnemonic.dec: Dec(); break;
case Mnemonic.dex: Dec(Registers.x); break;
case Mnemonic.dey: Dec(Registers.y); break;
case Mnemonic.eor: Eor(); break;
case Mnemonic.inc: Inc(); break;
case Mnemonic.inx: Inc(Registers.x); break;
case Mnemonic.iny: Inc(Registers.y); break;
case Mnemonic.jmp: Jmp(); break;
case Mnemonic.jsr: Jsr(); break;
case Mnemonic.lda: Ld(Registers.a); break;
case Mnemonic.ldx: Ld(Registers.x); break;
case Mnemonic.ldy: Ld(Registers.y); break;
case Mnemonic.lsr: Lsr(); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.ora: Ora(); break;
case Mnemonic.pha: Push(Registers.a); break;
case Mnemonic.php: Push(AllFlags()); break;
case Mnemonic.pla: Pull(Registers.a); break;
case Mnemonic.plp: Plp(); break;
case Mnemonic.rol: Rotate(PseudoProcedure.Rol); break;
case Mnemonic.ror: Rotate(PseudoProcedure.Ror); break;
case Mnemonic.rti: Rti(); break;
case Mnemonic.rts: Rts(); break;
case Mnemonic.sbc: Sbc(); break;
case Mnemonic.sec: SetFlag(FlagM.CF, true); break;
case Mnemonic.sed: SetFlag(FlagM.DF, true); break;
case Mnemonic.sei: SetFlag(FlagM.IF, true); break;
case Mnemonic.sta: St(Registers.a); break;
case Mnemonic.stx: St(Registers.x); break;
case Mnemonic.sty: St(Registers.y); break;
case Mnemonic.tax: Copy(Registers.x, Registers.a); break;
case Mnemonic.tay: Copy(Registers.y, Registers.a); break;
case Mnemonic.tsx: Copy(Registers.x, Registers.s); break;
case Mnemonic.txa: Copy(Registers.a, Registers.x); break;
case Mnemonic.txs: Copy(Registers.s, Registers.x); break;
case Mnemonic.tya: Copy(Registers.a, Registers.y); break;
}
yield return(new RtlInstructionCluster(
instrCur.Address,
instrCur.Length,
instrs.ToArray())
{
Class = rtlc
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var instr = dasm.Current;
this.iclass = instr.InstructionClass;
switch (instr.Mnemonic)
{
default:
EmitUnitTest(instr);
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
m.Invalid();
iclass = InstrClass.Invalid;
break;
case Mnemonic.add: RewriteAdd(instr); break;
case Mnemonic.adds: RewriteAdds(instr); break;
case Mnemonic.addx: RewriteAddxSubx(instr, m.IAdd); break;
case Mnemonic.and: RewriteLogical(instr, m.And); break;
case Mnemonic.bld: RewriteBtst(instr, C); break;
case Mnemonic.bset: RewriteBset(instr, Constant.True()); break;
case Mnemonic.bst: RewriteBset(instr, binder.EnsureFlagGroup(C)); break;
case Mnemonic.btst: RewriteBtst(instr, Z); break;
case Mnemonic.bra: RewriteBranch(instr); break;
case Mnemonic.brn: RewriteNop(); break;
case Mnemonic.bhi: RewriteBranch(instr, ConditionCode.UGT, ZC); break;
case Mnemonic.bls: RewriteBranch(instr, ConditionCode.ULE, ZC); break;
case Mnemonic.bcc: RewriteBranch(instr, ConditionCode.UGE, C); break;
case Mnemonic.bcs: RewriteBranch(instr, ConditionCode.ULT, C); break;
case Mnemonic.bne: RewriteBranch(instr, ConditionCode.NE, Z); break;
case Mnemonic.beq: RewriteBranch(instr, ConditionCode.EQ, Z); break;
case Mnemonic.bvc: RewriteBranch(instr, ConditionCode.NO, V); break;
case Mnemonic.bvs: RewriteBranch(instr, ConditionCode.OV, V); break;
case Mnemonic.bpl: RewriteBranch(instr, ConditionCode.GE, N); break;
case Mnemonic.bmi: RewriteBranch(instr, ConditionCode.LT, N); break;
case Mnemonic.bge: RewriteBranch(instr, ConditionCode.GE, NV); break;
case Mnemonic.blt: RewriteBranch(instr, ConditionCode.LT, NV); break;
case Mnemonic.bgt: RewriteBranch(instr, ConditionCode.GT, NZV); break;
case Mnemonic.ble: RewriteBranch(instr, ConditionCode.LE, NZV); break;
case Mnemonic.cmp: RewriteCmp(instr); break;
case Mnemonic.extu: RewriteExt(instr, Domain.UnsignedInt); break;
case Mnemonic.jmp: RewriteJmp(instr); break;
case Mnemonic.jsr: RewriteJsr(instr); break;
case Mnemonic.ldc: RewriteLdc(instr); break;
case Mnemonic.mov: RewriteMov(instr); break;
case Mnemonic.mulxu: RewriteMulxu(instr); break;
case Mnemonic.nop: RewriteNop(); break;
case Mnemonic.not: RewriteUnaryLogical(instr, m.Comp); break;
case Mnemonic.or: RewriteLogical(instr, m.Or); break;
case Mnemonic.rotxl: RewriteRotationX(instr, PseudoProcedure.RolC); break;
case Mnemonic.rotxr: RewriteRotationX(instr, PseudoProcedure.RorC); break;
case Mnemonic.rts: RewriteRts(); break;
case Mnemonic.shal: RewriteShift(instr, m.Shl); break;
case Mnemonic.shar: RewriteShift(instr, m.Sar); break;
case Mnemonic.shll: RewriteShift(instr, m.Shl); break;
case Mnemonic.shlr: RewriteShift(instr, m.Shr); break;
case Mnemonic.sub: RewriteSub(instr); break;
case Mnemonic.subs: RewriteSubs(instr); break;
case Mnemonic.subx: RewriteAddxSubx(instr, m.ISub); break;
case Mnemonic.xor: RewriteLogical(instr, m.Xor); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
this.m = new RtlEmitter(new List <RtlInstruction>());
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
var addr = dasm.Current.Address;
var len = dasm.Current.Length;
this.rtlInstructions = new List <RtlInstruction>();
this.rtlc = RtlClass.Linear;
this.m = new RtlEmitter(rtlInstructions);
switch (instr.opcode)
{
default:
host.Warn(
instr.Address,
"Rewriting of Risc-V instruction '{0}' not implemented yet.",
instr.opcode);
rtlc = RtlClass.Invalid;
m.Invalid();
break;
case Opcode.invalid: rtlc = RtlClass.Invalid; m.Invalid(); break;
case Opcode.add: RewriteAdd(); break;
case Opcode.addi: RewriteAdd(); break;
case Opcode.addiw: RewriteAddw(); break;
case Opcode.addw: RewriteAddw(); break;
case Opcode.and: RewriteAnd(); break;
case Opcode.andi: RewriteAnd(); break;
case Opcode.auipc: RewriteAuipc(); break;
case Opcode.beq: RewriteBranch(m.Eq); break;
case Opcode.bge: RewriteBranch(m.Ge); break;
case Opcode.bgeu: RewriteBranch(m.Uge); break;
case Opcode.blt: RewriteBranch(m.Lt); break;
case Opcode.bltu: RewriteBranch(m.Ult); break;
case Opcode.bne: RewriteBranch(m.Ne); break;
case Opcode.fcvt_d_s: RewriteFcvt(PrimitiveType.Real64); break;
case Opcode.feq_s: RewriteFcmp(PrimitiveType.Real32, m.FEq); break;
case Opcode.fmadd_s: RewriteFmadd(PrimitiveType.Real32, m.FAdd); break;
case Opcode.fmv_d_x: RewriteFcvt(PrimitiveType.Real64); break;
case Opcode.fmv_s_x: RewriteFcvt(PrimitiveType.Real32); break;
case Opcode.flw: RewriteFload(PrimitiveType.Real32); break;
case Opcode.jal: RewriteJal(); break;
case Opcode.jalr: RewriteJalr(); break;
case Opcode.lb: RewriteLoad(PrimitiveType.SByte); break;
case Opcode.lbu: RewriteLoad(PrimitiveType.Byte); break;
case Opcode.ld: RewriteLoad(PrimitiveType.Word64); break;
case Opcode.lh: RewriteLoad(PrimitiveType.Int16); break;
case Opcode.lhu: RewriteLoad(PrimitiveType.UInt16); break;
case Opcode.lui: RewriteLui(); break;
case Opcode.lw: RewriteLoad(PrimitiveType.Int32); break;
case Opcode.lwu: RewriteLoad(PrimitiveType.UInt32); break;
case Opcode.or: RewriteOr(); break;
case Opcode.ori: RewriteOr(); break;
case Opcode.sb: RewriteStore(PrimitiveType.Byte); break;
case Opcode.sd: RewriteStore(PrimitiveType.Word64); break;
case Opcode.sh: RewriteStore(PrimitiveType.Word16); break;
case Opcode.sw: RewriteStore(PrimitiveType.Word32); break;
case Opcode.slli: RewriteShift(m.Shl); break;
case Opcode.slliw: RewriteShiftw(m.Shl); break;
case Opcode.sllw: RewriteShiftw(m.Shl); break;
case Opcode.slt: RewriteSlt(false); break;
case Opcode.sltu: RewriteSlt(true); break;
case Opcode.srai: RewriteShift(m.Sar); break;
case Opcode.sraiw: RewriteShiftw(m.Sar); break;
case Opcode.srli: RewriteShift(m.Shr); break;
case Opcode.srliw: RewriteShiftw(m.Shr); break;
case Opcode.sub: RewriteSub(); break;
case Opcode.subw: RewriteSubw(); break;
case Opcode.xor: RewriteXor(); break;
case Opcode.xori: RewriteXor(); break;
}
yield return(new RtlInstructionCluster(
addr,
len,
rtlInstructions.ToArray())
{
Class = rtlc,
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var addr = dasm.Current.Address;
var len = dasm.Current.Length;
rtlInstructions = new List <RtlInstruction>();
rtlc = dasm.Current.IClass;
m = new RtlEmitter(rtlInstructions);
switch (dasm.Current.Opcode)
{
default:
//EmitUnitTest();
//emitter.SideEffect(Constant.String(
// dasm.Current.ToString(),
// StringType.NullTerminated(PrimitiveType.Char)));
host.Warn(
dasm.Current.Address,
"VAX instruction {0} not supported yet.",
dasm.Current.Opcode);
m.Invalid();
break;
case Opcode.Invalid: m.Invalid(); break;
case Opcode.Reserved: m.Invalid(); break;
case Opcode.acbb: RewriteAcbi(PrimitiveType.Byte); break;
case Opcode.acbd: RewriteAcbf(PrimitiveType.Real64); break;
case Opcode.acbf: RewriteAcbf(PrimitiveType.Real32); break;
case Opcode.acbg: RewriteAcbf(PrimitiveType.Real64); break;
case Opcode.acbh: RewriteAcbf(PrimitiveType.Real128); break;
case Opcode.acbl: RewriteAcbi(PrimitiveType.Word32); break;
case Opcode.acbw: RewriteAcbi(PrimitiveType.Word16); break;
case Opcode.adawi: RewriteAlu2(PrimitiveType.Word16, Adawi, AllFlags); break;
case Opcode.addb2: RewriteAlu2(PrimitiveType.Byte, m.IAdd, AllFlags); break;
case Opcode.addb3: RewriteAlu3(PrimitiveType.Byte, m.IAdd, AllFlags); break;
case Opcode.addd2: RewriteFpu2(PrimitiveType.Real64, m.FAdd, NZ00); break;
case Opcode.addd3: RewriteFpu3(PrimitiveType.Real64, m.FAdd, NZ00); break;
case Opcode.addf2: RewriteFpu2(PrimitiveType.Real32, m.FAdd, NZ00); break;
case Opcode.addf3: RewriteFpu3(PrimitiveType.Real32, m.FAdd, NZ00); break;
case Opcode.addl2: RewriteAlu2(PrimitiveType.Word32, m.IAdd, AllFlags); break;
case Opcode.addl3: RewriteAlu3(PrimitiveType.Word32, m.IAdd, AllFlags); break;
case Opcode.addp4: RewriteP4("vax_addp4"); break;
case Opcode.addp6: RewriteP6("vax_addp6"); break;
case Opcode.addw2: RewriteAlu2(PrimitiveType.Word16, m.IAdd, AllFlags); break;
case Opcode.addw3: RewriteAlu3(PrimitiveType.Word16, m.IAdd, AllFlags); break;
case Opcode.adwc: RewriteAdwc(); break;
case Opcode.aobleq: RewriteAob(m.Le); break;
case Opcode.aoblss: RewriteAob(m.Lt); break;
case Opcode.ashl: RewriteAsh(PrimitiveType.Word32); break;
case Opcode.ashp: RewriteAshp(); break;
case Opcode.ashq: RewriteAsh(PrimitiveType.Word64); break;
case Opcode.bbc: RewriteBb(false); break;
case Opcode.bbcc: RewriteBbxx(false, false); break;
case Opcode.bbcci: RewriteBbxxi(false); break;
case Opcode.bbcs: RewriteBbxx(false, true); break;
case Opcode.bbs: RewriteBb(true); break;
case Opcode.bbsc: RewriteBbxx(true, false); break;
case Opcode.bbss: RewriteBbxx(true, true); break;
case Opcode.bbssi: RewriteBbxxi(true); break;
case Opcode.beql: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.bgeq: RewriteBranch(ConditionCode.GE, FlagM.NF); break;
case Opcode.bgequ: RewriteBranch(ConditionCode.UGE, FlagM.CF); break;
case Opcode.bgtr: RewriteBranch(ConditionCode.GT, FlagM.ZF | FlagM.NF); break;
case Opcode.bgtru: RewriteBranch(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break;
case Opcode.bleq: RewriteBranch(ConditionCode.LE, FlagM.ZF | FlagM.NF); break;
case Opcode.blequ: RewriteBranch(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break;
case Opcode.blss: RewriteBranch(ConditionCode.LT, FlagM.NF); break;
case Opcode.blssu: RewriteBranch(ConditionCode.ULT, FlagM.CF); break;
case Opcode.bneq: RewriteBranch(ConditionCode.NE, FlagM.ZF); break;
case Opcode.bvc: RewriteBranch(ConditionCode.NO, FlagM.VF); break;
case Opcode.bvs: RewriteBranch(ConditionCode.OV, FlagM.VF); break;
case Opcode.bicb2: RewriteAlu2(PrimitiveType.Byte, Bic, NZ00); break;
case Opcode.bicb3: RewriteAlu3(PrimitiveType.Byte, Bic, NZ00); break;
case Opcode.bicl2: RewriteAlu2(PrimitiveType.Word32, Bic, NZ00); break;
case Opcode.bicl3: RewriteAlu3(PrimitiveType.Word32, Bic, NZ00); break;
case Opcode.bicpsw: RewriteBicpsw(); break;
case Opcode.bicw2: RewriteAlu2(PrimitiveType.Word16, Bic, NZ00); break;
case Opcode.bicw3: RewriteAlu3(PrimitiveType.Word16, Bic, NZ00); break;
case Opcode.bisb2: RewriteAlu2(PrimitiveType.Byte, m.Or, NZ00); break;
case Opcode.bisb3: RewriteAlu3(PrimitiveType.Byte, m.Or, NZ00); break;
case Opcode.bispsw: RewriteBispsw(); break;
case Opcode.bisl2: RewriteAlu2(PrimitiveType.Word32, m.Or, NZ00); break;
case Opcode.bisl3: RewriteAlu3(PrimitiveType.Word32, m.Or, NZ00); break;
case Opcode.bisw2: RewriteAlu2(PrimitiveType.Word16, m.Or, NZ00); break;
case Opcode.bisw3: RewriteAlu3(PrimitiveType.Word16, m.Or, NZ00); break;
case Opcode.bitb: RewriteBit(PrimitiveType.Byte); break;
case Opcode.bitw: RewriteBit(PrimitiveType.Byte); break;
case Opcode.bitl: RewriteBit(PrimitiveType.Byte); break;
case Opcode.blbc: RewriteBlb(m.Eq0); break;
case Opcode.blbs: RewriteBlb(m.Ne0); break;
case Opcode.bpt: RewriteBpt(); break;
case Opcode.brb: RewriteBranch(); break;
case Opcode.brw: RewriteBranch(); break;
case Opcode.bsbb: RewriteBsb(); break;
case Opcode.bsbw: RewriteBsb(); break;
case Opcode.caseb: goto default;
case Opcode.casel: goto default;
case Opcode.chme: RewriteChm("vax_chme"); break;
case Opcode.chmk: RewriteChm("vax_chmk"); break;
case Opcode.chms: RewriteChm("vax_chms"); break;
case Opcode.chmu: RewriteChm("vax_chmu"); break;
case Opcode.clrb: RewriteClr(PrimitiveType.Byte); break;
case Opcode.clrh: RewriteClr(PrimitiveType.Word128); break;
case Opcode.clrl: RewriteClr(PrimitiveType.Word32); break;
case Opcode.clrq: RewriteClr(PrimitiveType.Word64); break;
case Opcode.clrw: RewriteClr(PrimitiveType.Word16); break;
case Opcode.cmpb: RewriteCmp(PrimitiveType.Byte); break;
case Opcode.cmpd: RewriteCmp(PrimitiveType.Real64); break;
case Opcode.cmpf: RewriteCmp(PrimitiveType.Real32); break;
case Opcode.cmpg: RewriteCmp(PrimitiveType.Real64); break;
case Opcode.cmph: RewriteCmp(PrimitiveType.Real128); break;
case Opcode.cmpl: RewriteCmp(PrimitiveType.Word32); break;
case Opcode.cmpw: RewriteCmp(PrimitiveType.Word16); break;
case Opcode.cmpp3: RewriteCmpp3(); break;
case Opcode.cmpp4: RewriteCmpp4(); break;
case Opcode.cmpv: goto default;
case Opcode.cmpzv: goto default;
case Opcode.cvtbd: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break;
case Opcode.cvtbf: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real32); break;
case Opcode.cvtbg: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break;
case Opcode.cvtbh: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real128); break;
case Opcode.cvtbl: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int32); break;
case Opcode.cvtbw: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int16); break;
case Opcode.cvtdb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break;
case Opcode.cvtdf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break;
case Opcode.cvtdh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break;
case Opcode.cvtdl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Opcode.cvtdw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break;
case Opcode.cvtfb: RewriteCvt(PrimitiveType.Real32, PrimitiveType.SByte); break;
case Opcode.cvtfd: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break;
case Opcode.cvtfg: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break;
case Opcode.cvtfh: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real128); break;
case Opcode.cvtfl: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int32); break;
case Opcode.cvtfw: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int16); break;
case Opcode.cvtgb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break;
case Opcode.cvtgf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break;
case Opcode.cvtgh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break;
case Opcode.cvtgl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Opcode.cvtgw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break;
case Opcode.cvthb: RewriteCvt(PrimitiveType.Real128, PrimitiveType.SByte); break;
case Opcode.cvthd: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break;
case Opcode.cvthf: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real32); break;
case Opcode.cvthg: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break;
case Opcode.cvthl: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int32); break;
case Opcode.cvthw: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int16); break;
case Opcode.cvtps: RewriteCvtComplex("__cvtps"); break;
case Opcode.cvtrdl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Opcode.cvtrfl: RewriteCvtr(PrimitiveType.Real32, PrimitiveType.Int32); break;
case Opcode.cvtrgl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Opcode.cvtrhl: RewriteCvtr(PrimitiveType.Real128, PrimitiveType.Int32); break;
case Opcode.cvtlb: RewriteCvt(PrimitiveType.Int32, PrimitiveType.SByte); break;
case Opcode.cvtld: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break;
case Opcode.cvtlf: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real32); break;
case Opcode.cvtlg: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break;
case Opcode.cvtlh: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real128); break;
case Opcode.cvtlp: goto default;
case Opcode.cvtlw: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Int16); break;
case Opcode.cvtpl: goto default;
case Opcode.cvtpt: goto default;
case Opcode.cvtsp: RewriteCvtComplex("__cvtsp"); break;
case Opcode.cvttp: goto default;
case Opcode.cvtwb: RewriteCvt(PrimitiveType.Int16, PrimitiveType.SByte); break;
case Opcode.cvtwd: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break;
case Opcode.cvtwf: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real32); break;
case Opcode.cvtwg: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break;
case Opcode.cvtwh: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real128); break;
case Opcode.cvtwl: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Int32); break;;
case Opcode.decb: RewriteIncDec(PrimitiveType.Byte, Dec); break;
case Opcode.decl: RewriteIncDec(PrimitiveType.Word32, Dec); break;
case Opcode.decw: RewriteIncDec(PrimitiveType.Word16, Dec); break;
case Opcode.divb2: RewriteAlu2(PrimitiveType.Byte, m.SDiv, AllFlags); break;
case Opcode.divb3: RewriteAlu3(PrimitiveType.Byte, m.SDiv, AllFlags); break;
case Opcode.divd2: RewriteFpu2(PrimitiveType.Real64, m.FDiv, AllFlags); break;
case Opcode.divd3: RewriteFpu3(PrimitiveType.Real64, m.FDiv, AllFlags); break;
case Opcode.divf2: RewriteFpu2(PrimitiveType.Real32, m.FDiv, AllFlags); break;
case Opcode.divf3: RewriteFpu3(PrimitiveType.Real32, m.FDiv, AllFlags); break;
case Opcode.divl2: RewriteAlu2(PrimitiveType.Word32, m.SDiv, AllFlags); break;
case Opcode.divl3: RewriteAlu3(PrimitiveType.Word32, m.SDiv, AllFlags); break;
case Opcode.divp: RewriteDivp(); break;
case Opcode.divw2: RewriteAlu2(PrimitiveType.Word16, m.SDiv, AllFlags); break;
case Opcode.divw3: RewriteAlu3(PrimitiveType.Word16, m.SDiv, AllFlags); break;
case Opcode.emodd: RewriteEmod("emodd", PrimitiveType.Real64, PrimitiveType.Byte); break; //$TODO: VAX floating point types
case Opcode.emodf: RewriteEmod("emodf", PrimitiveType.Real32, PrimitiveType.Byte); break; //$TODO: VAX floating point types
case Opcode.emodg: RewriteEmod("emodg", PrimitiveType.Real64, PrimitiveType.Word16); break; //$TODO: VAX floating point types
case Opcode.emodh: RewriteEmod("emodh", PrimitiveType.Real128, PrimitiveType.Word16); break; //$TODO: VAX floating point types
case Opcode.ffc: RewriteFfx("__ffc"); break;
case Opcode.ffs: RewriteFfx("__ffs"); break;
case Opcode.halt: RewriteHalt(); break;
case Opcode.incb: RewriteIncDec(PrimitiveType.Byte, Inc); break;
case Opcode.incl: RewriteIncDec(PrimitiveType.Word32, Inc); break;
case Opcode.incw: RewriteIncDec(PrimitiveType.Word16, Inc); break;
case Opcode.insque: RewriteInsque(); break;
case Opcode.jmp: RewriteJmp(); break;
case Opcode.jsb: RewriteJsb(); break;
case Opcode.mcomb: RewriteAluUnary2(PrimitiveType.Byte, m.Comp, NZ00); break;
case Opcode.mcoml: RewriteAluUnary2(PrimitiveType.Word32, m.Comp, NZ00); break;
case Opcode.mcomw: RewriteAluUnary2(PrimitiveType.Word16, m.Comp, NZ00); break;
case Opcode.mnegb: RewriteAluUnary2(PrimitiveType.Byte, m.Neg, AllFlags); break;
case Opcode.mnegd: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break;
case Opcode.mnegf: RewriteAluUnary2(PrimitiveType.Real32, m.FNeg, NZ00); break;
case Opcode.mnegg: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break;
case Opcode.mnegh: RewriteAluUnary2(PrimitiveType.Word128, m.FNeg, NZ00); break;
case Opcode.mnegl: RewriteAluUnary2(PrimitiveType.Word32, m.Neg, AllFlags); break;
case Opcode.mnegw: RewriteAluUnary2(PrimitiveType.Word16, m.Neg, AllFlags); break;
case Opcode.movab: RewriteMova(PrimitiveType.Byte); break;
case Opcode.movah: RewriteMova(PrimitiveType.Real128); break;
case Opcode.moval: RewriteMova(PrimitiveType.Word32); break;
case Opcode.movaq: RewriteMova(PrimitiveType.Word64); break;
case Opcode.movaw: RewriteMova(PrimitiveType.Word16); break;
case Opcode.movb: RewriteAluUnary2(PrimitiveType.Byte, Copy, NZ00); break;
case Opcode.movc3: goto default;
case Opcode.movc5: goto default;
case Opcode.movd: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break;
case Opcode.movf: RewriteAluUnary2(PrimitiveType.Real32, Copy, NZ00); break;
case Opcode.movg: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break;
case Opcode.movh: RewriteAluUnary2(PrimitiveType.Real128, Copy, NZ00); break;
case Opcode.movl: RewriteAluUnary2(PrimitiveType.Word32, Copy, NZ00); break;
case Opcode.movo: RewriteAluUnary2(PrimitiveType.Word128, Copy, NZ00); break;
case Opcode.movp: goto default;
case Opcode.movq: RewriteAluUnary2(PrimitiveType.Word64, Copy, NZ00); break;
case Opcode.movw: RewriteAluUnary2(PrimitiveType.Word16, Copy, NZ00); break;
case Opcode.movzbl: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt32); break;
case Opcode.movzbw: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt16); break;
case Opcode.movzwl: RewriteMovz(PrimitiveType.Word16, PrimitiveType.UInt32); break;
case Opcode.mulb2: RewriteAlu2(PrimitiveType.Byte, m.IMul, AllFlags); break;
case Opcode.mulb3: RewriteAlu3(PrimitiveType.Byte, m.IMul, AllFlags); break;
case Opcode.muld2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Opcode.muld3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Opcode.mulf2: RewriteAlu2(PrimitiveType.Real32, m.FMul, AllFlags); break;
case Opcode.mulf3: RewriteAlu3(PrimitiveType.Real32, m.FMul, AllFlags); break;
case Opcode.mulg2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Opcode.mulg3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Opcode.mulh2: RewriteAlu2(PrimitiveType.Real128, m.FMul, AllFlags); break;
case Opcode.mulh3: RewriteAlu3(PrimitiveType.Real128, m.FMul, AllFlags); break;
case Opcode.mull2: RewriteAlu2(PrimitiveType.Word32, m.IMul, AllFlags); break;
case Opcode.mull3: RewriteAlu3(PrimitiveType.Word32, m.IMul, AllFlags); break;
case Opcode.mulp: RewriteMulp(); break;
case Opcode.mulw2: RewriteAlu2(PrimitiveType.Word16, m.IMul, AllFlags); break;
case Opcode.mulw3: RewriteAlu3(PrimitiveType.Word16, m.IMul, AllFlags); break;
case Opcode.nop: m.Nop(); break;
case Opcode.polyd: RewritePoly(PrimitiveType.Real64); break;
case Opcode.polyf: RewritePoly(PrimitiveType.Real32); break;
case Opcode.polyg: RewritePoly(PrimitiveType.Real64); break;
case Opcode.polyh: RewritePoly(PrimitiveType.Real128); break;
case Opcode.popr: goto default;
case Opcode.prober: goto default;
case Opcode.probew: goto default;
case Opcode.pushr: goto default;
case Opcode.pushab: RewritePusha(); break;
case Opcode.pushal: RewritePusha(); break;
case Opcode.pushah: RewritePusha(); break;
case Opcode.pushaw: RewritePusha(); break;
case Opcode.pushaq: RewritePusha(); break;
case Opcode.pushl: RewritePush(PrimitiveType.Word32); break;
case Opcode.rei: RewriteRei(); break;
case Opcode.ret: RewriteRet(); break;
case Opcode.rotl: RewriteAlu3(PrimitiveType.Word32, Rotl, NZ00); break;
case Opcode.rsb: RewriteRsb(); break;
case Opcode.sbwc: RewriteSbwc(); break;
case Opcode.scanc: RewriteScanc(); break;
case Opcode.sobgeq: RewriteSob(m.Ge); break;
case Opcode.sobgtr: RewriteSob(m.Gt); break;
case Opcode.subb2: RewriteAlu2(PrimitiveType.Byte, m.ISub, AllFlags); break;
case Opcode.subb3: RewriteAlu3(PrimitiveType.Byte, m.ISub, AllFlags); break;
case Opcode.subd2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break;
case Opcode.subd3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break;
case Opcode.subf2: RewriteAlu2(PrimitiveType.Real32, m.FSub, NZ00); break;
case Opcode.subf3: RewriteAlu3(PrimitiveType.Real32, m.FSub, NZ00); break;
case Opcode.subg2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break;
case Opcode.subg3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break;
case Opcode.subh2: RewriteAlu2(PrimitiveType.Real128, m.FSub, NZ00); break;
case Opcode.subh3: RewriteAlu3(PrimitiveType.Real128, m.FSub, NZ00); break;
case Opcode.subl2: RewriteAlu2(PrimitiveType.Word32, m.ISub, AllFlags); break;
case Opcode.subl3: RewriteAlu3(PrimitiveType.Word32, m.ISub, AllFlags); break;
case Opcode.subp4: RewriteP4("vax_subp4"); break;
case Opcode.subp6: RewriteP6("vax_subp6"); break;
case Opcode.subw2: RewriteAlu2(PrimitiveType.Word16, m.ISub, AllFlags); break;
case Opcode.subw3: RewriteAlu3(PrimitiveType.Word16, m.ISub, AllFlags); break;
case Opcode.tstb: RewriteTst(PrimitiveType.Byte, ICmp0); break;
case Opcode.tstd: RewriteTst(PrimitiveType.Real64, FCmp0); break;
case Opcode.tstf: RewriteTst(PrimitiveType.Real32, FCmp0); break;
case Opcode.tstg: RewriteTst(PrimitiveType.Real64, FCmp0); break;
case Opcode.tsth: RewriteTst(PrimitiveType.Real128, FCmp0); break;
case Opcode.tstl: RewriteTst(PrimitiveType.Word32, ICmp0); break;
case Opcode.tstw: RewriteTst(PrimitiveType.Word16, ICmp0); break;
case Opcode.xorb2: RewriteAlu2(PrimitiveType.Byte, m.Xor, NZ00); break;
case Opcode.xorb3: RewriteAlu3(PrimitiveType.Byte, m.Xor, NZ00); break;
case Opcode.xorl2: RewriteAlu2(PrimitiveType.Word32, m.Xor, NZ00); break;
case Opcode.xorl3: RewriteAlu3(PrimitiveType.Word32, m.Xor, NZ00); break;
case Opcode.xorw2: RewriteAlu2(PrimitiveType.Word16, m.Xor, NZ00); break;
case Opcode.xorw3: RewriteAlu3(PrimitiveType.Word16, m.Xor, NZ00); break;
case Opcode.ldpctx: goto default;
case Opcode.svpctx: goto default;
case Opcode.editpc: goto default;
case Opcode.matchc: goto default;
case Opcode.index: goto default;
case Opcode.locc: goto default;
case Opcode.crc: goto default;
case Opcode.skpc: goto default;
case Opcode.remque: goto default;
case Opcode.spanc: goto default;
case Opcode.insqhi: goto default;
case Opcode.insqti: goto default;
case Opcode.movtc: goto default;
case Opcode.remqhi: goto default;
case Opcode.movtuc: goto default;
case Opcode.remqti: goto default;
case Opcode.emul: goto default;
case Opcode.ediv: goto default;
case Opcode.casew: goto default;
case Opcode.extv: goto default;
case Opcode.extzv: goto default;
case Opcode.insv: goto default;
case Opcode.mtpr: goto default;
case Opcode.callg: goto default;
case Opcode.mfpr: goto default;
case Opcode.calls: goto default;
case Opcode.movpsl: goto default;
case Opcode.xfc: goto default;
case Opcode.mfvp: goto default;
case Opcode.vldl: goto default;
case Opcode.vgathl: goto default;
case Opcode.vldq: goto default;
case Opcode.vgathq: goto default;
case Opcode.addg2: goto default;
case Opcode.addg3: goto default;
case Opcode.divg2: goto default;
case Opcode.divg3: goto default;
case Opcode.addh2: goto default;
case Opcode.addh3: goto default;
case Opcode.divh2: goto default;
case Opcode.divh3: goto default;
case Opcode.vstl: goto default;
case Opcode.vscatl: goto default;
case Opcode.vstq: goto default;
case Opcode.vscatq: goto default;
case Opcode.vvmull: goto default;
case Opcode.vsmull: goto default;
case Opcode.vvmulg: goto default;
case Opcode.vsmulg: goto default;
case Opcode.vvmulf: goto default;
case Opcode.vsmulf: goto default;
case Opcode.vvmuld: goto default;
case Opcode.vsmuld: goto default;
case Opcode.vsync: goto default;
case Opcode.mtvp: goto default;
case Opcode.vvdivg: goto default;
case Opcode.vsdivg: goto default;
case Opcode.vvdivf: goto default;
case Opcode.vsdivf: goto default;
case Opcode.vvdivd: goto default;
case Opcode.vsdivd: goto default;
case Opcode.vvaddl: goto default;
case Opcode.vsaddl: goto default;
case Opcode.vvaddg: goto default;
case Opcode.vsaddg: goto default;
case Opcode.vvaddf: goto default;
case Opcode.vsaddf: goto default;
case Opcode.vvaddd: goto default;
case Opcode.vsaddd: goto default;
case Opcode.vvsubl: goto default;
case Opcode.vssubl: goto default;
case Opcode.vvsubg: goto default;
case Opcode.vssubg: goto default;
case Opcode.vvsubf: goto default;
case Opcode.vssubf: goto default;
case Opcode.vvsubd: goto default;
case Opcode.vssubd: goto default;
case Opcode.vvcmpl: goto default;
case Opcode.vvsrll: goto default;
case Opcode.vscmpl: goto default;
case Opcode.vssrll: goto default;
case Opcode.vvcmpg: goto default;
case Opcode.vscmpg: goto default;
case Opcode.vvcmpf: goto default;
case Opcode.vvslll: goto default;
case Opcode.vscmpf: goto default;
case Opcode.vsslll: goto default;
case Opcode.vvcmpd: goto default;
case Opcode.vscmpd: goto default;
case Opcode.vvbisl: goto default;
case Opcode.vvxorl: goto default;
case Opcode.vsbisl: goto default;
case Opcode.vsxorl: goto default;
case Opcode.vvbicl: goto default;
case Opcode.vvcvt: goto default;
case Opcode.vsbicl: goto default;
case Opcode.iota: goto default;
case Opcode.vvmerge: goto default;
case Opcode.vsmerge: goto default;
case Opcode.bugl: goto default;
case Opcode.bugw: goto default;
}
yield return(new RtlInstructionCluster(
addr,
len,
rtlInstructions.ToArray())
{
Class = rtlc
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (instrs.MoveNext())
{
if (!instrs.Current.TryGetInternal(out this.instr))
{
throw new AddressCorrelatedException(
instrs.Current.Address,
"Invalid opcode cannot be rewritten to IR.");
}
this.ops = instr.ArchitectureDetail.Operands;
this.ric = new RtlInstructionCluster(instrs.Current.Address, instr.Bytes.Length);
this.ric.Class = RtlClass.Linear;
this.emitter = new RtlEmitter(ric.Instructions);
switch (instr.Id)
{
default:
case Opcode.ADC:
case Opcode.ADR:
case Opcode.AESD:
case Opcode.AESE:
case Opcode.AESIMC:
case Opcode.AESMC:
case Opcode.BFC:
case Opcode.BFI:
case Opcode.BKPT:
case Opcode.BXJ:
case Opcode.CDP:
case Opcode.CDP2:
case Opcode.CLREX:
case Opcode.CLZ:
case Opcode.CPS:
case Opcode.CRC32B:
case Opcode.CRC32CB:
case Opcode.CRC32CH:
case Opcode.CRC32CW:
case Opcode.CRC32H:
case Opcode.CRC32W:
case Opcode.DBG:
case Opcode.DMB:
case Opcode.DSB:
case Opcode.VMOV:
case Opcode.FLDMDBX:
case Opcode.FLDMIAX:
case Opcode.VMRS:
case Opcode.FSTMDBX:
case Opcode.FSTMIAX:
case Opcode.HINT:
case Opcode.HLT:
case Opcode.ISB:
case Opcode.LDA:
case Opcode.LDAB:
case Opcode.LDAEX:
case Opcode.LDAEXB:
case Opcode.LDAEXD:
case Opcode.LDAEXH:
case Opcode.LDAH:
case Opcode.LDC2L:
case Opcode.LDC2:
case Opcode.LDCL:
case Opcode.LDC:
case Opcode.LDMDA:
case Opcode.LDMIB:
case Opcode.LDRBT:
case Opcode.LDRD:
case Opcode.LDREX:
case Opcode.LDREXB:
case Opcode.LDREXD:
case Opcode.LDREXH:
case Opcode.LDRHT:
case Opcode.LDRSBT:
case Opcode.LDRSHT:
case Opcode.LDRT:
case Opcode.MCR:
case Opcode.MCR2:
case Opcode.MCRR:
case Opcode.MCRR2:
case Opcode.MLA:
case Opcode.MLS:
case Opcode.MOVT:
case Opcode.MOVW:
case Opcode.MRC:
case Opcode.MRC2:
case Opcode.MRRC:
case Opcode.MRRC2:
case Opcode.MRS:
case Opcode.MSR:
case Opcode.MUL:
case Opcode.PKHBT:
case Opcode.PKHTB:
case Opcode.PLDW:
case Opcode.PLD:
case Opcode.PLI:
case Opcode.QADD:
case Opcode.QADD16:
case Opcode.QADD8:
case Opcode.QASX:
case Opcode.QDADD:
case Opcode.QDSUB:
case Opcode.QSAX:
case Opcode.QSUB:
case Opcode.QSUB16:
case Opcode.QSUB8:
case Opcode.RBIT:
case Opcode.REV:
case Opcode.REV16:
case Opcode.REVSH:
case Opcode.RFEDA:
case Opcode.RFEDB:
case Opcode.RFEIA:
case Opcode.RFEIB:
case Opcode.RSC:
case Opcode.SADD16:
case Opcode.SADD8:
case Opcode.SASX:
case Opcode.SBC:
case Opcode.SBFX:
case Opcode.SDIV:
case Opcode.SEL:
case Opcode.SETEND:
case Opcode.SHA1C:
case Opcode.SHA1H:
case Opcode.SHA1M:
case Opcode.SHA1P:
case Opcode.SHA1SU0:
case Opcode.SHA1SU1:
case Opcode.SHA256H:
case Opcode.SHA256H2:
case Opcode.SHA256SU0:
case Opcode.SHA256SU1:
case Opcode.SHADD16:
case Opcode.SHADD8:
case Opcode.SHASX:
case Opcode.SHSAX:
case Opcode.SHSUB16:
case Opcode.SHSUB8:
case Opcode.SMC:
case Opcode.SMLABB:
case Opcode.SMLABT:
case Opcode.SMLAD:
case Opcode.SMLADX:
case Opcode.SMLAL:
case Opcode.SMLALBB:
case Opcode.SMLALBT:
case Opcode.SMLALD:
case Opcode.SMLALDX:
case Opcode.SMLALTB:
case Opcode.SMLALTT:
case Opcode.SMLATB:
case Opcode.SMLATT:
case Opcode.SMLAWB:
case Opcode.SMLAWT:
case Opcode.SMLSD:
case Opcode.SMLSDX:
case Opcode.SMLSLD:
case Opcode.SMLSLDX:
case Opcode.SMMLA:
case Opcode.SMMLAR:
case Opcode.SMMLS:
case Opcode.SMMLSR:
case Opcode.SMMUL:
case Opcode.SMMULR:
case Opcode.SMUAD:
case Opcode.SMUADX:
case Opcode.SMULBB:
case Opcode.SMULBT:
case Opcode.SMULL:
case Opcode.SMULTB:
case Opcode.SMULTT:
case Opcode.SMULWB:
case Opcode.SMULWT:
case Opcode.SMUSD:
case Opcode.SMUSDX:
case Opcode.SRSDA:
case Opcode.SRSDB:
case Opcode.SRSIA:
case Opcode.SRSIB:
case Opcode.SSAT:
case Opcode.SSAT16:
case Opcode.SSAX:
case Opcode.SSUB16:
case Opcode.SSUB8:
case Opcode.STC2L:
case Opcode.STC2:
case Opcode.STCL:
case Opcode.STC:
case Opcode.STL:
case Opcode.STLB:
case Opcode.STLEX:
case Opcode.STLEXB:
case Opcode.STLEXD:
case Opcode.STLEXH:
case Opcode.STLH:
case Opcode.STMDA:
case Opcode.STRBT:
case Opcode.STRD:
case Opcode.STREX:
case Opcode.STREXB:
case Opcode.STREXD:
case Opcode.STREXH:
case Opcode.STRHT:
case Opcode.STRT:
case Opcode.SWP:
case Opcode.SWPB:
case Opcode.SXTAB:
case Opcode.SXTAB16:
case Opcode.SXTAH:
case Opcode.SXTB:
case Opcode.SXTB16:
case Opcode.SXTH:
case Opcode.TRAP:
case Opcode.UADD16:
case Opcode.UADD8:
case Opcode.UASX:
case Opcode.UBFX:
case Opcode.UDF:
case Opcode.UDIV:
case Opcode.UHADD16:
case Opcode.UHADD8:
case Opcode.UHASX:
case Opcode.UHSAX:
case Opcode.UHSUB16:
case Opcode.UHSUB8:
case Opcode.UMAAL:
case Opcode.UMLAL:
case Opcode.UMULL:
case Opcode.UQADD16:
case Opcode.UQADD8:
case Opcode.UQASX:
case Opcode.UQSAX:
case Opcode.UQSUB16:
case Opcode.UQSUB8:
case Opcode.USAD8:
case Opcode.USADA8:
case Opcode.USAT:
case Opcode.USAT16:
case Opcode.USAX:
case Opcode.USUB16:
case Opcode.USUB8:
case Opcode.UXTAB:
case Opcode.UXTAB16:
case Opcode.UXTAH:
case Opcode.UXTB:
case Opcode.UXTB16:
case Opcode.UXTH:
case Opcode.VABAL:
case Opcode.VABA:
case Opcode.VABDL:
case Opcode.VABD:
case Opcode.VABS:
case Opcode.VACGE:
case Opcode.VACGT:
case Opcode.VADD:
case Opcode.VADDHN:
case Opcode.VADDL:
case Opcode.VADDW:
case Opcode.VAND:
case Opcode.VBIC:
case Opcode.VBIF:
case Opcode.VBIT:
case Opcode.VBSL:
case Opcode.VCEQ:
case Opcode.VCGE:
case Opcode.VCGT:
case Opcode.VCLE:
case Opcode.VCLS:
case Opcode.VCLT:
case Opcode.VCLZ:
case Opcode.VCMP:
case Opcode.VCMPE:
case Opcode.VCNT:
case Opcode.VCVTA:
case Opcode.VCVTB:
case Opcode.VCVT:
case Opcode.VCVTM:
case Opcode.VCVTN:
case Opcode.VCVTP:
case Opcode.VCVTT:
case Opcode.VDIV:
case Opcode.VDUP:
case Opcode.VEOR:
case Opcode.VEXT:
case Opcode.VFMA:
case Opcode.VFMS:
case Opcode.VFNMA:
case Opcode.VFNMS:
case Opcode.VHADD:
case Opcode.VHSUB:
case Opcode.VLD1:
case Opcode.VLD2:
case Opcode.VLD3:
case Opcode.VLD4:
case Opcode.VLDMDB:
case Opcode.VLDMIA:
case Opcode.VLDR:
case Opcode.VMAXNM:
case Opcode.VMAX:
case Opcode.VMINNM:
case Opcode.VMIN:
case Opcode.VMLA:
case Opcode.VMLAL:
case Opcode.VMLS:
case Opcode.VMLSL:
case Opcode.VMOVL:
case Opcode.VMOVN:
case Opcode.VMSR:
case Opcode.VMUL:
case Opcode.VMULL:
case Opcode.VMVN:
case Opcode.VNEG:
case Opcode.VNMLA:
case Opcode.VNMLS:
case Opcode.VNMUL:
case Opcode.VORN:
case Opcode.VORR:
case Opcode.VPADAL:
case Opcode.VPADDL:
case Opcode.VPADD:
case Opcode.VPMAX:
case Opcode.VPMIN:
case Opcode.VQABS:
case Opcode.VQADD:
case Opcode.VQDMLAL:
case Opcode.VQDMLSL:
case Opcode.VQDMULH:
case Opcode.VQDMULL:
case Opcode.VQMOVUN:
case Opcode.VQMOVN:
case Opcode.VQNEG:
case Opcode.VQRDMULH:
case Opcode.VQRSHL:
case Opcode.VQRSHRN:
case Opcode.VQRSHRUN:
case Opcode.VQSHL:
case Opcode.VQSHLU:
case Opcode.VQSHRN:
case Opcode.VQSHRUN:
case Opcode.VQSUB:
case Opcode.VRADDHN:
case Opcode.VRECPE:
case Opcode.VRECPS:
case Opcode.VREV16:
case Opcode.VREV32:
case Opcode.VREV64:
case Opcode.VRHADD:
case Opcode.VRINTA:
case Opcode.VRINTM:
case Opcode.VRINTN:
case Opcode.VRINTP:
case Opcode.VRINTR:
case Opcode.VRINTX:
case Opcode.VRINTZ:
case Opcode.VRSHL:
case Opcode.VRSHRN:
case Opcode.VRSHR:
case Opcode.VRSQRTE:
case Opcode.VRSQRTS:
case Opcode.VRSRA:
case Opcode.VRSUBHN:
case Opcode.VSELEQ:
case Opcode.VSELGE:
case Opcode.VSELGT:
case Opcode.VSELVS:
case Opcode.VSHLL:
case Opcode.VSHL:
case Opcode.VSHRN:
case Opcode.VSHR:
case Opcode.VSLI:
case Opcode.VSQRT:
case Opcode.VSRA:
case Opcode.VSRI:
case Opcode.VST1:
case Opcode.VST2:
case Opcode.VST3:
case Opcode.VST4:
case Opcode.VSTMDB:
case Opcode.VSTMIA:
case Opcode.VSTR:
case Opcode.VSUB:
case Opcode.VSUBHN:
case Opcode.VSUBL:
case Opcode.VSUBW:
case Opcode.VSWP:
case Opcode.VTBL:
case Opcode.VTBX:
case Opcode.VCVTR:
case Opcode.VTRN:
case Opcode.VTST:
case Opcode.VUZP:
case Opcode.VZIP:
case Opcode.ADDW:
case Opcode.ASR:
case Opcode.DCPS1:
case Opcode.DCPS2:
case Opcode.DCPS3:
case Opcode.IT:
case Opcode.LSL:
case Opcode.LSR:
case Opcode.ASRS:
case Opcode.LSRS:
case Opcode.ORN:
case Opcode.ROR:
case Opcode.RRX:
case Opcode.SUBS:
case Opcode.SUBW:
case Opcode.TBB:
case Opcode.TBH:
case Opcode.CBNZ:
case Opcode.CBZ:
case Opcode.MOVS:
case Opcode.POP:
case Opcode.YIELD:
case Opcode.WFE:
case Opcode.WFI:
case Opcode.SEV:
case Opcode.SEVL:
case Opcode.VPUSH:
case Opcode.VPOP:
host.Error(
instrs.Current.Address,
string.Format(
"Rewriting ARM opcode '{0}' is not supported yet.",
instr.Mnemonic));
emitter.Invalid();
break;
case Opcode.AND: RewriteBinOp(emitter.And, instr.ArchitectureDetail.UpdateFlags); break;
case Opcode.ADD: RewriteBinOp(emitter.IAdd, instr.ArchitectureDetail.UpdateFlags); break;
case Opcode.EOR: RewriteBinOp(emitter.Xor, instr.ArchitectureDetail.UpdateFlags); break;
case Opcode.B: RewriteB(false); break;
case Opcode.BIC: RewriteBic(); break;
case Opcode.BL: RewriteB(true); break;
case Opcode.BLX: RewriteB(true); break;
case Opcode.BX: RewriteB(false); break;
case Opcode.CMN: RewriteCmn(); break;
case Opcode.CMP: RewriteCmp(); break;
case Opcode.LDR: RewriteLdr(PrimitiveType.Word32); break;
case Opcode.LDRB: RewriteLdr(PrimitiveType.Byte); break;
case Opcode.LDRH: RewriteLdr(PrimitiveType.UInt16); break;
case Opcode.LDRSB: RewriteLdr(PrimitiveType.SByte); break;
case Opcode.LDRSH: RewriteLdr(PrimitiveType.Int16); break;
case Opcode.LDM: RewriteLdm(); break;
case Opcode.LDMDB: RewriteLdm(); break;
case Opcode.NOP: emitter.Nop(); break;
case Opcode.MOV: RewriteMov(); break;
case Opcode.MVN: RewriteUnaryOp(Operator.Not); break;
case Opcode.ORR: RewriteBinOp(emitter.Or, false); break;
case Opcode.PUSH: RewritePush(); break;
case Opcode.RSB: RewriteRevBinOp(Operator.ISub, instr.ArchitectureDetail.UpdateFlags); break;
case Opcode.STM: RewriteStm(); break;
case Opcode.STMDB: RewriteStm(); break;
case Opcode.STMIB: RewriteStmib(); break;
case Opcode.STR: RewriteStr(PrimitiveType.Word32); break;
case Opcode.STRB: RewriteStr(PrimitiveType.Byte); break;
case Opcode.STRH: RewriteStr(PrimitiveType.UInt16); break;
case Opcode.SUB: RewriteBinOp(emitter.ISub, instr.ArchitectureDetail.UpdateFlags); break;
case Opcode.SVC: RewriteSvc(); break;
case Opcode.TEQ: RewriteTeq(); break;
case Opcode.TST: RewriteTst(); break;
}
yield return(ric);
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.iclass = instr.InstructionClass;
var rtls = new List <RtlInstruction>();
this.m = new RtlEmitter(rtls);
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
case Mnemonic.reserved:
m.Invalid(); break;
case Mnemonic.add: RewriteBinop(m.IAdd); break;
case Mnemonic.addi: RewriteBinop(m.IAdd); break;
case Mnemonic.and: RewriteBinop(m.And); break;
case Mnemonic.andhi: RewriteHiImm(m.And); break;
case Mnemonic.andi: RewriteBinop(m.And); break;
case Mnemonic.b: RewriteIndirectGoto(); break;
case Mnemonic.be: RewriteBranch(m.Eq); break;
case Mnemonic.bg: RewriteBranch(m.Gt); break;
case Mnemonic.bge: RewriteBranch(m.Ge); break;
case Mnemonic.bgeu: RewriteBranch(m.Uge); break;
case Mnemonic.bgu: RewriteBranch(m.Ugt); break;
case Mnemonic.bi: RewriteGoto(); break;
case Mnemonic.bne: RewriteBranch(m.Ne); break;
case Mnemonic.call: RewriteCall(); break;
case Mnemonic.calli: RewriteCall(); break;
case Mnemonic.cmpe: RewriteCmp(m.Eq); break;
case Mnemonic.cmpei: RewriteCmp(m.Eq); break;
case Mnemonic.cmpg: RewriteCmp(m.Gt); break;
case Mnemonic.cmpgi: RewriteCmp(m.Gt); break;
case Mnemonic.cmpge: RewriteCmp(m.Ge); break;
case Mnemonic.cmpgei: RewriteCmp(m.Ge); break;
case Mnemonic.cmpgeu: RewriteCmp(m.Uge); break;
case Mnemonic.cmpgeui: RewriteCmp(m.Uge); break;
case Mnemonic.cmpgu: RewriteCmp(m.Ugt); break;
case Mnemonic.cmpgui: RewriteCmp(m.Ugt); break;
case Mnemonic.cmpne: RewriteCmp(m.Ne); break;
case Mnemonic.cmpnei: RewriteCmp(m.Ne); break;
case Mnemonic.div: RewriteBinop(m.SDiv); break;
case Mnemonic.divu: RewriteBinop(m.UDiv); break;
case Mnemonic.lb: RewriteLoad(PrimitiveType.Int32); break;
case Mnemonic.lbu: RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.lh: RewriteLoad(PrimitiveType.Int32); break;
case Mnemonic.lhu: RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.lw: RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.mod: RewriteBinop(m.Mod); break;
case Mnemonic.modu: RewriteBinop(m.Mod); break;
case Mnemonic.mul: RewriteBinop(m.IMul); break;
case Mnemonic.muli: RewriteBinop(m.IMul); break;
case Mnemonic.nor: RewriteBinop(Nor); break;
case Mnemonic.nori: RewriteBinop(Nor); break;
case Mnemonic.or: RewriteBinop(m.Or); break;
case Mnemonic.orhi: RewriteHiImm(m.Or); break;
case Mnemonic.ori: RewriteBinop(m.Or); break;
case Mnemonic.sb: RewriteStore(); break;
case Mnemonic.sextb: RewriteSext(PrimitiveType.SByte); break;
case Mnemonic.sexth: RewriteSext(PrimitiveType.Int16); break;
case Mnemonic.sh: RewriteStore(); break;
case Mnemonic.sl: RewriteBinop(m.Shl); break;
case Mnemonic.sli: RewriteBinop(m.Shl); break;
case Mnemonic.sr: RewriteBinop(m.Sar); break;
case Mnemonic.sri: RewriteBinop(m.Sar); break;
case Mnemonic.sru: RewriteBinop(m.Shr); break;
case Mnemonic.srui: RewriteBinop(m.Shr); break;
case Mnemonic.sub: RewriteBinop(m.ISub); break;
case Mnemonic.sw: RewriteStore(); break;
case Mnemonic.xnor: RewriteBinop(Xnor); break;
case Mnemonic.xnori: RewriteBinop(Xnor); break;
case Mnemonic.xor: RewriteBinop(m.Xor); break;
case Mnemonic.xori: RewriteBinop(m.Xor); break;
}
yield return(new RtlInstructionCluster(instr.Address, instr.Length, rtls.ToArray())
{
Class = iclass
});
}
}
private void RewriteExg()
{
EmitUnitTest();
iclass = InstrClass.Invalid;
m.Invalid();
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
var instrs = new List <RtlInstruction>();
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.iclass = instr.InstructionClass;
instrs.Clear();
this.m = new RtlEmitter(instrs);
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
goto case Mnemonic.invalid;
case Mnemonic.invalid:
iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.abx: RewriteAbx(); break;
case Mnemonic.adca: RewriteBinary(Registers.A, Adc, NZVC); break;
case Mnemonic.adcb: RewriteBinary(Registers.B, Adc, NZVC); break;
case Mnemonic.adda: RewriteBinary(Registers.A, m.IAdd, NZVC); break;
case Mnemonic.addb: RewriteBinary(Registers.B, m.IAdd, NZVC); break;
case Mnemonic.addd: RewriteBinary(Registers.D, m.IAdd, NZVC); break;
case Mnemonic.anda: RewriteBinary(Registers.A, m.And, NZ0_); break;
case Mnemonic.andb: RewriteBinary(Registers.B, m.And, NZ0_); break;
case Mnemonic.andcc: RewriteModifyCc(m.And); break;
case Mnemonic.asr: RewriteUnary(Shl1, NZ_C); break;
case Mnemonic.beq: RewriteBranch(ConditionCode.EQ, FlagM.Z); break;
case Mnemonic.bge: RewriteBranch(ConditionCode.GE, FlagM.N | FlagM.V); break;
case Mnemonic.bgt: RewriteBranch(ConditionCode.GT, FlagM.N | FlagM.Z | FlagM.V); break;
case Mnemonic.bhi: RewriteBranch(ConditionCode.UGT, FlagM.Z | FlagM.C); break;
case Mnemonic.bhs: RewriteBranch(ConditionCode.UGE, FlagM.C); break;
case Mnemonic.bita: RewriteBinaryTest(Registers.A, m.And, NZ0_); break;
case Mnemonic.bitb: RewriteBinaryTest(Registers.A, m.And, NZ0_); break;
case Mnemonic.ble: RewriteBranch(ConditionCode.LE, FlagM.N | FlagM.Z | FlagM.V); break;
case Mnemonic.blo: RewriteBranch(ConditionCode.ULT, FlagM.C); break;
case Mnemonic.bls: RewriteBranch(ConditionCode.ULE, FlagM.Z | FlagM.C); break;
case Mnemonic.blt: RewriteBranch(ConditionCode.LT, FlagM.N | FlagM.V); break;
case Mnemonic.bmi: RewriteBranch(ConditionCode.LT, FlagM.N); break;
case Mnemonic.bne: RewriteBranch(ConditionCode.NE, FlagM.Z); break;
case Mnemonic.bpl: RewriteBranch(ConditionCode.GE, FlagM.N); break;
case Mnemonic.bra: RewriteBra(); break;
case Mnemonic.brn: m.Nop(); break;
case Mnemonic.bsr: RewriteBsr(); break;
case Mnemonic.bvc: RewriteBranch(ConditionCode.NO, FlagM.V); break;
case Mnemonic.bvs: RewriteBranch(ConditionCode.OV, FlagM.V); break;
case Mnemonic.clr: RewriteUnary(Clr, ClrCc); break;
case Mnemonic.cmpa: RewriteBinaryTest(Registers.A, m.ISub, NZVC); break;
case Mnemonic.cmpb: RewriteBinaryTest(Registers.B, m.ISub, NZVC); break;
case Mnemonic.cmpd: RewriteBinaryTest(Registers.D, m.ISub, NZVC); break;
case Mnemonic.cmps: RewriteBinaryTest(Registers.S, m.ISub, NZVC); break;
case Mnemonic.cmpu: RewriteBinaryTest(Registers.U, m.ISub, NZVC); break;
case Mnemonic.cmpx: RewriteBinaryTest(Registers.X, m.ISub, NZVC); break;
case Mnemonic.cmpy: RewriteBinaryTest(Registers.Y, m.ISub, NZVC); break;
case Mnemonic.com: RewriteUnary(m.Comp, NZ01); break;
case Mnemonic.cwai: RewriteCwai(); break;
case Mnemonic.daa: RewriteDaa(); break;
case Mnemonic.dec: RewriteUnary(Dec, NZV); break;
case Mnemonic.eora: RewriteBinaryTest(Registers.A, m.Xor, NZ0_); break;
case Mnemonic.eorb: RewriteBinaryTest(Registers.B, m.Xor, NZ0_); break;
case Mnemonic.exg: RewriteExg(); break;
case Mnemonic.inc: RewriteUnary(Inc, NZV); break;
case Mnemonic.jmp: RewriteJmp(); break;
case Mnemonic.jsr: RewriteJsr(); break;
case Mnemonic.lbeq: RewriteBranch(ConditionCode.EQ, FlagM.Z); break;
case Mnemonic.lbge: RewriteBranch(ConditionCode.GE, FlagM.N | FlagM.V); break;
case Mnemonic.lbgt: RewriteBranch(ConditionCode.GT, FlagM.N | FlagM.Z | FlagM.V); break;
case Mnemonic.lbhi: RewriteBranch(ConditionCode.UGT, FlagM.Z | FlagM.C); break;
case Mnemonic.lbhs: RewriteBranch(ConditionCode.UGE, FlagM.C); break;
case Mnemonic.lble: RewriteBranch(ConditionCode.LE, FlagM.N | FlagM.Z | FlagM.V); break;
case Mnemonic.lblo: RewriteBranch(ConditionCode.ULT, FlagM.C); break;
case Mnemonic.lbls: RewriteBranch(ConditionCode.ULE, FlagM.Z | FlagM.C); break;
case Mnemonic.lblt: RewriteBranch(ConditionCode.LT, FlagM.N | FlagM.V); break;
case Mnemonic.lbmi: RewriteBranch(ConditionCode.LT, FlagM.N); break;
case Mnemonic.lbne: RewriteBranch(ConditionCode.NE, FlagM.Z); break;
case Mnemonic.lbpl: RewriteBranch(ConditionCode.GE, FlagM.N); break;
case Mnemonic.lbra: RewriteBra(); break;
case Mnemonic.lbrn: m.Nop(); break;
case Mnemonic.lbsr: RewriteBsr(); break;
case Mnemonic.lbvc: RewriteBranch(ConditionCode.NO, FlagM.V); break;
case Mnemonic.lbvs: RewriteBranch(ConditionCode.OV, FlagM.V); break;
case Mnemonic.lda: RewriteBinary(Registers.A, Load, NZ0_); break;
case Mnemonic.ldb: RewriteBinary(Registers.B, Load, NZ0_); break;
case Mnemonic.ldd: RewriteBinary(Registers.D, Load, NZ0_); break;
case Mnemonic.lds: RewriteBinary(Registers.S, Load, NZ0_); break;
case Mnemonic.ldu: RewriteBinary(Registers.U, Load, NZ0_); break;
case Mnemonic.ldx: RewriteBinary(Registers.X, Load, NZ0_); break;
case Mnemonic.ldy: RewriteBinary(Registers.Y, Load, NZ0_); break;
case Mnemonic.leas: RewriteLea(Registers.S, NoCc); break;
case Mnemonic.leau: RewriteLea(Registers.U, NoCc); break;
case Mnemonic.leax: RewriteLea(Registers.X, _Z__); break;
case Mnemonic.leay: RewriteLea(Registers.Y, _Z__); break;
case Mnemonic.lsl: RewriteUnary(Shl1, NZVC); break;
case Mnemonic.lsr: RewriteUnary(Shr1, NZ_C); break;
case Mnemonic.mul: RewriteMul(); break;
case Mnemonic.neg: RewriteUnary(m.Neg, NZVC); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.ora: RewriteBinary(Registers.A, m.Or, NZ0_); break;
case Mnemonic.orb: RewriteBinary(Registers.B, m.Or, NZ0_); break;
case Mnemonic.orcc: RewriteModifyCc(m.Or); break;
case Mnemonic.pshs: RewritePsh(Registers.S); break;
case Mnemonic.pshu: RewritePsh(Registers.U); break;
case Mnemonic.puls: RewritePul(Registers.S); break;
case Mnemonic.pulu: RewritePul(Registers.U); break;
case Mnemonic.rol: RewriteUnary(Rol1, NZVC); break;
case Mnemonic.ror: RewriteUnary(Ror1, NZ_C); break;
case Mnemonic.rti: RewriteRti(); break;
case Mnemonic.rts: RewriteRts(); break;
case Mnemonic.sbca: RewriteBinary(Registers.A, Sbc, NZVC); break;
case Mnemonic.sbcb: RewriteBinary(Registers.B, Sbc, NZVC); break;
case Mnemonic.sex: RewriteSex(); break;
case Mnemonic.sta: RewriteUnary(Store(Registers.A), NZ0_); break;
case Mnemonic.stb: RewriteUnary(Store(Registers.B), NZ0_); break;
case Mnemonic.std: RewriteUnary(Store(Registers.D), NZ0_); break;
case Mnemonic.sts: RewriteUnary(Store(Registers.S), NZ0_); break;
case Mnemonic.stu: RewriteUnary(Store(Registers.U), NZ0_); break;
case Mnemonic.stx: RewriteUnary(Store(Registers.X), NZ0_); break;
case Mnemonic.sty: RewriteUnary(Store(Registers.Y), NZ0_); break;
case Mnemonic.suba: RewriteBinary(Registers.A, m.ISub, NZVC); break;
case Mnemonic.subb: RewriteBinary(Registers.B, m.ISub, NZVC); break;
case Mnemonic.subd: RewriteBinary(Registers.D, m.ISub, NZVC); break;
case Mnemonic.swi: RewriteSwi(0xFFFA); break;
case Mnemonic.swi2: RewriteSwi(0xFFF4); break;
case Mnemonic.swi3: RewriteSwi(0xFFF2); break;
case Mnemonic.sync: RewriteSync(); break;
case Mnemonic.tfr: RewriteTfr(); break;
case Mnemonic.tst: RewriteTst(); break;
}
yield return(new RtlInstructionCluster(instr.Address, instr.Length, instrs.ToArray())
{
Class = iclass,
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.iclass = instr.InstructionClass;
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.add: RewriteAddSub(m.IAdd); break;
case Mnemonic.and: RewriteLogical(m.And); break;
case Mnemonic.bclr: RewriteBclr(); break;
case Mnemonic.bset: RewriteBset(); break;
case Mnemonic.calla: RewriteCalla(); break;
case Mnemonic.cmp: RewriteCmp(); break;
case Mnemonic.cmpb: RewriteCmp(); break;
case Mnemonic.cmpd1: RewriteCmpIncDec(-1); break;
case Mnemonic.diswdt: RewriteDiswdt(); break;
case Mnemonic.einit: RewriteEinit(); break;
case Mnemonic.jmpa: RewriteJmpa(); break;
case Mnemonic.jmpr: RewriteJmpr(); break;
case Mnemonic.jmps: RewriteJmps(); break;
case Mnemonic.jnb: RewriteJnb(); break;
case Mnemonic.mov: RewriteMov(); break;
case Mnemonic.movb: RewriteMov(); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.push: RewritePush(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.reti: RewriteReti(); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
instrs.Clear();
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.iclass = InstrClass.Linear;
var instrs = new List <RtlInstruction>();
this.m = new RtlEmitter(instrs);
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
goto case Mnemonic.invalid;
case Mnemonic.invalid:
iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.aghi: RewriteAhi(PrimitiveType.Word64); break;
case Mnemonic.ahi: RewriteAhi(PrimitiveType.Word32); break;
case Mnemonic.agr: RewriteAgr(); break;
case Mnemonic.ar: RewriteAr(); break;
case Mnemonic.basr: RewriteBasr(); break;
case Mnemonic.ber: RewriteBranch(ConditionCode.EQ); break;
case Mnemonic.bler: RewriteBranch(ConditionCode.LE); break;
case Mnemonic.br: RewriteBr(); break;
case Mnemonic.brasl: RewriteBrasl(); break;
case Mnemonic.brctg: RewriteBrctg(); break;
case Mnemonic.chi: RewriteChi(); break;
case Mnemonic.clc: RewriteClc(); break;
case Mnemonic.clg: RewriteClg(); break;
case Mnemonic.cli: RewriteCli(); break;
case Mnemonic.j: RewriteJ(); break;
case Mnemonic.je: RewriteJcc(ConditionCode.EQ); break;
case Mnemonic.jg: RewriteJcc(ConditionCode.GT); break;
case Mnemonic.jh: RewriteJcc(ConditionCode.UGT); break;
case Mnemonic.jne: RewriteJcc(ConditionCode.NE); break;
case Mnemonic.la: RewriteLa(); break;
case Mnemonic.larl: RewriteLarl(); break;
case Mnemonic.l: RewriteL(PrimitiveType.Word32); break;
case Mnemonic.lg: RewriteL(PrimitiveType.Word64); break;
case Mnemonic.lgf: RewriteLgf(); break;
case Mnemonic.lgfr: RewriteLgfr(); break;
case Mnemonic.lghi: RewriteLghi(); break;
case Mnemonic.lgr: RewriteLgr(); break;
case Mnemonic.lhi: RewriteLhi(); break;
case Mnemonic.lmg: RewriteLmg(); break;
case Mnemonic.lr: RewriteLr(); break;
case Mnemonic.ltgr: RewriteLtgr(); break;
case Mnemonic.mvi: RewriteMvi(); break;
case Mnemonic.mvz: RewriteMvz(); break;
case Mnemonic.nc: RewriteNc(); break;
case Mnemonic.ngr: RewriteNgr(); break;
case Mnemonic.nopr: m.Nop(); break;
case Mnemonic.sgr: RewriteSgr(); break;
case Mnemonic.srag: RewriteSrag(); break;
case Mnemonic.srlg: RewriteSrlg(); break;
case Mnemonic.st: RewriteSt(PrimitiveType.Word32); break;
case Mnemonic.stg: RewriteSt(PrimitiveType.Word64); break;
case Mnemonic.stmg: RewriteStmg(); break;
case Mnemonic.xc: RewriteXc(); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
instrCur = dasm.Current;
var addr = instrCur.Address;
var rtlInstructions = new List <RtlInstruction>();
iclass = InstrClass.Linear;
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.fmuls: RewriteFmuls(); break;
case Mnemonic.fnegs: RewriteFmovs(); break;
case Mnemonic.fstod: RewriteFstod(); break;
case Mnemonic.fsubs: RewriteFsubs(); break;
case Mnemonic.jmpl: RewriteJmpl(); break;
case Mnemonic.ld: RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.lddf: RewriteLoad(PrimitiveType.Real64); break;
case Mnemonic.ldf: RewriteLoad(PrimitiveType.Real32); break;
case Mnemonic.ldd: RewriteLoad(PrimitiveType.Word64); break;
case Mnemonic.ldsb: RewriteLoad(PrimitiveType.SByte); break;
case Mnemonic.ldsh: RewriteLoad(PrimitiveType.Int16); break;
case Mnemonic.ldsw: RewriteLoad(PrimitiveType.Int32); break;
case Mnemonic.ldstub: RewriteLdstub(); break;
case Mnemonic.ldub: RewriteLoad(PrimitiveType.Byte); break;
case Mnemonic.lduh: RewriteLoad(PrimitiveType.Word16); break;
case Mnemonic.lduw: RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.ldx: RewriteLoad(PrimitiveType.Word64); break;
case Mnemonic.ldfsr: RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.mulx: RewriteAlu(m.IMul, false); break;
case Mnemonic.mulscc: RewriteMulscc(); break;
case Mnemonic.or: RewriteAlu(m.Or, false); break;
case Mnemonic.orcc: RewriteAluCc(m.Or, false); break;
case Mnemonic.orn: RewriteAlu(m.Or, true); break;
case Mnemonic.orncc: RewriteAlu(m.Or, true); break;
case Mnemonic.restore: RewriteRestore(); break;
case Mnemonic.rett: RewriteRett(); break;
case Mnemonic.@return: RewriteReturn(); break;
case Mnemonic.save: RewriteSave(); break;
case Mnemonic.sethi: RewriteSethi(); break;
case Mnemonic.sdiv: RewriteAlu(m.SDiv, false); break;
case Mnemonic.sdivcc: RewriteAlu(m.SDiv, false); break;
case Mnemonic.sll: RewriteAlu(m.Shl, false); break;
case Mnemonic.sllx: RewriteAlu(m.Shl, false); break;
case Mnemonic.smul: RewriteAlu(m.SMul, false); break;
case Mnemonic.smulcc: RewriteAluCc(m.SMul, false); break;
case Mnemonic.sra: RewriteAlu(m.Sar, false); break;
case Mnemonic.srax: RewriteAlu(m.Sar, false); break;
case Mnemonic.srl: RewriteAlu(m.Shr, false); break;
case Mnemonic.srlx: RewriteAlu(m.Shr, false); break;
case Mnemonic.st: RewriteStore(PrimitiveType.Word32); break;
case Mnemonic.stb: RewriteStore(PrimitiveType.Byte); break;
case Mnemonic.std: RewriteStore(PrimitiveType.Word64); break;
case Mnemonic.stdf: RewriteStore(PrimitiveType.Real64); break;
case Mnemonic.stf: RewriteStore(PrimitiveType.Real32); break;
case Mnemonic.sth: RewriteStore(PrimitiveType.Word16); break;
case Mnemonic.stw: RewriteStore(PrimitiveType.Word32); break;
case Mnemonic.stx: RewriteStore(PrimitiveType.Word64); break;
case Mnemonic.stfsr: RewriteStore(PrimitiveType.Word32); break;
case Mnemonic.sub: RewriteAlu(m.ISub, false); break;
case Mnemonic.subcc: RewriteAluCc(m.ISub, false); break;
case Mnemonic.subx: RewriteAddxSubx(m.ISub, false); break;
case Mnemonic.subxcc: RewriteAddxSubx(m.ISub, true); break;
case Mnemonic.ta: RewriteTrap(Constant.True()); break;
case Mnemonic.tn: RewriteTrap(Constant.False()); break;
case Mnemonic.tne: RewriteTrap(m.Test(ConditionCode.NE, Grf(FlagM.ZF))); break;
case Mnemonic.te: RewriteTrap(m.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break;
case Mnemonic.udiv: RewriteAlu(m.UDiv, false); break;
case Mnemonic.udivcc: RewriteAluCc(m.UDiv, false); break;
case Mnemonic.umul: RewriteAlu(m.UMul, false); break;
case Mnemonic.umulcc: RewriteAluCc(m.UMul, false); break;
case Mnemonic.unimp: m.Invalid(); break;
case Mnemonic.xor: RewriteAlu(m.Xor, false); break;
case Mnemonic.xorcc: RewriteAlu(m.Xor, true); break;
case Mnemonic.xnor: RewriteAlu(XNor, false); break;
case Mnemonic.xnorcc: RewriteAlu(XNor, true); break;
}
yield return(m.MakeCluster(addr, 4, iclass));
}
}
public void Rewrite(AvrInstruction instr)
{
this.instr = instr;
this.rtlInstructions = new List <RtlInstruction>();
this.iclass = instr.InstructionClass;
this.m = new RtlEmitter(rtlInstructions);
switch (instr.Mnemonic)
{
case Mnemonic.adc: RewriteAdcSbc(m.IAdd); break;
case Mnemonic.add: RewriteBinOp(m.IAdd, CmpFlags); break;
case Mnemonic.adiw: RewriteAddSubIW(m.IAdd); break;
case Mnemonic.and: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Mnemonic.andi: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Mnemonic.asr: RewriteAsr(); break;
case Mnemonic.brcc: RewriteBranch(ConditionCode.UGE, FlagM.CF); break;
case Mnemonic.brcs: RewriteBranch(ConditionCode.ULT, FlagM.CF); break;
case Mnemonic.breq: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break;
case Mnemonic.brge: RewriteBranch(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Mnemonic.brid: RewriteBranch(FlagM.IF, false); break;
case Mnemonic.brne: RewriteBranch(ConditionCode.NE, FlagM.ZF); break;
case Mnemonic.brpl: RewriteBranch(ConditionCode.GE, FlagM.NF); break;
case Mnemonic.call: RewriteCall(); break;
case Mnemonic.cli: RewriteCli(); break;
case Mnemonic.com: RewriteUnary(m.Comp, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF, FlagM.CF); break;
case Mnemonic.cp: RewriteCp(); break;
case Mnemonic.cpi: RewriteCp(); break;
case Mnemonic.cpc: RewriteCpc(); break;
case Mnemonic.cpse: SkipIf(m.Eq); break;
case Mnemonic.dec: RewriteIncDec(m.ISub); break;
case Mnemonic.des: RewriteDes(); break;
case Mnemonic.eor: RewriteBinOp(m.Xor, LogicalFlags, FlagM.VF); break;
case Mnemonic.icall: RewriteIcall(); break;
case Mnemonic.@in: RewriteIn(); break;
case Mnemonic.inc: RewriteIncDec(m.IAdd); break;
case Mnemonic.ijmp: RewriteIjmp(); break;
case Mnemonic.jmp: RewriteJmp(); break;
case Mnemonic.ld: RewriteLd(); break;
case Mnemonic.ldd: RewriteLd(); break;
case Mnemonic.ldi: RewriteLdi(); break;
case Mnemonic.lds: RewriteLds(); break;
case Mnemonic.lpm: RewriteLpm(); break;
case Mnemonic.lsr: RewriteLsr(); break;
case Mnemonic.mov: RewriteMov(); break;
case Mnemonic.movw: RewriteMovw(); break;
case Mnemonic.muls: RewriteMuls(); break;
case Mnemonic.neg: RewriteUnary(m.Neg, CmpFlags); break;
case Mnemonic.@out: RewriteOut(); break;
case Mnemonic.or: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Mnemonic.ori: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Mnemonic.pop: RewritePop(); break;
case Mnemonic.push: RewritePush(); break;
case Mnemonic.rcall: RewriteCall(); break;
case Mnemonic.ror: RewriteRor(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.reti: RewriteRet(); break; //$TODO: more to indicate interrupt return?
case Mnemonic.rjmp: RewriteJmp(); break;
case Mnemonic.sbc: RewriteAdcSbc(m.ISub); break;
case Mnemonic.sbci: RewriteAdcSbc(m.ISub); break;
case Mnemonic.sbis: RewriteSbis(); return; // We've already added ourself to clusters.
case Mnemonic.sbiw: RewriteAddSubIW(m.ISub); break;
case Mnemonic.sbrc: SkipIf(Sbrc); break;
case Mnemonic.sbrs: SkipIf(Sbrs); break;
case Mnemonic.sec: RewriteSetBit(FlagM.CF, true); break;
case Mnemonic.sei: RewriteSei(); break;
case Mnemonic.st: RewriteSt(); break;
case Mnemonic.std: RewriteSt(); break;
case Mnemonic.sts: RewriteSts(); break;
case Mnemonic.sub: RewriteBinOp(m.ISub, CmpFlags); break;
case Mnemonic.subi: RewriteBinOp(m.ISub, CmpFlags); break;
case Mnemonic.swap: RewriteSwap(); break;
default:
host.Error(instr.Address, string.Format("AVR8 instruction '{0}' is not supported yet.", instr.Mnemonic));
EmitUnitTest();
m.Invalid();
break;
}
clusters.Add(m.MakeCluster(instr.Address, instr.Length, iclass));
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
var cluster = new List <RtlInstruction>();
m = new RtlEmitter(cluster);
iclass = instr.InstructionClass;
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
host.Warn(
instr.Address,
"AArch64 instruction {0} is not supported yet.",
instr);
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.add: RewriteMaybeSimdBinary(m.IAdd, "__add_{0}"); break;
case Mnemonic.adds: RewriteBinary(m.IAdd, this.NZCV); break;
case Mnemonic.addv: RewriteAddv(); break;
case Mnemonic.adr: RewriteUnary(n => n); break;
case Mnemonic.asrv: RewriteBinary(m.Sar); break;
case Mnemonic.bic: RewriteBinary((a, b) => m.And(a, m.Comp(b))); break;
case Mnemonic.adrp: RewriteAdrp(); break;
case Mnemonic.and: RewriteBinary(m.And); break;
case Mnemonic.ands: RewriteBinary(m.And, this.NZ00); break;
case Mnemonic.asr: RewriteBinary(m.Sar); break;
case Mnemonic.b: RewriteB(); break;
case Mnemonic.bfm: RewriteBfm(); break;
case Mnemonic.bl: RewriteBl(); break;
case Mnemonic.blr: RewriteBlr(); break;
case Mnemonic.br: RewriteBr(); break;
case Mnemonic.cbnz: RewriteCb(m.Ne0); break;
case Mnemonic.cbz: RewriteCb(m.Eq0); break;
case Mnemonic.ccmn: RewriteCcmn(); break;
case Mnemonic.ccmp: RewriteCcmp(); break;
case Mnemonic.clz: RewriteClz(); break;
case Mnemonic.cmp: RewriteCmp(); break;
case Mnemonic.cmeq: RewriteCmeq(); break;
case Mnemonic.csel: RewriteCsel(); break;
case Mnemonic.csinc: RewriteCsinc(); break;
case Mnemonic.csinv: RewriteCsinv(); break;
case Mnemonic.csneg: RewriteCsneg(); break;
case Mnemonic.dsb: RewriteDsb(); break;
case Mnemonic.dup: RewriteDup(); break;
case Mnemonic.eor: RewriteBinary(m.Xor); break;
case Mnemonic.fabs: RewriteFabs(); break;
case Mnemonic.fadd: RewriteFadd(); break;
case Mnemonic.fcmp: RewriteFcmp(); break;
case Mnemonic.fcsel: RewriteFcsel(); break;
case Mnemonic.fcvt: RewriteFcvt(); break;
case Mnemonic.fcvtms: RewriteFcvtms(); break;
case Mnemonic.fcvtps: RewriteFcvtps(); break;
case Mnemonic.fcvtzs: RewriteFcvtzs(); break;
case Mnemonic.fdiv: RewriteMaybeSimdBinary(m.FDiv, "__fdiv_{0}", Domain.Real); break;
case Mnemonic.fmadd: RewriteIntrinsicFTernary("__fmaddf", "__fmadd"); break;
case Mnemonic.fmsub: RewriteIntrinsicFTernary("__fmsubf", "__fmsub"); break;
case Mnemonic.fmax: RewriteIntrinsicFBinary("fmaxf", "fmax"); break;
case Mnemonic.fmin: RewriteIntrinsicFBinary("fminf", "fmin"); break;
case Mnemonic.fmov: RewriteFmov(); break;
case Mnemonic.fmul: RewriteFmul(); break;
case Mnemonic.fneg: RewriteUnary(m.FNeg); break;
case Mnemonic.fnmul: RewriteFnmul(); break;
case Mnemonic.fsqrt: RewriteFsqrt(); break;
case Mnemonic.fsub: RewriteMaybeSimdBinary(m.FSub, "__fsub_{0}", Domain.Real); break;
case Mnemonic.isb: RewriteIsb(); break;
case Mnemonic.ld1r: RewriteLdNr("__ld1r"); break;
case Mnemonic.ld2: RewriteLdN("__ld2"); break;
case Mnemonic.ld3: RewriteLdN("__ld3"); break;
case Mnemonic.ld4: RewriteLdN("__ld4"); break;
case Mnemonic.ldp: RewriteLoadStorePair(true); break;
case Mnemonic.ldpsw: RewriteLoadStorePair(true, PrimitiveType.Int32, PrimitiveType.Int64); break;
case Mnemonic.ldr: RewriteLdr(null); break;
case Mnemonic.ldrb: RewriteLdr(PrimitiveType.Byte); break;
case Mnemonic.ldrh: RewriteLdr(PrimitiveType.Word16); break;
case Mnemonic.ldrsb: RewriteLdr(PrimitiveType.SByte); break;
case Mnemonic.ldrsh: RewriteLdr(PrimitiveType.Int16); break;
case Mnemonic.ldrsw: RewriteLdr(PrimitiveType.Int32); break;
case Mnemonic.lslv: RewriteBinary(m.Shl); break;
case Mnemonic.lsrv: RewriteBinary(m.Shr); break;
case Mnemonic.ldur: RewriteLdr(null); break;
case Mnemonic.ldurb: RewriteLdr(PrimitiveType.Byte); break;
case Mnemonic.ldurh: RewriteLdr(PrimitiveType.Word16); break;
case Mnemonic.ldursb: RewriteLdr(PrimitiveType.SByte); break;
case Mnemonic.ldursh: RewriteLdr(PrimitiveType.Int16); break;
case Mnemonic.ldursw: RewriteLdr(PrimitiveType.Int32); break;
case Mnemonic.lsl: RewriteBinary(m.Shl); break;
case Mnemonic.lsr: RewriteBinary(m.Shr); break;
case Mnemonic.madd: RewriteMaddSub(m.IAdd); break;
case Mnemonic.mneg: RewriteBinary((a, b) => m.Neg(m.IMul(a, b))); break;
case Mnemonic.msub: RewriteMaddSub(m.ISub); break;
case Mnemonic.mov: RewriteMov(); break;
case Mnemonic.movi: RewriteMovi(); break;
case Mnemonic.movk: RewriteMovk(); break;
case Mnemonic.movn: RewriteMovn(); break;
case Mnemonic.movz: RewriteMovz(); break;
case Mnemonic.mrs: RewriteMrs(); break;
case Mnemonic.msr: RewriteMsr(); break;
case Mnemonic.mul: RewriteMaybeSimdBinary(m.IMul, "__mul_{0}"); break;
case Mnemonic.mvn: RewriteUnary(m.Comp); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.not: RewriteMaybeSimdUnary(m.Comp, "__not_{0}"); break;
case Mnemonic.orr: RewriteBinary(m.Or); break;
case Mnemonic.orn: RewriteBinary((a, b) => m.Or(a, m.Comp(b))); break;
case Mnemonic.prfm: RewritePrfm(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.rev16: RewriteRev16(); break;
case Mnemonic.ror: RewriteRor(); break;
case Mnemonic.rorv: RewriteRor(); break;
case Mnemonic.sbfiz: RewriteSbfiz(); break;
case Mnemonic.sbfm: RewriteUSbfm("__sbfm"); break;
case Mnemonic.scvtf: RewriteScvtf(); break;
case Mnemonic.sdiv: RewriteBinary(m.SDiv); break;
case Mnemonic.shrn: RewriteShrn(); break;
case Mnemonic.smaddl: RewriteMaddl(PrimitiveType.Int64, m.SMul); break;
case Mnemonic.smax: RewriteSmax(); break;
case Mnemonic.smaxv: RewriteSmaxv(); break;
case Mnemonic.smc: RewriteSmc(); break;
case Mnemonic.smull: RewriteMull(PrimitiveType.Int64, m.SMul); break;
case Mnemonic.st1: RewriteStN("__st1"); break;
case Mnemonic.st2: RewriteStN("__st2"); break;
case Mnemonic.st3: RewriteStN("__st3"); break;
case Mnemonic.st4: RewriteStN("__st4"); break;
case Mnemonic.stlr: RewriteStlr(); break;
case Mnemonic.stp: RewriteLoadStorePair(false); break;
case Mnemonic.str: RewriteStr(null); break;
case Mnemonic.strb: RewriteStr(PrimitiveType.Byte); break;
case Mnemonic.strh: RewriteStr(PrimitiveType.Word16); break;
case Mnemonic.stur: RewriteStr(null); break;
case Mnemonic.sturb: RewriteStr(PrimitiveType.Byte); break;
case Mnemonic.sturh: RewriteStr(PrimitiveType.Word16); break;
case Mnemonic.sub: RewriteBinary(m.ISub); break;
case Mnemonic.subs: RewriteBinary(m.ISub, NZCV); break;
case Mnemonic.svc: RewriteSvc(); break;
case Mnemonic.sxtb: RewriteUSxt(Domain.SignedInt, 8); break;
case Mnemonic.sxth: RewriteUSxt(Domain.SignedInt, 16); break;
case Mnemonic.sxtl: RewriteSimdUnary("__sxtl_{0}", Domain.SignedInt); break;
case Mnemonic.sxtw: RewriteUSxt(Domain.SignedInt, 32); break;
case Mnemonic.tbnz: RewriteTb(m.Ne0); break;
case Mnemonic.tbz: RewriteTb(m.Eq0); break;
case Mnemonic.test: RewriteTest(); break;
case Mnemonic.uaddw: RewriteUaddw(); break;
case Mnemonic.ubfm: RewriteUSbfm("__ubfm"); break;
case Mnemonic.ucvtf: RewriteIcvt(Domain.UnsignedInt); break;
case Mnemonic.udiv: RewriteBinary(m.UDiv); break;
case Mnemonic.umaddl: RewriteMaddl(PrimitiveType.UInt64, m.UMul); break;
case Mnemonic.umlal: RewriteUmlal(); break;
case Mnemonic.umull: RewriteMull(PrimitiveType.UInt64, m.UMul); break;
case Mnemonic.umulh: RewriteMulh(PrimitiveType.UInt64, m.UMul); break;
case Mnemonic.uxtb: RewriteUSxt(Domain.UnsignedInt, 8); break;
case Mnemonic.uxth: RewriteUSxt(Domain.UnsignedInt, 16); break;
case Mnemonic.uxtl: RewriteSimdUnary("__uxtl_{0}", Domain.UnsignedInt); break;
case Mnemonic.uxtw: RewriteUSxt(Domain.UnsignedInt, 32); break;
case Mnemonic.xtn: RewriteSimdUnary("__xtn_{0}", Domain.None); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
/// <summary>
/// Iterator that yields one RtlIntructionCluster for each x86 instruction.
/// </summary>
/// <returns></returns>
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
instrCur = dasm.Current;
var addr = instrCur.Address;
this.rtlInstructions = new List <RtlInstruction>();
this.rtlc = instrCur.InstructionClass;
m = new RtlEmitter(rtlInstructions);
orw = arch.ProcessorMode.CreateOperandRewriter(arch, m, binder, host);
switch (instrCur.code)
{
default:
EmitUnitTest();
host.Warn(
dasm.Current.Address,
"x86 instruction '{0}' is not supported yet.",
instrCur.code);
goto case Opcode.illegal;
case Opcode.illegal: rtlc = InstrClass.Invalid; m.Invalid(); break;
case Opcode.aaa: RewriteAaa(); break;
case Opcode.aad: RewriteAad(); break;
case Opcode.aam: RewriteAam(); break;
case Opcode.aas: RewriteAas(); break;
case Opcode.adc: RewriteAdcSbb(m.IAdd); break;
case Opcode.add: RewriteAddSub(Operator.IAdd); break;
case Opcode.addss: RewriteScalarBinop(m.FAdd, PrimitiveType.Real32); break;
case Opcode.addsd:
case Opcode.vaddsd: RewriteScalarBinop(m.FAdd, PrimitiveType.Real64); break;
case Opcode.addps: RewritePackedBinop("__addps", PrimitiveType.Real32); break;
case Opcode.addpd: RewritePackedBinop("__addpd", PrimitiveType.Real64); break;
case Opcode.aesimc: RewriteAesimc(); break;
case Opcode.and: RewriteLogical(Operator.And); break;
case Opcode.andnps: RewriteAndnps(); break;
case Opcode.andpd: RewritePackedBinop("__andpd", PrimitiveType.Real64); break;
case Opcode.andps: RewritePackedBinop("__andps", PrimitiveType.Real32); break;
case Opcode.arpl: RewriteArpl(); break;
case Opcode.bound: RewriteBound(); break;
case Opcode.bsf: RewriteBsf(); break;
case Opcode.bsr: RewriteBsr(); break;
case Opcode.bswap: RewriteBswap(); break;
case Opcode.bt: RewriteBt(); break;
case Opcode.btc: RewriteBtc(); break;
case Opcode.btr: RewriteBtr(); break;
case Opcode.bts: RewriteBts(); break;
case Opcode.call: RewriteCall(instrCur.op1, instrCur.op1.Width); break;
case Opcode.cbw: RewriteCbw(); break;
case Opcode.clc: RewriteSetFlag(FlagM.CF, Constant.False()); break;
case Opcode.cld: RewriteSetFlag(FlagM.DF, Constant.False()); break;
case Opcode.cli: RewriteCli(); break;
case Opcode.clts: RewriteClts(); break;
case Opcode.cmc: m.Assign(orw.FlagGroup(FlagM.CF), m.Not(orw.FlagGroup(FlagM.CF))); break;
case Opcode.cmova: RewriteConditionalMove(ConditionCode.UGT, instrCur.op1, instrCur.op2); break;
case Opcode.cmovbe: RewriteConditionalMove(ConditionCode.ULE, instrCur.op1, instrCur.op2); break;
case Opcode.cmovc: RewriteConditionalMove(ConditionCode.ULT, instrCur.op1, instrCur.op2); break;
case Opcode.cmovge: RewriteConditionalMove(ConditionCode.GE, instrCur.op1, instrCur.op2); break;
case Opcode.cmovg: RewriteConditionalMove(ConditionCode.GT, instrCur.op1, instrCur.op2); break;
case Opcode.cmovl: RewriteConditionalMove(ConditionCode.LT, instrCur.op1, instrCur.op2); break;
case Opcode.cmovle: RewriteConditionalMove(ConditionCode.LE, instrCur.op1, instrCur.op2); break;
case Opcode.cmovnc: RewriteConditionalMove(ConditionCode.UGE, instrCur.op1, instrCur.op2); break;
case Opcode.cmovno: RewriteConditionalMove(ConditionCode.NO, instrCur.op1, instrCur.op2); break;
case Opcode.cmovns: RewriteConditionalMove(ConditionCode.NS, instrCur.op1, instrCur.op2); break;
case Opcode.cmovnz: RewriteConditionalMove(ConditionCode.NE, instrCur.op1, instrCur.op2); break;
case Opcode.cmovo: RewriteConditionalMove(ConditionCode.OV, instrCur.op1, instrCur.op2); break;
case Opcode.cmovpe: RewriteConditionalMove(ConditionCode.PE, instrCur.op1, instrCur.op2); break;
case Opcode.cmovpo: RewriteConditionalMove(ConditionCode.PO, instrCur.op1, instrCur.op2); break;
case Opcode.cmovs: RewriteConditionalMove(ConditionCode.SG, instrCur.op1, instrCur.op2); break;
case Opcode.cmovz: RewriteConditionalMove(ConditionCode.EQ, instrCur.op1, instrCur.op2); break;
case Opcode.cmpxchg: RewriteCmpxchg(); break;
case Opcode.cmp: RewriteCmp(); break;
case Opcode.cmps: RewriteStringInstruction(); break;
case Opcode.cmppd: RewriteCmpp("__cmppd", PrimitiveType.Real64); break;
case Opcode.cmpps: RewriteCmpp("__cmpps", PrimitiveType.Real32); break;
case Opcode.cmpsb: RewriteStringInstruction(); break;
case Opcode.comisd: RewriteComis(PrimitiveType.Real64); break;
case Opcode.comiss: RewriteComis(PrimitiveType.Real32); break;
case Opcode.cpuid: RewriteCpuid(); break;
case Opcode.cvtpi2ps: RewriteCvtPackedToReal(PrimitiveType.Real32); break;
case Opcode.cvtps2pi: RewriteCvtps2pi("__cvtps2pi", PrimitiveType.Real32, PrimitiveType.Int32); break;
case Opcode.cvtps2pd: RewriteCvtps2pi("__cvtps2pd", PrimitiveType.Real32, PrimitiveType.Real64); break;
case Opcode.cvtdq2ps: RewriteCvtps2pi("__cvtdq2ps", PrimitiveType.Int64, PrimitiveType.Real32); break;
case Opcode.cvtsd2si: RewriteCvts2si(PrimitiveType.Real64); break;
case Opcode.cvtsd2ss: RewriteCvtToReal(PrimitiveType.Real32); break;
case Opcode.cvtsi2ss:
case Opcode.vcvtsi2ss: RewriteCvtToReal(PrimitiveType.Real32); break;
case Opcode.cvtsi2sd:
case Opcode.vcvtsi2sd: RewriteCvtToReal(PrimitiveType.Real64); break;
case Opcode.cvtss2sd: RewriteCvtToReal(PrimitiveType.Real64); break;
case Opcode.cvtss2si: RewriteCvts2si(PrimitiveType.Real32); break;
case Opcode.cvttsd2si: RewriteCvtts2si(PrimitiveType.Real64); break;
case Opcode.cvttss2si: RewriteCvtts2si(PrimitiveType.Real32); break;
case Opcode.cvttps2pi: RewriteCvttps2pi(); break;
case Opcode.cwd: RewriteCwd(); break;
case Opcode.daa: EmitDaaDas("__daa"); break;
case Opcode.das: EmitDaaDas("__das"); break;
case Opcode.dec: RewriteIncDec(-1); break;
case Opcode.div: RewriteDivide(m.UDiv, Domain.UnsignedInt); break;
case Opcode.divps: RewritePackedBinop("__divps", PrimitiveType.Real32); break;
case Opcode.divsd: RewriteScalarBinop(m.FDiv, PrimitiveType.Real64); break;
case Opcode.divss: RewriteScalarBinop(m.FDiv, PrimitiveType.Real32); break;
case Opcode.f2xm1: RewriteF2xm1(); break;
case Opcode.emms: RewriteEmms(); break;
case Opcode.enter: RewriteEnter(); break;
case Opcode.fabs: RewriteFabs(); break;
case Opcode.fadd: EmitCommonFpuInstruction(m.FAdd, false, false); break;
case Opcode.faddp: EmitCommonFpuInstruction(m.FAdd, false, true); break;
case Opcode.fbld: RewriteFbld(); break;
case Opcode.fbstp: RewriteFbstp(); break;
case Opcode.fchs: EmitFchs(); break;
case Opcode.fclex: RewriteFclex(); break;
case Opcode.fcmovb: RewriteFcmov(FlagM.CF, ConditionCode.GE); break;
case Opcode.fcmovbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GT); break;
case Opcode.fcmove: RewriteFcmov(FlagM.ZF, ConditionCode.NE); break;
case Opcode.fcmovnb: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GE); break;
case Opcode.fcmovnbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.LE); break;
case Opcode.fcmovne: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break;
case Opcode.fcmovnu: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break;
case Opcode.fcmovu: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break;
case Opcode.fcom: RewriteFcom(0); break;
case Opcode.fcomi: RewrteFcomi(false); break;
case Opcode.fcomip: RewrteFcomi(true); break;
case Opcode.fcomp: RewriteFcom(1); break;
case Opcode.fcompp: RewriteFcom(2); break;
case Opcode.fcos: RewriteFUnary("cos"); break;
case Opcode.fdecstp: RewriteFdecstp(); break;
case Opcode.fdiv: EmitCommonFpuInstruction(m.FDiv, false, false); break;
case Opcode.fdivp: EmitCommonFpuInstruction(m.FDiv, false, true); break;
case Opcode.ffree: RewriteFfree(); break;
case Opcode.fiadd: EmitCommonFpuInstruction(m.FAdd, false, false, PrimitiveType.Real64); break;
case Opcode.ficom: RewriteFicom(false); break;
case Opcode.ficomp: RewriteFicom(true); break;
case Opcode.fimul: EmitCommonFpuInstruction(m.FMul, false, false, PrimitiveType.Real64); break;
case Opcode.fisub: EmitCommonFpuInstruction(m.FSub, false, false, PrimitiveType.Real64); break;
case Opcode.fisubr: EmitCommonFpuInstruction(m.FSub, true, false, PrimitiveType.Real64); break;
case Opcode.fidiv: EmitCommonFpuInstruction(m.FDiv, false, false, PrimitiveType.Real64); break;
case Opcode.fidivr: EmitCommonFpuInstruction(m.FDiv, true, false, PrimitiveType.Real64); break;
case Opcode.fdivr: EmitCommonFpuInstruction(m.FDiv, true, false); break;
case Opcode.fdivrp: EmitCommonFpuInstruction(m.FDiv, true, true); break;
case Opcode.fild: RewriteFild(); break;
case Opcode.fincstp: RewriteFincstp(); break;
case Opcode.fist: RewriteFist(false); break;
case Opcode.fistp: RewriteFist(true); break;
case Opcode.fisttp: RewriteFistt(true); break;
case Opcode.fld: RewriteFld(); break;
case Opcode.fld1: RewriteFldConst(1.0); break;
case Opcode.fldcw: RewriteFldcw(); break;
case Opcode.fldenv: RewriteFldenv(); break;
case Opcode.fldl2e: RewriteFldConst(Constant.LgE()); break;
case Opcode.fldl2t: RewriteFldConst(Constant.Lg10()); break;
case Opcode.fldlg2: RewriteFldConst(Constant.Log2()); break;
case Opcode.fldln2: RewriteFldConst(Constant.Ln2()); break;
case Opcode.fldpi: RewriteFldConst(Constant.Pi()); break;
case Opcode.fldz: RewriteFldConst(0.0); break;
case Opcode.fmul: EmitCommonFpuInstruction(m.FMul, false, false); break;
case Opcode.fmulp: EmitCommonFpuInstruction(m.FMul, false, true); break;
case Opcode.fninit: RewriteFninit(); break;
case Opcode.fnop: m.Nop(); break;
case Opcode.fpatan: RewriteFpatan(); break;
case Opcode.fprem: RewriteFprem(); break;
case Opcode.fprem1: RewriteFprem1(); break;
case Opcode.fptan: RewriteFptan(); break;
case Opcode.frndint: RewriteFUnary("__rndint"); break;
case Opcode.frstor: RewriteFrstor(); break;
case Opcode.fsave: RewriteFsave(); break;
case Opcode.fscale: RewriteFscale(); break;
case Opcode.fsin: RewriteFUnary("sin"); break;
case Opcode.fsincos: RewriteFsincos(); break;
case Opcode.fsqrt: RewriteFUnary("sqrt"); break;
case Opcode.fst: RewriteFst(false); break;
case Opcode.fstenv: RewriteFstenv(); break;
case Opcode.fstcw: RewriterFstcw(); break;
case Opcode.fstp: RewriteFst(true); break;
case Opcode.fstsw: RewriteFstsw(); break;
case Opcode.fsub: EmitCommonFpuInstruction(m.FSub, false, false); break;
case Opcode.fsubp: EmitCommonFpuInstruction(m.FSub, false, true); break;
case Opcode.fsubr: EmitCommonFpuInstruction(m.FSub, true, false); break;
case Opcode.fsubrp: EmitCommonFpuInstruction(m.FSub, true, true); break;
case Opcode.ftst: RewriteFtst(); break;
case Opcode.fucom: RewriteFcom(0); break;
case Opcode.fucomp: RewriteFcom(1); break;
case Opcode.fucompp: RewriteFcom(2); break;
case Opcode.fucomi: RewrteFcomi(false); break;
case Opcode.fucomip: RewrteFcomi(true); break;
case Opcode.fxam: RewriteFxam(); break;
case Opcode.fxch: RewriteExchange(); break;
case Opcode.fxtract: RewriteFxtract(); break;
case Opcode.fyl2x: RewriteFyl2x(); break;
case Opcode.fyl2xp1: RewriteFyl2xp1(); break;
case Opcode.getsec: RewriteGetsec(); break;
case Opcode.hlt: RewriteHlt(); break;
case Opcode.idiv: RewriteDivide(m.SDiv, Domain.SignedInt); break;
case Opcode.@in: RewriteIn(); break;
case Opcode.imul: RewriteMultiply(Operator.SMul, Domain.SignedInt); break;
case Opcode.inc: RewriteIncDec(1); break;
case Opcode.insb: RewriteStringInstruction(); break;
case Opcode.ins: RewriteStringInstruction(); break;
case Opcode.@int: RewriteInt(); break;
case Opcode.into: RewriteInto(); break;
case Opcode.invd: RewriteInvd(); break;
case Opcode.iret: RewriteIret(); break;
case Opcode.jmp: RewriteJmp(); break;
case Opcode.ja: RewriteConditionalGoto(ConditionCode.UGT, instrCur.op1); break;
case Opcode.jbe: RewriteConditionalGoto(ConditionCode.ULE, instrCur.op1); break;
case Opcode.jc: RewriteConditionalGoto(ConditionCode.ULT, instrCur.op1); break;
case Opcode.jcxz: RewriteJcxz(); break;
case Opcode.jge: RewriteConditionalGoto(ConditionCode.GE, instrCur.op1); break;
case Opcode.jg: RewriteConditionalGoto(ConditionCode.GT, instrCur.op1); break;
case Opcode.jl: RewriteConditionalGoto(ConditionCode.LT, instrCur.op1); break;
case Opcode.jle: RewriteConditionalGoto(ConditionCode.LE, instrCur.op1); break;
case Opcode.jnc: RewriteConditionalGoto(ConditionCode.UGE, instrCur.op1); break;
case Opcode.jno: RewriteConditionalGoto(ConditionCode.NO, instrCur.op1); break;
case Opcode.jns: RewriteConditionalGoto(ConditionCode.NS, instrCur.op1); break;
case Opcode.jnz: RewriteConditionalGoto(ConditionCode.NE, instrCur.op1); break;
case Opcode.jo: RewriteConditionalGoto(ConditionCode.OV, instrCur.op1); break;
case Opcode.jpe: RewriteConditionalGoto(ConditionCode.PE, instrCur.op1); break;
case Opcode.jpo: RewriteConditionalGoto(ConditionCode.PO, instrCur.op1); break;
case Opcode.js: RewriteConditionalGoto(ConditionCode.SG, instrCur.op1); break;
case Opcode.jz: RewriteConditionalGoto(ConditionCode.EQ, instrCur.op1); break;
case Opcode.lahf: RewriteLahf(); break;
case Opcode.lar: RewriteLar(); break;
case Opcode.lds: RewriteLxs(Registers.ds); break;
case Opcode.ldmxcsr: RewriteLdmxcsr(); break;
case Opcode.stmxcsr: RewriteStmxcsr(); break;
case Opcode.lea: RewriteLea(); break;
case Opcode.leave: RewriteLeave(); break;
case Opcode.les: RewriteLxs(Registers.es); break;
case Opcode.lfence: RewriteLfence(); break;
case Opcode.lfs: RewriteLxs(Registers.fs); break;
case Opcode.lgs: RewriteLxs(Registers.gs); break;
case Opcode.lgdt: RewriteLxdt("__lgdt"); break;
case Opcode.lidt: RewriteLxdt("__lidt"); break;
case Opcode.lldt: RewriteLxdt("__lldt"); break;
case Opcode.@lock: RewriteLock(); break;
case Opcode.lods: RewriteStringInstruction(); break;
case Opcode.lodsb: RewriteStringInstruction(); break;
case Opcode.loop: RewriteLoop(0, ConditionCode.EQ); break;
case Opcode.loope: RewriteLoop(FlagM.ZF, ConditionCode.EQ); break;
case Opcode.loopne: RewriteLoop(FlagM.ZF, ConditionCode.NE); break;
case Opcode.lsl: RewriteLsl(); break;
case Opcode.lss: RewriteLxs(Registers.ss); break;
case Opcode.maskmovq: RewriteMaskmovq(); break;
case Opcode.maxps: RewritePackedBinop("__maxps", PrimitiveType.Real32); break;
case Opcode.mfence: RewriteMfence(); break;
case Opcode.minpd: RewritePackedBinop("__minpd", PrimitiveType.Real64); break;
case Opcode.minps: RewritePackedBinop("__minps", PrimitiveType.Real32); break;
case Opcode.mov: RewriteMov(); break;
case Opcode.movapd:
case Opcode.movaps:
case Opcode.vmovapd:
case Opcode.vmovaps: RewriteMov(); break;
case Opcode.movd: RewriteMovzx(); break;
case Opcode.movdqa: RewriteMov(); break;
case Opcode.movhpd: RewritePackedUnaryop("__movhpd", PrimitiveType.Real64, PrimitiveType.Real64); break;
case Opcode.movhps: RewritePackedUnaryop("__movhps", PrimitiveType.Real32, PrimitiveType.Real64); break;
case Opcode.movlpd: RewritePackedUnaryop("__movlpd", PrimitiveType.Real64, PrimitiveType.Real64); break;
case Opcode.movlps: RewritePackedUnaryop("__movlps", PrimitiveType.Real32, PrimitiveType.Real64); break;
case Opcode.movlhps: RewriteMovlhps(); break;
case Opcode.movmskpd: RewriteMovmsk("__movmskpd", PrimitiveType.Real64); break;
case Opcode.movmskps: RewriteMovmsk("__movmskps", PrimitiveType.Real32); break;
case Opcode.movnti: RewriteMov(); break;
case Opcode.movntps: RewriteMov(); break;
case Opcode.movntq: RewriteMov(); break;
case Opcode.movq: RewriteMov(); break;
case Opcode.movs: RewriteStringInstruction(); break;
case Opcode.movsb: RewriteStringInstruction(); break;
case Opcode.movsd:
case Opcode.vmovsd: RewriteMovssd(PrimitiveType.Real64); break;
case Opcode.movss:
case Opcode.vmovss: RewriteMovssd(PrimitiveType.Real32); break;
case Opcode.movsx: RewriteMovsx(); break;
case Opcode.movups: RewriteMov(); break;
case Opcode.movupd: RewriteMov(); break;
case Opcode.movzx: RewriteMovzx(); break;
case Opcode.mul: RewriteMultiply(Operator.UMul, Domain.UnsignedInt); break;
case Opcode.mulpd: RewritePackedBinop("__mulpd", PrimitiveType.Real64); break;
case Opcode.mulps: RewritePackedBinop("__mulps", PrimitiveType.Real32); break;
case Opcode.mulss: RewriteScalarBinop(m.FMul, PrimitiveType.Real32); break;
case Opcode.mulsd: RewriteScalarBinop(m.FMul, PrimitiveType.Real64); break;
case Opcode.neg: RewriteNeg(); break;
case Opcode.nop: m.Nop(); break;
case Opcode.not: RewriteNot(); break;
case Opcode.or: RewriteLogical(BinaryOperator.Or); break;
case Opcode.orpd: RewritePackedBinop("__orpd", PrimitiveType.Real64); break;
case Opcode.orps: RewritePackedBinop("__orps", PrimitiveType.Real32); break;
case Opcode.@out: RewriteOut(); break;
case Opcode.@outs: RewriteStringInstruction(); break;
case Opcode.@outsb: RewriteStringInstruction(); break;
case Opcode.packssdw: RewritePackedBinop("__packssdw", PrimitiveType.Int32, new ArrayType(PrimitiveType.Int16, 0)); break;
case Opcode.packuswb: RewritePackedBinop("__packuswb", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt8, 0)); break;
case Opcode.paddb: RewritePackedBinop("__paddb", PrimitiveType.Byte); break;
case Opcode.paddd: RewritePackedBinop("__paddd", PrimitiveType.Word32); break;
case Opcode.paddq:
case Opcode.vpaddq: RewritePackedBinop("__paddq", PrimitiveType.Word64); break;
case Opcode.paddsw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break;
case Opcode.paddsb: RewritePackedBinop("__paddsb", PrimitiveType.SByte); break;
case Opcode.paddusb: RewritePackedBinop("__paddusb", PrimitiveType.Byte); break;
case Opcode.paddusw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break;
case Opcode.paddw: RewritePackedBinop("__paddw", PrimitiveType.Word16); break;
case Opcode.pand:
case Opcode.vpand: RewritePackedLogical("__pand"); break;
case Opcode.pandn:
case Opcode.vpandn: RewritePackedLogical("__pandn"); break;
case Opcode.pause: RewritePause(); break;
case Opcode.palignr: RewritePalignr(); break;
case Opcode.pavgb: RewritePavg("__pavgb", PrimitiveType.Byte); break;
case Opcode.pavgw: RewritePavg("__pavgw", PrimitiveType.Byte); break;
case Opcode.pcmpeqb: RewritePcmp("__pcmpeqb", PrimitiveType.Byte); break;
case Opcode.pcmpeqd: RewritePcmp("__pcmpeqd", PrimitiveType.Word32); break;
case Opcode.pcmpeqw: RewritePcmp("__pcmpeqw", PrimitiveType.Word16); break;
case Opcode.pcmpgtb: RewritePcmp("__pcmpgtb", PrimitiveType.Byte); break;
case Opcode.pcmpgtd: RewritePcmp("__pcmpgtd", PrimitiveType.Word32); break;
case Opcode.pcmpgtw: RewritePcmp("__pcmpgtw", PrimitiveType.Word16); break;
case Opcode.pextrw:
case Opcode.vextrw: RewritePextrw(); break;
case Opcode.pinsrw:
case Opcode.vpinsrw: RewritePinsrw(); break;
case Opcode.pmaddwd: RewritePackedBinop("__pmaddwd", PrimitiveType.Word16, new ArrayType(PrimitiveType.Word32, 0)); break;
case Opcode.pmaxsw: RewritePackedBinop("__pmaxsw", PrimitiveType.Int16); break;
case Opcode.pmaxub: RewritePackedBinop("__pmaxub", PrimitiveType.UInt8); break;
case Opcode.pminsw: RewritePackedBinop("__pminsw", PrimitiveType.Int16); break;
case Opcode.pminub: RewritePackedBinop("__pminub", PrimitiveType.UInt8); break;
case Opcode.pmovmskb: RewriteMovmsk("__pmovmskb", PrimitiveType.Byte); break;
case Opcode.pmulhuw: RewritePackedBinop("__pmulhuw", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt16, 8)); break;
case Opcode.pmulhw: RewritePackedBinop("__pmulhw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break;
case Opcode.pmullw:
case Opcode.vpmullw: RewritePackedBinop("__pmullw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break;
case Opcode.pmuludq: RewritePackedBinop("__pmuludq", PrimitiveType.UInt32, new ArrayType(PrimitiveType.UInt64, 0)); break;
case Opcode.prefetchw: RewritePrefetch("__prefetchw"); break;
case Opcode.psadbw: RewritePackedBinop("__psadbw", PrimitiveType.Byte, PrimitiveType.Word16); break;
case Opcode.pslld: RewritePackedBinop("__pslld", PrimitiveType.Word32); break;
case Opcode.psllq:
case Opcode.vpsllq: RewritePackedBinop("__psllq", PrimitiveType.Word64); break;
case Opcode.psllw: RewritePackedBinop("__psllw", PrimitiveType.Word16); break;
case Opcode.psrad: RewritePackedBinop("__psrad", PrimitiveType.Int32); break;
case Opcode.psraw: RewritePackedBinop("__psraw", PrimitiveType.Int16); break;
case Opcode.psrlq: RewritePackedBinop("__psrlq", PrimitiveType.Word64); break;
case Opcode.pop: RewritePop(); break;
case Opcode.popa: RewritePopa(); break;
case Opcode.popf: RewritePopf(); break;
case Opcode.por: RewritePackedLogical("__por"); break;
case Opcode.prefetchnta: RewritePrefetch("__prefetchnta"); break;
case Opcode.prefetcht0: RewritePrefetch("__prefetcht0"); break;
case Opcode.prefetcht1: RewritePrefetch("__prefetcht1"); break;
case Opcode.prefetcht2: RewritePrefetch("__prefetcht2"); break;
case Opcode.pshufd: RewritePshuf("__pshufd", PrimitiveType.Word32); break;
case Opcode.pshufw: RewritePshuf("__pshufw", PrimitiveType.Word16); break;
case Opcode.psrld: RewritePackedShift("__psrld", PrimitiveType.Word32); break;
case Opcode.psrlw: RewritePackedShift("__psrlw", PrimitiveType.Word16); break;
case Opcode.psubb: RewritePackedBinop("__psubb", PrimitiveType.Byte); break;
case Opcode.psubd:
case Opcode.vpsubd: RewritePackedBinop("__psubd", PrimitiveType.Word32); break;
case Opcode.psubq: RewritePackedBinop("__psubq", PrimitiveType.Word64); break;
case Opcode.psubsb: RewritePackedBinop("__psubsb", PrimitiveType.SByte); break;
case Opcode.psubsw: RewritePackedBinop("__psubsw", PrimitiveType.Word16); break;
case Opcode.psubusb: RewritePackedBinop("__psubusb", PrimitiveType.UInt8); break;
case Opcode.psubusw: RewritePackedBinop("__psubusw", PrimitiveType.UInt16); break;
case Opcode.psubw: RewritePackedBinop("__psubw", PrimitiveType.Word16); break;
case Opcode.punpckhbw: RewritePunpckhbw(); break;
case Opcode.punpckhdq: RewritePunpckhdq(); break;
case Opcode.punpckhwd: RewritePunpckhwd(); break;
case Opcode.punpcklbw: RewritePunpcklbw(); break;
case Opcode.punpckldq: RewritePunpckldq(); break;
case Opcode.punpcklwd: RewritePunpcklwd(); break;
case Opcode.push: RewritePush(); break;
case Opcode.pusha: RewritePusha(); break;
case Opcode.pushf: RewritePushf(); break;
case Opcode.pxor:
case Opcode.vpxor: RewritePxor(); break;
case Opcode.rcl: RewriteRotation(PseudoProcedure.RolC, true, true); break;
case Opcode.rcpps: RewritePackedUnaryop("__rcpps", PrimitiveType.Real32); break;
case Opcode.rcr: RewriteRotation(PseudoProcedure.RorC, true, false); break;
case Opcode.rol: RewriteRotation(PseudoProcedure.Rol, false, true); break;
case Opcode.ror: RewriteRotation(PseudoProcedure.Ror, false, false); break;
case Opcode.rdmsr: RewriteRdmsr(); break;
case Opcode.rdpmc: RewriteRdpmc(); break;
case Opcode.rdtsc: RewriteRdtsc(); break;
case Opcode.ret: RewriteRet(); break;
case Opcode.retf: RewriteRet(); break;
case Opcode.rsqrtps: RewritePackedUnaryop("__rsqrtps", PrimitiveType.Real32); break;
case Opcode.sahf: m.Assign(orw.FlagGroup(X86Instruction.DefCc(instrCur.code)), orw.AluRegister(Registers.ah)); break;
case Opcode.sar: RewriteBinOp(Operator.Sar); break;
case Opcode.sbb: RewriteAdcSbb(m.ISub); break;
case Opcode.scas: RewriteStringInstruction(); break;
case Opcode.scasb: RewriteStringInstruction(); break;
case Opcode.seta: RewriteSet(ConditionCode.UGT); break;
case Opcode.setc: RewriteSet(ConditionCode.ULT); break;
case Opcode.setbe: RewriteSet(ConditionCode.ULE); break;
case Opcode.setg: RewriteSet(ConditionCode.GT); break;
case Opcode.setge: RewriteSet(ConditionCode.GE); break;
case Opcode.setl: RewriteSet(ConditionCode.LT); break;
case Opcode.setle: RewriteSet(ConditionCode.LE); break;
case Opcode.setnc: RewriteSet(ConditionCode.UGE); break;
case Opcode.setno: RewriteSet(ConditionCode.NO); break;
case Opcode.setns: RewriteSet(ConditionCode.NS); break;
case Opcode.setnz: RewriteSet(ConditionCode.NE); break;
case Opcode.setpe: RewriteSet(ConditionCode.PE); break;
case Opcode.setpo: RewriteSet(ConditionCode.PO); break;
case Opcode.seto: RewriteSet(ConditionCode.OV); break;
case Opcode.sets: RewriteSet(ConditionCode.SG); break;
case Opcode.setz: RewriteSet(ConditionCode.EQ); break;
case Opcode.sfence: RewriteSfence(); break;
case Opcode.sgdt: RewriteSxdt("__sgdt"); break;
case Opcode.sha1msg2: RewriteSha1msg2(); break;
case Opcode.shl: RewriteBinOp(BinaryOperator.Shl); break;
case Opcode.shld: RewriteShxd("__shld"); break;
case Opcode.shr: RewriteBinOp(BinaryOperator.Shr); break;
case Opcode.shrd: RewriteShxd("__shrd"); break;
case Opcode.sidt: RewriteSxdt("__sidt"); break;
case Opcode.vshufps: RewritePackedTernaryop("__vshufps", PrimitiveType.Real32); break;
case Opcode.sldt: RewriteSxdt("__sldt"); break;
case Opcode.sqrtps: RewritePackedUnaryop("__sqrtps", PrimitiveType.Real32); break;
case Opcode.sqrtsd: RewriteSqrtsd(); break;
case Opcode.stc: RewriteSetFlag(FlagM.CF, Constant.True()); break;
case Opcode.std: RewriteSetFlag(FlagM.DF, Constant.True()); break;
case Opcode.sti: RewriteSti(); break;
case Opcode.stos: RewriteStringInstruction(); break;
case Opcode.stosb: RewriteStringInstruction(); break;
case Opcode.sub: RewriteAddSub(BinaryOperator.ISub); break;
case Opcode.subsd: RewriteScalarBinop(m.FSub, PrimitiveType.Real64); break;
case Opcode.subss: RewriteScalarBinop(m.FSub, PrimitiveType.Real32); break;
case Opcode.subpd: RewritePackedBinop("__subpd", PrimitiveType.Real64); break;
case Opcode.subps: RewritePackedBinop("__subps", PrimitiveType.Real32); break;
case Opcode.syscall: RewriteSyscall(); break;
case Opcode.sysenter: RewriteSysenter(); break;
case Opcode.sysexit: RewriteSysexit(); break;
case Opcode.sysret: RewriteSysret(); break;
case Opcode.ucomiss: RewriteComis(PrimitiveType.Real32); break;
case Opcode.ucomisd: RewriteComis(PrimitiveType.Real64); break;
case Opcode.ud2: rtlc = InstrClass.Invalid; m.Invalid(); break;
case Opcode.unpcklpd: RewritePackedBinop("__unpcklpd", PrimitiveType.Real64); break;
case Opcode.unpcklps: RewritePackedBinop("__unpcklps", PrimitiveType.Real32); break;
case Opcode.test: RewriteTest(); break;
case Opcode.wait: RewriteWait(); break;
case Opcode.wbinvd: RewriteWbinvd(); break;
case Opcode.wrmsr: RewriteWrsmr(); break;
case Opcode.xadd: RewriteXadd(); break;
case Opcode.xchg: RewriteExchange(); break;
case Opcode.xgetbv: RewriteXgetbv(); break;
case Opcode.xsetbv: RewriteXsetbv(); break;
case Opcode.xlat: RewriteXlat(); break;
case Opcode.xor: RewriteLogical(BinaryOperator.Xor); break;
case Opcode.xorpd:
case Opcode.vxorpd: RewritePackedBinop("__xorpd", PrimitiveType.Word64); break;
case Opcode.xorps: RewritePackedBinop("__xorps", PrimitiveType.Word32); break;
case Opcode.BOR_exp: RewriteFUnary("exp"); break;
case Opcode.BOR_ln: RewriteFUnary("log"); break;
}
var len = (int)(dasm.Current.Address - addr) + dasm.Current.Length;
yield return(new RtlInstructionCluster(addr, len, rtlInstructions.ToArray())
{
Class = rtlc
});
}
}
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 !;
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.rtlInstructions = new List <RtlInstruction>();
this.rtlc = RtlClass.Linear;
m = new RtlEmitter(this.rtlInstructions);
switch (instr.Opcode)
{
default:
host.Warn(
instr.Address,
"PDP-11 instruction {0} is not supported yet.",
instr.Opcode);
rtlc = RtlClass.Invalid;
m.Invalid();
break;
case Opcode.illegal: rtlc = RtlClass.Invalid; m.Invalid(); break;
case Opcode.adc: RewriteAdcSbc(m.IAdd); break;
case Opcode.add: RewriteAdd(); break;
case Opcode.addb: RewriteAdd(); break;
case Opcode.ash: RewriteShift(); break;
case Opcode.ashc: RewriteAshc(); break;
case Opcode.asl: RewriteAsl(); break;
case Opcode.asr: RewriteAsr(); break;
case Opcode.bcc: RewriteBxx(ConditionCode.UGE, FlagM.CF); break;
case Opcode.bcs: RewriteBxx(ConditionCode.ULT, FlagM.CF); break;
case Opcode.beq: RewriteBxx(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.bge: RewriteBxx(ConditionCode.GE, FlagM.VF | FlagM.NF); break;
case Opcode.bgt: RewriteBxx(ConditionCode.GT, FlagM.ZF | FlagM.NF | FlagM.VF); break;
case Opcode.bhi: RewriteBxx(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break;
case Opcode.bvs: RewriteBxx(ConditionCode.OV, FlagM.VF); break;
case Opcode.bic: RewriteBic(); break;
case Opcode.bis: RewriteBis(); break;
case Opcode.bisb: RewriteBis(); break;
case Opcode.bit: RewriteBit(); break;
case Opcode.bitb: RewriteBit(); break;
case Opcode.ble: RewriteBxx(ConditionCode.LE, FlagM.ZF | FlagM.NF | FlagM.VF); break;
case Opcode.blos: RewriteBxx(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break;
case Opcode.blt: RewriteBxx(ConditionCode.LT, FlagM.NF | FlagM.VF); break;
case Opcode.bmi: RewriteBxx(ConditionCode.LT, FlagM.NF); break;
case Opcode.bne: RewriteBxx(ConditionCode.NE, FlagM.ZF); break;
case Opcode.bpl: RewriteBxx(ConditionCode.GT, FlagM.NF); break;
case Opcode.bpt: RewriteBpt(); break;
case Opcode.br: RewriteBr(); break;
case Opcode.clr: RewriteClr(instr, m.Word16(0)); break;
case Opcode.clrb: RewriteClr(instr, m.Byte(0)); break;
case Opcode.clrflags: RewriteClrSetFlags(Constant.False); break;
case Opcode.cmp: RewriteCmp(); break;
case Opcode.com: RewriteCom(); break;
case Opcode.dec: RewriteIncDec(m.ISub); break;
case Opcode.div: RewriteDiv(); break;
case Opcode.emt: RewriteEmt(); break;
case Opcode.halt: RewriteHalt(); break;
case Opcode.iot: RewriteIot(); break;
case Opcode.inc: RewriteIncDec(m.IAdd); break;
case Opcode.jmp: RewriteJmp(); break;
case Opcode.jsr: RewriteJsr(); break;
case Opcode.mark: RewriteMark(); break;
case Opcode.mfpd: RewriteMfpd(); break;
case Opcode.mfpi: RewriteMfpi(); break;
case Opcode.mov: RewriteMov(); break;
case Opcode.movb: RewriteMov(); break;
case Opcode.mtpi: RewriteMtpi(); break;
case Opcode.mul: RewriteMul(); break;
case Opcode.neg: RewriteNeg(); break;
case Opcode.nop: m.Nop(); break;
case Opcode.reset: RewriteReset(); break;
case Opcode.rol: RewriteRotate(PseudoProcedure.Rol); break;
case Opcode.ror: RewriteRotate(PseudoProcedure.Ror); break;
case Opcode.rti: RewriteRti(); break;
case Opcode.rts: RewriteRts(); break;
case Opcode.rtt: RewriteRtt(); break;
case Opcode.sbc: RewriteAdcSbc(m.ISub); break;
case Opcode.setflags: RewriteClrSetFlags(Constant.True); break;
case Opcode.stcdi: RewriteStcdi(); break;
case Opcode.sob: RewriteSob(); break;
case Opcode.stexp: RewriteStexp(); break;
case Opcode.sub: RewriteSub(); break;
case Opcode.swab: RewriteSwab(); break;
case Opcode.sxt: RewriteSxt(); break;
case Opcode.trap: RewriteTrap(); break;
case Opcode.tst: RewriteTst(); break;
case Opcode.tstb: RewriteTst(); break;
case Opcode.wait: RewriteWait(); break;
case Opcode.xor: RewriteXor(); break;
}
yield return(new RtlInstructionCluster(instr.Address, instr.Length, this.rtlInstructions.ToArray())
{
Class = rtlc
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var addr = dasm.Current.Address;
var len = dasm.Current.Length;
var rtlInstructions = new List <RtlInstruction>();
iclass = InstrClass.Linear;
m = new RtlEmitter(rtlInstructions);
this.instr = dasm.Current;
switch (instr.Mnemonic)
{
default:
host.Error(instr.Address, $"Rewriting of Xtensa instruction '{instr}' not implemented yet.");
EmitUnitTest();
goto case Mnemonic.invalid;
case Mnemonic.invalid:
case Mnemonic.reserved:
iclass = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.abs: RewritePseudoFn("abs"); break;
case Mnemonic.add:
case Mnemonic.add_n: RewriteBinOp(m.IAdd); break;
case Mnemonic.add_s: RewriteBinOp(m.FAdd); break;
case Mnemonic.addi: RewriteAddi(); break;
case Mnemonic.addi_n: RewriteAddi(); break;
case Mnemonic.addmi: RewriteBinOp(m.IAdd); break;
case Mnemonic.addx2: RewriteAddx(2); break;
case Mnemonic.addx4: RewriteAddx(4); break;
case Mnemonic.addx8: RewriteAddx(8); break;
case Mnemonic.all4: RewriteAll(4, m.And); break;
case Mnemonic.all8: RewriteAll(8, m.And); break;
case Mnemonic.and: RewriteBinOp(m.And); break;
case Mnemonic.andb: RewriteBinOp(m.And); break;
case Mnemonic.andbc: RewriteBinOp((a, b) => m.And(a, m.Not(b))); break;
case Mnemonic.any4: RewriteAll(4, m.Or); break;
case Mnemonic.any8: RewriteAll(8, m.Or); break;
case Mnemonic.ball: RewriteBall(); break;
case Mnemonic.bany: RewriteBany(); break;
case Mnemonic.bbc:
case Mnemonic.bbci: RewriteBbx(m.Eq0); break;
case Mnemonic.bbs:
case Mnemonic.bbsi: RewriteBbx(m.Ne0); break;
case Mnemonic.beq:
case Mnemonic.beqi: RewriteBranch(m.Eq); break;
case Mnemonic.beqz:
case Mnemonic.beqz_n: RewriteBranchZ(m.Eq0); break;
case Mnemonic.bf: RewriteBranchZ(m.Not); break;
case Mnemonic.bge:
case Mnemonic.bgei: RewriteBranch(m.Ge); break;
case Mnemonic.bgeu:
case Mnemonic.bgeui: RewriteBranch(m.Uge); break;
case Mnemonic.bgez: RewriteBranchZ(m.Ge0); break;
case Mnemonic.blt: RewriteBranch(m.Lt); break;
case Mnemonic.blti: RewriteBranch(m.Lt); break;
case Mnemonic.bltu:
case Mnemonic.bltui: RewriteBranch(m.Ult); break;
case Mnemonic.bltz: RewriteBranchZ(m.Lt0); break;
case Mnemonic.bnall: RewriteBnall(); break;
case Mnemonic.bne: RewriteBranch(m.Ne); break;
case Mnemonic.bnei: RewriteBranch(m.Ne); break;
case Mnemonic.bnez:
case Mnemonic.bnez_n: RewriteBranchZ(m.Ne0); break;
case Mnemonic.bnone: RewriteBnone(); break;
case Mnemonic.@break: RewriteBreak(); break;
case Mnemonic.call0: RewriteCall0(); break;
case Mnemonic.call4: RewriteCallW(4); break;
case Mnemonic.call8: RewriteCallW(8); break;
case Mnemonic.call12: RewriteCallW(12); break;
case Mnemonic.callx0: RewriteCall0(); break;
case Mnemonic.callx4: RewriteCallW(4); break;
case Mnemonic.callx8: RewriteCallW(8); break;
case Mnemonic.callx12: RewriteCallW(12); break;
case Mnemonic.ceil_s: RewriteCvtFloatToIntegral("__ceil", PrimitiveType.Int32); break;
case Mnemonic.clamps: RewriteClamps(); break;
case Mnemonic.cust0: RewritePseudoProc("__cust0"); break;
case Mnemonic.cust1: RewritePseudoProc("__cust1"); break;
case Mnemonic.dhi: RewriteCacheFn("__dhi"); break;
case Mnemonic.dhu: RewriteCacheFn("__dhu"); break;
case Mnemonic.dhwb: RewriteCacheFn("__dhwb"); break;
case Mnemonic.dhwbi: RewriteCacheFn("__dhwbi"); break;
case Mnemonic.dii: RewriteCacheFn("__dii"); break;
case Mnemonic.diu: RewriteCacheFn("__diu"); break;
case Mnemonic.dpfr: RewriteCacheFn("__dpfr"); break;
case Mnemonic.dpfro: RewriteCacheFn("__dpfro"); break;
case Mnemonic.dpfw: RewriteCacheFn("__dpfw"); break;
case Mnemonic.dpfwo: RewriteCacheFn("__dpfwo"); break;
case Mnemonic.dsync: RewritePseudoProc("__dsync"); break;
case Mnemonic.esync: RewritePseudoProc("__esync"); break;
case Mnemonic.excw: RewritePseudoProc("__excw"); break;
case Mnemonic.extui: RewriteExtui(); break;
case Mnemonic.entry: RewriteEntry(); break;
case Mnemonic.float_s: RewriteFloat_s(PrimitiveType.Int32); break;
case Mnemonic.floor_s: RewritePseudoFn("__floor"); break;
case Mnemonic.iii: RewriteCacheFn("__iii"); break;
case Mnemonic.iitlb: RewritePseudoProc("__iitlb"); break;
case Mnemonic.ipf: RewriteCacheFn("__ipf"); break;
case Mnemonic.isync: RewritePseudoProc("__isync"); break;
case Mnemonic.j:
case Mnemonic.jx: RewriteJ(); break;
case Mnemonic.ill: RewriteIll(); break;
case Mnemonic.l16si: RewriteLsi(PrimitiveType.Int16); break;
case Mnemonic.l16ui: RewriteLui(PrimitiveType.UInt16); break;
case Mnemonic.l32ai: RewriteL32ai(); break;
case Mnemonic.l32i: RewriteL32i(); break;
case Mnemonic.l32e: RewriteL32e(); break;
case Mnemonic.l32i_n: RewriteL32i(); break;
case Mnemonic.l32r: RewriteCopy(); break;
case Mnemonic.l8ui: RewriteLui(PrimitiveType.Byte); break;
case Mnemonic.lddec: RewriteLddecinc(m.ISub); break;
case Mnemonic.ldinc: RewriteLddecinc(m.IAdd); break;
case Mnemonic.ldpte: RewritePseudoProc("__ldpte"); break;
case Mnemonic.loop: RewriteLoop(); break;
case Mnemonic.lsiu: RewriteLsiu(); break;
case Mnemonic.madd_s: RewriteMaddSub(m.FAdd); break;
case Mnemonic.memw: RewriteNop(); break; /// memory sync barriers?
case Mnemonic.max: RewriteMax(); break;
case Mnemonic.maxu: RewriteMaxu(); break;
case Mnemonic.min: RewriteMin(); break;
case Mnemonic.minu: RewriteMinu(); break;
case Mnemonic.mov_n: RewriteCopy(); break;
case Mnemonic.mov_s: RewriteCopy(); break;
case Mnemonic.movf:
case Mnemonic.movf_s: RewriteMovft(e => e); break;
case Mnemonic.movi: RewriteCopy(); break;
case Mnemonic.movi_n: RewriteMovi_n(); break;
case Mnemonic.movsp: RewriteCopy(); break;
case Mnemonic.moveqz:
case Mnemonic.moveqz_s: RewriteMovcc(m.Eq); break;
case Mnemonic.movltz:
case Mnemonic.movltz_s: RewriteMovcc(m.Lt); break;
case Mnemonic.movgez:
case Mnemonic.movgez_s: RewriteMovcc(m.Ge); break;
case Mnemonic.movnez:
case Mnemonic.movnez_s: RewriteMovcc(m.Ne); break;
case Mnemonic.movt:
case Mnemonic.movt_s: RewriteMovft(m.Not); break;
case Mnemonic.msub_s: RewriteMaddSub(m.FSub); break;
case Mnemonic.mul_aa_hh: RewriteMul("__mul_hh", Int40); break;
case Mnemonic.mul_aa_hl: RewriteMul("__mul_hl", Int40); break;
case Mnemonic.mul_aa_lh: RewriteMul("__mul_lh", Int40); break;
case Mnemonic.mul_aa_ll: RewriteMul("__mul_ll", Int40); break;
case Mnemonic.mul_ad_hh: RewriteMul("__mul_hh", Int40); break;
case Mnemonic.mul_ad_hl: RewriteMul("__mul_hl", Int40); break;
case Mnemonic.mul_ad_lh: RewriteMul("__mul_lh", Int40); break;
case Mnemonic.mul_ad_ll: RewriteMul("__mul_ll", Int40); break;
case Mnemonic.mul_da_hh: RewriteMul("__mul_hh", Int40); break;
case Mnemonic.mul_da_hl: RewriteMul("__mul_hl", Int40); break;
case Mnemonic.mul_da_lh: RewriteMul("__mul_lh", Int40); break;
case Mnemonic.mul_da_ll: RewriteMul("__mul_ll", Int40); break;
case Mnemonic.mul_dd_hh: RewriteMul("__mul_hh", Int40); break;
case Mnemonic.mul_dd_hl: RewriteMul("__mul_hl", Int40); break;
case Mnemonic.mul_dd_lh: RewriteMul("__mul_lh", Int40); break;
case Mnemonic.mul_dd_ll: RewriteMul("__mul_ll", Int40); break;
case Mnemonic.mula_aa_hh: RewriteMula("__mul_hh", Int40); break;
case Mnemonic.mula_aa_hl: RewriteMula("__mul_hl", Int40); break;
case Mnemonic.mula_aa_lh: RewriteMula("__mul_lh", Int40); break;
case Mnemonic.mula_aa_ll: RewriteMula("__mul_ll", Int40); break;
case Mnemonic.mula_ad_hh: RewriteMula("__mul_hh", Int40); break;
case Mnemonic.mula_ad_hl: RewriteMula("__mul_hl", Int40); break;
case Mnemonic.mula_ad_lh: RewriteMula("__mul_lh", Int40); break;
case Mnemonic.mula_ad_ll: RewriteMula("__mul_ll", Int40); break;
case Mnemonic.mula_da_hh: RewriteMula("__mul_hh", Int40); break;
case Mnemonic.mula_da_hh_lddec: RewriteMulaIncDec("__mul_hh", Int40, -4); break;
case Mnemonic.mula_da_hh_ldinc: RewriteMulaIncDec("__mul_hh", Int40, 4); break;
case Mnemonic.mula_da_hl: RewriteMula("__mul_hl", Int40); break;
case Mnemonic.mula_da_hl_lddec: RewriteMulaIncDec("__mul_hl", Int40, -4); break;
case Mnemonic.mula_da_hl_ldinc: RewriteMulaIncDec("__mul_hl", Int40, 4); break;
case Mnemonic.mula_da_lh: RewriteMula("__mul_lh", Int40); break;
case Mnemonic.mula_da_lh_lddec: RewriteMulaIncDec("__mul_lh", Int40, -4); break;
case Mnemonic.mula_da_lh_ldinc: RewriteMulaIncDec("__mul_lh", Int40, 4); break;
case Mnemonic.mula_da_ll: RewriteMula("__mul_ll", Int40); break;
case Mnemonic.mula_da_ll_lddec: RewriteMulaIncDec("__mul_ll", Int40, -4); break;
case Mnemonic.mula_da_ll_ldinc: RewriteMulaIncDec("__mul_ll", Int40, 4); break;
case Mnemonic.mula_dd_hh: RewriteMula("__mul_hh", Int40); break;
case Mnemonic.mula_dd_hh_lddec: RewriteMulaIncDec("__mul_hh", Int40, -4); break;
case Mnemonic.mula_dd_hl: RewriteMula("__mul_hl", Int40); break;
case Mnemonic.mula_dd_lh: RewriteMula("__mul_lh", Int40); break;
case Mnemonic.mula_dd_ll: RewriteMula("__mul_ll", Int40); break;
case Mnemonic.mula_dd_ll_lddec: RewriteMulaIncDec("__mul_ll", Int40, -4); break;
case Mnemonic.muls_aa_hh: RewriteMuls("__mul_hh", Int40); break;
case Mnemonic.muls_aa_hl: RewriteMuls("__mul_hl", Int40); break;
case Mnemonic.muls_aa_lh: RewriteMuls("__mul_lh", Int40); break;
case Mnemonic.muls_aa_ll: RewriteMuls("__mul_ll", Int40); break;
case Mnemonic.muls_ad_hh: RewriteMuls("__mul_hh", Int40); break;
case Mnemonic.muls_ad_hl: RewriteMuls("__mul_hl", Int40); break;
case Mnemonic.muls_ad_lh: RewriteMuls("__mul_lh", Int40); break;
case Mnemonic.muls_ad_ll: RewriteMuls("__mul_ll", Int40); break;
case Mnemonic.muls_da_hh: RewriteMuls("__mul_hh", Int40); break;
case Mnemonic.muls_da_hl: RewriteMuls("__mul_hl", Int40); break;
case Mnemonic.muls_da_lh: RewriteMuls("__mul_lh", Int40); break;
case Mnemonic.muls_da_ll: RewriteMuls("__mul_ll", Int40); break;
case Mnemonic.muls_dd_hh: RewriteMuls("__mul_hh", Int40); break;
case Mnemonic.muls_dd_hl: RewriteMuls("__mul_hl", Int40); break;
case Mnemonic.muls_dd_lh: RewriteMuls("__mul_lh", Int40); break;
case Mnemonic.muls_dd_ll: RewriteMuls("__mul_ll", Int40); break;
case Mnemonic.mul_s: RewriteBinOp(m.FMul); break;
case Mnemonic.mul16s: RewriteMul16(m.SMul, Domain.SignedInt); break;
case Mnemonic.mul16u: RewriteMul16(m.UMul, Domain.UnsignedInt); break;
case Mnemonic.mull: RewriteBinOp(m.IMul); break;
case Mnemonic.mulsh: RewriteMulh("__mulsh", PrimitiveType.Int32); break;
case Mnemonic.muluh: RewriteMulh("__muluh", PrimitiveType.UInt32); break;
case Mnemonic.neg: RewriteUnaryOp(m.Neg); break;
case Mnemonic.nsa: RewritePseudoFn("__nsa"); break;
case Mnemonic.nsau: RewritePseudoFn("__nsau"); break;
case Mnemonic.oeq_s: RewriteBinOp(m.FEq); break; //$REVIEW: what to do about 'ordered' and 'unordered'
case Mnemonic.ole_s: RewriteBinOp(m.FLe); break; //$REVIEW: what to do about 'ordered' and 'unordered'
case Mnemonic.olt_s: RewriteBinOp(m.FLt); break; //$REVIEW: what to do about 'ordered' and 'unordered'
case Mnemonic.or: RewriteOr(); break;
case Mnemonic.orb: RewriteOr(); break;
case Mnemonic.orbc: RewriteBinOp((a, b) => m.Or(a, m.Not(b))); break;
case Mnemonic.pitlb: RewritePseudoFn("__pitlb"); break;
case Mnemonic.quos: RewriteBinOp(m.SDiv); break;
case Mnemonic.quou: RewriteBinOp(m.UDiv); break;
case Mnemonic.rdtlb0: RewritePseudoFn("__rdtlb0"); break;
case Mnemonic.rdtlb1: RewritePseudoFn("__rdtlb1"); break;
case Mnemonic.rems: RewriteBinOp(m.Mod); break;
case Mnemonic.remu: RewriteBinOp(m.Mod); break;
case Mnemonic.ret:
case Mnemonic.ret_n: RewriteRet(); break;
case Mnemonic.rfe: RewriteRet(); break; //$REVIEW: emit some hint this is a return from exception?
case Mnemonic.rfi: RewriteRet(); break; //$REVIEW: emit some hint this is a return from interrupt?
case Mnemonic.ritlb0: RewritePseudoFn("__ritlb0"); break;
case Mnemonic.ritlb1: RewritePseudoFn("__ritlb1"); break;
case Mnemonic.rotw: RewritePseudoProc("__rotw"); break;
case Mnemonic.round_s: RewriteCvtFloatToIntegral("__round", PrimitiveType.Int32); break;
case Mnemonic.rsil: RewritePseudoFn("__rsil"); break;
case Mnemonic.rer: RewriteRer(); break;
case Mnemonic.rfr: RewriteCopy(); break;
case Mnemonic.rsr: RewriteCopy(); break;
case Mnemonic.rsync: RewriteRsync(); break;
case Mnemonic.rur: RewriteCopy(); break;
case Mnemonic.s16i: RewriteSi(PrimitiveType.Word16); break;
case Mnemonic.s32c1i: RewriteS32c1i(); break;
case Mnemonic.s32e: RewriteS32e(); break;
case Mnemonic.s32i:
case Mnemonic.s32i_n: RewriteSi(PrimitiveType.Word32); break;
case Mnemonic.s32ri: RewriteSi(PrimitiveType.Word32); break; //$REVIEW: what about concurrency semantics
case Mnemonic.s8i: RewriteSi(PrimitiveType.Byte); break;
case Mnemonic.sext: RewriteSext(); break;
case Mnemonic.sll: RewriteShift(m.Shl); break;
case Mnemonic.slli: RewriteShiftI(m.Shl); break;
case Mnemonic.sra: RewriteShift(m.Sar); break;
case Mnemonic.srai: RewriteShiftI(m.Sar); break;
case Mnemonic.src: RewriteSrc(); break;
case Mnemonic.srl: RewriteShift(m.Sar); break;
case Mnemonic.srli: RewriteShiftI(m.Shr); break;
case Mnemonic.ssa8b: RewriteSsa8b(); break;
case Mnemonic.ssa8l: RewriteSsa8l(); break;
case Mnemonic.ssi: RewriteSi(PrimitiveType.Real32); break;
case Mnemonic.ssl: RewriteSsl(); break;
case Mnemonic.ssr:
case Mnemonic.ssai: RewriteSsa(); break;
case Mnemonic.sub: RewriteBinOp(m.ISub); break;
case Mnemonic.sub_s: RewriteBinOp(m.FSub); break;
case Mnemonic.subx2: RewriteSubx(2); break;
case Mnemonic.subx4: RewriteSubx(4); break;
case Mnemonic.subx8: RewriteSubx(8); break;
case Mnemonic.syscall: RewriteSyscall(); break;
case Mnemonic.trunc_s: RewriteCvtFloatToIntegral("__trunc", PrimitiveType.Int32); break;
case Mnemonic.ueq_s: RewriteBinOp(m.Eq); break; //$REVIEW: what to do about 'ordered' and 'unordered'
case Mnemonic.ufloat_s: RewriteFloat_s(PrimitiveType.UInt32); break;
case Mnemonic.ule_s: RewriteBinOp(m.FLe); break; //$REVIEW: what to do about 'ordered' and 'unordered'
case Mnemonic.ult_s: RewriteBinOp(m.FLt); break; //$REVIEW: what to do about 'ordered' and 'unordered'
case Mnemonic.umul_aa_hh: RewriteMul("__umul_hh", UInt40); break;
case Mnemonic.umul_aa_hl: RewriteMul("__umul_hl", UInt40); break;
case Mnemonic.umul_aa_lh: RewriteMul("__umul_lh", UInt40); break;
case Mnemonic.umul_aa_ll: RewriteMul("__umul_ll", UInt40); break;
case Mnemonic.un_s: RewritePseudoFn("isunordered"); break;
case Mnemonic.utrunc_s: RewriteCvtFloatToIntegral("__utrunc", PrimitiveType.UInt32); break;
case Mnemonic.waiti: RewritePseudoProc("__waiti"); break;
case Mnemonic.wdtlb: RewritePseudoProc("__wdtlb"); break;
case Mnemonic.witlb: RewritePseudoProc("__witlb"); break;
case Mnemonic.wer: RewriteWer(); break;
case Mnemonic.wsr: RewriteWsr(); break;
case Mnemonic.wur: RewriteInverseCopy(); break;
case Mnemonic.xor: RewriteBinOp(m.Xor); break;
case Mnemonic.xorb: RewriteBinOp(m.Xor); break;
case Mnemonic.xsr: RewriteXsr(); break;
}
CheckForLoopExit();
yield return(m.MakeCluster(addr, len, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.iclass = instr.InstructionClass;
var instrs = new List <RtlInstruction>();
m = new RtlEmitter(instrs);
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
goto case Mnemonic.invalid;
case Mnemonic.invalid: m.Invalid(); break;
case Mnemonic.add: RewriteAdd(true); break;
case Mnemonic.add_c: RewriteAdd_c(); break;
case Mnemonic.add_l: RewriteAdd(false); break;
case Mnemonic.addb: RewriteAddb(); break;
case Mnemonic.addi: RewriteAddi(false); break;
case Mnemonic.addi_tc: RewriteAddi(true); break;
case Mnemonic.addib: RewriteAddb(); break;
case Mnemonic.addil: RewriteAddi(false); break;
case Mnemonic.and: RewriteLogical(m.And); break;
case Mnemonic.andcm: RewriteLogical((a, b) => m.And(a, m.Comp(b))); break;
case Mnemonic.b_l: RewriteBranch(); break;
case Mnemonic.be: RewriteBe(); break;
case Mnemonic.be_l: RewriteBe(); break;
case Mnemonic.bv: RewriteBv(); break;
case Mnemonic.cmpb: RewriteCmpb(0, 1); break;
case Mnemonic.cmpib: RewriteCmpb(1, 0); break;
case Mnemonic.@break: RewriteBreak(); break;
case Mnemonic.depwi: RewriteDepwi(); break;
case Mnemonic.diag: RewriteDiag(); break;
case Mnemonic.extrw: RewriteExtrw(); break;
case Mnemonic.fadd: RewriteFpArithmetic(m.FAdd); break;
case Mnemonic.fcpy: RewriteFcpy(); break;
case Mnemonic.fid: RewriteFid(); break;
case Mnemonic.fldd: RewriteFld(PrimitiveType.Real64); break;
case Mnemonic.fldw: RewriteFld(PrimitiveType.Real32); break;
case Mnemonic.fmpy: RewriteFpArithmetic(m.FMul); break;
case Mnemonic.fstd: RewriteFst(PrimitiveType.Real64); break;
case Mnemonic.fstw: RewriteFst(PrimitiveType.Real32); break;
case Mnemonic.fsub: RewriteFpArithmetic(m.FSub); break;
case Mnemonic.ldb: RewriteLd(PrimitiveType.Byte); break;
case Mnemonic.ldd: RewriteLd(PrimitiveType.Word64); break;
case Mnemonic.ldh: RewriteLd(PrimitiveType.Word16); break;
case Mnemonic.ldil: RewriteLdil(); break;
case Mnemonic.ldo: RewriteLdo(); break;
case Mnemonic.ldsid: RewriteLdsid(); break;
case Mnemonic.ldw: RewriteLd(PrimitiveType.Word32); break;
case Mnemonic.ldwa: RewriteLd(PrimitiveType.Word32); break;
case Mnemonic.mfctl: RewriteMfctl(); break;
case Mnemonic.mfctl_w: RewriteMfctl(); break;
case Mnemonic.mtctl: RewriteMtctl(); break;
case Mnemonic.mtsm: RewriteMtsm(); break;
case Mnemonic.mtsp: RewriteMtsp(); break;
case Mnemonic.or: RewriteOr(); break;
case Mnemonic.rfi: RewriteRfi("__rfi"); break;
case Mnemonic.rfi_r: RewriteRfi("__rfi_r"); break;
case Mnemonic.shladd: RewriteShladd(); break;
case Mnemonic.shrpd: RewriteShrp(PrimitiveType.Word64, PrimitiveType.Word128); break;
case Mnemonic.shrpw: RewriteShrp(PrimitiveType.Word32, PrimitiveType.Word64); break;
case Mnemonic.stb: RewriteSt(PrimitiveType.Byte); break;
case Mnemonic.std: RewriteSt(PrimitiveType.Word64); break;
case Mnemonic.stda: RewriteSt(PrimitiveType.Word64); break;
case Mnemonic.sth: RewriteSt(PrimitiveType.Word16); break;
case Mnemonic.stw: RewriteSt(PrimitiveType.Word32); break;
case Mnemonic.sub: RewriteSub(); break;
case Mnemonic.subi: RewriteSubi(); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
var rtlInstrs = new List <RtlInstruction>();
this.m = new RtlEmitter(rtlInstrs);
this.rtlc = RtlClass.Linear;
switch (instr.Opcode)
{
case Opcode.mov:
case Opcode.rev:
case Opcode.revw:
case Opcode.tbl:
host.Warn(
instr.Address,
"M6812 instruction '{0}' is not supported yet.",
instr.Opcode);
goto case Opcode.invalid;
case Opcode.invalid:
this.rtlc = RtlClass.Invalid;
m.Invalid();
break;
case Opcode.aba: RewriteAba(); break;
case Opcode.adca: RewriteAdcSbc(Registers.a, m.IAdd); break;
case Opcode.adcb: RewriteAdcSbc(Registers.b, m.IAdd); break;
case Opcode.adda: RewriteArithmetic(Registers.a, m.IAdd); break;
case Opcode.addb: RewriteArithmetic(Registers.b, m.IAdd); break;
case Opcode.addd: RewriteArithmetic(Registers.d, m.IAdd); break;
case Opcode.anda: RewriteLogical(Registers.a, m.And); break;
case Opcode.andb: RewriteLogical(Registers.b, m.And); break;
case Opcode.andcc: RewriteAndcc(); break;
case Opcode.asr: RewriteShiftMem(m.Sar); break;
case Opcode.asra: RewriteArithmetic(Registers.a, m.Sar); break;
case Opcode.asrb: RewriteArithmetic(Registers.b, m.Sar); break;
case Opcode.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break;
case Opcode.bclr: RewriteBclr(); break;
case Opcode.bcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break;
case Opcode.beq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.bge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Opcode.bgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.bhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Opcode.ble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.blt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break;
case Opcode.bls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break;
case Opcode.bmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break;
case Opcode.bne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break;
case Opcode.bpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break;
case Opcode.bvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break;
case Opcode.bvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break;
case Opcode.bgnd: RewriteBgnd(); break;
case Opcode.bita: RewriteBit(Registers.a); break;
case Opcode.bitb: RewriteBit(Registers.b); break;
case Opcode.bra: RewriteBra(); break;
case Opcode.brclr: RewriteBrclr(); break;
case Opcode.brn: m.Nop(); break;
case Opcode.brset: RewriteBrset(); break;
case Opcode.bset: RewriteBset(); break;
case Opcode.bsr: RewriteBsr(); break;
case Opcode.call: RewriteCall(); break;
case Opcode.cba: RewriteCba(); break;
case Opcode.clr: RewriteClr(); break;
case Opcode.clra: RewriteClr(Registers.a); break;
case Opcode.clrb: RewriteClr(Registers.b); break;
case Opcode.cmpa: RewriteCmp(Registers.a); break;
case Opcode.cmpb: RewriteCmp(Registers.b); break;
case Opcode.com: RewriteCom(); break;
case Opcode.coma: RewriteCom(Registers.a); break;
case Opcode.comb: RewriteCom(Registers.b); break;
case Opcode.cpd: RewriteCmp(Registers.d); break;
case Opcode.cps: RewriteCmp(Registers.sp); break;
case Opcode.cpx: RewriteCmp(Registers.x); break;
case Opcode.cpy: RewriteCmp(Registers.y); break;
case Opcode.daa: RewriteDaa(); break;
case Opcode.dbeq: RewriteDb(m.Eq0); break;
case Opcode.dbne: RewriteDb(m.Ne0); break;
case Opcode.dec: RewriteIncDec(m.ISub); break;
case Opcode.deca: RewriteIncDec(Registers.a, m.ISub); break;
case Opcode.decb: RewriteIncDec(Registers.b, m.ISub); break;
case Opcode.dex: RewriteIncDecXY(Registers.x, m.ISub); break;
case Opcode.dey: RewriteIncDecXY(Registers.y, m.ISub); break;
case Opcode.ediv: RewriteEdiv(m.UDiv, m.Remainder); break;
case Opcode.edivs: RewriteEdiv(m.SDiv, m.Remainder); break;
case Opcode.emacs: RewriteEmacs(); break;
case Opcode.emaxd: RewriteEmaxmind("__umax"); break;
case Opcode.emaxm: RewriteEmaxminm("__umax"); break;
case Opcode.emind: RewriteEmaxmind("__umin"); break;
case Opcode.eminm: RewriteEmaxminm("__umin"); break;
case Opcode.emul: RewriteEmul(m.UMul); break;
case Opcode.emuls: RewriteEmul(m.SMul); break;
case Opcode.eora: RewriteLogical(Registers.a, m.Xor); break;
case Opcode.eorb: RewriteLogical(Registers.b, m.Xor); break;
case Opcode.etbl: RewriteEtbl(); break;
case Opcode.fdiv: RewriteFdiv(); break;
case Opcode.ibeq: RewriteIb(m.Eq0); break;
case Opcode.ibne: RewriteIb(m.Ne0); break;
case Opcode.idiv: RewriteIdiv(m.UDiv); break;
case Opcode.idivs: RewriteIdiv(m.SDiv); break;
case Opcode.inc: RewriteIncDec(m.IAdd); break;
case Opcode.inca: RewriteIncDec(Registers.a, m.IAdd); break;
case Opcode.incb: RewriteIncDec(Registers.b, m.IAdd); break;
case Opcode.inx: RewriteIncDecXY(Registers.x, m.IAdd); break;
case Opcode.iny: RewriteIncDecXY(Registers.y, m.IAdd); break;
case Opcode.jmp: RewriteJmp(); break;
case Opcode.jsr: RewriteJsr(); break;
case Opcode.lbcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break;
case Opcode.lbcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break;
case Opcode.lbeq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.lbge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Opcode.lbgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.lbhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Opcode.lble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.lblt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break;
case Opcode.lbls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break;
case Opcode.lbmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break;
case Opcode.lbne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break;
case Opcode.lbpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break;
case Opcode.lbra: RewriteBra(); break;
case Opcode.lbrn: m.Nop(); break;
case Opcode.lbvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break;
case Opcode.lbvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break;
case Opcode.ldaa: RewriteLd(Registers.a); break;
case Opcode.ldab: RewriteLd(Registers.b); break;
case Opcode.ldd: RewriteLd(Registers.d); break;
case Opcode.lds: RewriteLd(Registers.sp); break;
case Opcode.ldx: RewriteLd(Registers.x); break;
case Opcode.ldy: RewriteLd(Registers.y); break;
case Opcode.leas: RewriteLea(Registers.sp); break;
case Opcode.leax: RewriteLea(Registers.x); break;
case Opcode.leay: RewriteLea(Registers.y); break;
case Opcode.lsl: RewriteShiftMem(m.Shl); break;
case Opcode.lsla: RewriteArithmetic(Registers.a, m.Shl); break;
case Opcode.lslb: RewriteArithmetic(Registers.b, m.Shl); break;
case Opcode.lsld: RewriteArithmetic(Registers.d, m.Shl); break;
case Opcode.lsr: RewriteShiftMem(m.Shr); break;
case Opcode.lsra: RewriteArithmetic(Registers.a, m.Shr); break;
case Opcode.lsrb: RewriteArithmetic(Registers.b, m.Shr); break;
case Opcode.lsrd: RewriteArithmetic(Registers.d, m.Shr); break;
case Opcode.maxa: RewriteMaxmina("__umax_b"); break;
case Opcode.maxm: RewriteMaxminm("__umax_b"); break;
case Opcode.mem: RewriteMem(); break;
case Opcode.mina: RewriteMaxmina("__umin_b"); break;
case Opcode.minm: RewriteMaxminm("__umin_b"); break;
case Opcode.mul: RewriteMul(); break;
case Opcode.neg: RewriteNeg(); break;
case Opcode.nega: RewriteNeg(Registers.a); break;
case Opcode.negb: RewriteNeg(Registers.b); break;
case Opcode.nop: m.Nop(); break;
case Opcode.oraa: RewriteLogical(Registers.a, m.Or); break;
case Opcode.orab: RewriteLogical(Registers.b, m.Or); break;
case Opcode.orcc: RewriteOrcc(); break;
case Opcode.psha: RewritePsh(Registers.a); break;
case Opcode.pshb: RewritePsh(Registers.b); break;
case Opcode.pshc: RewritePsh(Registers.ccr); break;
case Opcode.pshd: RewritePsh(Registers.d); break;
case Opcode.pshx: RewritePsh(Registers.x); break;
case Opcode.pshy: RewritePsh(Registers.y); break;
case Opcode.pula: RewritePul(Registers.a); break;
case Opcode.pulb: RewritePul(Registers.b); break;
case Opcode.pulc: RewritePul(Registers.ccr); break;
case Opcode.puld: RewritePul(Registers.d); break;
case Opcode.pulx: RewritePul(Registers.x); break;
case Opcode.puly: RewritePul(Registers.y); break;
case Opcode.rol: RewriteShiftMem(Rol); break;
case Opcode.rola: RewriteArithmetic(Registers.a, Rol); break;
case Opcode.rolb: RewriteArithmetic(Registers.b, Rol); break;
case Opcode.ror: RewriteShiftMem(Ror); break;
case Opcode.rora: RewriteArithmetic(Registers.a, Ror); break;
case Opcode.rorb: RewriteArithmetic(Registers.a, Ror); break;
case Opcode.rtc: RewriteRtc(); break;
case Opcode.rti: RewriteRti(); break;
case Opcode.rts: RewriteRts(); break;
case Opcode.sba: RewriteSba(); break;
case Opcode.sbca: RewriteAdcSbc(Registers.a, m.ISub); break;
case Opcode.sbcb: RewriteAdcSbc(Registers.b, m.ISub); break;
case Opcode.sex: RewriteSex(); break;
case Opcode.staa: RewriteSt(Registers.a); break;
case Opcode.stab: RewriteSt(Registers.b); break;
case Opcode.std: RewriteSt(Registers.d); break;
case Opcode.stop: RewriteStop(); break;
case Opcode.sts: RewriteSt(Registers.sp); break;
case Opcode.stx: RewriteSt(Registers.x); break;
case Opcode.sty: RewriteSt(Registers.y); break;
case Opcode.suba: RewriteSub(Registers.a); break;
case Opcode.subb: RewriteSub(Registers.b); break;
case Opcode.subd: RewriteSub(Registers.d); break;
case Opcode.swi: RewriteSwi(); break;
case Opcode.tab: RewriteTab(); break;
case Opcode.tba: RewriteTba(); break;
case Opcode.tbeq: RewriteTb(m.Eq0); break;
case Opcode.tbne: RewriteTb(m.Ne0); break;
case Opcode.tfr: RewriteTfr(); break;
case Opcode.trap: RewriteTrap(); break;
case Opcode.tst: RewriteTst(); break;
case Opcode.tsta: RewriteTst(Registers.a); break;
case Opcode.tstb: RewriteTst(Registers.b); break;
case Opcode.wai: RewriteWai(); break;
case Opcode.wav: RewriteWav(); break;
}
yield return(new RtlInstructionCluster(
instr.Address,
instr.Length,
rtlInstrs.ToArray())
{
Class = rtlc
});
}
}
private void Invalid()
{
m.Invalid();
rtlc = InstrClass.Invalid;
}
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,
});
}
}
private void Invalid()
{
this.iclass = InstrClass.Invalid;
m.Invalid();
}
private void Invalid()
{
m.Invalid();
rtlc = RtlClass.Invalid;
}
private void EmitInvalid()
{
rtlInstructions.Clear();
rtlc = InstrClass.Invalid;
m.Invalid();
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var addr = dasm.Current.Address;
var len = dasm.Current.Length;
this.iclass = dasm.Current.InstructionClass;
var rtlInstructions = new List <RtlInstruction>();
m = new RtlEmitter(rtlInstructions);
switch (dasm.Current.Mnemonic)
{
default: throw new AddressCorrelatedException(
dasm.Current.Address,
"Z80 instruction '{0}' is not supported yet.",
dasm.Current.Mnemonic);
case Mnemonic.illegal: m.Invalid(); break;
case Mnemonic.adc: RewriteAdc(); break;
case Mnemonic.add: RewriteAdd(); break;
case Mnemonic.and: RewriteAnd(); break;
case Mnemonic.bit: RewriteBit(); break;
case Mnemonic.call: RewriteCall(dasm.Current); break;
case Mnemonic.ccf: RewriteCcf(); break;
case Mnemonic.cp: RewriteCp(); break;
case Mnemonic.cpd: RewriteCp(m.ISub, false); break;
case Mnemonic.cpdr: RewriteCp(m.ISub, true); break;
case Mnemonic.cpi: RewriteCp(m.IAdd, false); break;
case Mnemonic.cpir: RewriteCp(m.IAdd, true); break;
case Mnemonic.cpl: RewriteCpl(); break;
case Mnemonic.di: RewriteDi(); break;
case Mnemonic.daa: RewriteDaa(); break;
case Mnemonic.dec: RewriteDec(); break;
case Mnemonic.djnz: RewriteDjnz(dasm.Current.Operands[0]); break;
case Mnemonic.ei: RewriteEi(); break;
case Mnemonic.ex: RewriteEx(); break;
case Mnemonic.ex_af: RewriteExAf(); break;
case Mnemonic.exx: RewriteExx(); break;
case Mnemonic.hlt: RewriteHlt(); break;
case Mnemonic.@in: RewriteIn(); break;
case Mnemonic.ind: RewriteIn(m.ISub, false); break;
case Mnemonic.indr: RewriteIn(m.ISub, true); break;
case Mnemonic.ini: RewriteIn(m.IAdd, false); break;
case Mnemonic.inir: RewriteIn(m.IAdd, true); break;
case Mnemonic.im:
m.SideEffect(host.PseudoProcedure("__im", VoidType.Instance, RewriteOp(dasm.Current.Operands[0])));
break;
case Mnemonic.inc: RewriteInc(); break;
case Mnemonic.jp: RewriteJp(dasm.Current); break;
case Mnemonic.jr: RewriteJr(); break;
case Mnemonic.ld: RewriteLd(); break;
case Mnemonic.rl: RewriteRotation(PseudoProcedure.RolC, true); break;
case Mnemonic.rla: RewriteRotation(PseudoProcedure.RolC, true); break;
case Mnemonic.rlc: RewriteRotation(PseudoProcedure.Rol, false); break;
case Mnemonic.rlca: RewriteRotation(PseudoProcedure.Rol, false); break;
case Mnemonic.rr: RewriteRotation(PseudoProcedure.RorC, true); break;
case Mnemonic.rra: RewriteRotation(PseudoProcedure.RorC, true); break;
case Mnemonic.rrc: RewriteRotation(PseudoProcedure.Ror, true); break;
case Mnemonic.rrca: RewriteRotation(PseudoProcedure.Ror, true); break;
case Mnemonic.ldd: RewriteBlockInstruction(m.ISub, false); break;
case Mnemonic.lddr: RewriteBlockInstruction(m.ISub, true); break;
case Mnemonic.ldi: RewriteBlockInstruction(m.IAdd, false); break;
case Mnemonic.ldir: RewriteBlockInstruction(m.IAdd, true); break;
case Mnemonic.neg: RewriteNeg(); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.or: RewriteOr(); break;
case Mnemonic.@out: RewriteOut(); break;
case Mnemonic.pop: RewritePop(); break;
case Mnemonic.push: RewritePush(dasm.Current); break;
case Mnemonic.res: RewriteResSet("__res"); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.rst: RewriteRst(); break;
case Mnemonic.sbc: RewriteSbc(); break;
case Mnemonic.scf: RewriteScf(); break;
case Mnemonic.set: RewriteResSet("__set"); break;
case Mnemonic.sla: RewriteShift(dasm.Current, m.Shl); break;
case Mnemonic.sra: RewriteShift(dasm.Current, m.Sar); break;
case Mnemonic.srl: RewriteShift(dasm.Current, m.Shr); break;
case Mnemonic.sub: RewriteSub(); break;
case Mnemonic.xor: RewriteXor(); break;
//$TODO: Not implemented yet; feel free to implement these!
case Mnemonic.otdr: goto default;
case Mnemonic.otir: goto default;
case Mnemonic.outd: goto default;
case Mnemonic.outi: goto default;
case Mnemonic.outr: goto default;
case Mnemonic.reti: goto default;
case Mnemonic.retn: goto default;
case Mnemonic.rld: goto default;
case Mnemonic.rrd: goto default;
case Mnemonic.swap: goto default;
}
yield return(m.MakeCluster(addr, len, iclass));
}
}
