--- /dev/null 2016-05-31 09:42:47.975716356 -0700 +++ new/src/jdk.vm.compiler/share/classes/org.graalvm.compiler.lir.jtt/src/org/graalvm/compiler/lir/jtt/LIRTest.java 2016-12-09 00:53:47.568696934 -0800 @@ -0,0 +1,261 @@ +/* + * 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 org.graalvm.compiler.lir.jtt; + +import static org.graalvm.compiler.lir.LIRValueUtil.isVariable; +import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED; +import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_IGNORED; + +import java.lang.annotation.ElementType; +import java.lang.annotation.RetentionPolicy; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.stream.Stream; + +import org.graalvm.compiler.api.replacements.SnippetReflectionProvider; +import org.graalvm.compiler.core.common.type.StampFactory; +import org.graalvm.compiler.graph.NodeClass; +import org.graalvm.compiler.graph.NodeInputList; +import org.graalvm.compiler.jtt.JTTTest; +import org.graalvm.compiler.nodeinfo.NodeInfo; +import org.graalvm.compiler.nodes.FixedWithNextNode; +import org.graalvm.compiler.nodes.ValueNode; +import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration; +import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderContext; +import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin; +import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugins; +import org.graalvm.compiler.nodes.spi.LIRLowerable; +import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool; + +import jdk.vm.ci.meta.JavaKind; +import jdk.vm.ci.meta.ResolvedJavaMethod; +import jdk.vm.ci.meta.Value; + +/** + * Base class for LIR tests. + *

+ * It provides facilities to replace methods with {@link LIRTestSpecification arbitrary LIR + * instructions}. + */ +public abstract class LIRTest extends JTTTest { + + @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED) + private static final class LIRTestNode extends FixedWithNextNode implements LIRLowerable { + + public static final NodeClass TYPE = NodeClass.create(LIRTestNode.class); + @Input protected ValueNode opsNode; + @Input protected NodeInputList values; + public final SnippetReflectionProvider snippetReflection; + + protected LIRTestNode(SnippetReflectionProvider snippetReflection, JavaKind kind, ValueNode opsNode, ValueNode[] values) { + super(TYPE, StampFactory.forKind(kind)); + this.opsNode = opsNode; + this.values = new NodeInputList<>(this, values); + this.snippetReflection = snippetReflection; + } + + public NodeInputList values() { + return values; + } + + public ValueNode getLIROpsNode() { + return opsNode; + } + + @Override + public void generate(NodeLIRBuilderTool gen) { + LIRTestSpecification ops = getLIROperations(); + Stream v = values().stream().map(node -> gen.operand(node)); + + ops.generate(gen.getLIRGeneratorTool(), v.toArray(size -> new Value[size])); + Value result = ops.getResult(); + if (result != null) { + gen.setResult(this, result); + } + } + + public LIRTestSpecification getLIROperations() { + assert getLIROpsNode().isConstant(); + LIRTestSpecification spec = snippetReflection.asObject(LIRTestSpecification.class, getLIROpsNode().asJavaConstant()); + return spec; + } + } + + @NodeInfo(cycles = CYCLES_IGNORED, size = SIZE_IGNORED) + private static final class LIRValueNode extends FixedWithNextNode implements LIRLowerable { + + public static final NodeClass TYPE = NodeClass.create(LIRValueNode.class); + @Input protected ValueNode opsNode; + @Input protected ValueNode name; + public final SnippetReflectionProvider snippetReflection; + + protected LIRValueNode(SnippetReflectionProvider snippetReflection, JavaKind kind, ValueNode opsNode, ValueNode name) { + super(TYPE, StampFactory.forKind(kind)); + this.opsNode = opsNode; + this.name = name; + this.snippetReflection = snippetReflection; + } + + public ValueNode getLIROpsNode() { + return opsNode; + } + + @Override + public void generate(NodeLIRBuilderTool gen) { + LIRTestSpecification spec = getLIROperations(); + Value output = spec.getOutput(getName()); + gen.setResult(this, isVariable(output) ? output : gen.getLIRGeneratorTool().emitMove(output)); + } + + private String getName() { + assert name.isConstant(); + return snippetReflection.asObject(String.class, name.asJavaConstant()); + } + + private LIRTestSpecification getLIROperations() { + assert getLIROpsNode().isConstant(); + return snippetReflection.asObject(LIRTestSpecification.class, getLIROpsNode().asJavaConstant()); + } + + } + + private InvocationPlugin lirTestPlugin = new InvocationPlugin() { + @Override + public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode spec) { + JavaKind returnKind = targetMethod.getSignature().getReturnKind(); + LIRTestNode node = new LIRTestNode(getSnippetReflection(), returnKind, spec, new ValueNode[]{}); + addNode(b, returnKind, node); + return true; + } + + @Override + public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode spec, ValueNode arg0) { + JavaKind returnKind = targetMethod.getSignature().getReturnKind(); + LIRTestNode node = new LIRTestNode(getSnippetReflection(), returnKind, spec, new ValueNode[]{arg0}); + addNode(b, returnKind, node); + return true; + } + + @Override + public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode spec, ValueNode arg0, ValueNode arg1) { + JavaKind returnKind = targetMethod.getSignature().getReturnKind(); + LIRTestNode node = new LIRTestNode(getSnippetReflection(), returnKind, spec, new ValueNode[]{arg0, arg1}); + addNode(b, returnKind, node); + return true; + } + + @Override + public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode spec, ValueNode arg0, ValueNode arg1, ValueNode arg2) { + JavaKind returnKind = targetMethod.getSignature().getReturnKind(); + LIRTestNode node = new LIRTestNode(getSnippetReflection(), returnKind, spec, new ValueNode[]{arg0, arg1, arg2}); + addNode(b, returnKind, node); + return true; + } + + @Override + public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode spec, ValueNode arg0, ValueNode arg1, ValueNode arg2, ValueNode arg3) { + JavaKind returnKind = targetMethod.getSignature().getReturnKind(); + LIRTestNode node = new LIRTestNode(getSnippetReflection(), returnKind, spec, new ValueNode[]{arg0, arg1, arg2, arg3}); + addNode(b, returnKind, node); + return true; + } + + private void addNode(GraphBuilderContext b, JavaKind returnKind, LIRTestNode node) { + if (returnKind.equals(JavaKind.Void)) { + b.add(node); + } else { + b.addPush(returnKind, node); + } + } + + }; + + @Override + protected GraphBuilderConfiguration editGraphBuilderConfiguration(GraphBuilderConfiguration conf) { + InvocationPlugins invocationPlugins = conf.getPlugins().getInvocationPlugins(); + + Class c = getClass(); + for (Method m : c.getMethods()) { + if (m.getAnnotation(LIRIntrinsic.class) != null) { + assert Modifier.isStatic(m.getModifiers()); + Class[] p = m.getParameterTypes(); + assert p.length > 0; + assert LIRTestSpecification.class.isAssignableFrom(p[0]); + + invocationPlugins.register(lirTestPlugin, c, m.getName(), p); + } + } + InvocationPlugin outputPlugin = new InvocationPlugin() { + @Override + public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode spec, ValueNode name, ValueNode expected) { + JavaKind returnKind = targetMethod.getSignature().getReturnKind(); + b.addPush(returnKind, new LIRValueNode(getSnippetReflection(), returnKind, spec, name)); + return true; + } + }; + invocationPlugins.register(outputPlugin, LIRTest.class, "getOutput", new Class[]{LIRTestSpecification.class, String.class, Object.class}); + invocationPlugins.register(outputPlugin, LIRTest.class, "getOutput", new Class[]{LIRTestSpecification.class, String.class, int.class}); + return super.editGraphBuilderConfiguration(conf); + } + + @SuppressWarnings("unused") + public static byte getOutput(LIRTestSpecification spec, String name, byte expected) { + return expected; + } + + @SuppressWarnings("unused") + public static short getOutput(LIRTestSpecification spec, String name, short expected) { + return expected; + } + + @SuppressWarnings("unused") + public static int getOutput(LIRTestSpecification spec, String name, int expected) { + return expected; + } + + @SuppressWarnings("unused") + public static long getOutput(LIRTestSpecification spec, String name, long expected) { + return expected; + } + + @SuppressWarnings("unused") + public static float getOutput(LIRTestSpecification spec, String name, float expected) { + return expected; + } + + @SuppressWarnings("unused") + public static double getOutput(LIRTestSpecification spec, String name, double expected) { + return expected; + } + + @SuppressWarnings("unused") + public static Object getOutput(LIRTestSpecification spec, String name, Object expected) { + return expected; + } + + @java.lang.annotation.Retention(RetentionPolicy.RUNTIME) + @java.lang.annotation.Target(ElementType.METHOD) + public static @interface LIRIntrinsic { + } + +}