@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 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); }
static boolean assignsDirectlyToVariable(BinaryExpr expr) { return expr.getOp() == BinOp.ASSIGN && expr.getLhs() instanceof VariableIdentifierExpr; }
@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; } } }
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 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) { visit(binaryExpr.getLhs()); out.append(" " + binaryExpr.getOp().getText() + " "); visit(binaryExpr.getRhs()); }
&& isSameVarIdentifier(((BinaryExpr) incr).getLhs(), loopCounterName)) { final Optional<Integer> incrementValue = getAsConstant(((BinaryExpr) incr).getRhs()); if (!incrementValue.isPresent()) {
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()); }
@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) { super.visitBinaryExpr(binaryExpr); Type lhsType = types.get(binaryExpr.getLhs()); Type rhsType = types.get(binaryExpr.getRhs()); if (lhsType instanceof QualifiedType) {
@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); }
&& ((ExprStmt) init).getExpr() instanceof BinaryExpr && ((BinaryExpr)(((ExprStmt) init).getExpr())).getOp() == BinOp.ASSIGN && ((BinaryExpr)(((ExprStmt) init).getExpr())).getLhs() instanceof VariableIdentifierExpr) { name = ((VariableIdentifierExpr) (((BinaryExpr)(((ExprStmt) init) .getExpr())).getLhs())).getName(); expr = ((BinaryExpr)(((ExprStmt) init) .getExpr())).getRhs();
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; }
be.getLhs().clone(), new FunctionCallExpr(newFunctionName, referencedVariables.stream().map(item -> new VariableIdentifierExpr(item)) .collect(Collectors.toList())), BinOp.ASSIGN)); ((VariableIdentifierExpr) be.getLhs()).getName()); if (returnType == null) { switch (((VariableIdentifierExpr) be.getLhs()).getName()) { case OpenGlConstants.GL_FRAG_COLOR: case OpenGlConstants.GL_FRAG_COORD: default: assert returnType != null : "No type for " + ((VariableIdentifierExpr) be.getLhs()).getName();
@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()) {
/** * 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; }