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)); }