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