@Override public void visitFunctionDefinition(FunctionDefinition functionDefinition) { super.visitFunctionDefinition(functionDefinition); String name = functionDefinition.getPrototype().getName(); if (!userDefinedFunctions.containsKey(name)) { userDefinedFunctions.put(name, new HashSet<>()); } userDefinedFunctions.get(name).add(functionDefinition.getPrototype()); }
@Override public boolean preconditionHolds() { return functionDefinition.getPrototype().getParameters().contains(parameterDecl); } }
private String functionName() { return fd.getPrototype().getName(); }
private boolean incompatibleReturnTypes(FunctionDefinition f1, FunctionDefinition f2) { return !f1.getPrototype().getReturnType().equals(f2.getPrototype().getReturnType()); }
@Override public void visitFunctionDefinition(FunctionDefinition functionDefinition) { System.out.println("Entering function " + functionDefinition.getPrototype().getName()); super.visitFunctionDefinition(functionDefinition); System.out.println("Leaving function " + functionDefinition.getPrototype().getName()); }
boolean check(TranslationUnit tu) { visit(tu); return triggerFunction.isPresent() && callsIndirectly.get("main").contains(triggerFunction.get().getPrototype().getName()); }
@Override public void visitFunctionDefinition(FunctionDefinition functionDefinition) { assert unusedParametersForCurrentFunction == null; unusedParametersForCurrentFunction = new ArrayList<>(); unusedParametersForCurrentFunction.addAll(functionDefinition.getPrototype().getParameters()); super.visitFunctionDefinition(functionDefinition); functionsToUnusedParameters.put(functionDefinition, unusedParametersForCurrentFunction); unusedParametersForCurrentFunction = null; }
@Override public void visitFunctionDefinition(FunctionDefinition functionDefinition) { assert enclosingFunctionName == null; enclosingFunctionName = functionDefinition.getPrototype().getName(); super.visitFunctionDefinition(functionDefinition); assert enclosingFunctionName == functionDefinition.getPrototype().getName(); enclosingFunctionName = null; }
private boolean hasArrayParameter(FunctionDefinition functionDefinition) { return functionDefinition.getPrototype().getParameters().stream() .anyMatch(item -> item.getArrayInfo() != null); }
private ConstCleaner(TranslationUnit tu, ShadingLanguageVersion shadingLanguageVersion) { this.atGlobalScope = true; this.currentVariablesDeclaration = Optional.empty(); this.globalsToBeReInitialized = new ArrayList<>(); this.shadingLanguageVersion = shadingLanguageVersion; visit(tu); addGlobalInitializers(tu .getTopLevelDeclarations() .stream() .filter(item -> item instanceof FunctionDefinition) .map(item -> (FunctionDefinition) item) .filter(item -> item.getPrototype().getName().equals("main")) .collect(Collectors.toList()) .get(0)); }
private boolean hasOutQualifier(FunctionDefinition functionDefinition) { return functionDefinition.getPrototype().getParameters().stream() .map(item -> item.getType()) .anyMatch(item -> item.hasQualifier(TypeQualifier.OUT_PARAM) || item.hasQualifier(TypeQualifier.INOUT_PARAM)); }
@Override public void visitFunctionCallExpr(FunctionCallExpr functionCallExpr) { super.visitFunctionCallExpr(functionCallExpr); if (enclosingFunction.isPresent()) { addCallGraphEdge(enclosingFunction.get().getPrototype().getName(), functionCallExpr.getCallee()); } }
@Override public void visitFunctionCallExpr(FunctionCallExpr functionCallExpr) { super.visitFunctionCallExpr(functionCallExpr); if (functionCallExpr.getCallee().equals(functionDefinition.getPrototype().getName())) { // As we only apply this reduction opportunity if the function name is not overloaded, // this has to be a call to the relevant function. functionCallExpr.removeArg(paramIndex); } }
@Override public void visitFunctionPrototype(FunctionPrototype functionPrototype) { super.visitFunctionPrototype(functionPrototype); if (functionPrototype.getName().equals(functionDefinition.getPrototype().getName())) { // As we only apply this reduction opportunity if the function name is not overloaded, // this has to be a prototype for the relevant function (there could be multiple identical // prototypes). functionPrototype.removeParameter(paramIndex); } }
@Override public void visitFunctionDefinition(FunctionDefinition functionDefinition) { visitChildFromParent(this::visitFunctionPrototype, functionDefinition.getPrototype(), functionDefinition); visitChildFromParent(this::visitBlockStmt, functionDefinition.getBody(), functionDefinition); }
@Override public void visitFunctionDefinition(FunctionDefinition functionDefinition) { assert enclosingFunction == null; enclosingFunction = functionDefinition; pushScope(); addEncounteredParametersToScope = true; visitFunctionPrototype(functionDefinition.getPrototype()); addEncounteredParametersToScope = false; visit(functionDefinition.getBody()); popScope(); enclosingFunction = null; }
private IfStmt prepareReturnStmt(IInjectionPoint injectionPoint, IRandom generator, ShadingLanguageVersion shadingLanguageVersion, GenerationParams generationParams) { Type returnType = injectionPoint.getEnclosingFunction().getPrototype().getReturnType(); Stmt stmtToInject; if (returnType.hasCanonicalConstant()) { stmtToInject = new ReturnStmt(returnType.getCanonicalConstant()); } else if (returnType.getWithoutQualifiers() == VoidType.VOID) { stmtToInject = new ReturnStmt(); } else { stmtToInject = new BlockStmt(new ArrayList<>(), true); } return makeDeadConditional(injectionPoint, stmtToInject, generator, shadingLanguageVersion, generationParams); }
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); } } }
@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)); }
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))))); }