1/* 2 * Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23package org.graalvm.compiler.core.gen; 24 25import jdk.vm.ci.meta.Value; 26 27import org.graalvm.compiler.core.match.MatchableNode; 28import org.graalvm.compiler.graph.Node; 29import org.graalvm.compiler.lir.LIRFrameState; 30import org.graalvm.compiler.lir.LIRInstruction; 31import org.graalvm.compiler.lir.LabelRef; 32import org.graalvm.compiler.lir.gen.LIRGeneratorTool; 33import org.graalvm.compiler.nodes.ConstantNode; 34import org.graalvm.compiler.nodes.DeoptimizingNode; 35import org.graalvm.compiler.nodes.FixedNode; 36import org.graalvm.compiler.nodes.IfNode; 37import org.graalvm.compiler.nodes.PiNode; 38import org.graalvm.compiler.nodes.calc.AddNode; 39import org.graalvm.compiler.nodes.calc.AndNode; 40import org.graalvm.compiler.nodes.calc.FloatConvertNode; 41import org.graalvm.compiler.nodes.calc.FloatEqualsNode; 42import org.graalvm.compiler.nodes.calc.FloatLessThanNode; 43import org.graalvm.compiler.nodes.calc.IntegerBelowNode; 44import org.graalvm.compiler.nodes.calc.IntegerEqualsNode; 45import org.graalvm.compiler.nodes.calc.IntegerLessThanNode; 46import org.graalvm.compiler.nodes.calc.IntegerTestNode; 47import org.graalvm.compiler.nodes.calc.LeftShiftNode; 48import org.graalvm.compiler.nodes.calc.MulNode; 49import org.graalvm.compiler.nodes.calc.NarrowNode; 50import org.graalvm.compiler.nodes.calc.ObjectEqualsNode; 51import org.graalvm.compiler.nodes.calc.OrNode; 52import org.graalvm.compiler.nodes.calc.PointerEqualsNode; 53import org.graalvm.compiler.nodes.calc.ReinterpretNode; 54import org.graalvm.compiler.nodes.calc.SignExtendNode; 55import org.graalvm.compiler.nodes.calc.SubNode; 56import org.graalvm.compiler.nodes.calc.UnsignedRightShiftNode; 57import org.graalvm.compiler.nodes.calc.XorNode; 58import org.graalvm.compiler.nodes.calc.ZeroExtendNode; 59import org.graalvm.compiler.nodes.java.LogicCompareAndSwapNode; 60import org.graalvm.compiler.nodes.java.ValueCompareAndSwapNode; 61import org.graalvm.compiler.nodes.memory.FloatingReadNode; 62import org.graalvm.compiler.nodes.memory.ReadNode; 63import org.graalvm.compiler.nodes.memory.WriteNode; 64 65@MatchableNode(nodeClass = ConstantNode.class, shareable = true) 66@MatchableNode(nodeClass = FloatConvertNode.class, inputs = {"value"}) 67@MatchableNode(nodeClass = FloatingReadNode.class, inputs = {"address"}) 68@MatchableNode(nodeClass = IfNode.class, inputs = {"condition"}) 69@MatchableNode(nodeClass = SubNode.class, inputs = {"x", "y"}) 70@MatchableNode(nodeClass = LeftShiftNode.class, inputs = {"x", "y"}) 71@MatchableNode(nodeClass = NarrowNode.class, inputs = {"value"}) 72@MatchableNode(nodeClass = ReadNode.class, inputs = {"address"}) 73@MatchableNode(nodeClass = ReinterpretNode.class, inputs = {"value"}) 74@MatchableNode(nodeClass = SignExtendNode.class, inputs = {"value"}) 75@MatchableNode(nodeClass = UnsignedRightShiftNode.class, inputs = {"x", "y"}) 76@MatchableNode(nodeClass = WriteNode.class, inputs = {"address", "value"}) 77@MatchableNode(nodeClass = ZeroExtendNode.class, inputs = {"value"}) 78@MatchableNode(nodeClass = AndNode.class, inputs = {"x", "y"}, commutative = true) 79@MatchableNode(nodeClass = FloatEqualsNode.class, inputs = {"x", "y"}, commutative = true) 80@MatchableNode(nodeClass = FloatLessThanNode.class, inputs = {"x", "y"}, commutative = true) 81@MatchableNode(nodeClass = PointerEqualsNode.class, inputs = {"x", "y"}, commutative = true) 82@MatchableNode(nodeClass = AddNode.class, inputs = {"x", "y"}, commutative = true) 83@MatchableNode(nodeClass = IntegerBelowNode.class, inputs = {"x", "y"}, commutative = true) 84@MatchableNode(nodeClass = IntegerEqualsNode.class, inputs = {"x", "y"}, commutative = true) 85@MatchableNode(nodeClass = IntegerLessThanNode.class, inputs = {"x", "y"}, commutative = true) 86@MatchableNode(nodeClass = MulNode.class, inputs = {"x", "y"}, commutative = true) 87@MatchableNode(nodeClass = IntegerTestNode.class, inputs = {"x", "y"}, commutative = true) 88@MatchableNode(nodeClass = ObjectEqualsNode.class, inputs = {"x", "y"}, commutative = true) 89@MatchableNode(nodeClass = OrNode.class, inputs = {"x", "y"}, commutative = true) 90@MatchableNode(nodeClass = XorNode.class, inputs = {"x", "y"}, commutative = true) 91@MatchableNode(nodeClass = PiNode.class, inputs = {"object"}) 92@MatchableNode(nodeClass = LogicCompareAndSwapNode.class, inputs = {"address", "expectedValue", "newValue"}) 93@MatchableNode(nodeClass = ValueCompareAndSwapNode.class, inputs = {"address", "expectedValue", "newValue"}) 94public abstract class NodeMatchRules { 95 96 NodeLIRBuilder lirBuilder; 97 protected final LIRGeneratorTool gen; 98 99 protected NodeMatchRules(LIRGeneratorTool gen) { 100 this.gen = gen; 101 } 102 103 protected LIRGeneratorTool getLIRGeneratorTool() { 104 return gen; 105 } 106 107 /* 108 * For now we do not want to expose the full lirBuilder to subclasses, so we delegate the few 109 * methods that are actually needed. If the list grows too long, exposing lirBuilder might be 110 * the better approach. 111 */ 112 113 protected final Value operand(Node node) { 114 return lirBuilder.operand(node); 115 } 116 117 protected final LIRFrameState state(DeoptimizingNode deopt) { 118 return lirBuilder.state(deopt); 119 } 120 121 protected final LabelRef getLIRBlock(FixedNode b) { 122 return lirBuilder.getLIRBlock(b); 123 } 124 125 protected final void append(LIRInstruction op) { 126 lirBuilder.append(op); 127 } 128} 129