private int CompareOperands(MachineOperand opA, MachineOperand opB)
{
if (!opA.GetType().IsAssignableFrom(opB.GetType()))
return -1;
RegisterOperand regOpA = opA as RegisterOperand;
if (regOpA != null)
{
RegisterOperand regOpB = (RegisterOperand) opB;
return (int) regOpB.Register.Number - (int) regOpA.Register.Number;
}
ImmediateOperand immOpA = opA as ImmediateOperand;
if (immOpA != null)
{
ImmediateOperand immOpB = (ImmediateOperand) opB;
return 0; // disregard immediate values.
}
throw new NotImplementedException("NYI");
}
public Expression GetEffectiveAddress(MachineOperand op)
{
var mem = op as MemoryOperand;
if (mem != null)
{
if (mem.Base == null)
{
return mem.Offset;
}
else if (mem.Base == Registers.pc)
{
return di.Address + mem.Offset.ToInt32();
}
else if (mem.Offset == null)
{
return frame.EnsureRegister(mem.Base);
}
else {
return emitter.IAdd(
frame.EnsureRegister(mem.Base),
Constant.Int32(mem.Offset.ToInt32()));
}
}
var addrOp = di.op1 as AddressOperand;
if (addrOp != null)
{
return addrOp.Address;
}
var indIdx = di.op1 as IndirectIndexedOperand;
if (indIdx != null)
{
var a = frame.EnsureRegister(indIdx.ARegister);
var x = frame.EnsureRegister(indIdx.XRegister);
return emitter.IAdd(a, x); //$REVIEW: woefully incomplete...
}
throw new NotImplementedException(string.Format("{0} ({1})", op, op.GetType().Name));
}
public bool CompareOperands(MachineOperand opA, MachineOperand opB)
{
if (opA.GetType() != opB.GetType())
return false;
RegisterOperand regOpA = opA as RegisterOperand;
if (regOpA != null)
{
RegisterOperand regOpB = (RegisterOperand) opB;
return NormalizeRegisters || regOpA.Register == regOpB.Register;
}
ImmediateOperand immOpA = opA as ImmediateOperand;
if (immOpA != null)
{
var immOpB = (ImmediateOperand) opB;
return NormalizeConstants || immOpA.Value.Equals(immOpB.Value); // disregard immediate values.
}
var addrOpA = opA as AddressOperand;
if (addrOpA != null)
{
var addrOpB = (AddressOperand)opB;
return NormalizeConstants || addrOpA.Address == addrOpB.Address;
}
var memOpA = opA as MemoryOperand;
if (memOpA != null)
{
var memOpB = (MemoryOperand)opB;
if (!base.CompareRegisters(memOpA.Base, memOpB.Base))
return false;
if (!base.CompareRegisters(memOpA.Index, memOpB.Index))
return false;
if (memOpA.Scale != memOpB.Scale)
return false;
return base.CompareValues(memOpA.Offset, memOpB.Offset);
}
throw new NotImplementedException("NYI");
}
/// <summary>
/// Rewrite operands being used as sources.
/// </summary>
/// <param name="operand"></param>
/// <param name="addrInstr">Address of the current instruction</param>
/// <returns></returns>
public Expression RewriteSrc(MachineOperand operand, Address addrInstr, bool addressAsAddress = false)
{
var reg = operand as RegisterOperand;
if (reg != null)
{
Expression r = frame.EnsureRegister(reg.Register);
if (DataWidth != null && DataWidth.Size != reg.Width.Size)
r = m.Cast(DataWidth, r);
return r;
}
var imm = operand as M68kImmediateOperand;
if (imm != null)
{
if (DataWidth != null && DataWidth.BitSize > imm.Width.BitSize)
return Constant.Create(DataWidth, imm.Constant.ToInt64());
else
return Constant.Create(imm.Width, imm.Constant.ToUInt32());
}
var mem = operand as MemoryOperand;
if (mem != null)
{
return RewriteMemoryAccess(mem, DataWidth, addrInstr);
}
var addr = operand as M68kAddressOperand;
if (addr != null)
{
if (addressAsAddress)
return addr.Address;
else
return m.Load(DataWidth, addr.Address);
}
var pre = operand as PredecrementMemoryOperand;
if (pre != null)
{
var ea = frame.EnsureRegister(pre.Register);
m.Assign(ea, m.ISub(ea, DataWidth.Size));
return m.Load(DataWidth, ea);
}
var post = operand as PostIncrementMemoryOperand;
if (post != null)
{
var r = frame.EnsureRegister(post.Register);
var tmp = frame.CreateTemporary(DataWidth);
m.Assign(tmp, m.Load(DataWidth, r));
m.Assign(r, m.IAdd(r, DataWidth.Size));
return tmp;
}
var indidx = operand as IndirectIndexedOperand;
if (indidx != null)
{
Expression ea = frame.EnsureRegister(indidx.ARegister);
if (indidx.Imm8 != 0)
ea = m.IAdd(ea, Constant.Int32(indidx.Imm8));
Expression ix = frame.EnsureRegister(indidx.XRegister);
if (indidx.Scale > 1)
ix = m.IMul(ix, Constant.Int32(indidx.Scale));
return m.Load(DataWidth, m.IAdd(ea, ix));
}
var indop = operand as IndexedOperand;
if (indop!=null)
{
Expression ea = Combine(indop.Base, indop.base_reg);
if (indop.postindex)
{
ea = m.LoadDw(ea);
}
if (indop.index_reg != null)
{
var idx = Combine(null, indop.index_reg);
if (indop.index_scale > 1)
idx = m.IMul(idx, indop.index_scale);
ea = Combine(ea, idx);
}
if (indop.preindex)
{
ea = m.LoadDw(ea);
}
ea = Combine(ea, indop.outer);
return m.Load(DataWidth, ea);
}
throw new NotImplementedException("Unimplemented RewriteSrc for operand type " + operand.GetType().Name);
}
public Expression RewriteMoveDst(MachineOperand opDst, Address addrInstr, PrimitiveType dataWidth, Expression src)
{
var reg = opDst as RegisterOperand;
if (reg != null)
{
var r = frame.EnsureRegister(reg.Register);
if (r.DataType.Size > dataWidth.Size)
{
var tmp = frame.CreateTemporary(dataWidth);
m.Assign(r, m.Dpb(r, src, 0, dataWidth.BitSize));
return tmp;
}
else
{
m.Assign(r, src);
return r;
}
}
var mem = opDst as MemoryOperand;
if (mem != null)
{
src = Spill(src, frame.EnsureRegister(mem.Base));
var load = RewriteMemoryAccess(mem, dataWidth,addrInstr);
var tmp = frame.CreateTemporary(dataWidth);
m.Assign(load, src);
return tmp;
}
var post = opDst as PostIncrementMemoryOperand;
if (post != null)
{
var r = frame.EnsureRegister(post.Register);
var rExp = Spill(src, r);
var load = m.Load(dataWidth, r);
m.Assign(load, rExp);
m.Assign(r, m.IAdd(r, dataWidth.Size));
return src;
}
var pre = opDst as PredecrementMemoryOperand;
if (pre != null)
{
var r = frame.EnsureRegister(pre.Register);
m.Assign(r, m.ISub(r, dataWidth.Size));
var rExp = Spill(src, r);
var load = m.Load(dataWidth, rExp);
m.Assign(load, src);
return src;
}
var indidx = opDst as IndirectIndexedOperand;
if (indidx != null)
{
var a = frame.EnsureRegister(indidx.ARegister);
var x = frame.EnsureRegister(indidx.XRegister);
var load = m.Load(dataWidth, m.IAdd(a, x));
m.Assign(load, src);
return src;
}
var mAddr = opDst as M68kAddressOperand;
if (mAddr != null)
{
m.Assign(
m.Load(
dataWidth,
Constant.Word32(mAddr.Address.ToUInt32())),
src);
return src;
}
throw new NotImplementedException("Unimplemented RewriteMoveDst for operand type " + opDst.GetType().Name);
}
private int GetHashCode(MachineOperand op)
{
int h;
RegisterOperand regOp = op as RegisterOperand;
if (regOp != null)
{
return base.GetRegisterHash(regOp.Register);
}
ImmediateOperand immOp = op as ImmediateOperand;
if (immOp != null)
{
return base.GetConstantHash(immOp.Value);
}
var addrOp = op as AddressOperand;
if (addrOp != null)
{
return base.NormalizeConstants
? 1
: addrOp.Address.GetHashCode();
}
var memOp = op as MemoryOperand;
if (memOp != null)
{
h = 0;
if (memOp.Base != null)
{
h = base.GetRegisterHash(memOp.Base);
}
if (memOp.Index != null)
{
h = 13 * h ^ base.GetRegisterHash(memOp.Index);
h = 17 * h ^ memOp.Scale;
}
if (memOp.Offset != null)
{
h = 23 * h ^ GetConstantHash(memOp.Offset);
}
if (memOp.SegOverride != null)
{
h = 29 * h ^ GetRegisterHash(memOp.SegOverride);
}
return h;
}
throw new NotImplementedException("Unhandled operand type: " + op.GetType().FullName);
}
