@Override public Expr getChild(int index) { if (index == 0) { return getLhs(); } if (index == 1) { return getRhs(); } throw new IndexOutOfBoundsException("Index for BinaryExpr must be 0 or 1"); }
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) { visitChildFromParent(binaryExpr.getLhs(), binaryExpr); visitChildFromParent(binaryExpr.getRhs(), binaryExpr); }
private static void replaceLoopCounterInCondition(Expr condition, String newLoopCounter) { BinaryExpr binaryExpr = (BinaryExpr) condition; VariableIdentifierExpr toReplace; if (binaryExpr.getLhs() instanceof VariableIdentifierExpr) { toReplace = (VariableIdentifierExpr) binaryExpr.getLhs(); } else { toReplace = (VariableIdentifierExpr) binaryExpr.getRhs(); } toReplace.setName(newLoopCounter); }
public OutlineStatementOpportunity(ExprStmt toOutline, Scope scopeOfStmt, TranslationUnit tu, FunctionDefinition enclosingFunction) { this.scopeOfStmt = scopeOfStmt; this.toOutline = toOutline; this.tu = tu; this.enclosingFunction = enclosingFunction; if (!isAssignment(toOutline)) { throw new IllegalArgumentException("Can only outline an assignment statement"); } if (!assignsDirectlyToVariable((BinaryExpr) toOutline.getExpr())) { throw new IllegalArgumentException("At present, can only outline an assignment directly to " + "a variable"); } if (referencesArray(((BinaryExpr) toOutline.getExpr()).getRhs())) { throw new IllegalArgumentException("At present, we cannot handle arrays on the RHS of an " + "outlined expression"); } }
@Override public void visitBinaryExpr(BinaryExpr binaryExpr) { visit(binaryExpr.getLhs()); out.append(" " + binaryExpr.getOp().getText() + " "); visit(binaryExpr.getRhs()); }
final Optional<Integer> incrementValue = getAsConstant(((BinaryExpr) incr).getRhs()); if (!incrementValue.isPresent()) { return Optional.empty();
@Override public void visitExprStmt(ExprStmt exprStmt) { super.visitExprStmt(exprStmt); if (!OutlineStatementOpportunity.isAssignment(exprStmt)) { return; } BinaryExpr be = (BinaryExpr) exprStmt.getExpr(); if (!OutlineStatementOpportunity.assignsDirectlyToVariable(be)) { return; } if (referencesArray(be.getRhs(), currentScope)) { return; } opportunities.add(new OutlineStatementOpportunity(exprStmt, currentScope, tu, enclosingFunction)); }
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); }
@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<>()); }
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); }
super.visitBinaryExpr(binaryExpr); Type lhsType = types.get(binaryExpr.getLhs()); Type rhsType = types.get(binaryExpr.getRhs()); if (lhsType instanceof QualifiedType) { lhsType = ((QualifiedType) lhsType).getTargetType();
@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; }
@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)); }
if (maybeBe.isPresent()) { final Expr lhs = maybeBe.get().getLhs(); final Expr rhs = maybeBe.get().getRhs(); switch (maybeBe.get().getOp()) {
.getExpr())).getLhs())).getName(); expr = ((BinaryExpr)(((ExprStmt) init) .getExpr())).getRhs(); } else if (init instanceof DeclarationStmt && ((DeclarationStmt) init).getVariablesDeclaration().getNumDecls() == 1
assert be.getOp() == BinOp.ASSIGN; final List<String> referencedVariables = getReferencedVariables(be.getRhs()); final String newFunctionName = Constants.OUTLINED_FUNCTION_PREFIX + idGenerator.freshId(); params), new BlockStmt(Arrays.asList( new ReturnStmt(be.getRhs().clone())), false)), enclosingFunction);