/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.test.lib.jittester.factories;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import jdk.test.lib.jittester.IRNode;
import jdk.test.lib.jittester.ProductionFailedException;
import jdk.test.lib.jittester.Symbol;
import jdk.test.lib.jittester.SymbolTable;
import jdk.test.lib.jittester.Type;
import jdk.test.lib.jittester.VariableInfo;
import jdk.test.lib.jittester.functions.Function;
import jdk.test.lib.jittester.functions.FunctionInfo;
import jdk.test.lib.jittester.types.TypeKlass;
import jdk.test.lib.jittester.utils.PseudoRandom;
class FunctionFactory extends SafeFactory<Function> {
private final FunctionInfo functionInfo;
private final int operatorLimit;
private final long complexityLimit;
private final boolean exceptionSafe;
private final TypeKlass ownerClass;
FunctionFactory(long complexityLimit, int operatorLimit, TypeKlass ownerClass,
Type resultType, boolean exceptionSafe) {
functionInfo = new FunctionInfo();
this.complexityLimit = complexityLimit;
this.operatorLimit = operatorLimit;
this.ownerClass = ownerClass;
this.functionInfo.type = resultType;
this.exceptionSafe = exceptionSafe;
}
@Override
protected Function sproduce() throws ProductionFailedException {
// Currently no function is exception-safe
if (exceptionSafe) {
throw new ProductionFailedException();
}
ArrayList<Symbol> allFunctions;
if (functionInfo.type == null) {
allFunctions = new ArrayList<>(SymbolTable.getAllCombined(FunctionInfo.class));
} else {
allFunctions = new ArrayList<>(SymbolTable.get(functionInfo.type, FunctionInfo.class));
}
if (!allFunctions.isEmpty()) {
PseudoRandom.shuffle(allFunctions);
Collection<TypeKlass> klassHierarchy = ownerClass.getAllParents();
for (Symbol function : allFunctions) {
FunctionInfo functionInfo = (FunctionInfo) function;
// Don't try to construct abstract classes.
if (functionInfo.isConstructor() && functionInfo.owner.isAbstract()) {
continue;
}
// We don't call methods from the same class which are not final, because if we
// do this may produce an infinite recursion. Simple example:
// class A
// {
// f1() { }
// f2() { f1(); }
// }
//
// class B : A
// {
// f1() { f2(); }
// }
//
// However the same example is obviously safe for static and final functions
// Also we introduce a special flag NONRECURSIVE to mark functions that
// are not overrided. We may also call such functions.
// If it's a local call.. or it's a call using some variable to some object of some type in our hierarchy
boolean inHierarchy = false;
if (ownerClass.equals(functionInfo.owner) || (inHierarchy = klassHierarchy.contains(functionInfo.owner))) {
if ((functionInfo.flags & FunctionInfo.FINAL) == 0 && (functionInfo.flags & FunctionInfo.STATIC) == 0
&& (functionInfo.flags & FunctionInfo.NONRECURSIVE) == 0) {
continue;
}
if (inHierarchy && (functionInfo.flags & FunctionInfo.PRIVATE) > 0) {
continue;
}
} else {
if ((functionInfo.flags & FunctionInfo.PUBLIC) == 0
&& (functionInfo.flags & FunctionInfo.DEFAULT) == 0) {
continue;
}
}
if (functionInfo.complexity < complexityLimit - 1) {
try {
List<IRNode> accum = new ArrayList<>();
if (!functionInfo.argTypes.isEmpty()) {
// Here we should do some analysis here to determine if
// there are any conflicting functions due to possible
// constant folding.
// For example the following can be done:
// Scan all the hieirachy where the class is declared.
// If there are function with a same name and same number of args,
// then disable usage of foldable expressions in the args.
boolean noconsts = false;
Collection<Symbol> allFuncsInKlass = SymbolTable.getAllCombined(functionInfo.owner,
FunctionInfo.class);
for (Symbol s2 : allFuncsInKlass) {
FunctionInfo i2 = (FunctionInfo) function;
if (!i2.equals(functionInfo) && i2.name.equals(functionInfo.name)
&& i2.argTypes.size() == functionInfo.argTypes.size()) {
noconsts = true;
break;
}
}
long argComp = (complexityLimit - 1 - functionInfo.complexity) / functionInfo.argTypes.size();
int argumentOperatorLimit = (operatorLimit - 1) / functionInfo.argTypes.size();
IRNodeBuilder b = new IRNodeBuilder().setOwnerKlass(ownerClass)
.setComplexityLimit(argComp)
.setOperatorLimit(argumentOperatorLimit)
.setExceptionSafe(exceptionSafe)
.setNoConsts(noconsts);
for (VariableInfo argType : functionInfo.argTypes) {
accum.add(b.setResultType(argType.type)
.getExpressionFactory()
.produce());
}
}
return new Function(ownerClass, functionInfo, accum);
} catch (ProductionFailedException e) {
// removeAllChildren();
}
}
}
}
throw new ProductionFailedException();
}
}