@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 void visitFunctionDefinition(FunctionDefinition functionDefinition) { visitChildFromParent(this::visitFunctionPrototype, functionDefinition.getPrototype(), functionDefinition); visitChildFromParent(this::visitBlockStmt, functionDefinition.getBody(), functionDefinition); }
@Override public FunctionDefinition clone() { return new FunctionDefinition(prototype.clone(), body.clone()); }
numNonMainFunctionsLeftToGenerate--; FunctionDefinition functionDefinition = fuzzFunction(); fuzzingContext.addFunction(functionDefinition.getPrototype()); decls.add(functionDefinition); new ArrayList<>()); fuzzingContext.enterFunction(mainPrototype); decls.add(new FunctionDefinition( mainPrototype, fuzzBlockStmt(false))); fuzzingContext.leaveFunction();
public OutlinedStatementReductionOpportunity(ExprStmt stmt, FunctionDefinition outlined, VisitationDepth depth) { super(depth); assert stmt.getExpr() instanceof BinaryExpr; assert outlined.getBody().getNumStmts() == 1; assert outlined.getBody().getStmt(0) instanceof ReturnStmt; this.stmt = stmt; this.outlined = outlined; }
private FunctionDefinition getCloneWithReturnsRemoved(FunctionDefinition fd) throws CannotInlineCallException { try { final FunctionDefinition clonedFunctionDefinition = fd.clone(); ReturnRemover.removeReturns(clonedFunctionDefinition, shadingLanguageVersion); return clonedFunctionDefinition; } catch (CannotRemoveReturnsException exception) { throw new CannotInlineCallException("Could not remove returns from callee"); } }
private void doRemoveReturns() throws CannotRemoveReturnsException { if (!containsReturn(fd.getBody())) { // No return to remove return; } if (numReturnStmts(fd.getBody()) == 1 && fd.getBody() .getStmt(fd.getBody().getNumStmts() - 1) instanceof ReturnStmt) { // Only one return at end -- removing it doesn't simplify things return; } if (containsSwitch(fd)) { throw new CannotRemoveReturnsException("Switch statements not yet supported."); } addReturnInstrumentation(); replaceReturnStatements(); addSpecialDeclarations(); }
@Override public boolean preconditionHolds() { return functionDefinition.getPrototype().getParameters().contains(parameterDecl); } }
@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; }
@Override public FunctionDefinition visitFunction_definition(Function_definitionContext ctx) { return new FunctionDefinition( visitFunction_prototype(ctx.function_prototype()), visitCompound_statement_no_new_scope(ctx.compound_statement_no_new_scope())); }
private String functionName() { return fd.getPrototype().getName(); }
.filter(item -> item instanceof FunctionDefinition) .map(item -> (FunctionDefinition) item) .filter(item -> item.getPrototype().getName().equals(callee)) .collect(Collectors.toList()); if (relevantFunctions.size() != 1) { if (relevantFunction.getBody().getNumStmts() != 1) { return; if (!(relevantFunction.getBody().getStmt(0) instanceof ReturnStmt)) { return;
private FunctionDefinition fuzzFunction() { fuzzingContext.enterScope(); List<ParameterDecl> params = new ArrayList<>(); for (int i = 0; i < generator.nextInt(MAX_FUNCTION_PARAMS); i++) { final String name = "p" + i; final Type type = fuzzType(); // TODO: consider adding array parameters final ParameterDecl parameterDecl = new ParameterDecl(name, type, null); fuzzingContext.addParameter(parameterDecl); params.add(parameterDecl); } FunctionPrototype prototype = new FunctionPrototype(createName("f"), fuzzType(), params); fuzzingContext.enterFunction(prototype); final BlockStmt body = fuzzBlockStmt(false); if (!containsReturnStmt(body)) { body.addStmt(fuzzReturnStmt()); } FunctionDefinition functionDefinition = new FunctionDefinition( prototype, body); fuzzingContext.leaveFunction(); fuzzingContext.leaveScope(); return functionDefinition; }
private boolean incompatibleReturnTypes(FunctionDefinition f1, FunctionDefinition f2) { return !f1.getPrototype().getReturnType().equals(f2.getPrototype().getReturnType()); }
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); } } }
tu.addDeclarationBefore(new FunctionDefinition(new FunctionPrototype( newFunctionName, returnType,
@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()); }
@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)); }
boolean check(TranslationUnit tu) { visit(tu); return triggerFunction.isPresent() && callsIndirectly.get("main").contains(triggerFunction.get().getPrototype().getName()); }
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))))); }