private void RewriteDaa()
{
var a = binder.EnsureRegister(Registers.A);
m.Assign(a, host.Intrinsic("__daa", false, PrimitiveType.Byte, a));
NZ_C(a);
}
private void RewriteBset(H8Instruction instr, Expression value)
{
var pos = OpSrc(instr.Operands[0]);
var dst = OpSrc(instr.Operands[1]);
m.Assign(dst, host.Intrinsic("__bst", false, dst.DataType, dst, value, pos));
}
public HExpr Ror(HExpr a, HExpr b)
{
var aa = GetExpression(a);
var bb = GetExpression(b);
return(MapToHandle(host.Intrinsic(IntrinsicProcedure.Ror, false, PrimitiveType.Word32, aa, bb)));
}
private void RewriteIO(int iRegOp, int iPortOp, bool read)
{
var reg = RewriteOp(iRegOp);
var port = ((ImmediateOperand)instr.Operands[iPortOp]).Value.ToByte();
if (port == 0x3F)
{
var psreg = binder.EnsureRegister(arch.sreg);
if (read)
{
m.Assign(reg, psreg);
}
else
{
m.Assign(psreg, reg);
}
}
else if (read)
{
m.Assign(reg, host.Intrinsic("__in", false, PrimitiveType.Byte, Constant.Byte(port)));
}
else
{
m.SideEffect(host.Intrinsic("__out", false, VoidType.Instance, Constant.Byte(port), reg));
}
}
private void RewriteAbs()
{
var i32 = PrimitiveType.Int32;
var tmp = binder.CreateTemporary(i32);
m.Assign(tmp, RewriteOp(0));
var src = host.Intrinsic("abs", true, i32, tmp);
var dst = RewriteOpDst(0, src);
m.Assign(binder.EnsureFlagGroup(Z), m.Eq0(dst));
}
private Expression RewriteSrc(MachineOperand op)
{
switch (op)
{
case RegisterOperand rop:
return(binder.EnsureRegister(rop.Register));
case ImmediateOperand iop:
return(iop.Value);
case AddressOperand aop:
return(aop.Address);
case MemoryOperand mop:
Expression ea;
if (mop.Base != null)
{
ea = binder.EnsureRegister(mop.Base);
if (mop.Offset != 0)
{
ea = m.IAddS(ea, mop.Offset);
}
}
else
{
ea = m.Ptr32((uint)mop.Offset);
}
if (mop.Index != null)
{
var idx = binder.EnsureRegister(mop.Index);
ea = m.IAdd(ea, idx);
}
return(m.Mem(op.Width, ea));
case BitOperand bit:
var bitSrc = RewriteSrc(bit.Operand);
return(host.Intrinsic(
"__bit",
false,
PrimitiveType.Bool,
bitSrc,
Constant.Byte((byte)bit.BitPosition)));
case FlagGroupOperand fop:
return(binder.EnsureFlagGroup(fop.FlagGroup));
default:
throw new NotImplementedException($"Rl87Rewriter: operand type {op.GetType().Name} not implemented yet.");
}
}
private Expression RorC(Expression a, Expression shift)
{
var cy = binder.EnsureFlagGroup(Registers.C);
var rorc = host.Intrinsic(IntrinsicProcedure.RorC, true, a.DataType, a, shift, cy);
return(rorc);
}
private void RewriteIntrinsic(string intrinsicName, bool isIntrinsic)
{
var dst = Op(0);
var args = Enumerable.Range(1, instrCur.Operands.Length - 1)
.Select(i => Op(i))
.ToArray();
m.Assign(dst, host.Intrinsic(intrinsicName, isIntrinsic, dst.DataType, args));
}
private void RewriteBclr()
{
var(bit, reg) = BitOp(0);
EmitCc(Registers.N, host.Intrinsic("__bit", false, PrimitiveType.Bool, reg, bit));
EmitCc(Registers.Z, m.Comp(binder.EnsureFlagGroup(Registers.N)));
m.Assign(reg, host.Intrinsic("__bit_clear", false, reg.DataType, reg, bit));
EmitCc(Registers.E, Constant.False());
EmitCc(Registers.V, Constant.False());
EmitCc(Registers.C, Constant.False());
}
private void RewriteDacDsb(string intrinsicName)
{
var opLeft = Operand(instr.Operands[0]);
var opRight = Operand(instr.Operands[0]);
var c = binder.EnsureFlagGroup(arch.GetFlagGroup(arch.st, (uint)FlagM.CF));
m.Assign(c, host.Intrinsic(
intrinsicName,
false,
PrimitiveType.Bool,
opLeft,
opRight,
c,
m.Out(opLeft.DataType, opLeft)));
CNZ(opLeft);
}
private void OperandDst(MachineOperand op, Action <Expression, Expression> write, Expression src)
{
switch (op)
{
case RegisterOperand rop:
write(binder.EnsureRegister(rop.Register), src);
return;
case MemoryOperand mem:
write(RewriteMemoryOperand(mem), src);
MaybeEmitIncrement(mem);
return;
case RegisterPairOperand pair:
write(binder.EnsureSequence(PrimitiveType.Word64, pair.HighRegister, pair.LowRegister), src);
return;
case DecoratorOperand dec:
if (dec.Width.BitSize < dec.Operand.Width.BitSize)
{
var dst = binder.EnsureRegister(((RegisterOperand)dec.Operand).Register);
var dt = PrimitiveType.CreateWord(32 - dec.Width.BitSize);
if (dec.BitOffset == 0)
{
var hi = m.Slice(dt, dst, dec.Width.BitSize);
write(dst, m.Seq(hi, src));
}
else
{
var lo = m.Slice(dt, dst, 0);
write(dst, m.Seq(src, lo));
}
return;
}
break;
case ApplicationOperand app:
var appOps = app.Operands.Select(OperandSrc).Concat(new[] { src }).ToArray();
m.SideEffect(host.Intrinsic(app.Mnemonic.ToString(), true, VoidType.Instance, appOps !));
return;
}
throw new NotImplementedException($"Hexagon rewriter for {op.GetType().Name} not implemented yet.");
}
private void RewriteBgnd()
{
var intrinsic = host.Intrinsic("__bgnd", true, VoidType.Instance);
m.SideEffect(intrinsic);
}
private void RewriteRotate(string rot)
{
var dst = OpSrc(instr.Operands[0], arch.DataMemory);
m.Assign(dst, host.Intrinsic(rot, true, dst.DataType, dst, m.Byte(1)));
}
private Expression Rol(Expression a, Expression b)
{
var intrinsic = host.Intrinsic(IntrinsicProcedure.RolC, true, a.DataType, a, b);
return(intrinsic);
}
private Expression Rol(Expression left, Expression right)
{
return(host.Intrinsic(IntrinsicProcedure.Rol, true, left.DataType, left, right));
}
private void ParseStatement()
{
if (!EatSpaces())
{
return;
}
byte b = line[i++];
switch ((Token)b)
{
case Token.END:
var c = new ProcedureCharacteristics {
Terminates = true
};
var intrinsic = host.Intrinsic("__End", false, c, VoidType.Instance);
m.SideEffect(intrinsic);
i = line.Length; // We never return from end.
return;
case Token.CLOSE:
RewriteClose();
break;
case Token.CLR:
RewriteClr();
break;
case Token.FOR:
RewriteFor();
break;
case Token.GET:
RewriteGet();
break;
case Token.GOSUB:
RewriteGosub();
break;
case Token.GOTO:
RewriteGoto();
break;
case Token.IF:
RewriteIf();
break;
case Token.INPUT:
RewriteInput();
break;
case Token.INPUT_hash:
RewriteInput_hash();
break;
case Token.NEXT:
RewriteNext();
break;
case Token.OPEN:
RewriteOpen();
break;
case Token.POKE:
RewritePoke();
break;
case Token.PRINT:
RewritePrint();
break;
case Token.PRINT_hash:
RewritePrint_hash();
break;
case Token.REM:
//$TODO: annotation
i = line.Length;
return;
case Token.RETURN:
RewriteReturn();
break;
case Token.SYS:
RewriteSys();
break;
case Token.COLON:
// Statement separator.
break;
default:
if (0x41 <= b && b <= 0x5A)
{
--i;
RewriteLet();
break;
}
throw new NotImplementedException(string.Format(
"Unimplemented BASIC token {0:X2} [{1}].",
(int)line[i - 1],
C64BasicInstruction.TokenToString(b)));
}
}
private void RewriteCli()
{
m.SideEffect(host.Intrinsic("__cli", false, VoidType.Instance));
}
private Expression Rol1(Expression e)
{
return(host.Intrinsic(IntrinsicProcedure.Rol, true, e.DataType, e, Constant.Byte(1)));
}
private Expression Rol(Expression a, Expression b)
{
var C = binder.EnsureFlagGroup(Registers.C);
var intrinsic = host.Intrinsic(IntrinsicProcedure.RolC, false, a.DataType, a, b, C);
return(intrinsic);
}
private Expression Dadd(Expression a, Expression b)
{
return(host.Intrinsic("__dadd", false, a.DataType, a, b));
}
private Expression Rol(Expression a, Expression b)
{
var C = binder.EnsureFlagGroup(arch.GetFlagGroup(Registers.ccr, (uint)FlagM.CF));
var intrinsic = host.Intrinsic(IntrinsicProcedure.RolC, true, a.DataType, a, b, C);
return(intrinsic);
}
private void RewriteCsync()
{
m.SideEffect(host.Intrinsic("__csync", true, VoidType.Instance));
}
private void RewriteBrk()
{
m.SideEffect(host.Intrinsic("__brk", true, VoidType.Instance));
}
