static boolean assignsDirectlyToVariable(BinaryExpr expr) { return expr.getOp() == BinOp.ASSIGN && expr.getLhs() instanceof VariableIdentifierExpr; }
static boolean isAssignment(Stmt stmt) { if (!(stmt instanceof ExprStmt)) { return false; } if (!(((ExprStmt)stmt).getExpr() instanceof BinaryExpr)) { return false; } return ((BinaryExpr)((ExprStmt)stmt).getExpr()).getOp() == BinOp.ASSIGN; }
private Optional<ImmutablePair<BinOp,Integer>> getCondTestTypeAndLimitValue(Expr cond, String loopCounterName) { if (!(cond instanceof BinaryExpr)) { return Optional.empty(); } final BinaryExpr binaryExprCond = (BinaryExpr) cond; Optional<Integer> condLimitValue = getAsConstant(binaryExprCond.getRhs()); if (condLimitValue.isPresent() && isSameVarIdentifier(binaryExprCond.getLhs(), loopCounterName)) { return Optional.of(new ImmutablePair<>(binaryExprCond.getOp(), condLimitValue.get())); } condLimitValue = getAsConstant(binaryExprCond.getLhs()); if (condLimitValue.isPresent() && isSameVarIdentifier(binaryExprCond.getRhs(), loopCounterName)) { return Optional.of(new ImmutablePair<>(switchCondTestType(binaryExprCond.getOp()), condLimitValue.get())); } return Optional.empty(); }
@Override public void visitBinaryExpr(BinaryExpr binaryExpr) { if (isSideEffectingBinOp(binaryExpr.getOp())) { insideLValueCount++; } visit(binaryExpr.getLhs()); if (isSideEffectingBinOp(binaryExpr.getOp())) { assert insideLValueCount > 0; insideLValueCount--; } visit(binaryExpr.getRhs()); // Skip the LHS if it is side-effecting identifyMutationPoints(binaryExpr, isSideEffectingBinOp(binaryExpr.getOp()) ? new HashSet<>(Arrays.asList(0)) : new HashSet<>()); }
@Override public void visitBinaryExpr(BinaryExpr binaryExpr) { if (binaryExpr.getOp().isSideEffecting()) { predicateHolds(); } super.visitBinaryExpr(binaryExpr); }
private boolean hasRegularLoopGuard(ForStmt loop, String counterName) { if (!(loop.getCondition() instanceof BinaryExpr)) { return false; } final BinaryExpr guard = (BinaryExpr) loop.getCondition(); if (!(guard.getOp() == BinOp.LT || guard.getOp() == BinOp.GT)) { return false; } if (!(guard.getLhs() instanceof VariableIdentifierExpr)) { return false; } if (!(guard.getRhs() instanceof IntConstantExpr)) { return false; } return ((VariableIdentifierExpr) guard.getLhs()).getName().equals(counterName); }
@Override public void visitBinaryExpr(BinaryExpr binaryExpr) { super.visitBinaryExpr(binaryExpr); if (binaryExpr.getOp().isSideEffecting()) { if (binaryExpr.getLhs() instanceof VariableIdentifierExpr && ((VariableIdentifierExpr) binaryExpr.getLhs()).getName() .equals(loopCounterName)) { foundModification = true; } } }
@Override public void visitBinaryExpr(BinaryExpr binaryExpr) { visit(binaryExpr.getLhs()); out.append(" " + binaryExpr.getOp().getText() + " "); visit(binaryExpr.getRhs()); }
return Optional.empty(); switch (((BinaryExpr) incr).getOp()) { case ADD_ASSIGN: return incrementValue;
if (be.getOp() != BinOp.ASSIGN) { return;
private boolean isRedundantCopy(Stmt stmt) { if (!(stmt instanceof ExprStmt)) { return false; } final Expr expr = ((ExprStmt) stmt).getExpr(); if (!(expr instanceof BinaryExpr)) { return false; } final BinaryExpr binaryExpr = (BinaryExpr) expr; if (binaryExpr.getOp() != BinOp.ASSIGN) { return false; } final Expr lhs = binaryExpr.getLhs(); if (!(lhs instanceof VariableIdentifierExpr)) { return false; } final Expr rhs = binaryExpr.getRhs(); if (!(rhs instanceof VariableIdentifierExpr)) { return false; } return ((VariableIdentifierExpr) lhs).getName() .equals(((VariableIdentifierExpr) rhs).getName()); }
private boolean canMergeLoops(Stmt first, Stmt second) { if (!(first instanceof ForStmt && second instanceof ForStmt)) { return false; } ForStmt firstLoop = (ForStmt) first; ForStmt secondLoop = (ForStmt) second; Optional<String> commonLoopCounter = checkForCommonLoopCounter(firstLoop, secondLoop); if (!commonLoopCounter.isPresent()) { return false; } if (!commonLoopCounter.get().startsWith(Constants.SPLIT_LOOP_COUNTER_PREFIX)) { return false; } if (!hasRegularLoopGuard(firstLoop, commonLoopCounter.get())) { return false; } if (!hasRegularLoopGuard(secondLoop, commonLoopCounter.get())) { return false; } final Integer firstLoopEnd = new Integer(((IntConstantExpr) ((BinaryExpr) firstLoop.getCondition()).getRhs()).getValue()); final BinOp firstLoopOp = ((BinaryExpr) firstLoop.getCondition()).getOp(); final Integer secondLoopStart = new Integer(((IntConstantExpr) ((ScalarInitializer) ((DeclarationStmt) secondLoop.getInit()).getVariablesDeclaration().getDeclInfo(0) .getInitializer()).getExpr()).getValue()); assert firstLoopOp == BinOp.LT || firstLoopOp == BinOp.GT : "Unexpected operator in split loops."; return firstLoopEnd.equals(secondLoopStart); }
rhsType = ((QualifiedType) rhsType).getTargetType(); switch (binaryExpr.getOp()) { case MUL: { Type resolvedType = TyperHelper.resolveTypeOfMul(lhsType, rhsType);
@Override public void visitBinaryExpr(BinaryExpr binaryExpr) { boolean isSideEffecting = binaryExpr.getOp().isSideEffecting(); if (isSideEffecting) { enterLValueContext(); } visitChildFromParent(binaryExpr.getLhs(), binaryExpr); if (isSideEffecting) { exitLValueContext(); } visitChildFromParent(binaryExpr.getRhs(), binaryExpr); }
private boolean isAssignment(Stmt stmt, String lhsName, String rhsName) { if (!(stmt instanceof ExprStmt)) { return false; } final ExprStmt exprStmt = (ExprStmt) stmt; if (!(exprStmt.getExpr() instanceof BinaryExpr)) { return false; } final BinaryExpr binaryExpr = (BinaryExpr) exprStmt.getExpr(); if (binaryExpr.getOp() != BinOp.ASSIGN) { return false; } if (!isVariable(binaryExpr.getLhs(), lhsName)) { return false; } if (!isVariable(binaryExpr.getRhs(), rhsName)) { return false; } return true; }
if (init instanceof ExprStmt && ((ExprStmt) init).getExpr() instanceof BinaryExpr && ((BinaryExpr)(((ExprStmt) init).getExpr())).getOp() == BinOp.ASSIGN && ((BinaryExpr)(((ExprStmt) init).getExpr())).getLhs() instanceof VariableIdentifierExpr) {
/** * Determines whether the given statement came from a live code injection. * * @param stmt A statement to be analysed * @return Whether the statement is injected live code or not */ public static boolean isSimpleLiveCodeInjection(Stmt stmt) { if (!(stmt instanceof ExprStmt)) { return false; } final Expr expr = ((ExprStmt) stmt).getExpr(); if (expr instanceof BinaryExpr) { if (!((BinaryExpr) expr).getOp().isSideEffecting()) { return false; } return isLiveInjectionVariableReference(((BinaryExpr) expr).getLhs()); } if (expr instanceof UnaryExpr) { if (!((UnaryExpr) expr).getOp().isSideEffecting()) { return false; } return isLiveInjectionVariableReference(((UnaryExpr) expr).getExpr()); } if (expr instanceof FunctionCallExpr) { return ((FunctionCallExpr) expr).getCallee().startsWith(Constants.LIVE_PREFIX); } return false; }
@Override public void applyReductionImpl() { final BinaryExpr assignment = (BinaryExpr) stmt.getExpr(); final Expr expr = ((ReturnStmt) outlined.getBody().getStmt(0)).getExpr().clone(); Map<String, Expr> paramReplacement = new HashMap<>(); for (int i = 0; i < outlined.getPrototype().getNumParameters(); i++) { Expr actualParam = ((FunctionCallExpr) assignment.getRhs()).getArg(i); assert actualParam != null; paramReplacement.put(outlined.getPrototype().getParameter(i).getName(), actualParam); } assert assignment.getOp() == BinOp.ASSIGN; stmt.setExpr(new BinaryExpr(assignment.getLhs(), applySubstitutionDestructive(expr, paramReplacement), BinOp.ASSIGN)); }
final Expr lhs = maybeBe.get().getLhs(); final Expr rhs = maybeBe.get().getRhs(); switch (maybeBe.get().getOp()) {
public void apply(IdGenerator idGenerator) { BinaryExpr be = (BinaryExpr) toOutline.getExpr(); assert be.getOp() == BinOp.ASSIGN;