public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, Frame frame, PrimitiveType dataWidth)
{
this.arch = arch;
this.m = emitter;
this.frame = frame;
this.DataWidth = dataWidth;
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.rtlc = new RtlInstructionCluster(dasm.Current.Address, dasm.Current.Length);
this.rtlc.Class = RtlClass.Linear;
this.m = new RtlEmitter(rtlc.Instructions);
switch (instr.opcode)
{
default:
throw new AddressCorrelatedException(
instr.Address,
"Rewriting of Risc-V instruction '{0}' not implemented yet.",
instr.opcode);
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.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.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(rtlc);
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var addr = dasm.Current.Address;
var len = dasm.Current.Length;
this.rtlc = RtlClass.Linear;
this.rtlInstructions = new List <RtlInstruction>();
m = new RtlEmitter(rtlInstructions);
switch (dasm.Current.Code)
{
default: throw new AddressCorrelatedException(
dasm.Current.Address,
"Rewriting of Z80 instruction '{0}' not implemented yet.",
dasm.Current.Code);
case Opcode.illegal: m.Invalid(); break;
case Opcode.adc: RewriteAdc(); break;
case Opcode.add: RewriteAdd(); break;
case Opcode.and: RewriteAnd(); break;
case Opcode.bit: RewriteBit(); break;
case Opcode.call: RewriteCall(dasm.Current); break;
case Opcode.ccf: RewriteCcf(); break;
case Opcode.cp: RewriteCp(); break;
case Opcode.cpd: RewriteCp(m.ISub, false); break;
case Opcode.cpdr: RewriteCp(m.ISub, true); break;
case Opcode.cpi: RewriteCp(m.IAdd, false); break;
case Opcode.cpir: RewriteCp(m.IAdd, true); break;
case Opcode.cpl: RewriteCpl(); break;
case Opcode.di: RewriteDi(); break;
case Opcode.daa: RewriteDaa(); break;
case Opcode.dec: RewriteDec(); break;
case Opcode.djnz: RewriteDjnz(dasm.Current.Op1); break;
case Opcode.ei: RewriteEi(); break;
case Opcode.ex: RewriteEx(); break;
case Opcode.ex_af: RewriteExAf(); break;
case Opcode.exx: RewriteExx(); break;
case Opcode.hlt: RewriteHlt(); break;
case Opcode.@in: RewriteIn(); break;
case Opcode.ind: RewriteIn(m.ISub, false); break;
case Opcode.indr: RewriteIn(m.ISub, true); break;
case Opcode.ini: RewriteIn(m.IAdd, false); break;
case Opcode.inir: RewriteIn(m.IAdd, true); break;
case Opcode.im:
m.SideEffect(host.PseudoProcedure("__im", VoidType.Instance, RewriteOp(dasm.Current.Op1)));
break;
case Opcode.inc: RewriteInc(); break;
case Opcode.jp: RewriteJp(dasm.Current); break;
case Opcode.jr: RewriteJr(); break;
case Opcode.ld: RewriteLd(); break;
case Opcode.rl: RewriteRotation(PseudoProcedure.RolC, true); break;
case Opcode.rla: RewriteRotation(PseudoProcedure.Rol, false); break;
case Opcode.rlc: RewriteRotation(PseudoProcedure.RolC, false); break;
case Opcode.rlca: RewriteRotation(PseudoProcedure.RolC, false); break;
case Opcode.rr: RewriteRotation(PseudoProcedure.RorC, true); break;
case Opcode.rra: RewriteRotation(PseudoProcedure.Ror, true); break;
case Opcode.rrc: RewriteRotation(PseudoProcedure.RorC, true); break;
case Opcode.rrca: RewriteRotation(PseudoProcedure.RorC, true); break;
case Opcode.ldd: RewriteBlockInstruction(m.ISub, false); break;
case Opcode.lddr: RewriteBlockInstruction(m.ISub, true); break;
case Opcode.ldi: RewriteBlockInstruction(m.IAdd, false); break;
case Opcode.ldir: RewriteBlockInstruction(m.IAdd, true); break;
case Opcode.neg: RewriteNeg(); break;
case Opcode.nop: m.Nop(); break;
case Opcode.or: RewriteOr(); break;
case Opcode.@out: RewriteOut(); break;
case Opcode.pop: RewritePop(); break;
case Opcode.push: RewritePush(dasm.Current); break;
case Opcode.res: RewriteResSet("__res"); break;
case Opcode.ret: RewriteRet(); break;
case Opcode.rst: RewriteRst(); break;
case Opcode.sbc: RewriteSbc(); break;
case Opcode.scf: RewriteScf(); break;
case Opcode.set: RewriteResSet("__set"); break;
case Opcode.sla: RewriteShift(dasm.Current, m.Shl); break;
case Opcode.sra: RewriteShift(dasm.Current, m.Sar); break;
case Opcode.srl: RewriteShift(dasm.Current, m.Shr); break;
case Opcode.sub: RewriteSub(); break;
case Opcode.xor: RewriteXor(); break;
//$TODO: Not implemented yet; feel free to implement these!
case Opcode.otdr: goto default;
case Opcode.otir: goto default;
case Opcode.outd: goto default;
case Opcode.outi: goto default;
case Opcode.outr: goto default;
case Opcode.reti: goto default;
case Opcode.retn: goto default;
case Opcode.rld: goto default;
case Opcode.rrd: goto default;
case Opcode.swap: goto default;
}
yield return(new RtlInstructionCluster(addr, len, rtlInstructions.ToArray())
{
Class = rtlc
});
}
}
public void Rewrite(AvrInstruction instr)
{
this.instr = instr;
this.rtlInstructions = new List <RtlInstruction>();
this.rtlc = instr.InstructionClass;
this.m = new RtlEmitter(rtlInstructions);
switch (instr.opcode)
{
case Opcode.adc: RewriteAdcSbc(m.IAdd); break;
case Opcode.add: RewriteBinOp(m.IAdd, CmpFlags); break;
case Opcode.adiw: RewriteAddSubIW(m.IAdd); break;
case Opcode.and: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Opcode.andi: RewriteBinOp(m.And, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Opcode.asr: RewriteAsr(); break;
case Opcode.brcc: RewriteBranch(ConditionCode.UGE, FlagM.CF); break;
case Opcode.brcs: RewriteBranch(ConditionCode.ULT, FlagM.CF); break;
case Opcode.breq: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.brge: RewriteBranch(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Opcode.brid: RewriteBranch(FlagM.IF, false); break;
case Opcode.brne: RewriteBranch(ConditionCode.NE, FlagM.ZF); break;
case Opcode.brpl: RewriteBranch(ConditionCode.GE, FlagM.NF); break;
case Opcode.call: RewriteCall(); break;
case Opcode.cli: RewriteCli(); break;
case Opcode.com: RewriteUnary(m.Comp, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF, FlagM.CF); break;
case Opcode.cp: RewriteCp(); break;
case Opcode.cpi: RewriteCp(); break;
case Opcode.cpc: RewriteCpc(); break;
case Opcode.cpse: SkipIf(m.Eq); break;
case Opcode.dec: RewriteIncDec(m.ISub); break;
case Opcode.des: RewriteDes(); break;
case Opcode.eor: RewriteBinOp(m.Xor, LogicalFlags, FlagM.VF); break;
case Opcode.icall: RewriteIcall(); break;
case Opcode.@in: RewriteIn(); break;
case Opcode.inc: RewriteIncDec(m.IAdd); break;
case Opcode.ijmp: RewriteIjmp(); break;
case Opcode.jmp: RewriteJmp(); break;
case Opcode.ld: RewriteLd(); break;
case Opcode.ldd: RewriteLd(); break;
case Opcode.ldi: RewriteLdi(); break;
case Opcode.lds: RewriteLds(); break;
case Opcode.lpm: RewriteLpm(); break;
case Opcode.lsr: RewriteLsr(); break;
case Opcode.mov: RewriteMov(); break;
case Opcode.movw: RewriteMovw(); break;
case Opcode.muls: RewriteMuls(); break;
case Opcode.neg: RewriteUnary(m.Neg, CmpFlags); break;
case Opcode.@out: RewriteOut(); break;
case Opcode.or: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Opcode.ori: RewriteBinOp(m.Or, FlagM.SF | FlagM.NF | FlagM.ZF, FlagM.VF); break;
case Opcode.pop: RewritePop(); break;
case Opcode.push: RewritePush(); break;
case Opcode.rcall: RewriteCall(); break;
case Opcode.ror: RewriteRor(); break;
case Opcode.ret: RewriteRet(); break;
case Opcode.reti: RewriteRet(); break; //$TODO: more to indicate interrupt return?
case Opcode.rjmp: RewriteJmp(); break;
case Opcode.sbc: RewriteAdcSbc(m.ISub); break;
case Opcode.sbci: RewriteAdcSbc(m.ISub); break;
case Opcode.sbis: RewriteSbis(); return; // We've already added ourself to clusters.
case Opcode.sbiw: RewriteAddSubIW(m.ISub); break;
case Opcode.sbrc: SkipIf(Sbrc); break;
case Opcode.sbrs: SkipIf(Sbrs); break;
case Opcode.sec: RewriteSetBit(FlagM.CF, true); break;
case Opcode.sei: RewriteSei(); break;
case Opcode.st: RewriteSt(); break;
case Opcode.std: RewriteSt(); break;
case Opcode.sts: RewriteSts(); break;
case Opcode.sub: RewriteBinOp(m.ISub, CmpFlags); break;
case Opcode.subi: RewriteBinOp(m.ISub, CmpFlags); break;
case Opcode.swap: RewriteSwap(); break;
default:
host.Error(instr.Address, string.Format("AVR8 instruction '{0}' is not supported yet.", instr.opcode));
EmitUnitTest();
m.Invalid();
break;
}
clusters.Add(new RtlInstructionCluster(
instr.Address,
instr.Length,
rtlInstructions.ToArray())
{
Class = rtlc
});
}
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, IntrinsicProcedure.RolC); break;
case Mnemonic.rotxr: RewriteRotationX(instr, IntrinsicProcedure.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;
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
});
}
}
/// <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.Mnemonic)
{
default:
EmitUnitTest();
host.Warn(
dasm.Current.Address,
"x86 instruction '{0}' is not supported yet.",
instrCur.Mnemonic);
goto case Mnemonic.illegal;
case Mnemonic.illegal: rtlc = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.aaa: RewriteAaa(); break;
case Mnemonic.aad: RewriteAad(); break;
case Mnemonic.aam: RewriteAam(); break;
case Mnemonic.aas: RewriteAas(); break;
case Mnemonic.adc: RewriteAdcSbb(m.IAdd); break;
case Mnemonic.add: RewriteAddSub(Operator.IAdd); break;
case Mnemonic.addss: RewriteScalarBinop(m.FAdd, PrimitiveType.Real32); break;
case Mnemonic.addsd:
case Mnemonic.vaddsd: RewriteScalarBinop(m.FAdd, PrimitiveType.Real64); break;
case Mnemonic.addps: RewritePackedBinop("__addps", PrimitiveType.Real32); break;
case Mnemonic.addpd: RewritePackedBinop("__addpd", PrimitiveType.Real64); break;
case Mnemonic.aesimc: RewriteAesimc(); break;
case Mnemonic.and: RewriteLogical(Operator.And); break;
case Mnemonic.andnps: RewriteAndnps(); break;
case Mnemonic.andpd: RewritePackedBinop("__andpd", PrimitiveType.Real64); break;
case Mnemonic.andps: RewritePackedBinop("__andps", PrimitiveType.Real32); break;
case Mnemonic.arpl: RewriteArpl(); break;
case Mnemonic.bound: RewriteBound(); break;
case Mnemonic.bsf: RewriteBsf(); break;
case Mnemonic.bsr: RewriteBsr(); break;
case Mnemonic.bswap: RewriteBswap(); break;
case Mnemonic.bt: RewriteBt(); break;
case Mnemonic.btc: RewriteBtc(); break;
case Mnemonic.btr: RewriteBtr(); break;
case Mnemonic.bts: RewriteBts(); break;
case Mnemonic.call: RewriteCall(instrCur.Operands[0], instrCur.Operands[0].Width); break;
case Mnemonic.cbw: RewriteCbw(); break;
case Mnemonic.clc: RewriteSetFlag(FlagM.CF, Constant.False()); break;
case Mnemonic.cld: RewriteSetFlag(FlagM.DF, Constant.False()); break;
case Mnemonic.cli: RewriteCli(); break;
case Mnemonic.clts: RewriteClts(); break;
case Mnemonic.cmc: m.Assign(orw.FlagGroup(FlagM.CF), m.Not(orw.FlagGroup(FlagM.CF))); break;
case Mnemonic.cmova: RewriteConditionalMove(ConditionCode.UGT, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovbe: RewriteConditionalMove(ConditionCode.ULE, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovc: RewriteConditionalMove(ConditionCode.ULT, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovge: RewriteConditionalMove(ConditionCode.GE, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovg: RewriteConditionalMove(ConditionCode.GT, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovl: RewriteConditionalMove(ConditionCode.LT, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovle: RewriteConditionalMove(ConditionCode.LE, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovnc: RewriteConditionalMove(ConditionCode.UGE, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovno: RewriteConditionalMove(ConditionCode.NO, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovns: RewriteConditionalMove(ConditionCode.NS, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovnz: RewriteConditionalMove(ConditionCode.NE, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovo: RewriteConditionalMove(ConditionCode.OV, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovpe: RewriteConditionalMove(ConditionCode.PE, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovpo: RewriteConditionalMove(ConditionCode.PO, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovs: RewriteConditionalMove(ConditionCode.SG, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmovz: RewriteConditionalMove(ConditionCode.EQ, instrCur.Operands[0], instrCur.Operands[1]); break;
case Mnemonic.cmpxchg: RewriteCmpxchg(); break;
case Mnemonic.cmp: RewriteCmp(); break;
case Mnemonic.cmps: RewriteStringInstruction(); break;
case Mnemonic.cmppd: RewriteCmpp("__cmppd", PrimitiveType.Real64); break;
case Mnemonic.cmpps: RewriteCmpp("__cmpps", PrimitiveType.Real32); break;
case Mnemonic.cmpsb: RewriteStringInstruction(); break;
case Mnemonic.comisd: RewriteComis(PrimitiveType.Real64); break;
case Mnemonic.comiss: RewriteComis(PrimitiveType.Real32); break;
case Mnemonic.cpuid: RewriteCpuid(); break;
case Mnemonic.cvtpi2ps: RewriteCvtPackedToReal(PrimitiveType.Real32); break;
case Mnemonic.cvtps2pi: RewriteCvtps2pi("__cvtps2pi", PrimitiveType.Real32, PrimitiveType.Int32); break;
case Mnemonic.cvtps2pd: RewriteCvtps2pi("__cvtps2pd", PrimitiveType.Real32, PrimitiveType.Real64); break;
case Mnemonic.cvtdq2ps: RewriteCvtps2pi("__cvtdq2ps", PrimitiveType.Int64, PrimitiveType.Real32); break;
case Mnemonic.cvtsd2si: RewriteCvts2si(PrimitiveType.Real64); break;
case Mnemonic.cvtsd2ss: RewriteCvtToReal(PrimitiveType.Real32); break;
case Mnemonic.cvtsi2ss:
case Mnemonic.vcvtsi2ss: RewriteCvtToReal(PrimitiveType.Real32); break;
case Mnemonic.cvtsi2sd:
case Mnemonic.vcvtsi2sd: RewriteCvtToReal(PrimitiveType.Real64); break;
case Mnemonic.cvtss2sd: RewriteCvtToReal(PrimitiveType.Real64); break;
case Mnemonic.cvtss2si: RewriteCvts2si(PrimitiveType.Real32); break;
case Mnemonic.cvttsd2si: RewriteCvtts2si(PrimitiveType.Real64); break;
case Mnemonic.cvttss2si: RewriteCvtts2si(PrimitiveType.Real32); break;
case Mnemonic.cvttps2pi: RewriteCvttps2pi(); break;
case Mnemonic.cwd: RewriteCwd(); break;
case Mnemonic.daa: EmitDaaDas("__daa"); break;
case Mnemonic.das: EmitDaaDas("__das"); break;
case Mnemonic.dec: RewriteIncDec(-1); break;
case Mnemonic.div: RewriteDivide(m.UDiv, Domain.UnsignedInt); break;
case Mnemonic.divps: RewritePackedBinop("__divps", PrimitiveType.Real32); break;
case Mnemonic.divsd: RewriteScalarBinop(m.FDiv, PrimitiveType.Real64); break;
case Mnemonic.divss: RewriteScalarBinop(m.FDiv, PrimitiveType.Real32); break;
case Mnemonic.f2xm1: RewriteF2xm1(); break;
case Mnemonic.emms: RewriteEmms(); break;
case Mnemonic.enter: RewriteEnter(); break;
case Mnemonic.fabs: RewriteFabs(); break;
case Mnemonic.fadd: EmitCommonFpuInstruction(m.FAdd, false, false); break;
case Mnemonic.faddp: EmitCommonFpuInstruction(m.FAdd, false, true); break;
case Mnemonic.fbld: RewriteFbld(); break;
case Mnemonic.fbstp: RewriteFbstp(); break;
case Mnemonic.fchs: EmitFchs(); break;
case Mnemonic.fclex: RewriteFclex(); break;
case Mnemonic.fcmovb: RewriteFcmov(FlagM.CF, ConditionCode.GE); break;
case Mnemonic.fcmovbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GT); break;
case Mnemonic.fcmove: RewriteFcmov(FlagM.ZF, ConditionCode.NE); break;
case Mnemonic.fcmovnb: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.GE); break;
case Mnemonic.fcmovnbe: RewriteFcmov(FlagM.CF | FlagM.ZF, ConditionCode.LE); break;
case Mnemonic.fcmovne: RewriteFcmov(FlagM.ZF, ConditionCode.EQ); break;
case Mnemonic.fcmovnu: RewriteFcmov(FlagM.PF, ConditionCode.IS_NAN); break;
case Mnemonic.fcmovu: RewriteFcmov(FlagM.PF, ConditionCode.NOT_NAN); break;
case Mnemonic.fcom: RewriteFcom(0); break;
case Mnemonic.fcomi: RewriteFcomi(false); break;
case Mnemonic.fcomip: RewriteFcomi(true); break;
case Mnemonic.fcomp: RewriteFcom(1); break;
case Mnemonic.fcompp: RewriteFcom(2); break;
case Mnemonic.fcos: RewriteFUnary("cos"); break;
case Mnemonic.fdecstp: RewriteFdecstp(); break;
case Mnemonic.fdiv: EmitCommonFpuInstruction(m.FDiv, false, false); break;
case Mnemonic.fdivp: EmitCommonFpuInstruction(m.FDiv, false, true); break;
case Mnemonic.ffree: RewriteFfree(); break;
case Mnemonic.fiadd: EmitCommonFpuInstruction(m.FAdd, false, false, PrimitiveType.Real64); break;
case Mnemonic.ficom: RewriteFicom(false); break;
case Mnemonic.ficomp: RewriteFicom(true); break;
case Mnemonic.fimul: EmitCommonFpuInstruction(m.FMul, false, false, PrimitiveType.Real64); break;
case Mnemonic.fisub: EmitCommonFpuInstruction(m.FSub, false, false, PrimitiveType.Real64); break;
case Mnemonic.fisubr: EmitCommonFpuInstruction(m.FSub, true, false, PrimitiveType.Real64); break;
case Mnemonic.fidiv: EmitCommonFpuInstruction(m.FDiv, false, false, PrimitiveType.Real64); break;
case Mnemonic.fidivr: EmitCommonFpuInstruction(m.FDiv, true, false, PrimitiveType.Real64); break;
case Mnemonic.fdivr: EmitCommonFpuInstruction(m.FDiv, true, false); break;
case Mnemonic.fdivrp: EmitCommonFpuInstruction(m.FDiv, true, true); break;
case Mnemonic.fild: RewriteFild(); break;
case Mnemonic.fincstp: RewriteFincstp(); break;
case Mnemonic.fist: RewriteFist(false); break;
case Mnemonic.fistp: RewriteFist(true); break;
case Mnemonic.fisttp: RewriteFistt(true); break;
case Mnemonic.fld: RewriteFld(); break;
case Mnemonic.fld1: RewriteFldConst(1.0); break;
case Mnemonic.fldcw: RewriteFldcw(); break;
case Mnemonic.fldenv: RewriteFldenv(); break;
case Mnemonic.fldl2e: RewriteFldConst(Constant.LgE()); break;
case Mnemonic.fldl2t: RewriteFldConst(Constant.Lg10()); break;
case Mnemonic.fldlg2: RewriteFldConst(Constant.Log2()); break;
case Mnemonic.fldln2: RewriteFldConst(Constant.Ln2()); break;
case Mnemonic.fldpi: RewriteFldConst(Constant.Pi()); break;
case Mnemonic.fldz: RewriteFldConst(0.0); break;
case Mnemonic.fmul: EmitCommonFpuInstruction(m.FMul, false, false); break;
case Mnemonic.fmulp: EmitCommonFpuInstruction(m.FMul, false, true); break;
case Mnemonic.fninit: RewriteFninit(); break;
case Mnemonic.fnop: m.Nop(); break;
case Mnemonic.fpatan: RewriteFpatan(); break;
case Mnemonic.fprem: RewriteFprem(); break;
case Mnemonic.fprem1: RewriteFprem1(); break;
case Mnemonic.fptan: RewriteFptan(); break;
case Mnemonic.frndint: RewriteFUnary("__rndint"); break;
case Mnemonic.frstor: RewriteFrstor(); break;
case Mnemonic.fsave: RewriteFsave(); break;
case Mnemonic.fscale: RewriteFscale(); break;
case Mnemonic.fsin: RewriteFUnary("sin"); break;
case Mnemonic.fsincos: RewriteFsincos(); break;
case Mnemonic.fsqrt: RewriteFUnary("sqrt"); break;
case Mnemonic.fst: RewriteFst(false); break;
case Mnemonic.fstenv: RewriteFstenv(); break;
case Mnemonic.fstcw: RewriterFstcw(); break;
case Mnemonic.fstp: RewriteFst(true); break;
case Mnemonic.fstsw: RewriteFstsw(); break;
case Mnemonic.fsub: EmitCommonFpuInstruction(m.FSub, false, false); break;
case Mnemonic.fsubp: EmitCommonFpuInstruction(m.FSub, false, true); break;
case Mnemonic.fsubr: EmitCommonFpuInstruction(m.FSub, true, false); break;
case Mnemonic.fsubrp: EmitCommonFpuInstruction(m.FSub, true, true); break;
case Mnemonic.ftst: RewriteFtst(); break;
case Mnemonic.fucom: RewriteFcom(0); break;
case Mnemonic.fucomp: RewriteFcom(1); break;
case Mnemonic.fucompp: RewriteFcom(2); break;
case Mnemonic.fucomi: RewriteFcomi(false); break;
case Mnemonic.fucomip: RewriteFcomi(true); break;
case Mnemonic.fxam: RewriteFxam(); break;
case Mnemonic.fxch: RewriteExchange(); break;
case Mnemonic.fxtract: RewriteFxtract(); break;
case Mnemonic.fyl2x: RewriteFyl2x(); break;
case Mnemonic.fyl2xp1: RewriteFyl2xp1(); break;
case Mnemonic.getsec: RewriteGetsec(); break;
case Mnemonic.hlt: RewriteHlt(); break;
case Mnemonic.idiv: RewriteDivide(m.SDiv, Domain.SignedInt); break;
case Mnemonic.@in: RewriteIn(); break;
case Mnemonic.imul: RewriteMultiply(Operator.SMul, Domain.SignedInt); break;
case Mnemonic.inc: RewriteIncDec(1); break;
case Mnemonic.insb: RewriteStringInstruction(); break;
case Mnemonic.ins: RewriteStringInstruction(); break;
case Mnemonic.@int: RewriteInt(); break;
case Mnemonic.into: RewriteInto(); break;
case Mnemonic.invd: RewriteInvd(); break;
case Mnemonic.iret: RewriteIret(); break;
case Mnemonic.jmp: RewriteJmp(); break;
case Mnemonic.ja: RewriteConditionalGoto(ConditionCode.UGT, instrCur.Operands[0]); break;
case Mnemonic.jbe: RewriteConditionalGoto(ConditionCode.ULE, instrCur.Operands[0]); break;
case Mnemonic.jc: RewriteConditionalGoto(ConditionCode.ULT, instrCur.Operands[0]); break;
case Mnemonic.jcxz: RewriteJcxz(); break;
case Mnemonic.jge: RewriteConditionalGoto(ConditionCode.GE, instrCur.Operands[0]); break;
case Mnemonic.jg: RewriteConditionalGoto(ConditionCode.GT, instrCur.Operands[0]); break;
case Mnemonic.jl: RewriteConditionalGoto(ConditionCode.LT, instrCur.Operands[0]); break;
case Mnemonic.jle: RewriteConditionalGoto(ConditionCode.LE, instrCur.Operands[0]); break;
case Mnemonic.jnc: RewriteConditionalGoto(ConditionCode.UGE, instrCur.Operands[0]); break;
case Mnemonic.jno: RewriteConditionalGoto(ConditionCode.NO, instrCur.Operands[0]); break;
case Mnemonic.jns: RewriteConditionalGoto(ConditionCode.NS, instrCur.Operands[0]); break;
case Mnemonic.jnz: RewriteConditionalGoto(ConditionCode.NE, instrCur.Operands[0]); break;
case Mnemonic.jo: RewriteConditionalGoto(ConditionCode.OV, instrCur.Operands[0]); break;
case Mnemonic.jpe: RewriteConditionalGoto(ConditionCode.PE, instrCur.Operands[0]); break;
case Mnemonic.jpo: RewriteConditionalGoto(ConditionCode.PO, instrCur.Operands[0]); break;
case Mnemonic.js: RewriteConditionalGoto(ConditionCode.SG, instrCur.Operands[0]); break;
case Mnemonic.jz: RewriteConditionalGoto(ConditionCode.EQ, instrCur.Operands[0]); break;
case Mnemonic.lahf: RewriteLahf(); break;
case Mnemonic.lar: RewriteLar(); break;
case Mnemonic.lds: RewriteLxs(Registers.ds); break;
case Mnemonic.ldmxcsr: RewriteLdmxcsr(); break;
case Mnemonic.stmxcsr: RewriteStmxcsr(); break;
case Mnemonic.lea: RewriteLea(); break;
case Mnemonic.leave: RewriteLeave(); break;
case Mnemonic.les: RewriteLxs(Registers.es); break;
case Mnemonic.lfence: RewriteLfence(); break;
case Mnemonic.lfs: RewriteLxs(Registers.fs); break;
case Mnemonic.lgs: RewriteLxs(Registers.gs); break;
case Mnemonic.lgdt: RewriteLxdt("__lgdt"); break;
case Mnemonic.lidt: RewriteLxdt("__lidt"); break;
case Mnemonic.lldt: RewriteLxdt("__lldt"); break;
case Mnemonic.@lock: RewriteLock(); break;
case Mnemonic.lods: RewriteStringInstruction(); break;
case Mnemonic.lodsb: RewriteStringInstruction(); break;
case Mnemonic.loop: RewriteLoop(0, ConditionCode.EQ); break;
case Mnemonic.loope: RewriteLoop(FlagM.ZF, ConditionCode.EQ); break;
case Mnemonic.loopne: RewriteLoop(FlagM.ZF, ConditionCode.NE); break;
case Mnemonic.lsl: RewriteLsl(); break;
case Mnemonic.lss: RewriteLxs(Registers.ss); break;
case Mnemonic.maskmovq: RewriteMaskmovq(); break;
case Mnemonic.maxps: RewritePackedBinop("__maxps", PrimitiveType.Real32); break;
case Mnemonic.mfence: RewriteMfence(); break;
case Mnemonic.minpd: RewritePackedBinop("__minpd", PrimitiveType.Real64); break;
case Mnemonic.minps: RewritePackedBinop("__minps", PrimitiveType.Real32); break;
case Mnemonic.mov: RewriteMov(); break;
case Mnemonic.movapd:
case Mnemonic.movaps:
case Mnemonic.vmovapd:
case Mnemonic.vmovaps: RewriteMov(); break;
case Mnemonic.vmread: RewriteVmread(); break;
case Mnemonic.vmwrite: RewriteVmwrite(); break;
case Mnemonic.movd: RewriteMovzx(); break;
case Mnemonic.movdqa: RewriteMov(); break;
case Mnemonic.movhpd: RewritePackedUnaryop("__movhpd", PrimitiveType.Real64, PrimitiveType.Real64); break;
case Mnemonic.movhps: RewritePackedUnaryop("__movhps", PrimitiveType.Real32, PrimitiveType.Real64); break;
case Mnemonic.movlpd: RewritePackedUnaryop("__movlpd", PrimitiveType.Real64, PrimitiveType.Real64); break;
case Mnemonic.movlps: RewritePackedUnaryop("__movlps", PrimitiveType.Real32, PrimitiveType.Real64); break;
case Mnemonic.movlhps: RewriteMovlhps(); break;
case Mnemonic.movmskpd: RewriteMovmsk("__movmskpd", PrimitiveType.Real64); break;
case Mnemonic.movmskps: RewriteMovmsk("__movmskps", PrimitiveType.Real32); break;
case Mnemonic.movnti: RewriteMov(); break;
case Mnemonic.movntps: RewriteMov(); break;
case Mnemonic.movntq: RewriteMov(); break;
case Mnemonic.movq: RewriteMov(); break;
case Mnemonic.movs: RewriteStringInstruction(); break;
case Mnemonic.movsb: RewriteStringInstruction(); break;
case Mnemonic.movsd:
case Mnemonic.vmovsd: RewriteMovssd(PrimitiveType.Real64); break;
case Mnemonic.movss:
case Mnemonic.vmovss: RewriteMovssd(PrimitiveType.Real32); break;
case Mnemonic.movsx: RewriteMovsx(); break;
case Mnemonic.movups: RewriteMov(); break;
case Mnemonic.movupd: RewriteMov(); break;
case Mnemonic.movzx: RewriteMovzx(); break;
case Mnemonic.mul: RewriteMultiply(Operator.UMul, Domain.UnsignedInt); break;
case Mnemonic.mulpd: RewritePackedBinop("__mulpd", PrimitiveType.Real64); break;
case Mnemonic.mulps: RewritePackedBinop("__mulps", PrimitiveType.Real32); break;
case Mnemonic.mulss: RewriteScalarBinop(m.FMul, PrimitiveType.Real32); break;
case Mnemonic.mulsd: RewriteScalarBinop(m.FMul, PrimitiveType.Real64); break;
case Mnemonic.neg: RewriteNeg(); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.not: RewriteNot(); break;
case Mnemonic.or: RewriteLogical(BinaryOperator.Or); break;
case Mnemonic.orpd: RewritePackedBinop("__orpd", PrimitiveType.Real64); break;
case Mnemonic.orps: RewritePackedBinop("__orps", PrimitiveType.Real32); break;
case Mnemonic.@out: RewriteOut(); break;
case Mnemonic.@outs: RewriteStringInstruction(); break;
case Mnemonic.@outsb: RewriteStringInstruction(); break;
case Mnemonic.packssdw: RewritePackedBinop("__packssdw", PrimitiveType.Int32, new ArrayType(PrimitiveType.Int16, 0)); break;
case Mnemonic.packuswb: RewritePackedBinop("__packuswb", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt8, 0)); break;
case Mnemonic.paddb: RewritePackedBinop("__paddb", PrimitiveType.Byte); break;
case Mnemonic.paddd: RewritePackedBinop("__paddd", PrimitiveType.Word32); break;
case Mnemonic.paddq:
case Mnemonic.vpaddq: RewritePackedBinop("__paddq", PrimitiveType.Word64); break;
case Mnemonic.paddsw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break;
case Mnemonic.paddsb: RewritePackedBinop("__paddsb", PrimitiveType.SByte); break;
case Mnemonic.paddusb: RewritePackedBinop("__paddusb", PrimitiveType.Byte); break;
case Mnemonic.paddusw: RewritePackedBinop("__paddsw", PrimitiveType.Word16); break;
case Mnemonic.paddw: RewritePackedBinop("__paddw", PrimitiveType.Word16); break;
case Mnemonic.pand:
case Mnemonic.vpand: RewritePackedLogical("__pand"); break;
case Mnemonic.pandn:
case Mnemonic.vpandn: RewritePackedLogical("__pandn"); break;
case Mnemonic.pause: RewritePause(); break;
case Mnemonic.palignr: RewritePalignr(); break;
case Mnemonic.pavgb: RewritePavg("__pavgb", PrimitiveType.Byte); break;
case Mnemonic.pavgw: RewritePavg("__pavgw", PrimitiveType.Byte); break;
case Mnemonic.pcmpeqb: RewritePcmp("__pcmpeqb", PrimitiveType.Byte); break;
case Mnemonic.pcmpeqd: RewritePcmp("__pcmpeqd", PrimitiveType.Word32); break;
case Mnemonic.pcmpeqw: RewritePcmp("__pcmpeqw", PrimitiveType.Word16); break;
case Mnemonic.pcmpgtb: RewritePcmp("__pcmpgtb", PrimitiveType.Byte); break;
case Mnemonic.pcmpgtd: RewritePcmp("__pcmpgtd", PrimitiveType.Word32); break;
case Mnemonic.pcmpgtw: RewritePcmp("__pcmpgtw", PrimitiveType.Word16); break;
case Mnemonic.pextrw:
case Mnemonic.vextrw: RewritePextrw(); break;
case Mnemonic.pinsrw:
case Mnemonic.vpinsrw: RewritePinsrw(); break;
case Mnemonic.pmaddwd: RewritePackedBinop("__pmaddwd", PrimitiveType.Word16, new ArrayType(PrimitiveType.Word32, 0)); break;
case Mnemonic.pmaxsw: RewritePackedBinop("__pmaxsw", PrimitiveType.Int16); break;
case Mnemonic.pmaxub: RewritePackedBinop("__pmaxub", PrimitiveType.UInt8); break;
case Mnemonic.pminsw: RewritePackedBinop("__pminsw", PrimitiveType.Int16); break;
case Mnemonic.pminub: RewritePackedBinop("__pminub", PrimitiveType.UInt8); break;
case Mnemonic.pmovmskb: RewriteMovmsk("__pmovmskb", PrimitiveType.Byte); break;
case Mnemonic.pmulhuw: RewritePackedBinop("__pmulhuw", PrimitiveType.UInt16, new ArrayType(PrimitiveType.UInt16, 8)); break;
case Mnemonic.pmulhw: RewritePackedBinop("__pmulhw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break;
case Mnemonic.pmullw:
case Mnemonic.vpmullw: RewritePackedBinop("__pmullw", PrimitiveType.Int16, new ArrayType(PrimitiveType.Int16, 8)); break;
case Mnemonic.pmuludq: RewritePackedBinop("__pmuludq", PrimitiveType.UInt32, new ArrayType(PrimitiveType.UInt64, 0)); break;
case Mnemonic.prefetchw: RewritePrefetch("__prefetchw"); break;
case Mnemonic.psadbw: RewritePackedBinop("__psadbw", PrimitiveType.Byte, PrimitiveType.Word16); break;
case Mnemonic.pslld: RewritePackedBinop("__pslld", PrimitiveType.Word32); break;
case Mnemonic.psllq:
case Mnemonic.vpsllq: RewritePackedBinop("__psllq", PrimitiveType.Word64); break;
case Mnemonic.psllw: RewritePackedBinop("__psllw", PrimitiveType.Word16); break;
case Mnemonic.psrad: RewritePackedBinop("__psrad", PrimitiveType.Int32); break;
case Mnemonic.psraw: RewritePackedBinop("__psraw", PrimitiveType.Int16); break;
case Mnemonic.psrlq: RewritePackedBinop("__psrlq", PrimitiveType.Word64); break;
case Mnemonic.pop: RewritePop(); break;
case Mnemonic.popa: RewritePopa(); break;
case Mnemonic.popf: RewritePopf(); break;
case Mnemonic.por: RewritePackedLogical("__por"); break;
case Mnemonic.prefetchnta: RewritePrefetch("__prefetchnta"); break;
case Mnemonic.prefetcht0: RewritePrefetch("__prefetcht0"); break;
case Mnemonic.prefetcht1: RewritePrefetch("__prefetcht1"); break;
case Mnemonic.prefetcht2: RewritePrefetch("__prefetcht2"); break;
case Mnemonic.pshufd: RewritePshuf("__pshufd", PrimitiveType.Word32); break;
case Mnemonic.pshufw: RewritePshuf("__pshufw", PrimitiveType.Word16); break;
case Mnemonic.psrld: RewritePackedShift("__psrld", PrimitiveType.Word32); break;
case Mnemonic.psrlw: RewritePackedShift("__psrlw", PrimitiveType.Word16); break;
case Mnemonic.psubb: RewritePackedBinop("__psubb", PrimitiveType.Byte); break;
case Mnemonic.psubd:
case Mnemonic.vpsubd: RewritePackedBinop("__psubd", PrimitiveType.Word32); break;
case Mnemonic.psubq: RewritePackedBinop("__psubq", PrimitiveType.Word64); break;
case Mnemonic.psubsb: RewritePackedBinop("__psubsb", PrimitiveType.SByte); break;
case Mnemonic.psubsw: RewritePackedBinop("__psubsw", PrimitiveType.Word16); break;
case Mnemonic.psubusb: RewritePackedBinop("__psubusb", PrimitiveType.UInt8); break;
case Mnemonic.psubusw: RewritePackedBinop("__psubusw", PrimitiveType.UInt16); break;
case Mnemonic.psubw: RewritePackedBinop("__psubw", PrimitiveType.Word16); break;
case Mnemonic.punpckhbw: RewritePunpckhbw(); break;
case Mnemonic.punpckhdq: RewritePunpckhdq(); break;
case Mnemonic.punpckhwd: RewritePunpckhwd(); break;
case Mnemonic.punpcklbw: RewritePunpcklbw(); break;
case Mnemonic.punpckldq: RewritePunpckldq(); break;
case Mnemonic.punpcklwd: RewritePunpcklwd(); break;
case Mnemonic.push: RewritePush(); break;
case Mnemonic.pusha: RewritePusha(); break;
case Mnemonic.pushf: RewritePushf(); break;
case Mnemonic.pxor:
case Mnemonic.vpxor: RewritePxor(); break;
case Mnemonic.rcl: RewriteRotation(PseudoProcedure.RolC, true, true); break;
case Mnemonic.rcpps: RewritePackedUnaryop("__rcpps", PrimitiveType.Real32); break;
case Mnemonic.rcr: RewriteRotation(PseudoProcedure.RorC, true, false); break;
case Mnemonic.rol: RewriteRotation(PseudoProcedure.Rol, false, true); break;
case Mnemonic.ror: RewriteRotation(PseudoProcedure.Ror, false, false); break;
case Mnemonic.rdmsr: RewriteRdmsr(); break;
case Mnemonic.rdpmc: RewriteRdpmc(); break;
case Mnemonic.rdtsc: RewriteRdtsc(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.retf: RewriteRet(); break;
case Mnemonic.rsqrtps: RewritePackedUnaryop("__rsqrtps", PrimitiveType.Real32); break;
case Mnemonic.sahf: m.Assign(orw.FlagGroup(X86Instruction.DefCc(instrCur.Mnemonic)), orw.AluRegister(Registers.ah)); break;
case Mnemonic.sar: RewriteBinOp(Operator.Sar); break;
case Mnemonic.sbb: RewriteAdcSbb(m.ISub); break;
case Mnemonic.scas: RewriteStringInstruction(); break;
case Mnemonic.scasb: RewriteStringInstruction(); break;
case Mnemonic.seta: RewriteSet(ConditionCode.UGT); break;
case Mnemonic.setc: RewriteSet(ConditionCode.ULT); break;
case Mnemonic.setbe: RewriteSet(ConditionCode.ULE); break;
case Mnemonic.setg: RewriteSet(ConditionCode.GT); break;
case Mnemonic.setge: RewriteSet(ConditionCode.GE); break;
case Mnemonic.setl: RewriteSet(ConditionCode.LT); break;
case Mnemonic.setle: RewriteSet(ConditionCode.LE); break;
case Mnemonic.setnc: RewriteSet(ConditionCode.UGE); break;
case Mnemonic.setno: RewriteSet(ConditionCode.NO); break;
case Mnemonic.setns: RewriteSet(ConditionCode.NS); break;
case Mnemonic.setnz: RewriteSet(ConditionCode.NE); break;
case Mnemonic.setpe: RewriteSet(ConditionCode.PE); break;
case Mnemonic.setpo: RewriteSet(ConditionCode.PO); break;
case Mnemonic.seto: RewriteSet(ConditionCode.OV); break;
case Mnemonic.sets: RewriteSet(ConditionCode.SG); break;
case Mnemonic.setz: RewriteSet(ConditionCode.EQ); break;
case Mnemonic.sfence: RewriteSfence(); break;
case Mnemonic.sgdt: RewriteSxdt("__sgdt"); break;
case Mnemonic.sha1msg2: RewriteSha1msg2(); break;
case Mnemonic.shl: RewriteBinOp(BinaryOperator.Shl); break;
case Mnemonic.shld: RewriteShxd("__shld"); break;
case Mnemonic.shr: RewriteBinOp(BinaryOperator.Shr); break;
case Mnemonic.shrd: RewriteShxd("__shrd"); break;
case Mnemonic.sidt: RewriteSxdt("__sidt"); break;
case Mnemonic.vshufps: RewritePackedTernaryop("__vshufps", PrimitiveType.Real32); break;
case Mnemonic.sldt: RewriteSxdt("__sldt"); break;
case Mnemonic.sqrtps: RewritePackedUnaryop("__sqrtps", PrimitiveType.Real32); break;
case Mnemonic.sqrtsd: RewriteSqrtsd(); break;
case Mnemonic.stc: RewriteSetFlag(FlagM.CF, Constant.True()); break;
case Mnemonic.std: RewriteSetFlag(FlagM.DF, Constant.True()); break;
case Mnemonic.sti: RewriteSti(); break;
case Mnemonic.stos: RewriteStringInstruction(); break;
case Mnemonic.stosb: RewriteStringInstruction(); break;
case Mnemonic.sub: RewriteAddSub(BinaryOperator.ISub); break;
case Mnemonic.subsd: RewriteScalarBinop(m.FSub, PrimitiveType.Real64); break;
case Mnemonic.subss: RewriteScalarBinop(m.FSub, PrimitiveType.Real32); break;
case Mnemonic.subpd: RewritePackedBinop("__subpd", PrimitiveType.Real64); break;
case Mnemonic.subps: RewritePackedBinop("__subps", PrimitiveType.Real32); break;
case Mnemonic.syscall: RewriteSyscall(); break;
case Mnemonic.sysenter: RewriteSysenter(); break;
case Mnemonic.sysexit: RewriteSysexit(); break;
case Mnemonic.sysret: RewriteSysret(); break;
case Mnemonic.ucomiss: RewriteComis(PrimitiveType.Real32); break;
case Mnemonic.ucomisd: RewriteComis(PrimitiveType.Real64); break;
case Mnemonic.ud0: rtlc = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.ud1: rtlc = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.ud2: rtlc = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.unpcklpd: RewritePackedBinop("__unpcklpd", PrimitiveType.Real64); break;
case Mnemonic.unpcklps: RewritePackedBinop("__unpcklps", PrimitiveType.Real32); break;
case Mnemonic.test: RewriteTest(); break;
case Mnemonic.wait: RewriteWait(); break;
case Mnemonic.wbinvd: RewriteWbinvd(); break;
case Mnemonic.wrmsr: RewriteWrsmr(); break;
case Mnemonic.xadd: RewriteXadd(); break;
case Mnemonic.xchg: RewriteExchange(); break;
case Mnemonic.xgetbv: RewriteXgetbv(); break;
case Mnemonic.xsetbv: RewriteXsetbv(); break;
case Mnemonic.xlat: RewriteXlat(); break;
case Mnemonic.xor: RewriteLogical(BinaryOperator.Xor); break;
case Mnemonic.xorpd:
case Mnemonic.vxorpd: RewritePackedBinop("__xorpd", PrimitiveType.Word64); break;
case Mnemonic.xorps: RewritePackedBinop("__xorps", PrimitiveType.Word32); break;
case Mnemonic.BOR_exp: RewriteFUnary("exp"); break;
case Mnemonic.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 rtls = new List <RtlInstruction>();
this.m = new RtlEmitter(rtls);
switch (instrCur.Mnemonic)
{
default:
EmitUnitTest();
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
m.Invalid(); iclass = InstrClass.Invalid;
break;
case Mnemonic.l_add: RewriteAluCV(m.IAdd); break;
case Mnemonic.l_addc: RewriteAddc(); break;
case Mnemonic.l_addi: RewriteAddi(); break;
case Mnemonic.l_addic: RewriteAddic(); break;
case Mnemonic.l_adrp: RewriteAdrp(); break;
case Mnemonic.l_and: RewriteBinOp(m.And); break;
case Mnemonic.l_andi: RewriteBinOpImm(m.And); break;
case Mnemonic.l_bf: RewriteBranch(false); break;
case Mnemonic.l_bnf: RewriteBranch(true); break;
case Mnemonic.l_cmov: RewriteCmov(); break;
case Mnemonic.l_csync: RewriteCsync(); break;
case Mnemonic.l_j: RewriteJ(); break;
case Mnemonic.l_jal: RewriteJal(); break;
case Mnemonic.l_jalr: RewriteJalr(); break;
case Mnemonic.l_jr: RewriteJr(); break;
case Mnemonic.l_lbs: RewriteLoad(arch.SignedWordWidth); break;
case Mnemonic.l_lbz: RewriteLoad(arch.WordWidth); break;
case Mnemonic.l_lf: RewriteLoad(arch.WordWidth); break;
case Mnemonic.l_lhs: RewriteLoad(arch.SignedWordWidth); break;
case Mnemonic.l_lhz: RewriteLoad(arch.WordWidth); break;
case Mnemonic.l_lwa: RewriteLwa(); break;
case Mnemonic.l_lws: RewriteLoad(arch.SignedWordWidth); break;
case Mnemonic.l_lwz: RewriteLoad(arch.WordWidth); break;
case Mnemonic.l_ld: RewriteLoad(arch.WordWidth); break;
case Mnemonic.l_maci: RewriteMaci(); break;
case Mnemonic.l_macrc: RewriteMacrc(); break;
case Mnemonic.l_movhi: RewriteMovhi(); break;
case Mnemonic.l_mfspr: RewriteMfspr(); break;
case Mnemonic.l_mtspr: RewriteMtspr(); break;
case Mnemonic.l_mul: RewriteAluV(m.SMul); break;
case Mnemonic.l_nop: m.Nop(); break;
case Mnemonic.l_or: RewriteBinOp(m.Or); break;
case Mnemonic.l_ori: RewriteBinOpImm(m.Or); break;
case Mnemonic.l_psync: RewritePsync(); break;
case Mnemonic.l_rfe: RewriteRfe(); break;
case Mnemonic.l_sb: RewriteStore(); break;
case Mnemonic.l_sh: RewriteStore(); break;
case Mnemonic.l_sw: RewriteStore(); break;
case Mnemonic.l_sfeq: RewriteSf(m.Eq); break;
case Mnemonic.l_sfeqi: RewriteSfi(m.Eq); break;
case Mnemonic.l_sfges: RewriteSf(m.Ge); break;
case Mnemonic.l_sfgesi: RewriteSfi(m.Ge); break;
case Mnemonic.l_sfgeu: RewriteSf(m.Uge); break;
case Mnemonic.l_sfgtsi: RewriteSfi(m.Gt); break;
case Mnemonic.l_sfgtu: RewriteSf(m.Ugt); break;
case Mnemonic.l_sfgtui: RewriteSfi(m.Ugt); break;
case Mnemonic.l_sfles: RewriteSf(m.Le); break;
case Mnemonic.l_sflesi: RewriteSfi(m.Le); break;
case Mnemonic.l_sfleu: RewriteSf(m.Ule); break;
case Mnemonic.l_sfleui: RewriteSfi(m.Ule); break;
case Mnemonic.l_sflts: RewriteSf(m.Lt); break;
case Mnemonic.l_sfltsi: RewriteSfi(m.Lt); break;
case Mnemonic.l_sfltu: RewriteSf(m.Ult); break;
case Mnemonic.l_sfltui: RewriteSfi(m.Ult); break;
case Mnemonic.l_sfne: RewriteSf(m.Ne); break;
case Mnemonic.l_sfnei: RewriteSfi(m.Ne); break;
case Mnemonic.l_sll: RewriteBinOp(m.Shl); break;
case Mnemonic.l_slli: RewriteBinOpImm(m.Shl); break;
case Mnemonic.l_sra: RewriteBinOp(m.Sar); break;
case Mnemonic.l_srai: RewriteBinOpImm(m.Sar); break;
case Mnemonic.l_srl: RewriteBinOp(m.Shr); break;
case Mnemonic.l_srli: RewriteBinOpImm(m.Shr); break;
case Mnemonic.l_sub: RewriteAluCV(m.ISub); break;
case Mnemonic.l_sys: RewriteSys(); break;
case Mnemonic.l_xor: RewriteBinOp(m.Xor); break;
case Mnemonic.l_xori: RewriteBinOpImm(m.Xor); break;
}
yield return(new RtlInstructionCluster(instrCur.Address, instrCur.Length, rtls.ToArray())
{
Class = this.iclass
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
iclass = InstrClass.Linear;
var instrs = new List <RtlInstruction>();
m = new RtlEmitter(instrs);
this.instr = dasm.Current;
switch (instr.Mnemonic)
{
default:
host.Warn(
instr.Address,
string.Format(
"TLCS-900 instruction '{0}' not supported yet.",
instr.Mnemonic));
EmitUnitTest();
Invalid();
break;
case Mnemonic.invalid:
Invalid();
break;
case Mnemonic.adc: RewriteAdcSbc(m.IAdd, "****0*"); break;
case Mnemonic.add: RewriteBinOp(m.IAdd, "***V0*"); break;
case Mnemonic.and: RewriteBinOp(m.And, "**1*00"); break;
case Mnemonic.bit: RewriteBit(); break;
case Mnemonic.bs1b: RewriteBs1b(); break;
case Mnemonic.call: RewriteCall(); break;
case Mnemonic.calr: RewriteCall(); break;
case Mnemonic.ccf: RewriteCcf(); break;
case Mnemonic.chg: RewriteChg(); break;
case Mnemonic.cp: RewriteCp("SZHV1C"); break;
case Mnemonic.daa: RewriteDaa("****-*"); break;
case Mnemonic.dec: RewriteIncDec(m.ISub, "****1-"); break;
case Mnemonic.decf: RewriteDecf(); break;
case Mnemonic.div: RewriteDiv(m.UDiv, "---V--"); break;
case Mnemonic.divs: RewriteDiv(m.SDiv, "---V--"); break;
case Mnemonic.djnz: RewriteDjnz(); break;
case Mnemonic.ei: RewriteEi(); break;
case Mnemonic.ex: RewriteEx(); break;
case Mnemonic.halt: RewriteHalt(); break;
case Mnemonic.inc: RewriteIncDec(m.IAdd, "****0-"); break;
case Mnemonic.incf: RewriteIncf(); break;
case Mnemonic.lda: RewriteLda(); break;
case Mnemonic.jp: RewriteJp(); break;
case Mnemonic.jr: RewriteJp(); break;
case Mnemonic.ld: RewriteLd(); break;
case Mnemonic.ldf: RewriteLdf(); break;
case Mnemonic.ldir: RewriteLdir(PrimitiveType.Byte, "--000-"); break;
case Mnemonic.ldirw: RewriteLdir(PrimitiveType.Word16, "--000-"); break;
case Mnemonic.mul: RewriteMul(m.UMul); break;
case Mnemonic.muls: RewriteMul(m.SMul); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.or: RewriteBinOp(m.Or, "**0*00"); break;
case Mnemonic.pop: RewritePop(); break;
case Mnemonic.push: RewritePush(); break;
case Mnemonic.rcf: RewriteRcf(); break;
case Mnemonic.res: RewriteRes(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.retd: RewriteRetd(); break;
case Mnemonic.reti: RewriteReti(); break;
case Mnemonic.sbc: RewriteAdcSbc(m.ISub, "****1*"); break;
case Mnemonic.scc: RewriteScc(); break;
case Mnemonic.scf: RewriteScf(); break;
case Mnemonic.set: RewriteSet(); break;
case Mnemonic.sla: RewriteShift(m.Shl, "**0*0*"); break;
case Mnemonic.sll: RewriteShift(m.Shl, "**0*0*"); break;
case Mnemonic.srl: RewriteShift(m.Shr, "**0*0*"); break;
case Mnemonic.sub: RewriteBinOp(m.ISub, "***V1*"); break;
case Mnemonic.swi: RewriteSwi(); break;
case Mnemonic.xor: RewriteBinOp(m.Xor, "**0*00"); break;
case Mnemonic.zcf: RewriteZcf(); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var rtlc = new RtlInstructionCluster(dasm.Current.Address, dasm.Current.Length);
emitter = new RtlEmitter(rtlc.Instructions);
switch (dasm.Current.Code)
{
default: throw new AddressCorrelatedException(
dasm.Current.Address,
"Rewriting of Z80 instruction {0} not implemented yet.",
dasm.Current.Code);
case Opcode.adc: RewriteAdc(); break;
case Opcode.add: RewriteAdd(); break;
case Opcode.call: RewriteCall(dasm.Current); break;
case Opcode.cp: RewriteCp(); break;
case Opcode.cpl: RewriteCpl(); break;
case Opcode.dec: RewriteDec(); break;
case Opcode.djnz: RewriteDjnz(dasm.Current.Op1); break;
case Opcode.inc: RewriteInc(); break;
case Opcode.jp: RewriteJp(dasm.Current); break;
case Opcode.jr: RewriteJr(); break;
case Opcode.ld: emitter.Assign(
RewriteOp(dasm.Current.Op1),
RewriteOp(dasm.Current.Op2));
break;
case Opcode.rla: RewriteRotation(PseudoProcedure.Rol, false); break;
case Opcode.rlc: RewriteRotation(PseudoProcedure.RolC, false); break;
case Opcode.rra: RewriteRotation(PseudoProcedure.Ror, true); break;
case Opcode.rrc: RewriteRotation(PseudoProcedure.RorC, true); break;
case Opcode.ldir: RewriteBlockInstruction(); break;
case Opcode.neg: RewriteNeg(); break;
case Opcode.or: RewriteOr(); break;
case Opcode.pop: RewritePop(); break;
case Opcode.push: RewritePush(dasm.Current); break;
case Opcode.ret: RewriteRet(); break;
case Opcode.sbc: RewriteSbc(); break;
case Opcode.sub: RewriteSub(); break;
}
yield return(rtlc);
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
this.rtlInstructions = new List <RtlInstruction>();
this.iclass = instr.InstructionClass;
m = new RtlEmitter(this.rtlInstructions);
switch (instr.Mnemonic)
{
default:
host.Warn(
instr.Address,
"PDP-11 instruction {0} is not supported yet.",
instr.Mnemonic);
iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.illegal: iclass = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.adc: RewriteAdcSbc(m.IAdd); break;
case Mnemonic.add: RewriteAdd(); break;
case Mnemonic.addb: RewriteAdd(); break;
case Mnemonic.ash: RewriteShift(); break;
case Mnemonic.ashc: RewriteAshc(); break;
case Mnemonic.asl: RewriteAsl(); break;
case Mnemonic.aslb: RewriteAsl(); break;
case Mnemonic.asr: RewriteAsr(); break;
case Mnemonic.asrb: RewriteAsr(); break;
case Mnemonic.bcc: RewriteBxx(ConditionCode.UGE, FlagM.CF); break;
case Mnemonic.bcs: RewriteBxx(ConditionCode.ULT, FlagM.CF); break;
case Mnemonic.beq: RewriteBxx(ConditionCode.EQ, FlagM.ZF); break;
case Mnemonic.bge: RewriteBxx(ConditionCode.GE, FlagM.VF | FlagM.NF); break;
case Mnemonic.bgt: RewriteBxx(ConditionCode.GT, FlagM.ZF | FlagM.NF | FlagM.VF); break;
case Mnemonic.bhi: RewriteBxx(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break;
case Mnemonic.bvs: RewriteBxx(ConditionCode.OV, FlagM.VF); break;
case Mnemonic.bic: RewriteBic(); break;
case Mnemonic.bicb: RewriteBic(); break;
case Mnemonic.bis: RewriteBis(); break;
case Mnemonic.bisb: RewriteBis(); break;
case Mnemonic.bit: RewriteBit(); break;
case Mnemonic.bitb: RewriteBit(); break;
case Mnemonic.ble: RewriteBxx(ConditionCode.LE, FlagM.ZF | FlagM.NF | FlagM.VF); break;
case Mnemonic.blos: RewriteBxx(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break;
case Mnemonic.blt: RewriteBxx(ConditionCode.LT, FlagM.NF | FlagM.VF); break;
case Mnemonic.bmi: RewriteBxx(ConditionCode.LT, FlagM.NF); break;
case Mnemonic.bne: RewriteBxx(ConditionCode.NE, FlagM.ZF); break;
case Mnemonic.bpl: RewriteBxx(ConditionCode.GT, FlagM.NF); break;
case Mnemonic.bpt: RewriteBpt(); break;
case Mnemonic.br: RewriteBr(); break;
case Mnemonic.clr: RewriteClr(instr, m.Word16(0)); break;
case Mnemonic.clrb: RewriteClr(instr, m.Byte(0)); break;
case Mnemonic.clrflags: RewriteClrSetFlags(Constant.False); break;
case Mnemonic.cmp: RewriteCmp(); break;
case Mnemonic.cmpb: RewriteCmp(); break;
case Mnemonic.com: RewriteCom(); break;
case Mnemonic.comb: RewriteCom(); break;
case Mnemonic.dec: RewriteIncDec(m.ISub); break;
case Mnemonic.decb: RewriteIncDec(m.ISub); break;
case Mnemonic.div: RewriteDiv(); break;
case Mnemonic.emt: RewriteEmt(); break;
case Mnemonic.halt: RewriteHalt(); break;
case Mnemonic.iot: RewriteIot(); break;
case Mnemonic.inc: RewriteIncDec(m.IAdd); break;
case Mnemonic.incb: RewriteIncDec(m.IAdd); break;
case Mnemonic.jmp: RewriteJmp(); break;
case Mnemonic.jsr: RewriteJsr(); break;
case Mnemonic.mark: RewriteMark(); break;
case Mnemonic.mfpd: RewriteMfpd(); break;
case Mnemonic.mfpi: RewriteMfpi(); break;
case Mnemonic.mov: RewriteMov(); break;
case Mnemonic.movb: RewriteMov(); break;
case Mnemonic.mtpi: RewriteMtpi(); break;
case Mnemonic.mul: RewriteMul(); break;
case Mnemonic.neg: RewriteNeg(); break;
case Mnemonic.negb: RewriteNeg(); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.reset: RewriteReset(); break;
case Mnemonic.rol: RewriteRotate(PseudoProcedure.Rol); break;
case Mnemonic.rolb: RewriteRotate(PseudoProcedure.Rol); break;
case Mnemonic.ror: RewriteRotate(PseudoProcedure.Ror); break;
case Mnemonic.rorb: RewriteRotate(PseudoProcedure.Ror); break;
case Mnemonic.rti: RewriteRti(); break;
case Mnemonic.rts: RewriteRts(); break;
case Mnemonic.rtt: RewriteRtt(); break;
case Mnemonic.sbc: RewriteAdcSbc(m.ISub); break;
case Mnemonic.sbcb: RewriteAdcSbc(m.ISub); break;
case Mnemonic.setflags: RewriteClrSetFlags(Constant.True); break;
case Mnemonic.stcdi: RewriteStcdi(); break;
case Mnemonic.sob: RewriteSob(); break;
case Mnemonic.stexp: RewriteStexp(); break;
case Mnemonic.sub: RewriteSub(); break;
case Mnemonic.swab: RewriteSwab(); break;
case Mnemonic.sxt: RewriteSxt(); break;
case Mnemonic.trap: RewriteTrap(); break;
case Mnemonic.tst: RewriteTst(); break;
case Mnemonic.tstb: RewriteTst(); break;
case Mnemonic.wait: RewriteWait(); break;
case Mnemonic.xor: RewriteXor(); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
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.Code)
{
default:
EmitUnitTest();
rtlc = InstrClass.Invalid;
m.Invalid();
break;
case Opcode.illegal: m.Invalid(); break;
case Opcode.adc: Adc(); break;
case Opcode.and: And(); break;
case Opcode.asl: Asl(); break;
case Opcode.bcc: Branch(ConditionCode.UGE, FlagM.CF); break;
case Opcode.bcs: Branch(ConditionCode.ULT, FlagM.CF); break;
case Opcode.beq: Branch(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.bit: Bit(); break;
case Opcode.bmi: Branch(ConditionCode.SG, FlagM.NF); break;
case Opcode.bne: Branch(ConditionCode.NE, FlagM.ZF); break;
case Opcode.bpl: Branch(ConditionCode.NS, FlagM.NF); break;
case Opcode.brk: Brk(); break;
case Opcode.bvc: Branch(ConditionCode.NO, FlagM.VF); break;
case Opcode.bvs: Branch(ConditionCode.OV, FlagM.VF); break;
case Opcode.clc: SetFlag(FlagM.CF, false); break;
case Opcode.cld: SetFlag(FlagM.DF, false); break;
case Opcode.cli: SetFlag(FlagM.IF, false); break;
case Opcode.clv: SetFlag(FlagM.VF, false); break;
case Opcode.cmp: Cmp(Registers.a); break;
case Opcode.cpx: Cmp(Registers.x); break;
case Opcode.cpy: Cmp(Registers.y); break;
case Opcode.dec: Dec(); break;
case Opcode.dex: Dec(Registers.x); break;
case Opcode.dey: Dec(Registers.y); break;
case Opcode.eor: Eor(); break;
case Opcode.inc: Inc(); break;
case Opcode.inx: Inc(Registers.x); break;
case Opcode.iny: Inc(Registers.y); break;
case Opcode.jmp: Jmp(); break;
case Opcode.jsr: Jsr(); break;
case Opcode.lda: Ld(Registers.a); break;
case Opcode.ldx: Ld(Registers.x); break;
case Opcode.ldy: Ld(Registers.y); break;
case Opcode.lsr: Lsr(); break;
case Opcode.nop: m.Nop(); break;
case Opcode.ora: Ora(); break;
case Opcode.pha: Push(Registers.a); break;
case Opcode.php: Push(AllFlags()); break;
case Opcode.pla: Pull(Registers.a); break;
case Opcode.plp: Plp(); break;
case Opcode.rol: Rotate(PseudoProcedure.Rol); break;
case Opcode.ror: Rotate(PseudoProcedure.Ror); break;
case Opcode.rti: Rti(); break;
case Opcode.rts: Rts(); break;
case Opcode.sbc: Sbc(); break;
case Opcode.sec: SetFlag(FlagM.CF, true); break;
case Opcode.sed: SetFlag(FlagM.DF, true); break;
case Opcode.sei: SetFlag(FlagM.IF, true); break;
case Opcode.sta: St(Registers.a); break;
case Opcode.stx: St(Registers.x); break;
case Opcode.sty: St(Registers.y); break;
case Opcode.tax: Copy(Registers.x, Registers.a); break;
case Opcode.tay: Copy(Registers.y, Registers.a); break;
case Opcode.tsx: Copy(Registers.x, Registers.s); break;
case Opcode.txa: Copy(Registers.a, Registers.x); break;
case Opcode.txs: Copy(Registers.s, Registers.x); break;
case Opcode.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())
{
this.instr = dasm.Current;
var rtls = new List<RtlInstruction>();
this.m = new RtlEmitter(rtls);
this.iclass = InstrClass.Linear;
switch (instr.Mnemonic)
{
default:
host.Warn(
instr.Address,
string.Format(
"i8051 instruction '{0}' not supported yet.",
instr.Mnemonic));
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
case Mnemonic.reserved:
Invalid();
break;
case Mnemonic.acall: RewriteCall(); break;
case Mnemonic.add: RewriteBinop(m.IAdd, FlagM.C | FlagM.AC | FlagM.OV | FlagM.P); break;
case Mnemonic.addc: RewriteAddcSubb(m.IAdd); break;
case Mnemonic.ajmp: RewriteJump(); break;
case Mnemonic.anl: RewriteLogical(m.And); break;
case Mnemonic.cjne: RewriteCjne(); break;
case Mnemonic.clr: RewriteClr(); break;
case Mnemonic.dec: RewriteIncDec(m.ISub); break;
case Mnemonic.djnz: RewriteDjnz(); break;
case Mnemonic.inc: RewriteIncDec(m.IAdd); break;
case Mnemonic.jb: RewriteJb(m.Ne0); break;
case Mnemonic.jbc: RewriteJbc(); break;
case Mnemonic.jc: RewriteJc(e => e); break;
case Mnemonic.jmp: RewriteJump(); break;
case Mnemonic.jnb: RewriteJb(m.Eq0); break;
case Mnemonic.jnc: RewriteJc(m.Not); break;
case Mnemonic.jnz: RewriteJz(m.Ne0); break;
case Mnemonic.jz: RewriteJz(m.Eq0); break;
case Mnemonic.lcall: RewriteCall(); break;
case Mnemonic.ljmp: RewriteJump(); break;
case Mnemonic.mov: RewriteMov(); break;
case Mnemonic.movc: RewriteMovc(); break;
case Mnemonic.movx: RewriteMovx(); break;
case Mnemonic.mul: RewriteMul(); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.orl: RewriteLogical(m.Or); break;
case Mnemonic.pop: RewritePop(); break;
case Mnemonic.push: RewritePush(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.reti: RewriteRet(); break;
case Mnemonic.rl: RewriteRotate(PseudoProcedure.Rol); break;
case Mnemonic.rr: RewriteRotate(PseudoProcedure.Ror); break;
case Mnemonic.setb: RewriteSetb(); break;
case Mnemonic.sjmp: RewriteJump(); break;
case Mnemonic.subb: RewriteAddcSubb(m.ISub); break;
case Mnemonic.swap: RewriteSwap(); break;
case Mnemonic.xrl: RewriteLogical(m.Xor); break;
case Mnemonic.xch: RewriteXch(); break;
case Mnemonic.cpl:
case Mnemonic.da:
case Mnemonic.div:
case Mnemonic.rrc:
case Mnemonic.rlc:
case Mnemonic.xchd:
EmitUnitTest();
Invalid();
break;
}
yield return m.MakeCluster(instr.Address, instr.Length, iclass);
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var instr = dasm.Current;
this.cluster = new RtlInstructionCluster(instr.Address, 4);
cluster.Class = RtlClass.Linear;
this.emitter = new RtlEmitter(cluster.Instructions);
switch (instr.opcode)
{
default: throw new AddressCorrelatedException(
instr.Address,
"Rewriting of MIPS instruction {0} not implemented yet.",
instr.opcode);
case Opcode.add:
case Opcode.addi:
case Opcode.addiu:
case Opcode.addu:
RewriteAdd(instr, PrimitiveType.Word32); break;
case Opcode.and:
case Opcode.andi:
RewriteAnd(instr); break;
case Opcode.beq:
RewriteBranch(instr, Operator.Eq, false); break;
case Opcode.beql:
RewriteBranch(instr, Operator.Eq, true); break;
case Opcode.bgez:
RewriteBranch0(instr, Operator.Ge, false); break;
case Opcode.bgezl:
RewriteBranch0(instr, Operator.Ge, true); break;
case Opcode.bgezal:
RewriteBranch0(instr, Operator.Ge, false); break;
case Opcode.bgezall:
RewriteBranch0(instr, Operator.Ge, true); break;
case Opcode.bgtz:
RewriteBranch0(instr, Operator.Gt, false); break;
case Opcode.bgtzl:
RewriteBranch0(instr, Operator.Gt, true); break;
case Opcode.blez:
RewriteBranch0(instr, Operator.Le, false); break;
case Opcode.blezl:
RewriteBranch0(instr, Operator.Le, true); break;
case Opcode.bltz:
RewriteBranch0(instr, Operator.Lt, false); break;
case Opcode.bltzl:
RewriteBranch0(instr, Operator.Lt, true); break;
case Opcode.bltzal:
RewriteBranch0(instr, Operator.Lt, false); break;
case Opcode.bltzall:
RewriteBranch0(instr, Operator.Lt, true); break;
case Opcode.bne:
RewriteBranch(instr, Operator.Ne, false); break;
case Opcode.bnel:
RewriteBranch(instr, Operator.Ne, true); break;
case Opcode.@break: RewriteBreak(instr); break;
case Opcode.dadd:
case Opcode.daddi:
RewriteAdd(instr, PrimitiveType.Word64); break;
case Opcode.daddiu:
case Opcode.daddu:
case Opcode.ddiv:
case Opcode.ddivu:
case Opcode.div: RewriteDiv(instr, emitter.SDiv); break;
case Opcode.divu: RewriteDiv(instr, emitter.UDiv); break;
case Opcode.dmult:
case Opcode.dmultu:
case Opcode.dsll:
case Opcode.dsll32:
case Opcode.dsllv:
case Opcode.dsra:
case Opcode.dsra32:
case Opcode.dsrav:
case Opcode.dsrl:
case Opcode.dsrl32:
case Opcode.dsrlv:
case Opcode.dsub:
case Opcode.dsubu:
goto default;
case Opcode.j:
RewriteJump(instr); break;
case Opcode.jal:
RewriteJal(instr); break;
case Opcode.jalr:
RewriteJalr(instr); break;
case Opcode.jr:
RewriteJr(instr); break;
case Opcode.lb:
case Opcode.lbu:
RewriteLoad(instr); break;
case Opcode.ld:
case Opcode.ldl:
case Opcode.ldr:
goto default;
case Opcode.lh:
case Opcode.lhu:
RewriteLoad(instr); break;
case Opcode.ll:
case Opcode.lld:
goto default;
case Opcode.lui: RewriteLui(instr); break;
case Opcode.lw: RewriteLoad(instr); break;
case Opcode.lwl: RewriteLwl(instr); break;
case Opcode.lwr: RewriteLwr(instr); break;
case Opcode.lwu:
goto default;
case Opcode.mfc0: RewriteMfc0(instr); break;
case Opcode.mfhi: RewriteMf(instr, Registers.hi); break;
case Opcode.mflo: RewriteMf(instr, Registers.lo); break;
case Opcode.mthi: RewriteMt(instr, Registers.hi); break;
case Opcode.mtlo: RewriteMt(instr, Registers.lo); break;
case Opcode.movn:
case Opcode.movz:
case Opcode.mult: RewriteMul(instr, emitter.SMul, PrimitiveType.Int64); break;
case Opcode.multu: RewriteMul(instr, emitter.UMul, PrimitiveType.UInt64); break;
goto default;
case Opcode.nop:
break;
case Opcode.nor:
RewriteNor(instr); break;
case Opcode.or:
case Opcode.ori:
RewriteOr(instr); break;
case Opcode.pref:
goto default;
case Opcode.sb: RewriteStore(instr); break;
case Opcode.sc:
case Opcode.scd:
case Opcode.sd:
case Opcode.sdl:
case Opcode.sdr:
goto default;
case Opcode.sh: RewriteStore(instr); break;
case Opcode.sll:
case Opcode.sllv:
RewriteSll(instr); break;
case Opcode.slt: RewriteSxx(instr, Operator.Lt); break;
case Opcode.slti: RewriteSxx(instr, Operator.Lt); break;
case Opcode.sltiu: RewriteSxx(instr, Operator.Ult); break;
case Opcode.sltu: RewriteSxx(instr, Operator.Ult); break;
case Opcode.sra: RewriteSra(instr); break;
case Opcode.srl: RewriteSrl(instr); break;
case Opcode.sub:
case Opcode.subu:
RewriteSub(instr); break;
case Opcode.sw:
RewriteStore(instr); break;
case Opcode.swl: RewriteSwl(instr); break;
case Opcode.swr: RewriteSwr(instr); break;
case Opcode.swu:
goto default;
case Opcode.xor:
case Opcode.xori:
RewriteXor(instr); break;
}
yield return(cluster);
}
}
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,
});
}
}
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;
var addr = dasm.Current.Address;
var len = dasm.Current.Length;
this.rtlInstructions = new List <RtlInstruction>();
this.rtlc = InstrClass.Linear;
this.m = new RtlEmitter(rtlInstructions);
switch (instr.opcode)
{
default:
host.Warn(
instr.Address,
"Risc-V instruction '{0}' not supported yet.",
instr.opcode);
rtlc = InstrClass.Invalid;
m.Invalid();
break;
case Opcode.invalid: rtlc = InstrClass.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())
{
instr = dasm.Current;
var addr = this.instr.Address;
var len = this.instr.Length;
this.rtlInstructions = new List <RtlInstruction>();
this.iclass = this.instr.InstructionClass;
this.m = new RtlEmitter(rtlInstructions);
switch (this.instr.Mnemonic)
{
default:
EmitUnitTest();
//emitter.SideEffect(Constant.String(
// this.instr.ToString(),
// StringType.NullTerminated(PrimitiveType.Char)));
//host.Warn(
// this.instr.Address,
// "VAX instruction {0} not supported yet.",
// this.instr.Mnemonic);
m.Invalid();
break;
case Mnemonic.Invalid: iclass = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.Reserved: iclass = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.acbb: RewriteAcbi(PrimitiveType.Byte); break;
case Mnemonic.acbd: RewriteAcbf(PrimitiveType.Real64); break;
case Mnemonic.acbf: RewriteAcbf(PrimitiveType.Real32); break;
case Mnemonic.acbg: RewriteAcbf(PrimitiveType.Real64); break;
case Mnemonic.acbh: RewriteAcbf(PrimitiveType.Real128); break;
case Mnemonic.acbl: RewriteAcbi(PrimitiveType.Word32); break;
case Mnemonic.acbw: RewriteAcbi(PrimitiveType.Word16); break;
case Mnemonic.adawi: RewriteAlu2(PrimitiveType.Word16, Adawi, AllFlags); break;
case Mnemonic.addb2: RewriteAlu2(PrimitiveType.Byte, m.IAdd, AllFlags); break;
case Mnemonic.addb3: RewriteAlu3(PrimitiveType.Byte, m.IAdd, AllFlags); break;
case Mnemonic.addd2: RewriteFpu2(PrimitiveType.Real64, m.FAdd, NZ00); break;
case Mnemonic.addd3: RewriteFpu3(PrimitiveType.Real64, m.FAdd, NZ00); break;
case Mnemonic.addf2: RewriteFpu2(PrimitiveType.Real32, m.FAdd, NZ00); break;
case Mnemonic.addf3: RewriteFpu3(PrimitiveType.Real32, m.FAdd, NZ00); break;
case Mnemonic.addl2: RewriteAlu2(PrimitiveType.Word32, m.IAdd, AllFlags); break;
case Mnemonic.addl3: RewriteAlu3(PrimitiveType.Word32, m.IAdd, AllFlags); break;
case Mnemonic.addp4: RewriteP4("vax_addp4"); break;
case Mnemonic.addp6: RewriteP6("vax_addp6"); break;
case Mnemonic.addw2: RewriteAlu2(PrimitiveType.Word16, m.IAdd, AllFlags); break;
case Mnemonic.addw3: RewriteAlu3(PrimitiveType.Word16, m.IAdd, AllFlags); break;
case Mnemonic.adwc: RewriteAdwc(); break;
case Mnemonic.aobleq: RewriteAob(m.Le); break;
case Mnemonic.aoblss: RewriteAob(m.Lt); break;
case Mnemonic.ashl: RewriteAsh(PrimitiveType.Word32); break;
case Mnemonic.ashp: RewriteAshp(); break;
case Mnemonic.ashq: RewriteAsh(PrimitiveType.Word64); break;
case Mnemonic.bbc: RewriteBb(false); break;
case Mnemonic.bbcc: RewriteBbxx(false, false); break;
case Mnemonic.bbcci: RewriteBbxxi(false); break;
case Mnemonic.bbcs: RewriteBbxx(false, true); break;
case Mnemonic.bbs: RewriteBb(true); break;
case Mnemonic.bbsc: RewriteBbxx(true, false); break;
case Mnemonic.bbss: RewriteBbxx(true, true); break;
case Mnemonic.bbssi: RewriteBbxxi(true); break;
case Mnemonic.beql: RewriteBranch(ConditionCode.EQ, FlagM.ZF); break;
case Mnemonic.bgeq: RewriteBranch(ConditionCode.GE, FlagM.NF); break;
case Mnemonic.bgequ: RewriteBranch(ConditionCode.UGE, FlagM.CF); break;
case Mnemonic.bgtr: RewriteBranch(ConditionCode.GT, FlagM.ZF | FlagM.NF); break;
case Mnemonic.bgtru: RewriteBranch(ConditionCode.UGT, FlagM.ZF | FlagM.CF); break;
case Mnemonic.bleq: RewriteBranch(ConditionCode.LE, FlagM.ZF | FlagM.NF); break;
case Mnemonic.blequ: RewriteBranch(ConditionCode.ULE, FlagM.ZF | FlagM.CF); break;
case Mnemonic.blss: RewriteBranch(ConditionCode.LT, FlagM.NF); break;
case Mnemonic.blssu: RewriteBranch(ConditionCode.ULT, FlagM.CF); break;
case Mnemonic.bneq: RewriteBranch(ConditionCode.NE, FlagM.ZF); break;
case Mnemonic.bvc: RewriteBranch(ConditionCode.NO, FlagM.VF); break;
case Mnemonic.bvs: RewriteBranch(ConditionCode.OV, FlagM.VF); break;
case Mnemonic.bicb2: RewriteAlu2(PrimitiveType.Byte, Bic, NZ00); break;
case Mnemonic.bicb3: RewriteAlu3(PrimitiveType.Byte, Bic, NZ00); break;
case Mnemonic.bicl2: RewriteAlu2(PrimitiveType.Word32, Bic, NZ00); break;
case Mnemonic.bicl3: RewriteAlu3(PrimitiveType.Word32, Bic, NZ00); break;
case Mnemonic.bicpsw: RewriteBicpsw(); break;
case Mnemonic.bicw2: RewriteAlu2(PrimitiveType.Word16, Bic, NZ00); break;
case Mnemonic.bicw3: RewriteAlu3(PrimitiveType.Word16, Bic, NZ00); break;
case Mnemonic.bisb2: RewriteAlu2(PrimitiveType.Byte, m.Or, NZ00); break;
case Mnemonic.bisb3: RewriteAlu3(PrimitiveType.Byte, m.Or, NZ00); break;
case Mnemonic.bispsw: RewriteBispsw(); break;
case Mnemonic.bisl2: RewriteAlu2(PrimitiveType.Word32, m.Or, NZ00); break;
case Mnemonic.bisl3: RewriteAlu3(PrimitiveType.Word32, m.Or, NZ00); break;
case Mnemonic.bisw2: RewriteAlu2(PrimitiveType.Word16, m.Or, NZ00); break;
case Mnemonic.bisw3: RewriteAlu3(PrimitiveType.Word16, m.Or, NZ00); break;
case Mnemonic.bitb: RewriteBit(PrimitiveType.Byte); break;
case Mnemonic.bitw: RewriteBit(PrimitiveType.Byte); break;
case Mnemonic.bitl: RewriteBit(PrimitiveType.Byte); break;
case Mnemonic.blbc: RewriteBlb(m.Eq0); break;
case Mnemonic.blbs: RewriteBlb(m.Ne0); break;
case Mnemonic.bpt: RewriteBpt(); break;
case Mnemonic.brb: RewriteBranch(); break;
case Mnemonic.brw: RewriteBranch(); break;
case Mnemonic.bsbb: RewriteBsb(); break;
case Mnemonic.bsbw: RewriteBsb(); break;
case Mnemonic.callg: RewriteCallg(); break;
case Mnemonic.calls: RewriteCalls(); break;
case Mnemonic.caseb: RewriteCase(PrimitiveType.Byte); break;
case Mnemonic.casel: RewriteCase(PrimitiveType.Word32); break;
case Mnemonic.casew: RewriteCase(PrimitiveType.Word16); break;
case Mnemonic.chme: RewriteChm("vax_chme"); break;
case Mnemonic.chmk: RewriteChm("vax_chmk"); break;
case Mnemonic.chms: RewriteChm("vax_chms"); break;
case Mnemonic.chmu: RewriteChm("vax_chmu"); break;
case Mnemonic.clrb: RewriteClr(PrimitiveType.Byte); break;
case Mnemonic.clrh: RewriteClr(PrimitiveType.Word128); break;
case Mnemonic.clrl: RewriteClr(PrimitiveType.Word32); break;
case Mnemonic.clrq: RewriteClr(PrimitiveType.Word64); break;
case Mnemonic.clrw: RewriteClr(PrimitiveType.Word16); break;
case Mnemonic.cmpb: RewriteCmp(PrimitiveType.Byte); break;
case Mnemonic.cmpd: RewriteCmp(PrimitiveType.Real64); break;
case Mnemonic.cmpf: RewriteCmp(PrimitiveType.Real32); break;
case Mnemonic.cmpg: RewriteCmp(PrimitiveType.Real64); break;
case Mnemonic.cmph: RewriteCmp(PrimitiveType.Real128); break;
case Mnemonic.cmpl: RewriteCmp(PrimitiveType.Word32); break;
case Mnemonic.cmpw: RewriteCmp(PrimitiveType.Word16); break;
case Mnemonic.cmpp3: RewriteCmpp3(); break;
case Mnemonic.cmpp4: RewriteCmpp4(); break;
case Mnemonic.cmpv: goto default;
case Mnemonic.cmpzv: goto default;
case Mnemonic.cvtbd: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break;
case Mnemonic.cvtbf: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real32); break;
case Mnemonic.cvtbg: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real64); break;
case Mnemonic.cvtbh: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Real128); break;
case Mnemonic.cvtbl: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int32); break;
case Mnemonic.cvtbw: RewriteCvt(PrimitiveType.SByte, PrimitiveType.Int16); break;
case Mnemonic.cvtdb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break;
case Mnemonic.cvtdf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break;
case Mnemonic.cvtdh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break;
case Mnemonic.cvtdl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Mnemonic.cvtdw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break;
case Mnemonic.cvtfb: RewriteCvt(PrimitiveType.Real32, PrimitiveType.SByte); break;
case Mnemonic.cvtfd: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break;
case Mnemonic.cvtfg: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real64); break;
case Mnemonic.cvtfh: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Real128); break;
case Mnemonic.cvtfl: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int32); break;
case Mnemonic.cvtfw: RewriteCvt(PrimitiveType.Real32, PrimitiveType.Int16); break;
case Mnemonic.cvtgb: RewriteCvt(PrimitiveType.Real64, PrimitiveType.SByte); break;
case Mnemonic.cvtgf: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break;
case Mnemonic.cvtgh: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real128); break;
case Mnemonic.cvtgl: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Mnemonic.cvtgw: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int16); break;
case Mnemonic.cvthb: RewriteCvt(PrimitiveType.Real128, PrimitiveType.SByte); break;
case Mnemonic.cvthd: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break;
case Mnemonic.cvthf: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real32); break;
case Mnemonic.cvthg: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Real64); break;
case Mnemonic.cvthl: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int32); break;
case Mnemonic.cvthw: RewriteCvt(PrimitiveType.Real128, PrimitiveType.Int16); break;
case Mnemonic.cvtps: RewriteCvtComplex("__cvtps"); break;
case Mnemonic.cvtrdl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Mnemonic.cvtrfl: RewriteCvtr(PrimitiveType.Real32, PrimitiveType.Int32); break;
case Mnemonic.cvtrgl: RewriteCvtr(PrimitiveType.Real64, PrimitiveType.Int32); break;
case Mnemonic.cvtrhl: RewriteCvtr(PrimitiveType.Real128, PrimitiveType.Int32); break;
case Mnemonic.cvtlb: RewriteCvt(PrimitiveType.Int32, PrimitiveType.SByte); break;
case Mnemonic.cvtld: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break;
case Mnemonic.cvtlf: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real32); break;
case Mnemonic.cvtlg: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real64); break;
case Mnemonic.cvtlh: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Real128); break;
case Mnemonic.cvtlp: goto default;
case Mnemonic.cvtlw: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Int16); break;
case Mnemonic.cvtpl: goto default;
case Mnemonic.cvtpt: goto default;
case Mnemonic.cvtsp: RewriteCvtComplex("__cvtsp"); break;
case Mnemonic.cvttp: goto default;
case Mnemonic.cvtwb: RewriteCvt(PrimitiveType.Int16, PrimitiveType.SByte); break;
case Mnemonic.cvtwd: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break;
case Mnemonic.cvtwf: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real32); break;
case Mnemonic.cvtwg: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real64); break;
case Mnemonic.cvtwh: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Real128); break;
case Mnemonic.cvtwl: RewriteCvt(PrimitiveType.Int16, PrimitiveType.Int32); break;;
case Mnemonic.decb: RewriteIncDec(PrimitiveType.Byte, Dec); break;
case Mnemonic.decl: RewriteIncDec(PrimitiveType.Word32, Dec); break;
case Mnemonic.decw: RewriteIncDec(PrimitiveType.Word16, Dec); break;
case Mnemonic.divb2: RewriteAlu2(PrimitiveType.Byte, m.SDiv, AllFlags); break;
case Mnemonic.divb3: RewriteAlu3(PrimitiveType.Byte, m.SDiv, AllFlags); break;
case Mnemonic.divd2: RewriteFpu2(PrimitiveType.Real64, m.FDiv, AllFlags); break;
case Mnemonic.divd3: RewriteFpu3(PrimitiveType.Real64, m.FDiv, AllFlags); break;
case Mnemonic.divf2: RewriteFpu2(PrimitiveType.Real32, m.FDiv, AllFlags); break;
case Mnemonic.divf3: RewriteFpu3(PrimitiveType.Real32, m.FDiv, AllFlags); break;
case Mnemonic.divl2: RewriteAlu2(PrimitiveType.Word32, m.SDiv, AllFlags); break;
case Mnemonic.divl3: RewriteAlu3(PrimitiveType.Word32, m.SDiv, AllFlags); break;
case Mnemonic.divp: RewriteDivp(); break;
case Mnemonic.divw2: RewriteAlu2(PrimitiveType.Word16, m.SDiv, AllFlags); break;
case Mnemonic.divw3: RewriteAlu3(PrimitiveType.Word16, m.SDiv, AllFlags); break;
case Mnemonic.emodd: RewriteEmod("emodd", PrimitiveType.Real64, PrimitiveType.Byte); break; //$TODO: VAX floating point types
case Mnemonic.emodf: RewriteEmod("emodf", PrimitiveType.Real32, PrimitiveType.Byte); break; //$TODO: VAX floating point types
case Mnemonic.emodg: RewriteEmod("emodg", PrimitiveType.Real64, PrimitiveType.Word16); break; //$TODO: VAX floating point types
case Mnemonic.emodh: RewriteEmod("emodh", PrimitiveType.Real128, PrimitiveType.Word16); break; //$TODO: VAX floating point types
case Mnemonic.extv: RewriteExtv(Domain.SignedInt); break;
case Mnemonic.extzv: RewriteExtv(Domain.UnsignedInt); break;
case Mnemonic.ffc: RewriteFfx("__ffc"); break;
case Mnemonic.ffs: RewriteFfx("__ffs"); break;
case Mnemonic.halt: RewriteHalt(); break;
case Mnemonic.incb: RewriteIncDec(PrimitiveType.Byte, Inc); break;
case Mnemonic.incl: RewriteIncDec(PrimitiveType.Word32, Inc); break;
case Mnemonic.incw: RewriteIncDec(PrimitiveType.Word16, Inc); break;
case Mnemonic.insque: RewriteInsque(); break;
case Mnemonic.jmp: RewriteJmp(); break;
case Mnemonic.jsb: RewriteJsb(); break;
case Mnemonic.mcomb: RewriteAluUnary2(PrimitiveType.Byte, m.Comp, NZ00); break;
case Mnemonic.mcoml: RewriteAluUnary2(PrimitiveType.Word32, m.Comp, NZ00); break;
case Mnemonic.mcomw: RewriteAluUnary2(PrimitiveType.Word16, m.Comp, NZ00); break;
case Mnemonic.mnegb: RewriteAluUnary2(PrimitiveType.Byte, m.Neg, AllFlags); break;
case Mnemonic.mnegd: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break;
case Mnemonic.mnegf: RewriteAluUnary2(PrimitiveType.Real32, m.FNeg, NZ00); break;
case Mnemonic.mnegg: RewriteAluUnary2(PrimitiveType.Real64, m.FNeg, NZ00); break;
case Mnemonic.mnegh: RewriteAluUnary2(PrimitiveType.Word128, m.FNeg, NZ00); break;
case Mnemonic.mnegl: RewriteAluUnary2(PrimitiveType.Word32, m.Neg, AllFlags); break;
case Mnemonic.mnegw: RewriteAluUnary2(PrimitiveType.Word16, m.Neg, AllFlags); break;
case Mnemonic.movab: RewriteMova(PrimitiveType.Byte); break;
case Mnemonic.movah: RewriteMova(PrimitiveType.Real128); break;
case Mnemonic.moval: RewriteMova(PrimitiveType.Word32); break;
case Mnemonic.movaq: RewriteMova(PrimitiveType.Word64); break;
case Mnemonic.movaw: RewriteMova(PrimitiveType.Word16); break;
case Mnemonic.movb: RewriteAluUnary2(PrimitiveType.Byte, Copy, NZ00); break;
case Mnemonic.movc3: goto default;
case Mnemonic.movc5: goto default;
case Mnemonic.movd: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break;
case Mnemonic.movf: RewriteAluUnary2(PrimitiveType.Real32, Copy, NZ00); break;
case Mnemonic.movg: RewriteAluUnary2(PrimitiveType.Real64, Copy, NZ00); break;
case Mnemonic.movh: RewriteAluUnary2(PrimitiveType.Real128, Copy, NZ00); break;
case Mnemonic.movl: RewriteAluUnary2(PrimitiveType.Word32, Copy, NZ00); break;
case Mnemonic.movo: RewriteAluUnary2(PrimitiveType.Word128, Copy, NZ00); break;
case Mnemonic.movp: RewriteMovp(); break;
case Mnemonic.movq: RewriteAluUnary2(PrimitiveType.Word64, Copy, NZ00); break;
case Mnemonic.movw: RewriteAluUnary2(PrimitiveType.Word16, Copy, NZ00); break;
case Mnemonic.movzbl: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt32); break;
case Mnemonic.movzbw: RewriteMovz(PrimitiveType.Byte, PrimitiveType.UInt16); break;
case Mnemonic.movzwl: RewriteMovz(PrimitiveType.Word16, PrimitiveType.UInt32); break;
case Mnemonic.mulb2: RewriteAlu2(PrimitiveType.Byte, m.IMul, AllFlags); break;
case Mnemonic.mulb3: RewriteAlu3(PrimitiveType.Byte, m.IMul, AllFlags); break;
case Mnemonic.muld2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Mnemonic.muld3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Mnemonic.mulf2: RewriteAlu2(PrimitiveType.Real32, m.FMul, AllFlags); break;
case Mnemonic.mulf3: RewriteAlu3(PrimitiveType.Real32, m.FMul, AllFlags); break;
case Mnemonic.mulg2: RewriteAlu2(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Mnemonic.mulg3: RewriteAlu3(PrimitiveType.Real64, m.FMul, AllFlags); break;
case Mnemonic.mulh2: RewriteAlu2(PrimitiveType.Real128, m.FMul, AllFlags); break;
case Mnemonic.mulh3: RewriteAlu3(PrimitiveType.Real128, m.FMul, AllFlags); break;
case Mnemonic.mull2: RewriteAlu2(PrimitiveType.Word32, m.IMul, AllFlags); break;
case Mnemonic.mull3: RewriteAlu3(PrimitiveType.Word32, m.IMul, AllFlags); break;
case Mnemonic.mulp: RewriteMulp(); break;
case Mnemonic.mulw2: RewriteAlu2(PrimitiveType.Word16, m.IMul, AllFlags); break;
case Mnemonic.mulw3: RewriteAlu3(PrimitiveType.Word16, m.IMul, AllFlags); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.polyd: RewritePoly(PrimitiveType.Real64); break;
case Mnemonic.polyf: RewritePoly(PrimitiveType.Real32); break;
case Mnemonic.polyg: RewritePoly(PrimitiveType.Real64); break;
case Mnemonic.polyh: RewritePoly(PrimitiveType.Real128); break;
case Mnemonic.popr: goto default;
case Mnemonic.prober: RewriteProber(); break;
case Mnemonic.probew: goto default;
case Mnemonic.pushr: goto default;
case Mnemonic.pushab: RewritePusha(); break;
case Mnemonic.pushal: RewritePusha(); break;
case Mnemonic.pushah: RewritePusha(); break;
case Mnemonic.pushaw: RewritePusha(); break;
case Mnemonic.pushaq: RewritePusha(); break;
case Mnemonic.pushl: RewritePush(PrimitiveType.Word32); break;
case Mnemonic.rei: RewriteRei(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.rotl: RewriteAlu3(PrimitiveType.Word32, Rotl, NZ00); break;
case Mnemonic.rsb: RewriteRsb(); break;
case Mnemonic.sbwc: RewriteSbwc(); break;
case Mnemonic.scanc: RewriteScanc(); break;
case Mnemonic.sobgeq: RewriteSob(m.Ge); break;
case Mnemonic.sobgtr: RewriteSob(m.Gt); break;
case Mnemonic.subb2: RewriteAlu2(PrimitiveType.Byte, m.ISub, AllFlags); break;
case Mnemonic.subb3: RewriteAlu3(PrimitiveType.Byte, m.ISub, AllFlags); break;
case Mnemonic.subd2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break;
case Mnemonic.subd3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break;
case Mnemonic.subf2: RewriteAlu2(PrimitiveType.Real32, m.FSub, NZ00); break;
case Mnemonic.subf3: RewriteAlu3(PrimitiveType.Real32, m.FSub, NZ00); break;
case Mnemonic.subg2: RewriteAlu2(PrimitiveType.Real64, m.FSub, NZ00); break;
case Mnemonic.subg3: RewriteAlu3(PrimitiveType.Real64, m.FSub, NZ00); break;
case Mnemonic.subh2: RewriteAlu2(PrimitiveType.Real128, m.FSub, NZ00); break;
case Mnemonic.subh3: RewriteAlu3(PrimitiveType.Real128, m.FSub, NZ00); break;
case Mnemonic.subl2: RewriteAlu2(PrimitiveType.Word32, m.ISub, AllFlags); break;
case Mnemonic.subl3: RewriteAlu3(PrimitiveType.Word32, m.ISub, AllFlags); break;
case Mnemonic.subp4: RewriteP4("vax_subp4"); break;
case Mnemonic.subp6: RewriteP6("vax_subp6"); break;
case Mnemonic.subw2: RewriteAlu2(PrimitiveType.Word16, m.ISub, AllFlags); break;
case Mnemonic.subw3: RewriteAlu3(PrimitiveType.Word16, m.ISub, AllFlags); break;
case Mnemonic.tstb: RewriteTst(PrimitiveType.Byte, ICmp0); break;
case Mnemonic.tstd: RewriteTst(PrimitiveType.Real64, FCmp0); break;
case Mnemonic.tstf: RewriteTst(PrimitiveType.Real32, FCmp0); break;
case Mnemonic.tstg: RewriteTst(PrimitiveType.Real64, FCmp0); break;
case Mnemonic.tsth: RewriteTst(PrimitiveType.Real128, FCmp0); break;
case Mnemonic.tstl: RewriteTst(PrimitiveType.Word32, ICmp0); break;
case Mnemonic.tstw: RewriteTst(PrimitiveType.Word16, ICmp0); break;
case Mnemonic.xorb2: RewriteAlu2(PrimitiveType.Byte, m.Xor, NZ00); break;
case Mnemonic.xorb3: RewriteAlu3(PrimitiveType.Byte, m.Xor, NZ00); break;
case Mnemonic.xorl2: RewriteAlu2(PrimitiveType.Word32, m.Xor, NZ00); break;
case Mnemonic.xorl3: RewriteAlu3(PrimitiveType.Word32, m.Xor, NZ00); break;
case Mnemonic.xorw2: RewriteAlu2(PrimitiveType.Word16, m.Xor, NZ00); break;
case Mnemonic.xorw3: RewriteAlu3(PrimitiveType.Word16, m.Xor, NZ00); break;
case Mnemonic.ldpctx: goto default;
case Mnemonic.svpctx: goto default;
case Mnemonic.editpc: goto default;
case Mnemonic.matchc: goto default;
case Mnemonic.index: goto default;
case Mnemonic.locc: goto default;
case Mnemonic.crc: goto default;
case Mnemonic.skpc: goto default;
case Mnemonic.remque: goto default;
case Mnemonic.spanc: goto default;
case Mnemonic.insqhi: goto default;
case Mnemonic.insqti: goto default;
case Mnemonic.movtc: goto default;
case Mnemonic.remqhi: goto default;
case Mnemonic.movtuc: goto default;
case Mnemonic.remqti: goto default;
case Mnemonic.emul: goto default;
case Mnemonic.ediv: goto default;
case Mnemonic.insv: goto default;
case Mnemonic.mtpr: goto default;
case Mnemonic.mfpr: goto default;
case Mnemonic.movpsl: goto default;
case Mnemonic.xfc: goto default;
case Mnemonic.mfvp: goto default;
case Mnemonic.vldl: goto default;
case Mnemonic.vgathl: goto default;
case Mnemonic.vldq: goto default;
case Mnemonic.vgathq: goto default;
case Mnemonic.addg2: goto default;
case Mnemonic.addg3: goto default;
case Mnemonic.divg2: goto default;
case Mnemonic.divg3: goto default;
case Mnemonic.addh2: goto default;
case Mnemonic.addh3: goto default;
case Mnemonic.divh2: goto default;
case Mnemonic.divh3: goto default;
case Mnemonic.vstl: goto default;
case Mnemonic.vscatl: goto default;
case Mnemonic.vstq: goto default;
case Mnemonic.vscatq: goto default;
case Mnemonic.vvmull: goto default;
case Mnemonic.vsmull: goto default;
case Mnemonic.vvmulg: goto default;
case Mnemonic.vsmulg: goto default;
case Mnemonic.vvmulf: goto default;
case Mnemonic.vsmulf: goto default;
case Mnemonic.vvmuld: goto default;
case Mnemonic.vsmuld: goto default;
case Mnemonic.vsync: goto default;
case Mnemonic.mtvp: goto default;
case Mnemonic.vvdivg: goto default;
case Mnemonic.vsdivg: goto default;
case Mnemonic.vvdivf: goto default;
case Mnemonic.vsdivf: goto default;
case Mnemonic.vvdivd: goto default;
case Mnemonic.vsdivd: goto default;
case Mnemonic.vvaddl: goto default;
case Mnemonic.vsaddl: goto default;
case Mnemonic.vvaddg: goto default;
case Mnemonic.vsaddg: goto default;
case Mnemonic.vvaddf: goto default;
case Mnemonic.vsaddf: goto default;
case Mnemonic.vvaddd: goto default;
case Mnemonic.vsaddd: goto default;
case Mnemonic.vvsubl: goto default;
case Mnemonic.vssubl: goto default;
case Mnemonic.vvsubg: goto default;
case Mnemonic.vssubg: goto default;
case Mnemonic.vvsubf: goto default;
case Mnemonic.vssubf: goto default;
case Mnemonic.vvsubd: goto default;
case Mnemonic.vssubd: goto default;
case Mnemonic.vvcmpl: goto default;
case Mnemonic.vvsrll: goto default;
case Mnemonic.vscmpl: goto default;
case Mnemonic.vssrll: goto default;
case Mnemonic.vvcmpg: goto default;
case Mnemonic.vscmpg: goto default;
case Mnemonic.vvcmpf: goto default;
case Mnemonic.vvslll: goto default;
case Mnemonic.vscmpf: goto default;
case Mnemonic.vsslll: goto default;
case Mnemonic.vvcmpd: goto default;
case Mnemonic.vscmpd: goto default;
case Mnemonic.vvbisl: goto default;
case Mnemonic.vvxorl: goto default;
case Mnemonic.vsbisl: goto default;
case Mnemonic.vsxorl: goto default;
case Mnemonic.vvbicl: goto default;
case Mnemonic.vvcvt: goto default;
case Mnemonic.vsbicl: goto default;
case Mnemonic.iota: goto default;
case Mnemonic.vvmerge: goto default;
case Mnemonic.vsmerge: goto default;
case Mnemonic.bugl: goto default;
case Mnemonic.bugw: goto default;
}
yield return(m.MakeCluster(addr, len, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
var instrs = new List <RtlInstruction>();
this.m = new RtlEmitter(instrs);
this.iclass = dasm.Current.InstructionClass;
switch (instr.Mnemonic)
{
case Mnemonic.invalid:
m.Invalid(); break;
case Mnemonic.brk:
case Mnemonic.cmps:
case Mnemonic.movs:
case Mnemonic.retb:
case Mnemonic.stop:
default:
EmitUnitTest();
this.iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.add: RewriteAdd(); break;
case Mnemonic.addc: RewriteAddcSubc(m.IAdd); break;
case Mnemonic.addw: RewriteAddw(); break;
case Mnemonic.and: RewriteLogical(m.And); break;
case Mnemonic.and1: RewriteLogical1(m.And); break;
case Mnemonic.bc: RewriteBranch(ConditionCode.ULT, C()); break;
case Mnemonic.bf: RewriteBf(); break;
case Mnemonic.bh: RewriteBranch(ConditionCode.UGT, CZ()); break;
case Mnemonic.bnc: RewriteBranch(ConditionCode.UGE, C()); break;
case Mnemonic.bnh: RewriteBranch(ConditionCode.ULE, CZ()); break;
case Mnemonic.bnz: RewriteBranch(ConditionCode.NE, Z()); break;
case Mnemonic.br: RewriteBr(); break;
case Mnemonic.bt: RewriteBt(); break;
case Mnemonic.btclr: RewriteBtclr(); break;
case Mnemonic.bz: RewriteBranch(ConditionCode.EQ, Z()); break;
case Mnemonic.call: RewriteCall(); break;
case Mnemonic.callt: RewriteCall(); break;
case Mnemonic.clr1: RewriteClr1(); break;
case Mnemonic.clrb: RewriteClr(PrimitiveType.Byte); break;
case Mnemonic.clrw: RewriteClr(PrimitiveType.Word16); break;
case Mnemonic.cmp: RewriteCmp(); break;
case Mnemonic.cmp0: RewriteCmp0(); break;
case Mnemonic.cmpw: RewriteCmp(); break;
case Mnemonic.dec: RewriteIncDec((a, b) => m.ISubS(a, 1)); break;
case Mnemonic.decw: RewriteIncwDecw((a, b) => m.ISubS(a, 1)); break;
case Mnemonic.halt: RewriteHalt(); break;
case Mnemonic.inc: RewriteIncDec((a, b) => m.IAddS(a, 1)); break;
case Mnemonic.incw: RewriteIncwDecw((a, b) => m.IAddS(a, 1)); break;
case Mnemonic.mov: RewriteMov(); break;
case Mnemonic.mov1: RewriteMov1(); break;
case Mnemonic.movw: RewriteMov(); break;
case Mnemonic.mulu: RewriteMulu(); break;
case Mnemonic.oneb: RewriteOne(PrimitiveType.Byte); break;
case Mnemonic.onew: RewriteOne(PrimitiveType.Word16); break;
case Mnemonic.or: RewriteLogical(m.Or); break;
case Mnemonic.or1: RewriteLogical1(m.Or); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.not1: RewriteNot1(); break;
case Mnemonic.pop: RewritePop(); break;
case Mnemonic.push: RewritePush(); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.reti: RewriteRet(); break;
case Mnemonic.rol: RewriteRotate(IntrinsicProcedure.Rol); break;
case Mnemonic.rolc: RewriteRotateC(IntrinsicProcedure.RolC); break;
case Mnemonic.rolwc: RewriteRotateC(IntrinsicProcedure.RolC); break;
case Mnemonic.ror: RewriteRotate(IntrinsicProcedure.Ror); break;
case Mnemonic.rorc: RewriteRotate(IntrinsicProcedure.RorC); break;
case Mnemonic.sar: RewriteShift(m.Sar); break;
case Mnemonic.sarw: RewriteShiftw(m.Sar); break;
case Mnemonic.sel: RewriteSel(); break;
case Mnemonic.set1: RewriteSet1(); break;
case Mnemonic.shl: RewriteShift(m.Shl); break;
case Mnemonic.shlw: RewriteShiftw(m.Shl); break;
case Mnemonic.shr: RewriteShift(m.Shr); break;
case Mnemonic.shrw: RewriteShiftw(m.Shr); break;
case Mnemonic.skc: RewriteSkip(ConditionCode.ULT, C()); break;
case Mnemonic.skh: RewriteSkip(ConditionCode.UGT, CZ()); break;
case Mnemonic.sknc: RewriteSkip(ConditionCode.UGE, C()); break;
case Mnemonic.sknh: RewriteSkip(ConditionCode.ULE, CZ()); break;
case Mnemonic.sknz: RewriteSkip(ConditionCode.NE, Z()); break;
case Mnemonic.skz: RewriteSkip(ConditionCode.EQ, Z()); break;
case Mnemonic.sub: RewriteSub(); break;
case Mnemonic.subc: RewriteAddcSubc(m.ISub); break;
case Mnemonic.subw: RewriteSubw(); break;
case Mnemonic.xch: RewriteXch(); break;
case Mnemonic.xchw: RewriteXch(); break;
case Mnemonic.xor: RewriteLogical(m.Xor); break;
case Mnemonic.xor1: RewriteLogical1(m.Xor); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, 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)
{
case Mnemonic.abs:
case Mnemonic.abss:
case Mnemonic.abssw:
case Mnemonic.adds:
case Mnemonic.asls:
case Mnemonic.asrs:
case Mnemonic.ex:
case Mnemonic.jcc:
case Mnemonic.jcs:
case Mnemonic.jge:
case Mnemonic.jgt:
case Mnemonic.jhi:
case Mnemonic.jle:
case Mnemonic.jls:
case Mnemonic.jlt:
case Mnemonic.jmi:
case Mnemonic.jne:
case Mnemonic.jpl:
case Mnemonic.jpnz:
case Mnemonic.jvc:
case Mnemonic.jvs:
case Mnemonic.negs:
case Mnemonic.negsw:
case Mnemonic.norm:
case Mnemonic.normw:
case Mnemonic.rlc:
case Mnemonic.rnd16:
case Mnemonic.rrc:
case Mnemonic.sat16:
case Mnemonic.subs:
case Mnemonic.swap:
case Mnemonic.abs_s:
case Mnemonic.not_s:
case Mnemonic.unimp_s:
default:
EmitUnitTest(this.instr);
goto case Mnemonic.Invalid;
case Mnemonic.Invalid:
this.iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.adc: RewriteAluOp(Adc, ZNCV); break;
case Mnemonic.add:
case Mnemonic.add_s:
RewriteAluOp(m.IAdd, ZNCV); break;
case Mnemonic.add1:
case Mnemonic.add1_s:
RewriteAluOp(Add1, ZNCV); break;
case Mnemonic.add2:
case Mnemonic.add2_s:
RewriteAluOp(Add2, ZNCV); break;
case Mnemonic.add3:
case Mnemonic.add3_s:
RewriteAluOp(Add3, ZNCV); break;
case Mnemonic.addsdw: RewriteAddSubsdw("__addsdw"); break;
case Mnemonic.and:
case Mnemonic.and_s:
RewriteAluOp(m.And, ZN); break;
case Mnemonic.asl:
case Mnemonic.asl_s:
RewriteShift(m.Shl, ZNCV); break;
case Mnemonic.asr:
case Mnemonic.asr_s:
RewriteShift(m.Sar, ZNCV); break;
case Mnemonic.b:
case Mnemonic.b_s: RewriteB(ArcCondition.AL); break;
case Mnemonic.bcc:
case Mnemonic.bhs_s: RewriteB(ArcCondition.CC); break;
case Mnemonic.bcs:
case Mnemonic.blo_s: RewriteB(ArcCondition.CS); break;
case Mnemonic.beq:
case Mnemonic.beq_s: RewriteB(ArcCondition.EQ); break;
case Mnemonic.bge:
case Mnemonic.bge_s: RewriteB(ArcCondition.GE); break;
case Mnemonic.bgt:
case Mnemonic.bgt_s: RewriteB(ArcCondition.GT); break;
case Mnemonic.bhi:
case Mnemonic.bhi_s: RewriteB(ArcCondition.HI); break;
case Mnemonic.ble:
case Mnemonic.ble_s: RewriteB(ArcCondition.LE); break;
case Mnemonic.bls:
case Mnemonic.bls_s: RewriteB(ArcCondition.LS); break;
case Mnemonic.blt:
case Mnemonic.blt_s: RewriteB(ArcCondition.LT); break;
case Mnemonic.bmi: RewriteB(ArcCondition.MI); break;
case Mnemonic.bne:
case Mnemonic.bne_s: RewriteB(ArcCondition.NE); break;
case Mnemonic.bpl: RewriteB(ArcCondition.PL); break;
case Mnemonic.bpnz: RewriteB(ArcCondition.PNZ); break;
case Mnemonic.bvc: RewriteB(ArcCondition.VC); break;
case Mnemonic.bvs: RewriteB(ArcCondition.VS); break;
case Mnemonic.bsc: RewriteB(ArcCondition.SC); break;
case Mnemonic.bss: RewriteB(ArcCondition.SS); break;
case Mnemonic.bbit0: RewriteBbit(false); break;
case Mnemonic.bbit1: RewriteBbit(true); break;
case Mnemonic.bclr:
case Mnemonic.bclr_s:
RewriteAluOp(Bclr, ZN); break;
case Mnemonic.bl:
case Mnemonic.bl_s:
RewriteBl(ArcCondition.AL); break;
case Mnemonic.blal: RewriteBl(ArcCondition.AL); break;
case Mnemonic.blcc: RewriteBl(ArcCondition.CC); break;
case Mnemonic.blcs: RewriteBl(ArcCondition.CS); break;
case Mnemonic.bleq: RewriteBl(ArcCondition.EQ); break;
case Mnemonic.blge: RewriteBl(ArcCondition.GE); break;
case Mnemonic.blgt: RewriteBl(ArcCondition.GT); break;
case Mnemonic.blhi: RewriteBl(ArcCondition.HI); break;
case Mnemonic.blle: RewriteBl(ArcCondition.LE); break;
case Mnemonic.blls: RewriteBl(ArcCondition.LS); break;
case Mnemonic.bllt: RewriteBl(ArcCondition.LT); break;
case Mnemonic.blmi: RewriteBl(ArcCondition.MI); break;
case Mnemonic.blne: RewriteBl(ArcCondition.NE); break;
case Mnemonic.blpl: RewriteBl(ArcCondition.PL); break;
case Mnemonic.blpnz: RewriteBl(ArcCondition.PNZ); break;
case Mnemonic.blvc: RewriteBl(ArcCondition.VC); break;
case Mnemonic.blvs: RewriteBl(ArcCondition.VS); break;
case Mnemonic.breq:
case Mnemonic.breq_s: RewriteBr(m.Eq); break;
case Mnemonic.brge: RewriteBr(m.Ge); break;
case Mnemonic.brhs: RewriteBr(m.Uge); break;
case Mnemonic.brlo: RewriteBr(m.Ult); break;
case Mnemonic.brlt: RewriteBr(m.Lt); break;
case Mnemonic.brne:
case Mnemonic.brne_s: RewriteBr(m.Ne); break;
case Mnemonic.brk:
case Mnemonic.brk_s:
RewriteBrk(); break;
case Mnemonic.bic:
case Mnemonic.bic_s:
RewriteAluOp(AndNot, ZN); break;
case Mnemonic.bmsk:
case Mnemonic.bmsk_s:
RewriteAluOp(Bmsk, ZN); break;
case Mnemonic.bset:
case Mnemonic.bset_s:
RewriteAluOp(Bset, ZN); break;
case Mnemonic.btst:
case Mnemonic.btst_s:
RewriteCondInstr(Btst, ZN); break;
case Mnemonic.bxor:
RewriteAluOp(Bxor, ZN); break;
case Mnemonic.cmp:
case Mnemonic.cmp_s:
RewriteCondInstr(m.ISub, ZNCV); break;
case Mnemonic.divaw: RewriteDivaw(); break;
case Mnemonic.extb:
case Mnemonic.extb_s:
RewriteExt(PrimitiveType.Byte, PrimitiveType.Word32); break;
case Mnemonic.extw:
case Mnemonic.extw_s:
RewriteExt(PrimitiveType.Word16, PrimitiveType.Word32); break;
case Mnemonic.flag: RewriteFlag(); break;
case Mnemonic.j:
case Mnemonic.j_s: RewriteJ(ArcCondition.AL); break;
case Mnemonic.jeq: RewriteJ(ArcCondition.EQ); break;
case Mnemonic.jl:
case Mnemonic.jl_s: RewriteJl(); break;
case Mnemonic.ld:
case Mnemonic.ld_s:
RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.ldb:
case Mnemonic.ldb_s:
RewriteLoad(PrimitiveType.Byte); break;
case Mnemonic.ldw:
case Mnemonic.ldw_s:
RewriteLoad(PrimitiveType.Word16); break;
case Mnemonic.lp: RewriteLp(ArcCondition.AL); break;
case Mnemonic.lpcc: RewriteLp(ArcCondition.CC); break;
case Mnemonic.lpcs: RewriteLp(ArcCondition.CS); break;
case Mnemonic.lpeq: RewriteLp(ArcCondition.EQ); break;
case Mnemonic.lpge: RewriteLp(ArcCondition.GE); break;
case Mnemonic.lpgt: RewriteLp(ArcCondition.GT); break;
case Mnemonic.lphi: RewriteLp(ArcCondition.HI); break;
case Mnemonic.lple: RewriteLp(ArcCondition.LE); break;
case Mnemonic.lpls: RewriteLp(ArcCondition.LS); break;
case Mnemonic.lplt: RewriteLp(ArcCondition.LT); break;
case Mnemonic.lpmi: RewriteLp(ArcCondition.MI); break;
case Mnemonic.lpne: RewriteLp(ArcCondition.NE); break;
case Mnemonic.lppl: RewriteLp(ArcCondition.PL); break;
case Mnemonic.lppnz: RewriteLp(ArcCondition.PNZ); break;
case Mnemonic.lpvc: RewriteLp(ArcCondition.VC); break;
case Mnemonic.lpvs: RewriteLp(ArcCondition.VS); break;
case Mnemonic.lr: RewriteLr(); break;
case Mnemonic.lsr:
case Mnemonic.lsr_s:
RewriteShift(m.Shr, ZNC); break;
case Mnemonic.max: RewriteAluOp(Max, ZNCV); break;
case Mnemonic.min: RewriteAluOp(Min, ZNCV); break;
case Mnemonic.mov:
case Mnemonic.mov_s:
RewriteMov(); break;
case Mnemonic.mul64:
case Mnemonic.mul64_s:
RewriteMul(m.SMul, PrimitiveType.Int64); break;
case Mnemonic.mulu64:
RewriteMul(m.UMul, PrimitiveType.UInt64); break;
case Mnemonic.neg_s: RewriteAluOp(m.Neg, ZNCV); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.not: RewriteAluOp(m.Comp, ZN); break;
case Mnemonic.or:
case Mnemonic.or_s:
RewriteAluOp(m.Or, ZN); break;
case Mnemonic.pop_s: RewritePop(); break;
case Mnemonic.push_s: RewritePush(); break;
case Mnemonic.rcmp: RewriteCondInstr(Rsub, ZNCV); break;
case Mnemonic.ror: RewriteShift(Ror, ZNC); break;
case Mnemonic.rsub: RewriteAluOp(Rsub, ZNCV); break;
case Mnemonic.sbc: RewriteAluOp(Sbc, ZNCV); break;
case Mnemonic.sexb:
case Mnemonic.sexb_s:
RewriteExt(PrimitiveType.SByte, PrimitiveType.Int32); break;
case Mnemonic.sexw:
case Mnemonic.sexw_s:
RewriteExt(PrimitiveType.Int16, PrimitiveType.Int32); break;
case Mnemonic.sr: RewriteSr(); break;
case Mnemonic.st:
case Mnemonic.st_s:
RewriteStore(PrimitiveType.Word32); break;
case Mnemonic.stb:
case Mnemonic.stb_s:
RewriteStore(PrimitiveType.Byte); break;
case Mnemonic.stw:
case Mnemonic.stw_s:
RewriteStore(PrimitiveType.Word16); break;
case Mnemonic.sub:
case Mnemonic.sub_s:
RewriteAluOp(m.ISub, ZNCV); break;
case Mnemonic.sub1: RewriteAluOp(Sub1, ZNCV); break;
case Mnemonic.sub2: RewriteAluOp(Sub2, ZNCV); break;
case Mnemonic.sub3: RewriteAluOp(Sub3, ZNCV); break;
case Mnemonic.subsdw: RewriteAddSubsdw("__subsdw"); break;
case Mnemonic.trap_s:
case Mnemonic.trap0:
RewriteTrap();
break;
case Mnemonic.tst:
case Mnemonic.tst_s:
RewriteCondInstr(m.And, ZN); break;
case Mnemonic.xor:
case Mnemonic.xor_s:
RewriteAluOp(m.Xor, ZN); break;
}
TryHandlingZeroOverheadLoop();
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;
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(new RtlInstructionCluster(instr.Address, instr.Length, instrs.ToArray())
{
Class = iclass,
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
var rtlInstrs = new List <RtlInstruction>();
this.m = new RtlEmitter(rtlInstrs);
this.iclass = instr.InstructionClass;
switch (instr.Mnemonic)
{
case Mnemonic.mov:
case Mnemonic.rev:
case Mnemonic.revw:
case Mnemonic.tbl:
EmitUnitTest();
host.Warn(
instr.Address,
"M6812 instruction '{0}' is not supported yet.",
instr.Mnemonic);
goto case Mnemonic.invalid;
case Mnemonic.invalid:
this.iclass = InstrClass.Invalid;
m.Invalid();
break;
case Mnemonic.aba: RewriteAba(); break;
case Mnemonic.adca: RewriteAdcSbc(Registers.a, m.IAdd); break;
case Mnemonic.adcb: RewriteAdcSbc(Registers.b, m.IAdd); break;
case Mnemonic.adda: RewriteArithmetic(Registers.a, m.IAdd); break;
case Mnemonic.addb: RewriteArithmetic(Registers.b, m.IAdd); break;
case Mnemonic.addd: RewriteArithmetic(Registers.d, m.IAdd); break;
case Mnemonic.anda: RewriteLogical(Registers.a, m.And); break;
case Mnemonic.andb: RewriteLogical(Registers.b, m.And); break;
case Mnemonic.andcc: RewriteAndcc(); break;
case Mnemonic.asr: RewriteShiftMem(m.Sar); break;
case Mnemonic.asra: RewriteArithmetic(Registers.a, m.Sar); break;
case Mnemonic.asrb: RewriteArithmetic(Registers.b, m.Sar); break;
case Mnemonic.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break;
case Mnemonic.bclr: RewriteBclr(); break;
case Mnemonic.bcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break;
case Mnemonic.beq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break;
case Mnemonic.bge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Mnemonic.bgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Mnemonic.bhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Mnemonic.ble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Mnemonic.blt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break;
case Mnemonic.bls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break;
case Mnemonic.bmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break;
case Mnemonic.bne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break;
case Mnemonic.bpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break;
case Mnemonic.bvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break;
case Mnemonic.bvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break;
case Mnemonic.bgnd: RewriteBgnd(); break;
case Mnemonic.bita: RewriteBit(Registers.a); break;
case Mnemonic.bitb: RewriteBit(Registers.b); break;
case Mnemonic.bra: RewriteBra(); break;
case Mnemonic.brclr: RewriteBrclr(); break;
case Mnemonic.brn: m.Nop(); break;
case Mnemonic.brset: RewriteBrset(); break;
case Mnemonic.bset: RewriteBset(); break;
case Mnemonic.bsr: RewriteBsr(); break;
case Mnemonic.call: RewriteCall(); break;
case Mnemonic.cba: RewriteCba(); break;
case Mnemonic.clr: RewriteClr(); break;
case Mnemonic.clra: RewriteClr(Registers.a); break;
case Mnemonic.clrb: RewriteClr(Registers.b); break;
case Mnemonic.cmpa: RewriteCmp(Registers.a); break;
case Mnemonic.cmpb: RewriteCmp(Registers.b); break;
case Mnemonic.com: RewriteCom(); break;
case Mnemonic.coma: RewriteCom(Registers.a); break;
case Mnemonic.comb: RewriteCom(Registers.b); break;
case Mnemonic.cpd: RewriteCmp(Registers.d); break;
case Mnemonic.cps: RewriteCmp(Registers.sp); break;
case Mnemonic.cpx: RewriteCmp(Registers.x); break;
case Mnemonic.cpy: RewriteCmp(Registers.y); break;
case Mnemonic.daa: RewriteDaa(); break;
case Mnemonic.dbeq: RewriteDb(m.Eq0); break;
case Mnemonic.dbne: RewriteDb(m.Ne0); break;
case Mnemonic.dec: RewriteIncDec(m.ISub); break;
case Mnemonic.deca: RewriteIncDec(Registers.a, m.ISub); break;
case Mnemonic.decb: RewriteIncDec(Registers.b, m.ISub); break;
case Mnemonic.dex: RewriteIncDecXY(Registers.x, m.ISub); break;
case Mnemonic.dey: RewriteIncDecXY(Registers.y, m.ISub); break;
case Mnemonic.ediv: RewriteEdiv(m.UDiv, m.Remainder); break;
case Mnemonic.edivs: RewriteEdiv(m.SDiv, m.Remainder); break;
case Mnemonic.emacs: RewriteEmacs(); break;
case Mnemonic.emaxd: RewriteEmaxmind("__umax"); break;
case Mnemonic.emaxm: RewriteEmaxminm("__umax"); break;
case Mnemonic.emind: RewriteEmaxmind("__umin"); break;
case Mnemonic.eminm: RewriteEmaxminm("__umin"); break;
case Mnemonic.emul: RewriteEmul(m.UMul); break;
case Mnemonic.emuls: RewriteEmul(m.SMul); break;
case Mnemonic.eora: RewriteLogical(Registers.a, m.Xor); break;
case Mnemonic.eorb: RewriteLogical(Registers.b, m.Xor); break;
case Mnemonic.etbl: RewriteEtbl(); break;
case Mnemonic.fdiv: RewriteFdiv(); break;
case Mnemonic.ibeq: RewriteIb(m.Eq0); break;
case Mnemonic.ibne: RewriteIb(m.Ne0); break;
case Mnemonic.idiv: RewriteIdiv(m.UDiv); break;
case Mnemonic.idivs: RewriteIdiv(m.SDiv); break;
case Mnemonic.inc: RewriteIncDec(m.IAdd); break;
case Mnemonic.inca: RewriteIncDec(Registers.a, m.IAdd); break;
case Mnemonic.incb: RewriteIncDec(Registers.b, m.IAdd); break;
case Mnemonic.inx: RewriteIncDecXY(Registers.x, m.IAdd); break;
case Mnemonic.iny: RewriteIncDecXY(Registers.y, m.IAdd); break;
case Mnemonic.jmp: RewriteJmp(); break;
case Mnemonic.jsr: RewriteJsr(); break;
case Mnemonic.lbcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); break;
case Mnemonic.lbcs: RewriteBcc(ConditionCode.ULT, FlagM.CF); break;
case Mnemonic.lbeq: RewriteBcc(ConditionCode.EQ, FlagM.ZF); break;
case Mnemonic.lbge: RewriteBcc(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Mnemonic.lbgt: RewriteBcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Mnemonic.lbhi: RewriteBcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Mnemonic.lble: RewriteBcc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Mnemonic.lblt: RewriteBcc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break;
case Mnemonic.lbls: RewriteBcc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break;
case Mnemonic.lbmi: RewriteBcc(ConditionCode.LT, FlagM.NF); break;
case Mnemonic.lbne: RewriteBcc(ConditionCode.NE, FlagM.ZF); break;
case Mnemonic.lbpl: RewriteBcc(ConditionCode.GT, FlagM.NF); break;
case Mnemonic.lbra: RewriteBra(); break;
case Mnemonic.lbrn: m.Nop(); break;
case Mnemonic.lbvc: RewriteBcc(ConditionCode.NO, FlagM.VF); break;
case Mnemonic.lbvs: RewriteBcc(ConditionCode.OV, FlagM.VF); break;
case Mnemonic.ldaa: RewriteLd(Registers.a); break;
case Mnemonic.ldab: RewriteLd(Registers.b); break;
case Mnemonic.ldd: RewriteLd(Registers.d); break;
case Mnemonic.lds: RewriteLd(Registers.sp); break;
case Mnemonic.ldx: RewriteLd(Registers.x); break;
case Mnemonic.ldy: RewriteLd(Registers.y); break;
case Mnemonic.leas: RewriteLea(Registers.sp); break;
case Mnemonic.leax: RewriteLea(Registers.x); break;
case Mnemonic.leay: RewriteLea(Registers.y); break;
case Mnemonic.lsl: RewriteShiftMem(m.Shl); break;
case Mnemonic.lsla: RewriteArithmetic(Registers.a, m.Shl); break;
case Mnemonic.lslb: RewriteArithmetic(Registers.b, m.Shl); break;
case Mnemonic.lsld: RewriteArithmetic(Registers.d, m.Shl); break;
case Mnemonic.lsr: RewriteShiftMem(m.Shr); break;
case Mnemonic.lsra: RewriteArithmetic(Registers.a, m.Shr); break;
case Mnemonic.lsrb: RewriteArithmetic(Registers.b, m.Shr); break;
case Mnemonic.lsrd: RewriteArithmetic(Registers.d, m.Shr); break;
case Mnemonic.maxa: RewriteMaxmina("__umax_b"); break;
case Mnemonic.maxm: RewriteMaxminm("__umax_b"); break;
case Mnemonic.mem: RewriteMem(); break;
case Mnemonic.mina: RewriteMaxmina("__umin_b"); break;
case Mnemonic.minm: RewriteMaxminm("__umin_b"); break;
case Mnemonic.mul: RewriteMul(); break;
case Mnemonic.neg: RewriteNeg(); break;
case Mnemonic.nega: RewriteNeg(Registers.a); break;
case Mnemonic.negb: RewriteNeg(Registers.b); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.oraa: RewriteLogical(Registers.a, m.Or); break;
case Mnemonic.orab: RewriteLogical(Registers.b, m.Or); break;
case Mnemonic.orcc: RewriteOrcc(); break;
case Mnemonic.psha: RewritePsh(Registers.a); break;
case Mnemonic.pshb: RewritePsh(Registers.b); break;
case Mnemonic.pshc: RewritePsh(Registers.ccr); break;
case Mnemonic.pshd: RewritePsh(Registers.d); break;
case Mnemonic.pshx: RewritePsh(Registers.x); break;
case Mnemonic.pshy: RewritePsh(Registers.y); break;
case Mnemonic.pula: RewritePul(Registers.a); break;
case Mnemonic.pulb: RewritePul(Registers.b); break;
case Mnemonic.pulc: RewritePul(Registers.ccr); break;
case Mnemonic.puld: RewritePul(Registers.d); break;
case Mnemonic.pulx: RewritePul(Registers.x); break;
case Mnemonic.puly: RewritePul(Registers.y); break;
case Mnemonic.rol: RewriteShiftMem(Rol); break;
case Mnemonic.rola: RewriteArithmetic(Registers.a, Rol); break;
case Mnemonic.rolb: RewriteArithmetic(Registers.b, Rol); break;
case Mnemonic.ror: RewriteShiftMem(Ror); break;
case Mnemonic.rora: RewriteArithmetic(Registers.a, Ror); break;
case Mnemonic.rorb: RewriteArithmetic(Registers.a, Ror); break;
case Mnemonic.rtc: RewriteRtc(); break;
case Mnemonic.rti: RewriteRti(); break;
case Mnemonic.rts: RewriteRts(); break;
case Mnemonic.sba: RewriteSba(); break;
case Mnemonic.sbca: RewriteAdcSbc(Registers.a, m.ISub); break;
case Mnemonic.sbcb: RewriteAdcSbc(Registers.b, m.ISub); break;
case Mnemonic.sex: RewriteSex(); break;
case Mnemonic.staa: RewriteSt(Registers.a); break;
case Mnemonic.stab: RewriteSt(Registers.b); break;
case Mnemonic.std: RewriteSt(Registers.d); break;
case Mnemonic.stop: RewriteStop(); break;
case Mnemonic.sts: RewriteSt(Registers.sp); break;
case Mnemonic.stx: RewriteSt(Registers.x); break;
case Mnemonic.sty: RewriteSt(Registers.y); break;
case Mnemonic.suba: RewriteSub(Registers.a); break;
case Mnemonic.subb: RewriteSub(Registers.b); break;
case Mnemonic.subd: RewriteSub(Registers.d); break;
case Mnemonic.swi: RewriteSwi(); break;
case Mnemonic.tab: RewriteTab(); break;
case Mnemonic.tba: RewriteTba(); break;
case Mnemonic.tbeq: RewriteTb(m.Eq0); break;
case Mnemonic.tbne: RewriteTb(m.Ne0); break;
case Mnemonic.tfr: RewriteTfr(); break;
case Mnemonic.trap: RewriteTrap(); break;
case Mnemonic.tst: RewriteTst(); break;
case Mnemonic.tsta: RewriteTst(Registers.a); break;
case Mnemonic.tstb: RewriteTst(Registers.b); break;
case Mnemonic.wai: RewriteWai(); break;
case Mnemonic.wav: RewriteWav(); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
instrCur = dasm.Current;
ric = new RtlInstructionCluster(instrCur.Address, 4);
ric.Class = RtlClass.Linear;
emitter = new RtlEmitter(ric.Instructions);
switch (instrCur.Opcode)
{
default:
throw new AddressCorrelatedException(
instrCur.Address,
"Rewriting SPARC opcode '{0}' is not supported yet.",
instrCur.Opcode);
case Opcode.add: RewriteAlu(emitter.IAdd, false); break;
case Opcode.addcc: RewriteAluCc(emitter.IAdd, false); break;
case Opcode.addx: RewriteAddxSubx(emitter.IAdd, false); break;
case Opcode.addxcc: RewriteAddxSubx(emitter.IAdd, true); break;
case Opcode.and: RewriteAlu(emitter.And, false); break;
case Opcode.andcc: RewriteAluCc(emitter.And, false); break;
case Opcode.andn: RewriteAlu(emitter.And, true); break;
case Opcode.ba: RewriteBranch(Constant.True()); break;
case Opcode.bn: RewriteBranch(Constant.False()); break;
case Opcode.bne: RewriteBranch(emitter.Test(ConditionCode.NE, Grf(FlagM.ZF))); break;
case Opcode.be: RewriteBranch(emitter.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break;
case Opcode.bg: RewriteBranch(emitter.Test(ConditionCode.GT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break;
case Opcode.bge: RewriteBranch(emitter.Test(ConditionCode.GE, Grf(FlagM.NF | FlagM.VF))); break;
case Opcode.bgu: RewriteBranch(emitter.Test(ConditionCode.UGE, Grf(FlagM.CF | FlagM.ZF))); break;
case Opcode.bl: RewriteBranch(emitter.Test(ConditionCode.LT, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break;
case Opcode.ble: RewriteBranch(emitter.Test(ConditionCode.LE, Grf(FlagM.ZF | FlagM.NF | FlagM.VF))); break;
case Opcode.bleu: RewriteBranch(emitter.Test(ConditionCode.ULE, Grf(FlagM.CF | FlagM.ZF))); break;
case Opcode.bcc: RewriteBranch(emitter.Test(ConditionCode.UGE, Grf(FlagM.CF))); break;
case Opcode.bcs: RewriteBranch(emitter.Test(ConditionCode.ULT, Grf(FlagM.CF))); break;
case Opcode.bneg: RewriteBranch(emitter.Test(ConditionCode.LT, Grf(FlagM.NF))); break;
case Opcode.bpos: RewriteBranch(emitter.Test(ConditionCode.GE, Grf(FlagM.NF))); break;
// Z
//case Opcode.bgu not (C or Z)
//case Opcode.bleu (C or Z)
//case Opcode.bcc not C
//case Opcode.bcs C
//case Opcode.bpos not N
//case Opcode.bneg N
//case Opcode.bvc not V
//case Opcode.bvs V
case Opcode.call: RewriteCall(); break;
case Opcode.fabss: RewriteFabss(); break;
case Opcode.fadds: RewriteFadds(); break;
case Opcode.fbne: RewriteBranch(emitter.Test(ConditionCode.NE, Grf(FlagM.LF | FlagM.GF))); break;
case Opcode.fba: RewriteBranch(Constant.True()); break;
case Opcode.fbn: RewriteBranch(Constant.False()); break;
case Opcode.fbu: RewriteBranch(emitter.Test(ConditionCode.NE, Grf(FlagM.UF))); break;
case Opcode.fbg: RewriteBranch(emitter.Test(ConditionCode.GT, Grf(FlagM.GF))); break;
case Opcode.fbug: RewriteBranch(emitter.Test(ConditionCode.GT, Grf(FlagM.GF | FlagM.UF))); break;
//case Opcode.fbug : on Unordered or Greater G or U
//case Opcode.fbl : on Less L
case Opcode.fbul: RewriteBranch(emitter.Test(ConditionCode.LT, Grf(FlagM.GF | FlagM.UF))); break;
//case Opcode.fbul : on Unordered or Less L or U
//case Opcode.fblg : on Less or Greater L or G
//case Opcode.fbne : on Not Equal L or G or U
//case Opcode.fbe : on Equal E
//case Opcode.fbue : on Unordered or Equal E or U
//case Opcode.fbge : on Greater or Equal E or G
//case Opcode.fbuge : on Unordered or Greater or Equal E or G or U
case Opcode.fbuge: RewriteBranch(emitter.Test(ConditionCode.GE, Grf(FlagM.EF | FlagM.GF | FlagM.UF))); break;
//case Opcode.fble : on Less or Equal E or L
//case Opcode.fbule : on Unordered or Less or Equal E or L or U
case Opcode.fbule: RewriteBranch(emitter.Test(ConditionCode.LE, Grf(FlagM.EF | FlagM.LF | FlagM.UF))); break;
// case Opcode.FBO : on Ordered E or L or G
case Opcode.fcmpes: RewriteFcmpes(); break;
case Opcode.fdivs: RewriteFdivs(); break;
case Opcode.fitod: RewriteFitod(); break;
case Opcode.fitoq: RewriteFitoq(); break;
case Opcode.fitos: RewriteFitos(); break;
case Opcode.fmovs: RewriteFmovs(); break;
case Opcode.fmuls: RewriteFmuls(); break;
case Opcode.fnegs: RewriteFmovs(); break;
case Opcode.fsubs: RewriteFsubs(); break;
case Opcode.jmpl: RewriteJmpl(); break;
case Opcode.ld: RewriteLoad(PrimitiveType.Word32); break;
case Opcode.lddf: RewriteDLoad(PrimitiveType.Real64); break;
case Opcode.ldf: RewriteLoad(PrimitiveType.Real32); break;
case Opcode.ldd: RewriteLoad(PrimitiveType.Word64); break;
case Opcode.ldsb: RewriteLoad(PrimitiveType.SByte); break;
case Opcode.ldsh: RewriteLoad(PrimitiveType.Int16); break;
case Opcode.ldub: RewriteLoad(PrimitiveType.Byte); break;
case Opcode.lduh: RewriteLoad(PrimitiveType.Word16); break;
case Opcode.mulscc: RewriteMulscc(); break;
case Opcode.or: RewriteAlu(emitter.Or, false); break;
case Opcode.orcc: RewriteAluCc(emitter.Or, false); break;
case Opcode.restore: RewriteRestore(); break;
case Opcode.rett: RewriteRett(); break;
case Opcode.save: RewriteSave(); break;
case Opcode.sethi: RewriteSethi(); break;
case Opcode.sdiv: RewriteAlu(emitter.SDiv, false); break;
case Opcode.sdivcc: RewriteAlu(emitter.SDiv, false); break;
case Opcode.sll: RewriteAlu(emitter.Shl, false); break;
case Opcode.smul: RewriteAlu(emitter.SMul, false); break;
case Opcode.smulcc: RewriteAluCc(emitter.SMul, false); break;
case Opcode.sra: RewriteAlu(emitter.Sar, false); break;
case Opcode.srl: RewriteAlu(emitter.Shr, false); break;
case Opcode.st: RewriteStore(PrimitiveType.Word32); break;
case Opcode.stb: RewriteStore(PrimitiveType.Byte); break;
case Opcode.std: RewriteStore(PrimitiveType.Word64); break;
case Opcode.stf: RewriteStore(PrimitiveType.Real32); break;
case Opcode.sth: RewriteStore(PrimitiveType.Word16); break;
case Opcode.sub: RewriteAlu(emitter.ISub, false); break;
case Opcode.subcc: RewriteAluCc(emitter.ISub, false); break;
case Opcode.subx: RewriteAddxSubx(emitter.ISub, false); break;
case Opcode.subxcc: RewriteAddxSubx(emitter.ISub, true); break;
case Opcode.ta: RewriteTrap(Constant.True()); break;
case Opcode.tn: RewriteTrap(Constant.False()); break;
case Opcode.tne: RewriteTrap(emitter.Test(ConditionCode.NE, Grf(FlagM.ZF))); break;
case Opcode.te: RewriteTrap(emitter.Test(ConditionCode.EQ, Grf(FlagM.ZF))); break;
case Opcode.udiv: RewriteAlu(emitter.UDiv, false); break;
case Opcode.udivcc: RewriteAluCc(emitter.UDiv, false); break;
case Opcode.umul: RewriteAlu(emitter.UMul, false); break;
case Opcode.umulcc: RewriteAluCc(emitter.UMul, false); break;
case Opcode.unimp: emitter.Invalid(); break;
case Opcode.xor: RewriteAlu(emitter.Xor, false); break;
}
yield return(ric);
}
}
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())
{
di = dasm.Current;
var addr = di.Address;
var len = di.Length;
rtlInstructions = new List <RtlInstruction>();
rtlc = RtlClass.Linear;
m = new RtlEmitter(rtlInstructions);
orw = new OperandRewriter(arch, this.m, this.binder, di.dataWidth);
switch (di.code)
{
default:
host.Warn(
di.Address,
"M68k instruction '{0}' is not supported yet.",
di.code);
m.Invalid();
break;
case Opcode.illegal: RewriteIllegal(); break;
case Opcode.abcd: RewriteAbcd(); break;
case Opcode.add: RewriteBinOp((s, d) => m.IAdd(d, s), FlagM.CVZNX); break;
case Opcode.adda: RewriteBinOp((s, d) => m.IAdd(d, s)); break;
case Opcode.addi: RewriteArithmetic((s, d) => m.IAdd(d, s)); break;
case Opcode.addq: RewriteAddSubq((s, d) => m.IAdd(d, s)); break;
case Opcode.addx: RewriteAddSubx(m.IAdd); break;
case Opcode.and: RewriteLogical((s, d) => m.And(d, s)); break;
case Opcode.andi: RewriteLogical((s, d) => m.And(d, s)); break;
case Opcode.asl: RewriteArithmetic((s, d) => m.Shl(d, s)); break;
case Opcode.asr: RewriteShift((s, d) => m.Sar(d, s)); break;
/*
*
* Mnemonic Condition Encoding Test
* T* True 0000 1
* F* False 0001 0
* HI High 0010 C L Z
* LS Low or Same 0011 C V Z
* VC Overflow Clear 1000 V
* VS Overflow Set 1001 V
*/
case Opcode.bclr: RewriteBclrBset("__bclr"); break;
case Opcode.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); 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.bchg: RewriteBchg(); break;
case Opcode.bkpt: RewriteBkpt(); break;
case Opcode.bra: RewriteBra(); break;
case Opcode.bset: RewriteBclrBset("__bset"); break;
case Opcode.bsr: RewriteBsr(); break;
case Opcode.btst: RewriteBtst(); break;
case Opcode.callm: RewriteCallm(); break;
case Opcode.cas: RewriteCas(); break;
case Opcode.clr: RewriteClr(); break;
case Opcode.chk: RewriteChk(); break;
case Opcode.chk2: RewriteChk2(); break;
case Opcode.cmp: RewriteCmp(); break;
case Opcode.cmp2: RewriteCmp2(); break;
case Opcode.cmpa: RewriteCmp(); break;
case Opcode.cmpi: RewriteCmp(); break;
case Opcode.cmpm: RewriteCmp(); break;
case Opcode.dbcc: RewriteDbcc(ConditionCode.UGE, FlagM.CF); break;
case Opcode.dbcs: RewriteDbcc(ConditionCode.ULT, FlagM.CF); break;
case Opcode.dbeq: RewriteDbcc(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.dbge: RewriteDbcc(ConditionCode.GE, FlagM.NF | FlagM.ZF); break;
case Opcode.dble: RewriteDbcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.dbls: RewriteDbcc(ConditionCode.ULE, FlagM.CF | FlagM.ZF); break;
case Opcode.dbhi: RewriteDbcc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Opcode.dbpl: RewriteDbcc(ConditionCode.GT, FlagM.NF); break;
case Opcode.dbne: RewriteDbcc(ConditionCode.NE, FlagM.ZF); break;
case Opcode.dbt: RewriteDbcc(ConditionCode.ALWAYS, 0); break;
case Opcode.dbra: RewriteDbcc(ConditionCode.None, 0); break;
case Opcode.divs: RewriteDiv(m.SDiv, PrimitiveType.Int16); break;
case Opcode.divsl: RewriteDiv(m.SDiv, PrimitiveType.Int32); break;
case Opcode.divu: RewriteDiv(m.UDiv, PrimitiveType.UInt16); break;
case Opcode.divul: RewriteDiv(m.UDiv, PrimitiveType.UInt32); break;
case Opcode.eor: RewriteLogical((s, d) => m.Xor(d, s)); break;
case Opcode.eori: RewriteLogical((s, d) => m.Xor(d, s)); break;
case Opcode.exg: RewriteExg(); break;
case Opcode.ext: RewriteExt(); break;
case Opcode.extb: RewriteExtb(); break;
case Opcode.fadd: RewriteFBinOp((s, d) => m.FAdd(d, s)); break;
//$REVIEW: the following don't respect NaN, but NaN typically doesn't exist in HLLs.
case Opcode.fbf: m.Nop(); break;
case Opcode.fblt: RewriteFbcc(ConditionCode.LT); break;
case Opcode.fbgl: RewriteFbcc(ConditionCode.NE); break;
case Opcode.fbgt: RewriteFbcc(ConditionCode.GT); break;
case Opcode.fbgle: RewriteFbcc(ConditionCode.NE); break; //$BUG: should be !is_nan
case Opcode.fbne: RewriteFbcc(ConditionCode.NE); break;
case Opcode.fbnge: RewriteFbcc(ConditionCode.LT); break;
case Opcode.fbngl: RewriteFbcc(ConditionCode.EQ); break;
case Opcode.fbngle: RewriteFbcc(ConditionCode.EQ); break; //$BUG: should be is_nan
case Opcode.fbnlt: RewriteFbcc(ConditionCode.GE); break;
case Opcode.fbnle: RewriteFbcc(ConditionCode.GT); break;
case Opcode.fbogl: RewriteFbcc(ConditionCode.NE); break;
case Opcode.fbole: RewriteFbcc(ConditionCode.LE); break;
case Opcode.fbolt: RewriteFbcc(ConditionCode.LT); break;
case Opcode.fbogt: RewriteFbcc(ConditionCode.GT); break;
case Opcode.fbor: RewriteFbcc(ConditionCode.EQ); break; //$REVIEW: is this correct?
case Opcode.fbseq: RewriteFbcc(ConditionCode.EQ); break;
case Opcode.fbsf: RewriteFbcc(ConditionCode.NEVER); break;
case Opcode.fbsne: RewriteFbcc(ConditionCode.NE); break;
case Opcode.fbst: RewriteFbcc(ConditionCode.ALWAYS); break;
case Opcode.fbuge: RewriteFbcc(ConditionCode.GE); break;
case Opcode.fbugt: RewriteFbcc(ConditionCode.GT); break;
case Opcode.fbult: RewriteFbcc(ConditionCode.LT); break;
case Opcode.fbun: RewriteFbcc(ConditionCode.IS_NAN); break;
case Opcode.fasin: RewriteFasin(); break;
case Opcode.fintrz: RewriteFintrz(); break;
case Opcode.fcmp: RewriteFcmp(); break;
case Opcode.fdiv: RewriteFBinOp((s, d) => m.FDiv(d, s)); break;
case Opcode.fmove: RewriteFmove(); break;
case Opcode.fmovecr: RewriteFmovecr(); break;
case Opcode.fmovem: RewriteMovem(i => arch.GetRegister(i + Registers.fp0.Number)); break;
case Opcode.fmul: RewriteFBinOp((s, d) => m.FMul(d, s)); break;
case Opcode.fneg: RewriteFUnaryOp(m.Neg); break;
case Opcode.fsqrt: RewriteFsqrt(); break;
case Opcode.fsub: RewriteFBinOp((s, d) => m.FSub(d, s)); break;
case Opcode.ftan: RewriteFtan(); break;
case Opcode.jmp: RewriteJmp(); break;
case Opcode.jsr: RewriteJsr(); break;
case Opcode.lea: RewriteLea(); break;
case Opcode.link: RewriteLink(); break;
case Opcode.lsl: RewriteShift((s, d) => m.Shl(d, s)); break;
case Opcode.lsr: RewriteShift((s, d) => m.Shr(d, s)); break;
case Opcode.move: RewriteMove(true); break;
case Opcode.move16: RewriteMove16(); break;
case Opcode.movea: RewriteMove(false); break;
case Opcode.movep: RewriteMovep(); break;
case Opcode.moveq: RewriteMoveq(); break;
case Opcode.moves: RewriteMoves(); break;
case Opcode.movem: RewriteMovem(arch.GetRegister); break;
case Opcode.muls: RewriteMul((s, d) => m.SMul(d, s)); break;
case Opcode.mulu: RewriteMul((s, d) => m.UMul(d, s)); break;
case Opcode.nbcd: RewriteNbcd(); break;
case Opcode.neg: RewriteUnary(s => m.Neg(s), AllConditions); break;
case Opcode.negx: RewriteUnary(RewriteNegx, AllConditions); break;
case Opcode.nop: m.Nop(); break;
case Opcode.not: RewriteUnary(s => m.Comp(s), LogicalConditions); break;
case Opcode.or: RewriteLogical((s, d) => m.Or(d, s)); break;
case Opcode.ori: RewriteLogical((s, d) => m.Or(d, s)); break;
case Opcode.pack: RewritePack(); break;
case Opcode.pea: RewritePea(); break;
case Opcode.pflushr: RewritePflushr(); break;
case Opcode.ptest: RewritePtest(); break;
case Opcode.rol: RewriteRotation(PseudoProcedure.Rol); break;
case Opcode.ror: RewriteRotation(PseudoProcedure.Ror); break;
case Opcode.roxl: RewriteRotationX(PseudoProcedure.RolC); break;
case Opcode.roxr: RewriteRotationX(PseudoProcedure.RorC); break;
case Opcode.rte: RewriteRte(); break;
case Opcode.rtm: RewriteRtm(); break;
case Opcode.rts: RewriteRts(); break;
case Opcode.sbcd: RewriteSbcd(); break;
case Opcode.scc: RewriteScc(ConditionCode.UGE, FlagM.CF); break;
case Opcode.scs: RewriteScc(ConditionCode.ULT, FlagM.CF); break;
case Opcode.seq: RewriteScc(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.sge: RewriteScc(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Opcode.sgt: RewriteScc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.shi: RewriteScc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Opcode.sle: RewriteScc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.slt: RewriteScc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break;
case Opcode.sls: RewriteScc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break;
case Opcode.smi: RewriteScc(ConditionCode.LT, FlagM.NF); break;
case Opcode.sne: RewriteScc(ConditionCode.NE, FlagM.ZF); break;
case Opcode.spl: RewriteScc(ConditionCode.GT, FlagM.NF); break;
case Opcode.svc: RewriteScc(ConditionCode.NO, FlagM.VF); break;
case Opcode.svs: RewriteScc(ConditionCode.OV, FlagM.VF); break;
case Opcode.st: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.True()); break;
case Opcode.sf: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.False()); break;
case Opcode.stop: RewriteStop(); break;
case Opcode.sub: RewriteArithmetic((s, d) => m.ISub(d, s)); break;
case Opcode.suba: RewriteArithmetic((s, d) => m.ISub(d, s)); break;
case Opcode.subi: RewriteArithmetic((s, d) => m.ISub(d, s)); break;
case Opcode.subq: RewriteAddSubq((s, d) => m.ISub(d, s)); break;
case Opcode.subx: RewriteArithmetic((s, d) => m.ISub(m.ISub(d, s), binder.EnsureFlagGroup(Registers.ccr, (uint)FlagM.XF, "X", PrimitiveType.Bool))); break;
case Opcode.swap: RewriteSwap(); break;
case Opcode.trap: RewriteTrap(); break;
case Opcode.trapeq: RewriteTrapCc(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.trapf: RewriteTrapCc(ConditionCode.NEVER, 0); break;
case Opcode.traphi: RewriteTrapCc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Opcode.trapls: RewriteTrapCc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break;
case Opcode.traplt: RewriteTrapCc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break;
case Opcode.tas: RewriteTas(); break;
case Opcode.tst: RewriteTst(); break;
case Opcode.unlk: RewriteUnlk(); break;
case Opcode.unpk: RewriteUnpk(); break;
}
yield return(new RtlInstructionCluster(
addr,
len,
rtlInstructions.ToArray())
{
Class = rtlc
});
}
yield break;
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
iclass = instr.InstructionClass;
var instrs = new List <RtlInstruction>();
this.m = new RtlEmitter(instrs);
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
Invalid();
host.Warn(
instr.Address,
string.Format(
"TLCS-90 instruction '{0}' not supported yet.",
instr.Mnemonic));
break;
case Mnemonic.invalid: m.Invalid(); break;
case Mnemonic.adc: RewriteAdcSbc(m.IAdd, "**-**V0*"); break;
case Mnemonic.add: RewriteBinOp(m.IAdd, "**-***0*"); break;
case Mnemonic.and: RewriteBinOp(m.And, "**-10*00"); break;
case Mnemonic.bit: RewriteBit("*--I**0-"); break;
case Mnemonic.call: RewriteCall(); break;
case Mnemonic.callr: RewriteCall(); break;
case Mnemonic.ccf: RewriteCcf(); break;
case Mnemonic.cp: RewriteCp(); break;
case Mnemonic.cpl: RewriteCpl("---1--1-"); break;
case Mnemonic.daa: RewriteDaa(); break;
case Mnemonic.dec: RewriteIncDec(m.ISub, false); break;
case Mnemonic.decx: RewriteIncDec(m.ISub, true); break;
case Mnemonic.di: RewriteDi(); break;
case Mnemonic.div: RewriteDiv(); break;
case Mnemonic.djnz: RewriteDjnz(); break;
case Mnemonic.ei: RewriteEi(); break;
case Mnemonic.ex: RewriteEx(); break;
case Mnemonic.exx: RewriteExx(); break;
case Mnemonic.halt: RewriteHalt(); break;
case Mnemonic.inc: RewriteIncDec(m.IAdd, false); break;
case Mnemonic.incw: RewriteIncwDecw(m.IAdd); break;
case Mnemonic.incx: RewriteIncDec(m.IAdd, true); break;
case Mnemonic.jp: RewriteJp(); break;
case Mnemonic.jr: RewriteJp(); break;
case Mnemonic.ld: RewriteLd(); break;
case Mnemonic.ldar: RewriteLdar(); break;
case Mnemonic.ldir: RewriteLdir("---0-00-"); break;
case Mnemonic.ldw: RewriteLd(); break;
case Mnemonic.mul: RewriteMul(); break;
case Mnemonic.neg: RewriteNeg(); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.or: RewriteBinOp(m.Or, "**-00*00"); break;
case Mnemonic.pop: RewritePop(); break;
case Mnemonic.push: RewritePush(); break;
case Mnemonic.rcf: RewriteRcf(); break;
case Mnemonic.res: RewriteSetRes(false); break;
case Mnemonic.ret: RewriteRet(); break;
case Mnemonic.reti: RewriteReti(); break;
case Mnemonic.rl: RewriteRotation(CommonOps.RolC, true); break;
case Mnemonic.rlc: RewriteRotation(CommonOps.Ror, false); break;
case Mnemonic.rr: RewriteRotation(CommonOps.RorC, true); break;
case Mnemonic.rrc: RewriteRotation(CommonOps.Ror, false); break;
case Mnemonic.sbc: RewriteAdcSbc(m.ISub, "**-**V1*"); break;
case Mnemonic.scf: RewriteScf(); break;
case Mnemonic.set: RewriteSetRes(true); break;
case Mnemonic.tset: RewriteTset("*--I**0-"); break;
case Mnemonic.sla: RewriteShift(m.Shl); break;
case Mnemonic.sll: RewriteShift(m.Shl); break;
case Mnemonic.sra: RewriteShift(m.Sar); break;
case Mnemonic.srl: RewriteShift(m.Shr); break;
case Mnemonic.sub: RewriteBinOp(m.ISub, "**-**V1*"); break;
case Mnemonic.swi: RewriteSwi(); break;
case Mnemonic.xor: RewriteBinOp(m.Xor, "**-10*00"); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
var instr = dasm.Current;
var rtlInstructions = new List <RtlInstruction>();
this.iclass = instr.InstructionClass;
this.m = new RtlEmitter(rtlInstructions);
switch (instr.Mnemonic)
{
default:
host.Error(
instr.Address,
string.Format("MIPS instruction '{0}' is not supported yet.", instr));
EmitUnitTest(instr);
goto case Mnemonic.illegal;
case Mnemonic.illegal:
iclass = InstrClass.Invalid; m.Invalid(); break;
case Mnemonic.add:
case Mnemonic.addi:
case Mnemonic.addiu:
case Mnemonic.addu:
RewriteAdd(instr, PrimitiveType.Word32); break;
case Mnemonic.add_s: RewriteFpuBinopS(instr, m.FAdd); break;
case Mnemonic.add_d: RewriteFpuBinopD(instr, m.FAdd); break;
case Mnemonic.and:
case Mnemonic.andi:
RewriteAnd(instr); break;
case Mnemonic.bc1f: RewriteBranchConditional1(instr, false); break;
case Mnemonic.bc1t: RewriteBranchConditional1(instr, true); break;
case Mnemonic.beq: RewriteBranch(instr, m.Eq, false); break;
case Mnemonic.beql: RewriteBranchLikely(instr, m.Eq); break;
case Mnemonic.bgez:
RewriteBranch0(instr, m.Ge, false); break;
case Mnemonic.bgezl:
RewriteBranch0(instr, m.Ge, true); break;
case Mnemonic.bgezal:
RewriteBgezal(instr); break;
case Mnemonic.bgezall:
RewriteBranch0(instr, m.Ge, true); break;
case Mnemonic.bgtz:
RewriteBranch0(instr, m.Gt, false); break;
case Mnemonic.bgtzl:
RewriteBranch0(instr, m.Gt, true); break;
case Mnemonic.blez:
RewriteBranch0(instr, m.Le, false); break;
case Mnemonic.blezl:
RewriteBranch0(instr, m.Le, true); break;
case Mnemonic.bltz:
RewriteBranch0(instr, m.Lt, false); break;
case Mnemonic.bltzl:
RewriteBranch0(instr, m.Lt, true); break;
case Mnemonic.bltzal:
RewriteBranch0(instr, m.Lt, true); break;
case Mnemonic.bltzall:
RewriteBranch0(instr, m.Lt, true); break;
case Mnemonic.bne:
RewriteBranch(instr, m.Ne, false); break;
case Mnemonic.bnel: RewriteBranchLikely(instr, m.Ne); break;
case Mnemonic.@break: RewriteBreak(instr); break;
case Mnemonic.c_le_d: RewriteFpuCmpD(instr, Operator.Fle); break;
case Mnemonic.c_le_s: RewriteFpuCmpD(instr, Operator.Fle); break;
case Mnemonic.c_lt_d: RewriteFpuCmpD(instr, Operator.Flt); break;
case Mnemonic.c_lt_s: RewriteFpuCmpD(instr, Operator.Flt); break;
case Mnemonic.c_eq_d: RewriteFpuCmpD(instr, Operator.Feq); break;
case Mnemonic.c_eq_s: RewriteFpuCmpD(instr, Operator.Feq); break;
case Mnemonic.cache: RewriteCache(instr, "__cache"); break;
case Mnemonic.cfc1: RewriteCfc1(instr); break;
case Mnemonic.ctc1: RewriteCtc1(instr); break;
case Mnemonic.clo: RewriteClo(instr); break;
case Mnemonic.clz: RewriteClz(instr); break;
case Mnemonic.cvt_d_l: RewriteCvtToD(instr, PrimitiveType.Int32); break;
case Mnemonic.cvt_s_d: RewriteCvtFromD(instr, PrimitiveType.Real32); break;
case Mnemonic.cvt_w_d: RewriteCvtFromD(instr, PrimitiveType.Int32); break;
case Mnemonic.dadd:
case Mnemonic.daddi:
RewriteAdd(instr, PrimitiveType.Word64); break;
case Mnemonic.daddiu:
case Mnemonic.daddu: RewriteAdd(instr, PrimitiveType.Word64); break;
case Mnemonic.ddiv: RewriteDiv(instr, m.SDiv); break;
case Mnemonic.ddivu: RewriteDiv(instr, m.UDiv); break;
case Mnemonic.div: RewriteDiv(instr, m.SDiv); break;
case Mnemonic.divu: RewriteDiv(instr, m.UDiv); break;
case Mnemonic.div_d: RewriteFpuBinopD(instr, m.FDiv); break;
case Mnemonic.dmfc0: RewriteMfc0(instr); break;
case Mnemonic.dmfc1: RewriteMfc1(instr); break;
case Mnemonic.dmtc0: RewriteMtc0(instr); break;
case Mnemonic.dmtc1: RewriteMtc1(instr); break;
case Mnemonic.dmult: RewriteMul(instr, m.SMul, PrimitiveType.Int128); break;
case Mnemonic.dmultu: RewriteMul(instr, m.UMul, PrimitiveType.UInt128); break;
case Mnemonic.dsll: RewriteSll(instr); break;
case Mnemonic.dsll32: RewriteDshift32(instr, m.Shl); break;
case Mnemonic.dsllv: RewriteSrl(instr); break;
case Mnemonic.dsra: RewriteSra(instr); break;
case Mnemonic.dsra32: RewriteDshift32(instr, m.Sar); break;
case Mnemonic.dsrav: RewriteSra(instr); break;
case Mnemonic.dsrl: RewriteSrl(instr); break;
case Mnemonic.dsrl32: RewriteDshift32(instr, m.Shr); break;
case Mnemonic.dsrlv: RewriteSrl(instr); break;
case Mnemonic.dsub:
case Mnemonic.dsubu:
RewriteSub(instr, PrimitiveType.Word64); break;
case Mnemonic.eret: RewriteEret(instr); break;
case Mnemonic.j: RewriteJump(instr); break;
case Mnemonic.jal: RewriteJal(instr); break;
case Mnemonic.jalr: RewriteJalr(instr); break;
case Mnemonic.jr: RewriteJr(instr); break;
case Mnemonic.lb: RewriteLoad(instr, PrimitiveType.SByte); break;
case Mnemonic.lbu: RewriteLoad(instr, PrimitiveType.Byte); break;
case Mnemonic.ld: RewriteLoad(instr, PrimitiveType.Word64); break;
case Mnemonic.ldl: RewriteLdl(instr); break;
case Mnemonic.ldr: RewriteLdr(instr); break;
case Mnemonic.ldc1: RewriteLcpr1(instr); break;
case Mnemonic.ldc2: RewriteLdc2(instr); break;
case Mnemonic.ldxc1: RewriteLcpr1(instr); break;
case Mnemonic.luxc1: RewriteLcpr1(instr); break;
case Mnemonic.lwxc1: RewriteLcpr1(instr); break;
case Mnemonic.lh: RewriteLoad(instr, PrimitiveType.Int16); break;
case Mnemonic.lhxs: RewriteLoadIndexed(instr, PrimitiveType.Int16, PrimitiveType.Int32, 2); break;
case Mnemonic.lhu: RewriteLoad(instr, PrimitiveType.UInt16); break;
case Mnemonic.lhuxs: RewriteLoadIndexed(instr, PrimitiveType.Word16, PrimitiveType.Word32, 2); break;
case Mnemonic.ll: RewriteLoadLinked32(instr); break;
case Mnemonic.lld: RewriteLoadLinked64(instr); break;
case Mnemonic.lui: RewriteLui(instr); break;
case Mnemonic.lw: RewriteLoad(instr, PrimitiveType.Word32, PrimitiveType.Int32); break;
case Mnemonic.lwc1: RewriteLcpr1(instr); break;
case Mnemonic.lwc2: RewriteLdc2(instr); break;
case Mnemonic.lwl: RewriteLwl(instr); break;
case Mnemonic.lwr: RewriteLwr(instr); break;
case Mnemonic.lwu: RewriteLoad(instr, PrimitiveType.UInt32); break;
case Mnemonic.madd: RewriteMac_int(instr, m.IAdd); break;
case Mnemonic.madd_s: RewriteMac_real(instr, PrimitiveType.Real32, m.FAdd); break;
case Mnemonic.madd_ps: RewriteMac_vec(instr, PrimitiveType.Real32, m.FAdd); break;
case Mnemonic.mfc0: RewriteMfc0(instr); break;
case Mnemonic.mfc1: RewriteMfc1(instr); break;
case Mnemonic.mfhi: RewriteMf(instr, arch.hi); break;
case Mnemonic.mflo: RewriteMf(instr, arch.lo); break;
case Mnemonic.mtc0: RewriteMtc0(instr); break;
case Mnemonic.mthi: RewriteMt(instr, arch.hi); break;
case Mnemonic.mtlo: RewriteMt(instr, arch.lo); break;
case Mnemonic.movf: RewriteMovft(instr, false); break;
case Mnemonic.movn: RewriteMovCc(instr, m.Ne0); break;
case Mnemonic.movt: RewriteMovft(instr, true); break;
case Mnemonic.movz: RewriteMovCc(instr, m.Eq0); break;
case Mnemonic.mov_d: RewriteCopy(instr); break;
case Mnemonic.mov_s: RewriteCopy(instr); break;
case Mnemonic.msub: RewriteMac_int(instr, m.ISub); break;
case Mnemonic.msub_s: RewriteMac_real(instr, PrimitiveType.Real32, m.FSub); break;
case Mnemonic.mtc1: RewriteMtc1(instr); break;
case Mnemonic.mul: RewriteMul(instr, m.SMul, PrimitiveType.Int32); break;
case Mnemonic.mult: RewriteMul(instr, m.SMul, PrimitiveType.Int64); break;
case Mnemonic.multu: RewriteMul(instr, m.UMul, PrimitiveType.UInt64); break;
case Mnemonic.mul_s: RewriteMul(instr, m.FMul, PrimitiveType.Real32); break;
case Mnemonic.mul_d: RewriteMulD(instr); break;
case Mnemonic.nmadd_d: RewriteNmac_real(instr, PrimitiveType.Real64, m.FAdd); break;
case Mnemonic.nmadd_s: RewriteNmac_real(instr, PrimitiveType.Real32, m.FAdd); break;
case Mnemonic.nop: m.Nop(); break;
case Mnemonic.nor: RewriteNor(instr); break;
case Mnemonic.nmsub_d: RewriteNmac_real(instr, PrimitiveType.Real64, m.FSub); break;
case Mnemonic.nmsub_s: RewriteNmac_real(instr, PrimitiveType.Real32, m.FSub); break;
case Mnemonic.nmsub_ps: RewriteNmac_vec(instr, PrimitiveType.Real32, m.FSub); break;
case Mnemonic.or:
case Mnemonic.ori: RewriteOr(instr); break;
case Mnemonic.pref:
case Mnemonic.prefx: RewritePrefx(instr); break;
case Mnemonic.sb: RewriteStore(instr); break;
case Mnemonic.sc: RewriteStoreConditional32(instr); break;
case Mnemonic.scd: RewriteStoreConditional64(instr); break;
case Mnemonic.sd: RewriteStore(instr); break;
case Mnemonic.sdc1: RewriteStore(instr); break;
case Mnemonic.sdc2: RewriteSdc2(instr); break;
case Mnemonic.sdl: RewriteSdl(instr); break;
case Mnemonic.sdr: RewriteSdr(instr); break;
case Mnemonic.seb: RewriteSignExtend(instr, PrimitiveType.Byte); break;
case Mnemonic.seh: RewriteSignExtend(instr, PrimitiveType.Word16); break;
case Mnemonic.seqi: RewriteScc(instr, m.Eq); break;
case Mnemonic.sh: RewriteStore(instr); break;
case Mnemonic.sll:
case Mnemonic.sllv:
RewriteSll(instr); 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.sltu: RewriteScc(instr, m.Ult); break;
case Mnemonic.sra:
case Mnemonic.srav:
RewriteSra(instr); break;
case Mnemonic.srl:
case Mnemonic.srlv:
RewriteSrl(instr); break;
case Mnemonic.sub:
case Mnemonic.subu:
RewriteSub(instr, PrimitiveType.Word32); break;
case Mnemonic.sub_d: RewriteFpuBinopD(instr, m.FSub); break;
case Mnemonic.sw:
case Mnemonic.swc1: RewriteStore(instr); break;
case Mnemonic.swc2: RewriteSdc2(instr); break;
case Mnemonic.swl: RewriteSwl(instr); break;
case Mnemonic.swr: RewriteSwr(instr); break;
case Mnemonic.swxc1: RewriteStore(instr); break;
case Mnemonic.sync: RewriteSync(instr); break;
case Mnemonic.syscall: RewriteSyscall(instr); break;
case Mnemonic.teq: RewriteTrap(instr, m.Eq); break;
case Mnemonic.teqi: RewriteTrap(instr, m.Eq); break;
case Mnemonic.tge: RewriteTrap(instr, m.Ge); break;
case Mnemonic.tgeu: RewriteTrap(instr, m.Uge); break;
case Mnemonic.tgei: RewriteTrapi(instr, m.Ge); break;
case Mnemonic.tgeiu: RewriteTrapi(instr, m.Uge); break;
case Mnemonic.tlbp: RewriteTlbp(instr); break;
case Mnemonic.tlbr: RewriteTlbr(instr); break;
case Mnemonic.tlbwi: RewriteTlbwi(instr); break;
case Mnemonic.tlbwr: RewriteTlbwr(instr); break;
case Mnemonic.tlt: RewriteTrap(instr, m.Lt); break;
case Mnemonic.tlti: RewriteTrapi(instr, m.Lt); break;
case Mnemonic.tltiu: RewriteTrapi(instr, m.Ult); break;
case Mnemonic.tltu: RewriteTrap(instr, m.Ult); break;
case Mnemonic.tne: RewriteTrap(instr, m.Ne); break;
case Mnemonic.tnei: RewriteTrapi(instr, m.Ne); break;
case Mnemonic.trunc_l_d: RewriteTrunc(instr, "trunc", PrimitiveType.Real64, PrimitiveType.Int64); break;
case Mnemonic.wait: RewriteWait(instr); break;
case Mnemonic.xor:
case Mnemonic.xori: RewriteXor(instr); break;
// Nano instructions
case Mnemonic.addiupc: RewriteAddiupc(instr); break;
case Mnemonic.aluipc: RewriteAluipc(instr); break;
case Mnemonic.balc: RewriteBalc(instr); break;
case Mnemonic.balrsc: RewriteBalrsc(instr); break;
case Mnemonic.bbeqzc: RewriteBb(instr, e => e); break;
case Mnemonic.bbnezc: RewriteBb(instr, m.Not); break;
case Mnemonic.bc: RewriteJump(instr); break;
case Mnemonic.beqc: RewriteBranch(instr, m.Eq, false); break;
case Mnemonic.beqic: RewriteBranchImm(instr, m.Eq, false); break;
case Mnemonic.beqzc: RewriteBranch0(instr, m.Eq, false); break;
case Mnemonic.bgec: RewriteBranch(instr, m.Ge, false); break;
case Mnemonic.bgeic: RewriteBranchImm(instr, m.Ge, false); break;
case Mnemonic.bgeiuc: RewriteBranchImm(instr, m.Uge, false); break;
case Mnemonic.bgeuc: RewriteBranch(instr, m.Uge, false); break;
case Mnemonic.bltc: RewriteBranch(instr, m.Lt, false); break;
case Mnemonic.bltic: RewriteBranchImm(instr, m.Lt, false); break;
case Mnemonic.bltiuc: RewriteBranchImm(instr, m.Ult, false); break;
case Mnemonic.bltuc: RewriteBranch(instr, m.Ult, false); break;
case Mnemonic.bnec: RewriteBranch(instr, m.Ne, false); break;
case Mnemonic.bneiuc: RewriteBranchImm(instr, m.Ne, false); break;
case Mnemonic.bnezc: RewriteBranch0(instr, m.Ne, false); break;
case Mnemonic.cachee: RewriteCache(instr, "__cache_EVA"); break;
case Mnemonic.ext: RewriteExt(instr); break;
case Mnemonic.ins: RewriteIns(instr); break;
case Mnemonic.jalrc: RewriteJalr(instr); break;
case Mnemonic.jalrc_hb: RewriteJalr_hb(instr); break;
case Mnemonic.jrc: RewriteJr(instr); break;
case Mnemonic.lbue: RewriteLe(instr, PrimitiveType.Byte, "__load_ub_EVA"); break;
case Mnemonic.lbux: RewriteLx(instr, PrimitiveType.Byte, 1); break;
case Mnemonic.lwx: RewriteLx(instr, PrimitiveType.Word32, 1); break;
case Mnemonic.lwpc: RewriteLwpc(instr); break;
case Mnemonic.li: RewriteMove(instr); break;
case Mnemonic.lsa: RewriteLsa(instr); break;
case Mnemonic.lwm: RewriteLwm(instr); break;
case Mnemonic.lwxs: RewriteLwxs(instr); break;
case Mnemonic.mod: RewriteMod(instr, m.Mod); break;
case Mnemonic.modu: RewriteMod(instr, m.Mod); break; //$TODO: unsigned modulus.
case Mnemonic.move: RewriteMove(instr); break;
case Mnemonic.move_balc: RewriteMoveBalc(instr); break;
case Mnemonic.movep: RewriteMovep(instr); break;
case Mnemonic.muh: RewriteMuh(instr, PrimitiveType.Int64, m.SMul); break;
case Mnemonic.muhu: RewriteMuh(instr, PrimitiveType.UInt64, m.UMul); break;
case Mnemonic.not: RewriteNot(instr); break;
case Mnemonic.rdhwr: RewriteReadHardwareRegister(instr); break;
case Mnemonic.restore: RewriteRestore(instr, false); break;
case Mnemonic.restore_jrc: RewriteRestore(instr, true); break;
case Mnemonic.rotr: RewriteRotr(instr); break;
case Mnemonic.rotx: RewriteRotx(instr); break;
case Mnemonic.save: RewriteSave(instr); break;
case Mnemonic.sdbbp: RewriteSdbbp(instr); break;
case Mnemonic.sigrie: RewriteSigrie(instr); break;
case Mnemonic.swm: RewriteSwm(instr); break;
case Mnemonic.swpc: RewriteSwpc(instr); break;
case Mnemonic.sbx: RewriteSxs(instr, PrimitiveType.Byte, 1); break;
case Mnemonic.shxs: RewriteSxs(instr, PrimitiveType.Word16, 2); break;
case Mnemonic.swx: RewriteSxs(instr, PrimitiveType.Word32, 1); break;
case Mnemonic.swxs: RewriteSxs(instr, PrimitiveType.Word32, 4); break;
case Mnemonic.ualwm: RewriteLwm(instr); 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>();
rtlc = 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:
rtlc = 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;
// Z
//case Opcode.bgu not (C or Z)
//case Opcode.bleu (C or Z)
//case Opcode.bcc not C
//case Opcode.bcs C
//case Opcode.bpos not N
//case Opcode.bneg N
//case Opcode.bvc not V
//case Opcode.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 Opcode.fbug : on Unordered or Greater G or U
//case Opcode.fbl : on Less L
case Mnemonic.fbul: RewriteBranch(m.Test(ConditionCode.LT, Grf(FlagM.GF | FlagM.UF))); break;
//case Opcode.fbul : on Unordered or Less L or U
//case Opcode.fblg : on Less or Greater L or G
//case Opcode.fbne : on Not Equal L or G or U
//case Opcode.fbe : on Equal E
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 Opcode.fble : on Less or Equal E or L
//case Opcode.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 Opcode.FBO : on Ordered E or L or G
case Mnemonic.fcmpes: RewriteFcmpes(); 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.ldstub: RewriteLdstub(); break;
case Mnemonic.ldub: RewriteLoad(PrimitiveType.Byte); break;
case Mnemonic.lduh: RewriteLoad(PrimitiveType.Word16); break;
case Mnemonic.ldfsr: RewriteLoad(PrimitiveType.Word32); break;
case Mnemonic.mulscc: RewriteMulscc(); break;
case Mnemonic.or: RewriteAlu(m.Or, false); break;
case Mnemonic.orcc: RewriteAluCc(m.Or, false); break;
case Mnemonic.restore: RewriteRestore(); break;
case Mnemonic.rett: RewriteRett(); 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.smul: RewriteAlu(m.SMul, false); break;
case Mnemonic.smulcc: RewriteAluCc(m.SMul, false); break;
case Mnemonic.sra: RewriteAlu(m.Sar, false); break;
case Mnemonic.srl: 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.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(new RtlInstructionCluster(addr, 4, rtlInstructions.ToArray())
{
Class = rtlc
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
rtlc = RtlClass.Linear;
var instrs = new List <RtlInstruction>();
this.m = new RtlEmitter(instrs);
switch (instr.Opcode)
{
default:
EmitUnitTest();
Invalid();
break;
case Opcode.invalid: rtlc = RtlClass.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,
});
}
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
di = dasm.Current;
ric = new RtlInstructionCluster(di.Address, di.Length);
ric.Class = RtlClass.Linear;
emitter = new RtlEmitter(ric.Instructions);
orw = new OperandRewriter(arch, this.emitter, this.frame, di.dataWidth);
switch (di.code)
{
case Opcode.add: RewriteBinOp((s, d) => emitter.IAdd(d, s), FlagM.CVZNX); break;
case Opcode.adda: RewriteBinOp((s, d) => emitter.IAdd(d, s)); break;
case Opcode.addi: RewriteArithmetic((s, d) => emitter.IAdd(d, s)); break;
case Opcode.addq: RewriteAddSubq((s, d) => emitter.IAdd(d, s)); break;
case Opcode.addx: RewriteAddSubx(Operator.IAdd); break;
case Opcode.and: RewriteLogical((s, d) => emitter.And(d, s)); break;
case Opcode.andi: RewriteLogical((s, d) => emitter.And(d, s)); break;
case Opcode.asl: RewriteArithmetic((s, d) => emitter.Shl(d, s)); break;
case Opcode.asr: RewriteShift((s, d) => emitter.Sar(d, s)); break;
/*
*
* Mnemonic Condition Encoding Test
* T* True 0000 1
* F* False 0001 0
* HI High 0010 C L Z
* LS Low or Same 0011 C V Z
* VC Overflow Clear 1000 V
* VS Overflow Set 1001 V
*/
case Opcode.bclr: RewriteBclrBset("__bclr"); break;
case Opcode.bcc: RewriteBcc(ConditionCode.UGE, FlagM.CF); 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.bchg: RewriteBchg(); break;
case Opcode.bra: RewriteBra(); break;
case Opcode.bset: RewriteBclrBset("__bset"); break;
case Opcode.bsr: RewriteBsr(); break;
case Opcode.btst: RewriteBtst(); break;
case Opcode.clr: RewriteClr(); break;
case Opcode.cmp: RewriteCmp(); break;
case Opcode.cmpa: RewriteCmp(); break;
case Opcode.cmpi: RewriteCmp(); break;
case Opcode.cmpm: RewriteCmp(); break;
case Opcode.dbeq: RewriteDbcc(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.dble: RewriteDbcc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.dbhi: RewriteDbcc(ConditionCode.ULE, FlagM.CF | FlagM.ZF); break;
case Opcode.dbne: RewriteDbcc(ConditionCode.NE, FlagM.ZF); break;
case Opcode.dbra: RewriteDbcc(ConditionCode.None, 0); break;
case Opcode.divu: RewriteDiv(Operator.UDiv); break;
case Opcode.eor: RewriteLogical((s, d) => emitter.Xor(d, s)); break;
case Opcode.eori: RewriteLogical((s, d) => emitter.Xor(d, s)); break;
case Opcode.exg: RewriteExg(); break;
case Opcode.ext: RewriteExt(); break;
case Opcode.extb: RewriteExtb(); break;
case Opcode.illegal: if (!RewriteIllegal())
{
goto default;
}
break;
case Opcode.jmp: RewriteJmp(); break;
case Opcode.jsr: RewriteJsr(); break;
case Opcode.lea: RewriteLea(); break;
case Opcode.link: RewriteLink(); break;
case Opcode.lsl: RewriteShift((s, d) => emitter.Shl(d, s)); break;
case Opcode.lsr: RewriteShift((s, d) => emitter.Shr(d, s)); break;
case Opcode.move: RewriteMove(true); break;
case Opcode.movea: RewriteMove(false); break;
case Opcode.moveq: RewriteMoveq(); break;
case Opcode.movem: RewriteMovem(); break;
case Opcode.muls: RewriteMul((s, d) => emitter.SMul(d, s)); break;
case Opcode.mulu: RewriteMul((s, d) => emitter.UMul(d, s)); break;
case Opcode.neg: RewriteUnary(s => emitter.Neg(s), AllConditions); break;
case Opcode.negx: RewriteUnary(RewriteNegx, AllConditions); break;
case Opcode.nop: emitter.Nop(); break;
case Opcode.not: RewriteUnary(s => emitter.Comp(s), LogicalConditions); break;
case Opcode.or: RewriteLogical((s, d) => emitter.Or(d, s)); break;
case Opcode.ori: RewriteLogical((s, d) => emitter.Or(d, s)); break;
case Opcode.pea: RewritePea(); break;
case Opcode.rol: RewriteRotation(PseudoProcedure.Rol); break;
case Opcode.ror: RewriteRotation(PseudoProcedure.Ror); break;
case Opcode.roxl: RewriteRotationX(PseudoProcedure.RolC); break;
case Opcode.roxr: RewriteRotationX(PseudoProcedure.RorC); break;
case Opcode.rts: RewriteRts(); break;
case Opcode.scc: RewriteScc(ConditionCode.UGE, FlagM.CF); break;
case Opcode.scs: RewriteScc(ConditionCode.ULT, FlagM.CF); break;
case Opcode.seq: RewriteScc(ConditionCode.EQ, FlagM.ZF); break;
case Opcode.sge: RewriteScc(ConditionCode.GE, FlagM.NF | FlagM.VF); break;
case Opcode.sgt: RewriteScc(ConditionCode.GT, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.shi: RewriteScc(ConditionCode.UGT, FlagM.CF | FlagM.ZF); break;
case Opcode.sle: RewriteScc(ConditionCode.LE, FlagM.NF | FlagM.VF | FlagM.ZF); break;
case Opcode.slt: RewriteScc(ConditionCode.LT, FlagM.CF | FlagM.ZF); break;
case Opcode.sls: RewriteScc(ConditionCode.ULE, FlagM.VF | FlagM.ZF); break;
case Opcode.smi: RewriteScc(ConditionCode.LT, FlagM.NF); break;
case Opcode.sne: RewriteScc(ConditionCode.NE, FlagM.ZF); break;
case Opcode.spl: RewriteScc(ConditionCode.GT, FlagM.NF); break;
case Opcode.st: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.True()); break;
case Opcode.sf: orw.RewriteMoveDst(di.op1, di.Address, PrimitiveType.Bool, Constant.False()); break;
case Opcode.sub: RewriteArithmetic((s, d) => emitter.ISub(d, s)); break;
case Opcode.suba: RewriteArithmetic((s, d) => emitter.ISub(d, s)); break;
case Opcode.subi: RewriteArithmetic((s, d) => emitter.ISub(d, s)); break;
case Opcode.subq: RewriteAddSubq((s, d) => emitter.ISub(d, s)); break;
case Opcode.subx: RewriteArithmetic((s, d) => emitter.ISub(emitter.ISub(d, s), frame.EnsureFlagGroup(Registers.ccr, (uint)FlagM.XF, "X", PrimitiveType.Bool))); break;
case Opcode.swap: RewriteSwap(); break;
case Opcode.tst: RewriteTst(); break;
case Opcode.unlk: RewriteUnlk(); break;
default:
throw new AddressCorrelatedException(
di.Address,
"Rewriting M68k opcode '{0}' is not supported yet.",
di.code);
}
yield return(ric);
}
yield break;
}
public IEnumerator <RtlInstructionCluster> GetEnumerator()
{
while (dasm.MoveNext())
{
this.instr = dasm.Current;
var instrs = new List <RtlInstruction>();
this.m = new RtlEmitter(instrs);
this.iclass = instr.InstructionClass;
switch (instr.Mnemonic)
{
default:
EmitUnitTest();
Invalid();
host.Warn(
instr.Address,
string.Format(
"Alpha AXP instruction '{0}' not supported yet.",
instr.Mnemonic));
break;
case Mnemonic.invalid:
Invalid();
break;
case Mnemonic.addf_c: RewriteFpuOp(m.FAdd); break;
case Mnemonic.adds: RewriteFpuOp(m.FAdd); break;
case Mnemonic.adds_c: RewriteFpuOp(m.FAdd); break;
case Mnemonic.addl: RewriteBin(addl); break;
case Mnemonic.addl_v: RewriteBinOv(addl); break;
case Mnemonic.addt: RewriteFpuOp(m.FAdd); break;
case Mnemonic.addq: RewriteBin(addq); break;
case Mnemonic.addq_v: RewriteBinOv(addq); break;
case Mnemonic.and: RewriteBin(and); break;
case Mnemonic.beq: RewriteBranch(m.Eq0); break;
case Mnemonic.bge: RewriteBranch(m.Ge0); break;
case Mnemonic.bgt: RewriteBranch(m.Gt0); break;
case Mnemonic.bic: RewriteBin(bic); break;
case Mnemonic.bis: RewriteBin(bis); break;
case Mnemonic.blbc: RewriteBranch(lbc); break;
case Mnemonic.blbs: RewriteBranch(lbs); break;
case Mnemonic.ble: RewriteBranch(m.Le0); break;
case Mnemonic.blt: RewriteBranch(m.Lt0); break;
case Mnemonic.bne: RewriteBranch(m.Ne0); break;
case Mnemonic.br: RewriteBr(); break;
case Mnemonic.bsr: RewriteBr(); break;
case Mnemonic.cmovlt: RewriteCmov(m.Lt0); break;
case Mnemonic.cmovne: RewriteCmov(m.Ne0); break;
case Mnemonic.cmovge: RewriteCmov(m.Ge0); break;
case Mnemonic.cmovlbc: RewriteCmov(lbc); break;
case Mnemonic.cmovlbs: RewriteCmov(lbs); break;
case Mnemonic.cmpbge: RewriteInstrinsic("__cmpbge", false); break;
case Mnemonic.cmpeq: RewriteCmp(m.Eq); break;
case Mnemonic.cmple: RewriteCmp(m.Le); break;
case Mnemonic.cmplt: RewriteCmp(m.Lt); break;
case Mnemonic.cmpteq: RewriteCmpt(m.Eq); break;
case Mnemonic.cmptle: RewriteCmpt(m.Le); break;
case Mnemonic.cmptlt: RewriteCmpt(m.Lt); break;
case Mnemonic.cmpule: RewriteCmp(m.Ule); break;
case Mnemonic.cmpult: RewriteCmp(m.Ult); break;
case Mnemonic.cpys: RewriteCpys("__cpys"); break;
case Mnemonic.cpyse: RewriteCpys("__cpyse"); break;
case Mnemonic.cpysn: RewriteCpys("__cpysn"); break;
case Mnemonic.cvtlq: RewriteCvt(PrimitiveType.Int32, PrimitiveType.Int64); break;
case Mnemonic.cvtql: RewriteCvt(PrimitiveType.Int64, PrimitiveType.Int32); break;
case Mnemonic.cvtqs: RewriteCvt(PrimitiveType.Int64, PrimitiveType.Real32); break;
case Mnemonic.cvtqt: RewriteCvt(PrimitiveType.Int64, PrimitiveType.Real64); break;
case Mnemonic.cvttq_c: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Int64); break;
case Mnemonic.cvtts: RewriteCvt(PrimitiveType.Real64, PrimitiveType.Real32); break;
case Mnemonic.divs: RewriteFpuOp(m.FDiv); break;
case Mnemonic.divt: RewriteFpuOp(m.FDiv); break;
case Mnemonic.extbl: RewriteInstrinsic("__extbl", true); break;
case Mnemonic.extlh: RewriteInstrinsic("__extlh", true); break;
case Mnemonic.extll: RewriteInstrinsic("__extll", true); break;
case Mnemonic.extqh: RewriteInstrinsic("__extqh", true); break;
case Mnemonic.extql: RewriteInstrinsic("__extql", true); break;
case Mnemonic.extwh: RewriteInstrinsic("__extwh", true); break;
case Mnemonic.extwl: RewriteInstrinsic("__extwl", true); break;
case Mnemonic.fbeq: RewriteFBranch(Operator.Feq); break;
case Mnemonic.fbge: RewriteFBranch(Operator.Fge); break;
case Mnemonic.fbgt: RewriteFBranch(Operator.Fgt); break;
case Mnemonic.fble: RewriteFBranch(Operator.Fle); break;
case Mnemonic.fblt: RewriteFBranch(Operator.Flt); break;
case Mnemonic.fbne: RewriteFBranch(Operator.Fne); break;
case Mnemonic.fcmoveq: RewriteFCmov(Operator.Feq); break;
case Mnemonic.fcmovle: RewriteFCmov(Operator.Fle); break;
case Mnemonic.fcmovlt: RewriteFCmov(Operator.Flt); break;
case Mnemonic.fcmovne: RewriteFCmov(Operator.Fne); break;
case Mnemonic.halt: RewriteHalt(); break;
case Mnemonic.implver: RewriteInstrinsic("__implver", true); break;
case Mnemonic.insbl: RewriteInstrinsic("__insbl", true); break;
case Mnemonic.inslh: RewriteInstrinsic("__inslh", true); break;
case Mnemonic.insll: RewriteInstrinsic("__insll", true); break;
case Mnemonic.insqh: RewriteInstrinsic("__insqh", true); break;
case Mnemonic.insql: RewriteInstrinsic("__insql", true); break;
case Mnemonic.inswl: RewriteInstrinsic("__inswl", true); break;
case Mnemonic.jmp: RewriteJmp(); break;
case Mnemonic.jsr: RewriteJmp(); break;
case Mnemonic.jsr_coroutine: RewriteJmp(); break;
case Mnemonic.lda: RewriteLda(0); break;
case Mnemonic.ldah: RewriteLda(16); break;
case Mnemonic.ldbu: RewriteLd(PrimitiveType.Byte, PrimitiveType.Word64); break;
case Mnemonic.ldf: RewriteLd(PrimitiveType.Real32, PrimitiveType.Real64); break;
case Mnemonic.ldg: RewriteLd(PrimitiveType.Real64, PrimitiveType.Real64); break;
case Mnemonic.ldl: RewriteLd(PrimitiveType.Int32, PrimitiveType.Word64); break;
case Mnemonic.ldl_l: RewriteLoadInstrinsic("__ldl_l", true, PrimitiveType.Word32); break;
case Mnemonic.ldq_l: RewriteLoadInstrinsic("__ldq_l", true, PrimitiveType.Word64); break;
case Mnemonic.ldq: RewriteLd(PrimitiveType.Word64, PrimitiveType.Word64); break;
case Mnemonic.ldq_u: RewriteLd(PrimitiveType.Word64, PrimitiveType.Word64); break;
case Mnemonic.lds: RewriteLd(PrimitiveType.Real32, PrimitiveType.Real64); break;
case Mnemonic.ldt: RewriteLd(PrimitiveType.Real64, PrimitiveType.Real64); break;
case Mnemonic.ldwu: RewriteLd(PrimitiveType.UInt16, PrimitiveType.Word64); break;
case Mnemonic.mskbl: RewriteInstrinsic("__mskbl", true); break;
case Mnemonic.msklh: RewriteInstrinsic("__msklh", true); break;
case Mnemonic.mskll: RewriteInstrinsic("__mskll", true); break;
case Mnemonic.mskqh: RewriteInstrinsic("__mskqh", true); break;
case Mnemonic.mskql: RewriteInstrinsic("__mskql", true); break;
case Mnemonic.mskwl: RewriteInstrinsic("__mskwl", true); break;
case Mnemonic.mull: RewriteBin(mull); break;
case Mnemonic.mulq: RewriteBin(mulq); break;
case Mnemonic.muls: RewriteFpuOp(m.FMul); break;
case Mnemonic.mult: RewriteFpuOp(m.FMul); break;
case Mnemonic.mult_c: RewriteFpuOp(m.FMul); break;
case Mnemonic.ornot: RewriteBin(ornot); break;
case Mnemonic.ret: RewriteJmp(); break;
case Mnemonic.s4addl: RewriteBin(s4addl); break;
case Mnemonic.s4addq: RewriteBin(s4addq); break;
case Mnemonic.s8addl: RewriteBin(s8addl); break;
case Mnemonic.s8addq: RewriteBin(s8addq); break;
case Mnemonic.s4subl: RewriteBin(s4subl); break;
case Mnemonic.s4subq: RewriteBin(s4subq); break;
case Mnemonic.s8subl: RewriteBin(s8subl); break;
case Mnemonic.s8subq: RewriteBin(s8subq); break;
case Mnemonic.sll: RewriteBin(sll); break;
case Mnemonic.src: RewriteInstrinsic("__src", true); break;
case Mnemonic.srl: RewriteBin(srl); break;
case Mnemonic.stb: RewriteSt(PrimitiveType.Byte); break;
case Mnemonic.stf: RewriteSt(PrimitiveType.Real64, PrimitiveType.Real32); break;
case Mnemonic.stl: RewriteSt(PrimitiveType.Word32); break;
case Mnemonic.stl_c: RewriteStoreInstrinsic("__stl_c", PrimitiveType.Word32); break;
case Mnemonic.stq_c: RewriteStoreInstrinsic("__stq_c", PrimitiveType.Word64); break;
case Mnemonic.stq_u: RewriteStoreInstrinsic("__stq_u", PrimitiveType.Word64); break;
case Mnemonic.stg: RewriteSt(PrimitiveType.Real64); break;
case Mnemonic.stw: RewriteSt(PrimitiveType.Word16); break;
case Mnemonic.sts: RewriteSt(PrimitiveType.Real32); break;
case Mnemonic.stt: RewriteSt(PrimitiveType.Real64); break;
case Mnemonic.stq: RewriteSt(PrimitiveType.Word64); break;
case Mnemonic.subf_s: RewriteFpuOp(m.FSub); break;
case Mnemonic.subf_uc: RewriteFpuOp(m.FSub); break;
case Mnemonic.subl: RewriteBin(subl); break;
case Mnemonic.subl_v: RewriteBinOv(subl); break;
case Mnemonic.subq: RewriteBin(subq); break;
case Mnemonic.subq_v: RewriteBinOv(subq); break;
case Mnemonic.subs: RewriteFpuOp(m.FSub); break;
case Mnemonic.subt: RewriteFpuOp(m.FSub); break;
case Mnemonic.trapb: RewriteTrapb(); break;
case Mnemonic.umulh: RewriteBin(umulh); break;
case Mnemonic.xor: RewriteBin(xor); break;
case Mnemonic.zap: RewriteInstrinsic("__zap", true); break;
case Mnemonic.zapnot: RewriteInstrinsic("__zapnot", true); break;
}
yield return(m.MakeCluster(instr.Address, instr.Length, iclass));
}
}
