| /* |
| * Copyright (c) 2016, 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.utils; |
| |
| import java.util.Arrays; |
| import java.util.ArrayList; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import jdk.test.lib.jittester.BinaryOperator; |
| import jdk.test.lib.jittester.Block; |
| import jdk.test.lib.jittester.CatchBlock; |
| import jdk.test.lib.jittester.IRNode; |
| import jdk.test.lib.jittester.Literal; |
| import jdk.test.lib.jittester.LocalVariable; |
| import jdk.test.lib.jittester.NonStaticMemberVariable; |
| import jdk.test.lib.jittester.Nothing; |
| import jdk.test.lib.jittester.Operator; |
| import jdk.test.lib.jittester.OperatorKind; |
| import jdk.test.lib.jittester.PrintVariables; |
| import jdk.test.lib.jittester.Statement; |
| import jdk.test.lib.jittester.StaticMemberVariable; |
| import jdk.test.lib.jittester.Symbol; |
| import jdk.test.lib.jittester.TryCatchBlock; |
| import jdk.test.lib.jittester.Type; |
| import jdk.test.lib.jittester.TypeList; |
| import jdk.test.lib.jittester.VariableInfo; |
| import jdk.test.lib.jittester.VariableInitialization; |
| import jdk.test.lib.jittester.functions.ArgumentDeclaration; |
| import jdk.test.lib.jittester.functions.Function; |
| import jdk.test.lib.jittester.functions.FunctionDefinition; |
| import jdk.test.lib.jittester.functions.FunctionInfo; |
| import jdk.test.lib.jittester.functions.Return; |
| import jdk.test.lib.jittester.jtreg.Printer; |
| import jdk.test.lib.jittester.loops.CounterInitializer; |
| import jdk.test.lib.jittester.loops.CounterManipulator; |
| import jdk.test.lib.jittester.loops.For; |
| import jdk.test.lib.jittester.loops.Loop; |
| import jdk.test.lib.jittester.loops.LoopingCondition; |
| import jdk.test.lib.jittester.types.TypeArray; |
| import jdk.test.lib.jittester.types.TypeKlass; |
| |
| public class FixedTrees { |
| private static final Literal EOL = new Literal("\n", TypeList.STRING); |
| |
| public static FunctionDefinition printVariablesAsFunction(PrintVariables node) { |
| TypeKlass owner = node.getOwner(); |
| |
| ArrayList<IRNode> nodes = new ArrayList<>(); |
| |
| VariableInfo resultInfo = new VariableInfo("result", node.getOwner(), TypeList.STRING, VariableInfo.LOCAL); |
| nodes.add(new Statement(new VariableInitialization(resultInfo, new Literal("[", TypeList.STRING)), true)); |
| LocalVariable resultVar = new LocalVariable(resultInfo); |
| |
| List<Symbol> vars = node.getVars(); |
| |
| TypeKlass printerKlass = new TypeKlass(Printer.class.getName()); |
| VariableInfo thisInfo = new VariableInfo("this", node.getOwner(), |
| node.getOwner(), VariableInfo.LOCAL | VariableInfo.INITIALIZED); |
| |
| LocalVariable thisVar = new LocalVariable(thisInfo); |
| |
| for (int i = 0; i < vars.size(); i++) { |
| Symbol v = vars.get(i); |
| nodes.add(new Statement(new BinaryOperator(OperatorKind.COMPOUND_ADD, TypeList.STRING, resultVar, |
| new Literal(v.owner.getName() + "." + v.name + " = ", TypeList.STRING)), true)); |
| VariableInfo argInfo = new VariableInfo("arg", printerKlass, |
| v.type instanceof TypeKlass ? TypeList.OBJECT : v.type, |
| VariableInfo.LOCAL | VariableInfo.INITIALIZED); |
| FunctionInfo printInfo = new FunctionInfo("print", printerKlass, |
| TypeList.STRING, 0, FunctionInfo.PUBLIC | FunctionInfo.STATIC, argInfo); |
| Function call = new Function(owner, printInfo, null); |
| VariableInfo varInfo = new VariableInfo(v.name, v.owner, v.type, v.flags); |
| if (v.isStatic()) { |
| call.addChild(new StaticMemberVariable(v.owner, varInfo)); |
| } else { |
| call.addChild(new NonStaticMemberVariable(thisVar, varInfo)); |
| } |
| nodes.add(new Statement(new BinaryOperator(OperatorKind.COMPOUND_ADD, TypeList.STRING, resultVar, |
| call), true)); |
| if (i < vars.size() - 1) { |
| nodes.add(new Statement(new BinaryOperator(OperatorKind.COMPOUND_ADD, TypeList.STRING, resultVar, |
| EOL), true)); |
| } |
| } |
| nodes.add(new Statement( |
| new BinaryOperator(OperatorKind.COMPOUND_ADD, TypeList.STRING, resultVar, new Literal("]\n", TypeList.STRING)), |
| true)); |
| |
| Block block = new Block(node.getOwner(), TypeList.STRING, nodes, 1); |
| FunctionInfo toStringInfo = new FunctionInfo("toString", owner, TypeList.STRING, 0L, FunctionInfo.PUBLIC, thisInfo); |
| return new FunctionDefinition(toStringInfo, new ArrayList<>(), block, new Return(resultVar)); |
| } |
| |
| public static FunctionDefinition generateMainOrExecuteMethod(TypeKlass owner, boolean isMain) { |
| Nothing nothing = new Nothing(); |
| ArrayList<IRNode> testCallNodeContent = new ArrayList<>(); |
| VariableInfo tInfo = new VariableInfo("t", owner, owner, VariableInfo.LOCAL); |
| LocalVariable tVar = new LocalVariable(tInfo); |
| Function testCallNode = new Function(owner, new FunctionInfo("test", owner, TypeList.VOID, |
| 0L, FunctionInfo.PRIVATE, tInfo), null); |
| testCallNode.addChild(tVar); |
| testCallNodeContent.add(new Statement(testCallNode, true)); |
| // { t.test(); } |
| Block testCallNodeBlock = new Block(owner, TypeList.VOID, testCallNodeContent, 4); |
| |
| IRNode tryNode = testCallNodeBlock; |
| if (isMain) { |
| VariableInfo iInfo = new VariableInfo("i", owner, TypeList.INT, VariableInfo.LOCAL); |
| LocalVariable iVar = new LocalVariable(iInfo); |
| Operator increaseCounter = new BinaryOperator(OperatorKind.ASSIGN, TypeList.INT, |
| iVar, |
| new BinaryOperator(OperatorKind.ADD, TypeList.INT, |
| iVar, new Literal(1, TypeList.INT))); |
| Loop loop = new Loop(); |
| Block emptyBlock = new Block(owner, TypeList.VOID, new LinkedList<>(), 3); |
| loop.initialization = new CounterInitializer(iInfo, new Literal(0, TypeList.INT)); |
| loop.manipulator = new CounterManipulator(new Statement(increaseCounter, false)); |
| loop.condition = new LoopingCondition(new BinaryOperator(OperatorKind.LT, TypeList.BOOLEAN, iVar, |
| new Literal(150000, TypeList.INT))); |
| For forNode = new For(4, loop, 150000, emptyBlock, new Statement(nothing, false), |
| new Statement(nothing, false), testCallNodeBlock, emptyBlock, emptyBlock); |
| tryNode = forNode; |
| } |
| |
| FunctionInfo constrInfo = new FunctionInfo(owner.getName(), owner, owner, 0, FunctionInfo.PUBLIC); |
| Function testConstructor = new Function(owner, constrInfo, null); |
| // Test t = new Test() |
| VariableInitialization testInit = new VariableInitialization(tInfo, testConstructor); |
| |
| TypeKlass throwableKlass = new TypeKlass("java.lang.Throwable"); |
| List<Type> throwables = new ArrayList<>(); |
| throwables.add(throwableKlass); |
| |
| TypeKlass printStreamKlass = new TypeKlass("java.io.PrintStream"); |
| FunctionInfo printInfo = new FunctionInfo("print", printStreamKlass, |
| TypeList.VOID, 0, FunctionInfo.PUBLIC, |
| new VariableInfo("this", owner, printStreamKlass, VariableInfo.LOCAL | VariableInfo.INITIALIZED), |
| new VariableInfo("t", owner, TypeList.OBJECT, |
| VariableInfo.LOCAL | VariableInfo.INITIALIZED)); |
| TypeKlass systemKlass = new TypeKlass("java.lang.System"); |
| StaticMemberVariable systemErrVar = new StaticMemberVariable(owner, |
| new VariableInfo("err", systemKlass, printStreamKlass, VariableInfo.STATIC | VariableInfo.PUBLIC)); |
| |
| LocalVariable exVar = new LocalVariable( |
| new VariableInfo("ex", owner, throwableKlass, VariableInfo.LOCAL | VariableInfo.INITIALIZED)); |
| TypeKlass classKlass = new TypeKlass("java.lang.Class"); |
| FunctionInfo getClassInfo = new FunctionInfo("getClass", TypeList.OBJECT, |
| classKlass, 0, FunctionInfo.PUBLIC, |
| new VariableInfo("this", owner, TypeList.OBJECT, VariableInfo.LOCAL | VariableInfo.INITIALIZED)); |
| Function getClass = new Function(TypeList.OBJECT, getClassInfo, Arrays.asList(exVar)); |
| FunctionInfo getNameInfo = new FunctionInfo("getName", classKlass, |
| TypeList.STRING, 0, FunctionInfo.PUBLIC, |
| new VariableInfo("this", owner, TypeList.OBJECT, VariableInfo.LOCAL | VariableInfo.INITIALIZED)); |
| Function getName = new Function(classKlass, getNameInfo, Arrays.asList(getClass)); |
| ArrayList<IRNode> printExceptionBlockContent = new ArrayList<>(); |
| // { System.err.print(ex.getClass().getName()); System.err.print("\n"); } |
| printExceptionBlockContent.add(new Statement( |
| new Function(printStreamKlass, printInfo, Arrays.asList(systemErrVar, getName)), true)); |
| printExceptionBlockContent.add(new Statement( |
| new Function(printStreamKlass, printInfo, Arrays.asList(systemErrVar, EOL)), true)); |
| |
| Block printExceptionBlock = new Block(owner, TypeList.VOID, printExceptionBlockContent, 3); |
| List<CatchBlock> catchBlocks1 = new ArrayList<>(); |
| catchBlocks1.add(new CatchBlock(printExceptionBlock, throwables, 3)); |
| List<CatchBlock> catchBlocks2 = new ArrayList<>(); |
| catchBlocks2.add(new CatchBlock(printExceptionBlock, throwables, 3)); |
| List<CatchBlock> catchBlocks3 = new ArrayList<>(); |
| catchBlocks3.add(new CatchBlock(printExceptionBlock, throwables, 2)); |
| |
| TryCatchBlock tryCatch1 = new TryCatchBlock(tryNode, nothing, catchBlocks1, 3); |
| List<IRNode> printArgs = new ArrayList<>(); |
| VariableInfo systemOutInfo = new VariableInfo("out", systemKlass, printStreamKlass, |
| VariableInfo.STATIC | VariableInfo.PUBLIC); |
| StaticMemberVariable systemOutVar = new StaticMemberVariable(owner, systemOutInfo); |
| printArgs.add(systemOutVar); |
| printArgs.add(tVar); |
| Function print = new Function(printStreamKlass, printInfo, printArgs); |
| ArrayList<IRNode> printBlockContent = new ArrayList<>(); |
| printBlockContent.add(new Statement(print, true)); |
| Block printBlock = new Block(owner, TypeList.VOID, printBlockContent, 3); |
| TryCatchBlock tryCatch2 = new TryCatchBlock(printBlock, nothing, catchBlocks2, 3); |
| |
| List<IRNode> mainTryCatchBlockContent = new ArrayList<>(); |
| mainTryCatchBlockContent.add(new Statement(testInit, true)); |
| mainTryCatchBlockContent.add(tryCatch1); |
| mainTryCatchBlockContent.add(tryCatch2); |
| Block mainTryCatchBlock = new Block(owner, TypeList.VOID, mainTryCatchBlockContent, 2); |
| TryCatchBlock mainTryCatch = new TryCatchBlock(mainTryCatchBlock, nothing, catchBlocks3, 2); |
| ArrayList<IRNode> bodyContent = new ArrayList<>(); |
| bodyContent.add(mainTryCatch); |
| Block funcBody = new Block(owner, TypeList.VOID, bodyContent, 1); |
| |
| // static main(String[] args)V or static execute()V |
| VariableInfo mainArgs = new VariableInfo("args", owner, |
| new TypeArray(TypeList.STRING, 1), VariableInfo.LOCAL); |
| FunctionInfo fInfo = isMain |
| ? new FunctionInfo("main", owner, TypeList.VOID, 0, FunctionInfo.PUBLIC | FunctionInfo.STATIC, mainArgs) |
| : new FunctionInfo("execute", owner, TypeList.VOID, 0, FunctionInfo.PUBLIC | FunctionInfo.STATIC); |
| ArrayList<ArgumentDeclaration> argDecl = new ArrayList<>(); |
| if (isMain) { |
| argDecl.add(new ArgumentDeclaration(mainArgs)); |
| } |
| return new FunctionDefinition(fInfo, argDecl, funcBody, new Return(nothing)); |
| } |
| } |
