private void RewriteRotation(string pseudoOp, bool useCarry)
{
Expression reg;
if (dasm.Current.Op1 != null)
{
reg = RewriteOp(dasm.Current.Op1);
}
else
{
reg = frame.EnsureRegister(Registers.a);
}
var C = FlagGroup(FlagM.CF);
Expression src;
if (useCarry)
{
src = emitter.Fn(
new PseudoProcedure(pseudoOp, reg.DataType, 2),
reg, C);
}
else
{
src = emitter.Fn(
new PseudoProcedure(pseudoOp, reg.DataType, 1),
reg);
}
emitter.Assign(reg, src);
emitter.Assign(C, emitter.Cond(reg));
}
private Expression Rol(Expression a, Expression b)
{
var C = binder.EnsureFlagGroup(Registers.C);
var intrinsic = m.Fn(CommonOps.RolC, a, b, C);
return(intrinsic);
}
private void RewriteRotate(IntrinsicProcedure rot)
{
var op = Operand(instr.Operands[0]);
var C = binder.EnsureFlagGroup(arch.GetFlagGroup(arch.st, (uint)FlagM.CF));
m.Assign(op, m.Fn(rot, op, m.Byte(1)));
m.Assign(C, m.Cond(op));
}
public HExpr Ror(HExpr a, HExpr b)
{
var aa = GetExpression(a);
var bb = GetExpression(b);
var ror = CommonOps.Ror.MakeInstance(aa.DataType, bb.DataType);
return(MapToHandle(m.Fn(ror, aa, bb)));
}
private void RewriteRol()
{
var src = RewriteOp(0);
var c = binder.EnsureFlagGroup(C);
var dst = RewriteOpDst(0, m.Fn(CommonOps.RolC, src, m.Int32(1), c));
EmitCc(NZC, dst);
}
private void RewriteRotate(IntrinsicProcedure intrinsic)
{
var src = RewriteSrc(instr.Operands[0]);
var dst = RewriteDst(instr.Operands[0], src, (a, b) =>
m.Fn(
intrinsic,
b,
RewriteSrc(instr.Operands[1])));
EmitCond(dst, C());
}
public Expression PseudoProc(PseudoProcedure ppp, DataType retType, params Expression[] args)
{
if (args.Length != ppp.Arity)
{
throw new ArgumentOutOfRangeException(
string.Format("Pseudoprocedure {0} expected {1} arguments, but was passed {2}.",
ppp.Name,
ppp.Arity,
args.Length));
}
return(emitter.Fn(new ProcedureConstant(arch.PointerType, ppp), retType, args));
}
private Expression RorC(Expression a, Expression shift)
{
var cy = binder.EnsureFlagGroup(Registers.C);
var rorc = m.Fn(CommonOps.RorC, a, shift, cy);
return(rorc);
}
private Application PseudoProc(string name, DataType ret, params Expression[] exprs)
{
var ppp = host.EnsurePseudoProcedure(name, ret, exprs.Length);
var fn = emitter.Fn(ppp, exprs);
return(fn);
}
/// <summary>
/// Pops all the args and makes an Application instance.
/// </summary>
/// <param name="fn"></param>
/// <returns></returns>
public HExpr Fn(HExpr fn)
{
var appl = m.Fn(GetExpression(fn), this.args.ToArray());
this.args.Clear();
return(MapToHandle(appl));
}
private void RewriteRor()
{
var c = binder.EnsureFlagGroup(arch.C);
var reg = RewriteOp(0);
m.Assign(reg, m.Fn(CommonOps.RorC, reg, m.Int32(1), c));
EmitFlags(reg, CmpFlags);
}
private void RewriteRotationX(H8Instruction instr, IntrinsicProcedure intrinsic)
{
var src = OpSrc(instr.Operands[0]);
var c = binder.EnsureFlagGroup(C);
m.Assign(src, m.Fn(intrinsic, src, Constant.Int32(1), c));
EmitCond(NZC, src);
m.Assign(binder.EnsureFlagGroup(V), Constant.False());
}
private void Rotate(string rot)
{
var fn = new ProcedureConstant(
new Pointer(new CodeType(), 2),
host.EnsurePseudoProcedure(rot, PrimitiveType.Byte, 2));
var c = FlagGroupStorage(FlagM.NF | FlagM.ZF | FlagM.CF);
var arg = RewriteOperand(instrCur.Operand);
emitter.Assign(arg, emitter.Fn(fn, arg, Constant.Byte(1)));
emitter.Assign(c, emitter.Cond(arg));
}
private void RewriteRotation(string pseudoOp, bool useCarry)
{
var a = frame.EnsureRegister(Registers.a);
var C = FlagGroup(FlagM.CF);
Expression src;
if (useCarry)
{
src = emitter.Fn(
new PseudoProcedure(pseudoOp, a.DataType, 2),
a, C);
}
else
{
src = emitter.Fn(
new PseudoProcedure(pseudoOp, a.DataType, 1),
a);
}
emitter.Assign(a, src);
emitter.Assign(C, emitter.Cond(a));
}
private void RewriteRrc()
{
var src = RewriteOp(instr.Operands[0]);
var dst = RewriteDst(
instr.Operands[0],
src,
(a, b) => m.Fn(
CommonOps.RorC,
a,
m.Byte(1),
binder.EnsureFlagGroup(Registers.C)));
EmitCc(dst, Registers.NZC);
Assign(Registers.V, Constant.False());
}
private void RewriteSvc()
{
emitter.SideEffect(emitter.Fn(
host.EnsurePseudoProcedure("__syscall", VoidType.Instance, 2),
Operand(instr.Dst)));
}
private void RewriteSvc()
{
m.SideEffect(m.Fn(
host.EnsurePseudoProcedure(PseudoProcedure.Syscall, VoidType.Instance, 2),
Operand(Dst)));
}
private void RewriteRotate(IntrinsicProcedure rot)
{
var dst = OpSrc(instr.Operands[0], arch.DataMemory);
m.Assign(dst, m.Fn(rot, dst, m.Byte(1)));
}
private void RewriteRot(IntrinsicProcedure intrinsic)
{
var op1 = SrcOp(instr.Operands[0]);
m.Assign(op1, m.Fn(intrinsic, op1, m.Int32(1)));
}
private Expression Rol1(Expression e)
{
return(m.Fn(CommonOps.Rol, e, Constant.Byte(1)));
}
private Expression Rol(Expression left, Expression right)
{
return(m.Fn(CommonOps.Rol, left, right));
}
