private void RewriteIncDec(Func<Expression, Expression, Expression> fn)
{
var dst = OpSrc(instr.Operands[0]);
m.Assign(dst, fn(dst, m.Const(dst.DataType, 1)));
if (dst is Identifier id && id.Storage is RegisterStorage)
{
var flg = arch.GetFlagGroup(Registers.PSW, (uint)FlagM.P);
m.Assign(binder.EnsureFlagGroup(flg), m.Cond(dst));
}
}
private void RewriteBlockInstruction()
{
var bc = frame.EnsureRegister(Registers.bc);
var de = frame.EnsureRegister(Registers.de);
var hl = frame.EnsureRegister(Registers.hl);
var V = FlagGroup(FlagM.PF);
emitter.Assign(emitter.LoadB(de), emitter.LoadB(hl));
emitter.Assign(hl, emitter.IAdd(hl, 1));
emitter.Assign(de, emitter.IAdd(de, 1));
emitter.Assign(bc, emitter.ISub(bc, 1));
emitter.BranchInMiddleOfInstruction(emitter.Ne0(bc), dasm.Current.Address, RtlClass.Transfer);
emitter.Assign(V, emitter.Const(PrimitiveType.Bool, 0));
}
private void RewriteBlockInstruction(Func <Expression, Expression, Expression> incdec, bool repeat)
{
var bc = frame.EnsureRegister(Registers.bc);
var de = frame.EnsureRegister(Registers.de);
var hl = frame.EnsureRegister(Registers.hl);
var V = FlagGroup(FlagM.PF);
emitter.Assign(emitter.LoadB(de), emitter.LoadB(hl));
emitter.Assign(hl, incdec(hl, Constant.Int16(1)));
emitter.Assign(de, incdec(de, Constant.Int16(1)));
emitter.Assign(bc, emitter.ISub(bc, 1));
if (repeat)
{
emitter.BranchInMiddleOfInstruction(emitter.Ne0(bc), dasm.Current.Address, RtlClass.Transfer);
}
emitter.Assign(V, emitter.Const(PrimitiveType.Bool, 0));
}
private void RewriteBlockInstruction(Func <Expression, Expression, Expression> incdec, bool repeat)
{
var bc = binder.EnsureRegister(Registers.bc);
var de = binder.EnsureRegister(Registers.de);
var hl = binder.EnsureRegister(Registers.hl);
var V = FlagGroup(FlagM.PF);
m.Assign(m.Mem8(de), m.Mem8(hl));
m.Assign(hl, incdec(hl, Constant.Int16(1)));
m.Assign(de, incdec(de, Constant.Int16(1)));
m.Assign(bc, m.ISub(bc, 1));
if (repeat)
{
m.BranchInMiddleOfInstruction(m.Ne0(bc), dasm.Current.Address, InstrClass.Transfer);
}
m.Assign(V, m.Const(PrimitiveType.Bool, 0));
}
public Expression RewriteMoveDst(MachineOperand opDst, Address addrInstr, PrimitiveType dataWidth, Expression src)
{
switch (opDst)
{
case RegisterOperand reg:
{
var r = binder.EnsureRegister(reg.Register);
if (r.DataType.BitSize > src.DataType.BitSize)
{
var tmpLo = binder.CreateTemporary(src.DataType);
var tmpHi = binder.CreateTemporary(PrimitiveType.CreateWord(r.DataType.BitSize - src.DataType.BitSize));
m.Assign(tmpHi, m.Slice(tmpHi.DataType, r, dataWidth.BitSize));
m.Assign(r, m.Seq(tmpHi, src));
return(tmpLo);
}
else
{
m.Assign(r, src);
return(r);
}
}
case MemoryOperand mem:
{
src = Spill(src, binder.EnsureRegister(mem.Base));
var access = RewriteMemoryAccess(mem, dataWidth, addrInstr);
m.Assign(access, src);
return(src);
}
case PostIncrementMemoryOperand post:
{
var r = binder.EnsureRegister(post.Register);
var rExp = Spill(src, r);
var access = m.Mem(dataWidth, r);
m.Assign(access, rExp);
m.Assign(r, m.IAddS(r, dataWidth.Size));
return(src);
}
case PredecrementMemoryOperand pre:
{
var r = binder.EnsureRegister(pre.Register);
m.Assign(r, m.ISubS(r, dataWidth.Size));
var rExp = Spill(src, r);
var access = m.Mem(dataWidth, rExp);
m.Assign(access, src);
return(src);
}
case IndexedOperand idxop:
{
Expression?ea = null;
if (idxop.Index != null)
{
var i = binder.EnsureRegister(idxop.Index);
var s = m.Const(i.DataType, idxop.IndexScale);
if (idxop.IndexScale > 1)
{
ea = m.IMul(i, s);
}
else
{
ea = i;
}
}
if (idxop.Base != null)
{
var b = binder.EnsureRegister(idxop.Base);
if (ea != null)
{
ea = m.IAdd(b, ea);
}
else
{
ea = b;
}
}
if (idxop.BaseDisplacement != null)
{
if (ea != null)
{
ea = m.IAdd(ea, idxop.BaseDisplacement);
}
else
{
ea = idxop.BaseDisplacement;
}
}
var access = m.Mem(dataWidth, ea !);
m.Assign(access, src);
return(src);
}
case IndirectIndexedOperand indidx:
{
var a = binder.EnsureRegister(indidx.ARegister);
var x = binder.EnsureRegister(indidx.XRegister);
var access = m.Mem(dataWidth, m.IAdd(a, x));
m.Assign(access, src);
return(src);
}
case M68kAddressOperand mAddr:
{
m.Assign(
m.Mem(
dataWidth,
m.Ptr32(mAddr.Address.ToUInt32())),
src);
return(src);
}
}
throw new NotImplementedException("Unimplemented RewriteMoveDst for operand type " + opDst.GetType().Name);
}
public Expression RewriteMoveDst(MachineOperand opDst, Address addrInstr, PrimitiveType dataWidth, Expression src)
{
var reg = opDst as RegisterOperand;
if (reg != null)
{
var r = binder.EnsureRegister(reg.Register);
if (r.DataType.Size > dataWidth.Size)
{
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(r, m.Dpb(r, src, 0));
return(tmp);
}
else
{
m.Assign(r, src);
return(r);
}
}
var mem = opDst as MemoryOperand;
if (mem != null)
{
src = Spill(src, binder.EnsureRegister(mem.Base));
var load = RewriteMemoryAccess(mem, dataWidth, addrInstr);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(load, src);
return(tmp);
}
var post = opDst as PostIncrementMemoryOperand;
if (post != null)
{
var r = binder.EnsureRegister(post.Register);
var rExp = Spill(src, r);
var load = m.Mem(dataWidth, r);
m.Assign(load, rExp);
m.Assign(r, m.IAdd(r, m.Int32(dataWidth.Size)));
return(src);
}
var pre = opDst as PredecrementMemoryOperand;
if (pre != null)
{
var r = binder.EnsureRegister(pre.Register);
m.Assign(r, m.ISub(r, m.Int32(dataWidth.Size)));
var rExp = Spill(src, r);
var load = m.Mem(dataWidth, rExp);
m.Assign(load, src);
return(src);
}
var idxop = opDst as IndexedOperand;
if (idxop != null)
{
var b = binder.EnsureRegister(idxop.base_reg);
var i = binder.EnsureRegister(idxop.index_reg);
Expression ea = b;
if (i != null)
{
var s = m.Const(i.DataType, idxop.index_scale);
if (idxop.index_scale > 1)
{
ea = m.IMul(i, s);
}
else
{
ea = i;
}
}
if (b != null)
{
if (ea != null)
{
ea = m.IAdd(b, ea);
}
else
{
ea = b;
}
}
if (idxop.Base != null)
{
if (ea != null)
{
ea = m.IAdd(ea, idxop.Base);
}
else
{
ea = idxop.Base;
}
}
var load = m.Mem(dataWidth, ea);
m.Assign(load, src);
return(src);
}
var indidx = opDst as IndirectIndexedOperand;
if (indidx != null)
{
var a = binder.EnsureRegister(indidx.ARegister);
var x = binder.EnsureRegister(indidx.XRegister);
var load = m.Mem(dataWidth, m.IAdd(a, x));
m.Assign(load, src);
return(src);
}
var mAddr = opDst as M68kAddressOperand;
if (mAddr != null)
{
m.Assign(
m.Mem(
dataWidth,
Constant.Word32(mAddr.Address.ToUInt32())),
src);
return(src);
}
throw new NotImplementedException("Unimplemented RewriteMoveDst for operand type " + opDst.GetType().Name);
}
