@Override public ScalarInitializer clone() { return new ScalarInitializer(expr.clone()); }
@Override public void visitScalarInitializer(ScalarInitializer scalarInitializer) { visitChildFromParent(scalarInitializer.getExpr(), scalarInitializer); }
new ScalarInitializer(((TypeConstructorExpr) item.getExpr()) .getArg(currentIndex)));
@Override public void replaceChild(IAstNode child, IAstNode newChild) { if (!(child == expr && newChild instanceof Expr)) { throw new IllegalArgumentException(); } setExpr((Expr) newChild); }
private void structifyDeclaration(String enclosingStructVariableName, StructDefinitionType enclosingStructType) { declToTransform.getVariablesDeclaration() .setBaseType(enclosingStructType.getStructNameType()); final VariableDeclInfo declInfo = declToTransform.getVariablesDeclaration().getDeclInfo(0); declInfo.setName(enclosingStructVariableName); if (declInfo.hasInitializer()) { declInfo.setInitializer( new ScalarInitializer( makeInitializationExpr(enclosingStructType, ((ScalarInitializer) declInfo.getInitializer()).getExpr()) ) ); } }
@Override public Initializer visitInitializer(InitializerContext ctx) { if (ctx == null) { return null; } if (ctx.assignment_expression() != null) { return new ScalarInitializer(visitAssignment_expression(ctx.assignment_expression())); } throw new RuntimeException(); }
private void addOpportunities() { for (Pair<VariableDeclInfo, VariableIdentifierExpr> pair : inlineableUsages) { if (!blackList.contains(pair.getLeft())) { addOpportunity(new SimplifyExprReductionOpportunity( parentMap.getParent(pair.getRight()), new ParenExpr(((ScalarInitializer) pair.getLeft().getInitializer()).getExpr().clone()), pair.getRight(), getVistitationDepth())); } } }
private void adjustInitializer(ForStmt loop, int numIterationsToSplitAfter, LoopSplitInfo loopSplitInfo) { final Integer newStart = new Integer(loopSplitInfo.getStartValue() + (loopSplitInfo.getIncreasing() ? 1 : -1) * numIterationsToSplitAfter); VariablesDeclaration varDecl = ((DeclarationStmt) loop.getInit()).getVariablesDeclaration(); varDecl.getDeclInfo(0).setInitializer(new ScalarInitializer(new IntConstantExpr( newStart.toString()))); }
boolean initializerIsScalarAndSideEffectFree(VariableDeclInfo variableDeclInfo) { if (!variableDeclInfo.hasInitializer()) { return false; } if (!(variableDeclInfo.getInitializer() instanceof ScalarInitializer)) { return false; } return SideEffectChecker.isSideEffectFree( ((ScalarInitializer) variableDeclInfo.getInitializer()).getExpr(), context.getShadingLanguageVersion()); }
private static Initializer makeInitializer(BasicType baseType, ArrayInfo arrayInfo, List<Number> args) { if (arrayInfo != null) { assert arrayInfo.getSize() * baseType.getNumElements() == args.size(); List<Expr> argExprs = new ArrayList<>(); for (int index = 0; index < arrayInfo.getSize(); index++) { argExprs.add(getBasicTypeLiteralExpr(baseType, args.subList(index * baseType.getNumElements(), (index + 1) * baseType.getNumElements()))); } return new ScalarInitializer(new ArrayConstructorExpr( new ArrayType(baseType.getWithoutQualifiers(), arrayInfo.clone()), argExprs)); } return new ScalarInitializer(getBasicTypeLiteralExpr(baseType, args)); }
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); }
private List<Stmt> getInlinedStmts(FunctionDefinition functionDefinition, Optional<String> returnVariableName) { final List<Stmt> inlinedStmts = new ArrayList<>(); for (int i = 0; i < functionDefinition.getPrototype().getNumParameters(); i++) { ParameterDecl pd = functionDefinition.getPrototype().getParameter(i); inlinedStmts.add(new DeclarationStmt( new VariablesDeclaration( pd.getType().getWithoutQualifiers(), new VariableDeclInfo(pd.getName(), null, new ScalarInitializer(call.getArg(i).clone()))))); } for (Stmt stmt : functionDefinition.getBody().getStmts()) { if (stmt instanceof ReturnStmt) { if (((ReturnStmt) stmt).hasExpr()) { inlinedStmts.add(new ExprStmt( new BinaryExpr( new VariableIdentifierExpr(returnVariableName.get()), (((ReturnStmt) stmt).getExpr()), BinOp.ASSIGN))); } } else { inlinedStmts.add(stmt); } } return inlinedStmts; }
private void addGlobalInitializers(FunctionDefinition mainFunction) { assert mainFunction.getPrototype().getName().equals("main"); for (int i = globalsToBeReInitialized.size() - 1; i >= 0; i--) { for (int j = globalsToBeReInitialized.get(i).getNumDecls() - 1; j >= 0; j--) { final VariableDeclInfo vdi = globalsToBeReInitialized.get(i).getDeclInfo(j); if (!(vdi.getInitializer() instanceof ScalarInitializer)) { throw new RuntimeException("Only know how to deal with scalar initializers at present."); } mainFunction.getBody().insertStmt(0, new ExprStmt(new BinaryExpr(new VariableIdentifierExpr(vdi.getName()), ((ScalarInitializer) vdi.getInitializer()).getExpr(), BinOp.ASSIGN))); vdi.setInitializer(null); } } }
private void addSpecialDeclarations() { if (fd.getPrototype().getReturnType().getWithoutQualifiers() != VoidType.VOID) { fd.getBody().insertStmt(0, new DeclarationStmt( new VariablesDeclaration(fd.getPrototype().getReturnType().getWithoutQualifiers(), new VariableDeclInfo(makeReturnValueName(), null, null)))); fd.getBody().addStmt(new ReturnStmt(makeReturnValue())); } fd.getBody().insertStmt(0, new DeclarationStmt( new VariablesDeclaration(BasicType.BOOL, new VariableDeclInfo(makeHasReturnedName(), null, new ScalarInitializer(BoolConstantExpr.FALSE))))); }
.getInitializer()).getExpr()); if (!maybeStartValue.isPresent()) { return Optional.empty();
private Stmt makeSingleIterationForStmt(Stmt stmt, OpaqueExpressionGenerator opaqueExpressionGenerator, Fuzzer fuzzer, IRandom generator, ShadingLanguageVersion shadingLanguageVersion) { boolean up = generator.nextBoolean(); String loopVariableName = "_injected_loop_counter_" + loopVariableCounter; loopVariableCounter++; boolean loopBoundsMustBeConst = shadingLanguageVersion.restrictedForLoops(); Expr start = up ? opaqueExpressionGenerator .makeOpaqueZero(BasicType.INT, loopBoundsMustBeConst, 0, fuzzer) : opaqueExpressionGenerator .makeOpaqueOne(BasicType.INT, loopBoundsMustBeConst, 0, fuzzer); DeclarationStmt init = new DeclarationStmt(new VariablesDeclaration(BasicType.INT, new VariableDeclInfo(loopVariableName, null, new ScalarInitializer(start)))); Expr end = up ? opaqueExpressionGenerator .makeOpaqueOne(BasicType.INT, loopBoundsMustBeConst, 0, fuzzer) : opaqueExpressionGenerator .makeOpaqueZero(BasicType.INT, loopBoundsMustBeConst, 0, fuzzer); BinOp testOp = generator.nextBoolean() ? (up ? BinOp.LT : BinOp.GT) : BinOp.NE; Expr test = new BinaryExpr(new VariableIdentifierExpr(loopVariableName), end, testOp); UnOp incOp = up ? UnOp.POST_INC : UnOp.POST_DEC; Expr inc = new UnaryExpr(new VariableIdentifierExpr(loopVariableName), incOp); return new ForStmt(init, makeWrappedLoopCondition(test), inc, stmt); }
expr = ((ScalarInitializer)((DeclarationStmt) init) .getVariablesDeclaration().getDeclInfo(0) .getInitializer()).getExpr();
initializer = new ScalarInitializer(new IntConstantExpr("0")); } else { initializer = getScalarInitializer(injectionPoint, donationContext, type, true,
new VariablesDeclaration(BasicType.INT, new VariableDeclInfo(limiterName, null, new ScalarInitializer(new IntConstantExpr("0")))));