private void RewriteAlu(Operator op) { var dst = RewriteOp(instrCur.Op3); var src1 = RewriteOp(instrCur.Op1); var src2 = RewriteOp(instrCur.Op2); emitter.Assign(dst, new BinaryExpression(op, PrimitiveType.Word32, src1, src2)); }
private void RewriteRevBinOp(Operator op, bool setflags) { var opDst = this.Operand(instr.Dst); var opSrc1 = this.Operand(instr.Src2); var opSrc2 = this.Operand(instr.Src1); ConditionalAssign(opDst, new BinaryExpression(op, PrimitiveType.Word32, opSrc1, opSrc2)); if (setflags) { ConditionalAssign(frame.EnsureFlagGroup(0x1111, "SZCO", PrimitiveType.Byte), emitter.Cond(opDst)); } }
public bool Match(BinaryExpression binExp) { cLeft = binExp.Left as Constant; cRight = binExp.Right as Constant; if (cLeft != null && cRight != null && binExp.Operator != Operator.Eq) { if (!cLeft.IsReal && !cRight.IsReal) { op = binExp.Operator; return true; } } return false; }
public bool Match(BinaryExpression b) { op = b.Operator; if (op != Operator.Shl && op != Operator.Shr && op != Operator.Sar) return false; c1 = b.Right as Constant; if (c1 == null) return false; BinaryExpression b2 = b.Left as BinaryExpression; if (b2 == null) return false; if (op != b2.Operator) return false; c2 = b2.Right as Constant; if (c2 == null) return false; e = b2.Left; return true; }
public bool Match(BinaryExpression b) { if (b.Operator != Operator.Shl) return false; cShift = b.Right as Constant; if (cShift == null) return false; b = b.Left as BinaryExpression; if (b == null) return false; if (b.Operator != Operator.SMul && b.Operator != Operator.UMul && b.Operator != Operator.IMul) return false; op = b.Operator; cMul = b.Right as Constant; if (cMul == null) return false; e = b.Left; return true; }
public void VisitBinaryExpression(Operator op, DataType dataType, Expression left, Expression right) { if (op == Operator.IAdd || op == Operator.ISub) { // Handle mem[x+const] case. Array accesses of the form // mem[x + (i * const) + const] will have been converted // to ArrayAccesses by a previous stage. Constant offset = right as Constant; if (offset != null) { if (op == Operator.ISub) offset = offset.Negate(); var iv = GetInductionVariable(left); if (iv != null) { VisitInductionVariable((Identifier) left, iv, offset); return; } else if (left is BinaryExpression) { var bl = (BinaryExpression) left; //$HACK: we've already done the analysis of the mul operator! // We should be using the returned value of trait collection. if (bl.Operator is IMulOperator) { arrayContext = true; EmitAccessTrait(basePointer, left, dataType.Size, offset.ToInt32()); return; } } EmitAccessTrait(basePointer, left, dataType.Size, offset.ToInt32()); return; } // Handle odd mem[x + y] case; perhaps a later stage can detect that x (or y) // is a pointer and therefore y isn't. EmitAccessTrait(basePointer, left, dataType.Size, 0); return; } throw new TypeInferenceException("Couldn't generate address traits for binary operator {0}.", op); }
private void RewriteAluCc(Operator op) { RewriteAlu(op); var dst = RewriteOp(instrCur.Op3); EmitCc(dst); }
private bool IsSignedOperator(Operator op) { return op == Operator.Lt || op == Operator.Le || op == Operator.Gt || op == Operator.Ge; }
private static bool IsAddOrSub(Operator op) { return op == Operator.IAdd || op == Operator.ISub; }
private static bool IsIAddOrISub(Operator op) { return (op == Operator.IAdd || op == Operator.ISub); }
public int FindUsingInstruction2(StatementList stms, int i, Operator next) { for (++i; i < stms.Count; ++i) { var ass = stms[i].Instruction as Assignment; if (ass == null) continue; var bin = ass.Src as BinaryExpression; if (bin == null) continue; if (bin.Operator == next) return i; if (IsCarryFlag(ass.Dst)) return -1; } return -1; }
private void RewriteCtrBranch(bool updateLinkRegister, bool toLinkRegister, Operator decOp, bool ifSet) { var ctr = frame.EnsureRegister(arch.ctr); var ccOp = instr.op1 as ConditionOperand; Expression dest; Expression cond = new BinaryExpression( decOp, PrimitiveType.Bool, ctr, Constant.Zero(ctr.DataType)); if (ccOp != null) { Expression test = emitter.Test( CcFromOperand(ccOp), frame.EnsureRegister(CrFromOperand(ccOp))); if (!ifSet) test = test.Invert(); cond = emitter.Cand(cond, test); dest = RewriteOperand(instr.op2); } else { dest = RewriteOperand(instr.op1); } emitter.Assign(ctr, emitter.ISub(ctr, 1)); if (updateLinkRegister) { emitter.If( cond, new RtlCall(dest, 0, RtlClass.ConditionalTransfer)); } else { emitter.Branch( cond, (Address)dest, RtlClass.ConditionalTransfer); } }