private void EmitBranch(ConditionOperand cOp, Address dst) { m.Branch( GenerateTestExpression(cOp, false), dst, InstrClass.ConditionalTransfer); }
private void RewriteBranch(ConditionCode cc, FlagGroupStorage flags) { var grf = binder.EnsureFlagGroup(flags); var target = (Address)RewriteOp(0); m.Branch(m.Test(cc, grf), target, InstrClass.ConditionalTransfer); }
private void RewriteBranch(ConditionCode cc, FlagM grfM) { var grf = binder.EnsureFlagGroup(arch.GetFlagGroup(arch.sreg, (uint)grfM)); var target = (Address)RewriteOp(0); m.Branch(m.Test(cc, grf), target, InstrClass.ConditionalTransfer); }
private void RewriteBeqz(MipsInstruction instr) { var reg = binder.EnsureRegister(((RegisterOperand)instr.Operands[0]).Register); var dst = ((AddressOperand)instr.Operands[1]).Address; m.Branch(m.Eq0(reg), dst); // No jump delay slot }
private void RewriteBf() { var cond = RewriteSrc(instr.Operands[0]); var target = (Address)RewriteSrc(instr.Operands[1]); m.Branch(m.Not(cond), target, InstrClass.ConditionalTransfer); }
private void EmitBranch(ConditionOperand cOp, ImmediateOperand dst) { emitter.Branch( GenerateTestExpression(cOp, false), Address.Ptr16(dst.Value.ToUInt16()), RtlClass.Transfer); }
private void RewriteCjne() { iclass = InstrClass.ConditionalTransfer; var a = OpSrc(instr.Operands[0]); var b = OpSrc(instr.Operands[1]); var addr = ((AddressOperand)instr.Operands[2]).Address; m.Branch(m.Ne(a, b), addr, iclass); }
private void EmitBranch(ConditionOperand cOp, Address dst) { rtlc.Class = RtlClass.ConditionalTransfer; emitter.Branch( GenerateTestExpression(cOp, false), dst, RtlClass.ConditionalTransfer); }
private void RewriteBranch(ConditionCode cc, FlagM grfM) { rtlc.Class = RtlClass.ConditionalTransfer; var grf = frame.EnsureFlagGroup(arch.GetFlagGroup((uint)grfM)); var target = (Address)RewriteOp(0); m.Branch(m.Test(cc, grf), target, RtlClass.ConditionalTransfer); }
private void RewriteCjne() { rtlc = InstrClass.ConditionalTransfer; var a = OpSrc(instr.Operand1); var b = OpSrc(instr.Operand2); var addr = ((AddressOperand)instr.Operand3).Address; m.Branch(m.Ne(a, b), addr, rtlc); }
private void RewriteBtj(Func <Expression, Expression> fn) { this.iclass = InstrClass.ConditionalTransfer; var opLeft = Operand(instr.Operands[1]); var opRight = Operand(instr.Operands[0]); NZ0(m.And(opLeft, fn(opRight))); var z = binder.EnsureFlagGroup(arch.GetFlagGroup(arch.st, (uint)FlagM.ZF)); m.Branch( m.Test(ConditionCode.NE, z), ((AddressOperand)instr.Operands[2]).Address, InstrClass.ConditionalTransfer); }
protected void ArithCondSkip(Expression dst, Expression src, Expression cond, FSRIndexedMode indMode, Expression memPtr) { iclass = InstrClass.ConditionalTransfer; switch (indMode) { case FSRIndexedMode.None: m.Assign(dst, src); m.Branch(cond, SkipToAddr(), iclass); break; case FSRIndexedMode.INDF: case FSRIndexedMode.PLUSW: m.Assign(dst, src); m.Branch(cond, SkipToAddr(), iclass); break; case FSRIndexedMode.POSTDEC: m.Assign(dst, src); m.BranchInMiddleOfInstruction(cond, SkipToAddr(), iclass); m.Assign(memPtr, m.ISub(memPtr, 1)); break; case FSRIndexedMode.POSTINC: m.Assign(dst, src); m.BranchInMiddleOfInstruction(cond, SkipToAddr(), iclass); m.Assign(memPtr, m.IAdd(memPtr, 1)); break; case FSRIndexedMode.PREINC: m.Assign(memPtr, m.IAdd(memPtr, 1)); m.Assign(dst, src); m.Branch(cond, SkipToAddr(), iclass); break; } }
private void RewriteBtj(Func <Expression, Expression> fn) { this.rtlc = RtlClass.ConditionalTransfer; var opLeft = Operand(instr.op2); var opRight = Operand(instr.op1); NZ0(m.And(opLeft, fn(opRight))); var z = binder.EnsureFlagGroup(arch.GetFlagGroup((uint)FlagM.ZF)); m.Branch( m.Test(ConditionCode.NE, z), ((AddressOperand)instr.op3).Address, RtlClass.ConditionalTransfer); }
private void RewriteIf() { var expr = ParseExpr(); if (expr == null) { SyntaxError(); } if (PeekAndDiscard((byte)Token.THEN)) { if (!EatSpaces()) { SyntaxError(); } byte b = line[i]; int lineNumber; if (IsDigit(b)) { if (!GetInteger(out lineNumber)) { SyntaxError(); } cluster.Class = RtlClass.ConditionalTransfer; emitter.Branch(expr, Address.Ptr16((ushort)lineNumber), RtlClass.ConditionalTransfer); return; } var cl = cluster; var em = emitter; cluster = new RtlInstructionCluster(cl.Address, 1); emitter = new RtlEmitter(cluster.Instructions); ParseStatement(); em.If(expr, cluster.Instructions.Last()); cluster = cl; emitter = em; return; } else if (PeekAndDiscard((byte)Token.GOTO)) { int lineNumber; if (!GetInteger(out lineNumber)) { SyntaxError(); } cluster.Class = RtlClass.ConditionalTransfer; emitter.Branch(expr, Address.Ptr16((ushort)lineNumber), RtlClass.ConditionalTransfer); return; } throw new NotImplementedException(); }
private void RewriteIf() { var expr = ParseExpr(); if (expr == null) { SyntaxError(); } if (PeekAndDiscard((byte)Token.THEN)) { if (!EatSpaces()) { SyntaxError(); } byte b = line[i]; int lineNumber; if (IsDigit(b)) { if (!GetInteger(out lineNumber)) { SyntaxError(); } rtlc = InstrClass.ConditionalTransfer; m.Branch(expr, Address.Ptr16((ushort)lineNumber), InstrClass.ConditionalTransfer); return; } var cl = rtlInstructions; var em = m; rtlInstructions = new List <RtlInstruction>(); m = new RtlEmitter(rtlInstructions); ParseStatement(); em.If(expr, rtlInstructions.Last()); rtlInstructions = cl; m = em; return; } else if (PeekAndDiscard((byte)Token.GOTO)) { int lineNumber; if (!GetInteger(out lineNumber)) { SyntaxError(); } rtlc = InstrClass.ConditionalTransfer; m.Branch(expr, Address.Ptr16((ushort)lineNumber), InstrClass.ConditionalTransfer); return; } throw new NotImplementedException(); }
private void RewriteJmpa() { var target = (Address)Src(1); var c = ((ConditionalOperand)instr.Operands[0]).CondCode; if (c == CondCode.cc_UC) { m.Goto(target); } else { var condition = TestFromCondition(c); m.Branch(condition, target); } }
private void RewriteB(bool link) { Address addr = ((AddressOperand)instr.Dst).Address; if (link) { if (instr.Cond == Condition.al) { emitter.Call(addr, 0); } else { emitter.If(TestCond(instr.Cond), new RtlCall(addr, 0, RtlClass.Transfer)); } } else { if (instr.Cond == Condition.al) { emitter.Goto(addr); } else { emitter.Branch(TestCond(instr.Cond), addr, RtlClass.ConditionalTransfer); } } }
private void RewriteB(bool link) { Address addr = Address.Ptr32((uint)Dst.ImmediateValue.Value); if (link) { ric.Class = RtlClass.Transfer; if (instr.ArchitectureDetail.CodeCondition == ArmCodeCondition.AL) { emitter.Call(addr, 0); } else { emitter.If(TestCond(instr.ArchitectureDetail.CodeCondition), new RtlCall(addr, 0, RtlClass.Transfer)); } } else { if (instr.ArchitectureDetail.CodeCondition == ArmCodeCondition.AL) { ric.Class = RtlClass.Transfer; emitter.Goto(addr); } else { ric.Class = RtlClass.ConditionalTransfer; emitter.Branch(TestCond(instr.ArchitectureDetail.CodeCondition), addr, RtlClass.ConditionalTransfer); } } }
private void RewriteBranch(ConditionCode cc, FlagM flags) { rtlc = InstrClass.ConditionalTransfer; var grf = binder.EnsureFlagGroup(arch.GetFlagGroup((uint)flags)); m.Branch(m.Test(cc, grf), ((AddressOperand)instr.op1).Address, InstrClass.ConditionalTransfer); }
private bool MaybeConditionalJump( InstrClass iclass, Address addrTaken, Func <Expression, Expression, Expression> rewriteCondition, bool invert, Expression left, Expression?right = null) { if (instr.Condition == null || instr.Condition.Type == ConditionType.Never || instr.Condition.Type == ConditionType.Never64) { return(false); } right = right ?? Constant.Word(left.DataType.BitSize, 0); Expression e = rewriteCondition(left, right); if (e is Constant c) { if (!c.IsZero) { m.Goto(addrTaken); return(true); } } if (invert) { e = e.Invert(); } m.Branch(e, addrTaken, iclass); return(true); }
private void RewriteBranch(ConditionCode cc, FlagM flags) { iclass = InstrClass.ConditionalTransfer; var grf = binder.EnsureFlagGroup(arch.GetFlagGroup(Registers.sr, (uint)flags)); m.Branch(m.Test(cc, grf), ((AddressOperand)instr.Operands[0]).Address, InstrClass.ConditionalTransfer); }
private void RewriteBranch(Func <Expression, Expression, Expression> fn) { var src1 = Rewrite(instr.Operands[0]); var src2 = Rewrite(instr.Operands[1]); var dst = ((AddressOperand)instr.Operands[2]).Address; m.Branch(fn(src1, src2), dst); }
private void Branch(ConditionCode cc, FlagM flags) { var f = FlagGroupStorage(flags); emitter.Branch( emitter.Test(cc, f), Address.Ptr16(instrCur.Operand.Offset.ToUInt16()), RtlClass.ConditionalTransfer); }
private void Branch(ConditionCode cc, FlagM flags) { var f = FlagGroupStorage(flags); m.Branch( m.Test(cc, f), Address.Ptr16(((Operand)instrCur.Operands[0]).Offset.ToUInt16()), rtlc); }
private void RewriteBranch(bool v) { Expression f = binder.EnsureFlagGroup(Registers.F); if (v) { f = m.Not(f); } var target = (AddressOperand)instrCur.Operands[0]; m.Branch(f, target.Address, instrCur.InstructionClass); }
private void RewriteBranch() { var addr = ((AddressOperand)instr.Operands[0]).Address; if (instr.Condition == Avr32Condition.al) { m.Goto(addr); } else { m.Branch(Condition(), addr); } }
private void RewriteBranch(bool takenOnTset, bool delaySlot) { this.iclass = delaySlot ? InstrClass.ConditionalTransfer | InstrClass.Delay : InstrClass.ConditionalTransfer; Expression cond = binder.EnsureFlagGroup(Registers.T); var addr = ((AddressOperand)instr.Operands[0]).Address; if (!takenOnTset) { cond = m.Not(cond); } m.Branch(cond, addr, this.iclass); }
private void RewriteBranch0(MipsInstruction instr, BinaryOperator condOp, bool link) { if (!link) { var reg = RewriteOperand(instr.op1); var addr = (Address)RewriteOperand(instr.op2); var cond = new BinaryExpression(condOp, PrimitiveType.Bool, reg, Constant.Zero(reg.DataType)); emitter.Branch(cond, addr, RtlClass.ConditionalTransfer | RtlClass.Delay); } else { throw new NotImplementedException("Linked branches not implemented yet."); } }
private void RewriteB(bool link) { Expression dst; if (Dst.Type == ArmInstructionOperandType.Immediate) { dst = Address.Ptr32((uint)Dst.ImmediateValue.Value); } else { dst = Operand(Dst); } if (link) { rtlc = RtlClass.Transfer | RtlClass.Call; if (instr.ArchitectureDetail.CodeCondition != ArmCodeCondition.AL) { m.BranchInMiddleOfInstruction( TestCond(instr.ArchitectureDetail.CodeCondition).Invert(), Address.Ptr32((uint)(instr.Address + instr.Bytes.Length)), RtlClass.ConditionalTransfer); } m.Call(dst, 0); } else { if (instr.ArchitectureDetail.CodeCondition == ArmCodeCondition.AL) { rtlc = RtlClass.Transfer; m.Goto(dst); } else { rtlc = RtlClass.ConditionalTransfer; var addr = dst as Address; if (addr != null) { m.Branch(TestCond(instr.ArchitectureDetail.CodeCondition), addr, RtlClass.ConditionalTransfer); } else { m.BranchInMiddleOfInstruction( TestCond(instr.ArchitectureDetail.CodeCondition).Invert(), Address.Ptr32((uint)(instr.Address + instr.Bytes.Length)), RtlClass.ConditionalTransfer); m.Goto(dst, RtlClass.Transfer); } } } }
private void RewriteBranch(bool takenOnTset, bool delaySlot) { rtlc = delaySlot ? RtlClass.ConditionalTransfer | RtlClass.Delay : RtlClass.ConditionalTransfer; Expression cond = binder.EnsureFlagGroup(Registers.T); var addr = ((AddressOperand)instr.op1).Address; if (!takenOnTset) { cond = m.Not(cond); } m.Branch(cond, addr, rtlc); }