1 /*
2 * Copyright (c) 2013, 2018, 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 */
23
24
25 package org.graalvm.compiler.replacements.nodes.arithmetic;
26
27 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_2;
28 import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_2;
29
30 import org.graalvm.compiler.core.common.type.Stamp;
31 import org.graalvm.compiler.graph.NodeClass;
32 import org.graalvm.compiler.graph.spi.Simplifiable;
33 import org.graalvm.compiler.nodeinfo.NodeInfo;
34 import org.graalvm.compiler.nodes.AbstractBeginNode;
35 import org.graalvm.compiler.nodes.BeginNode;
36 import org.graalvm.compiler.nodes.ControlSplitNode;
37 import org.graalvm.compiler.nodes.DeoptimizeNode;
38 import org.graalvm.compiler.nodes.FixedNode;
39 import org.graalvm.compiler.nodes.FixedWithNextNode;
40 import org.graalvm.compiler.nodes.StructuredGraph;
41 import org.graalvm.compiler.nodes.ValueNode;
42 import org.graalvm.compiler.nodes.calc.FloatingNode;
43 import org.graalvm.compiler.nodes.spi.LIRLowerable;
44 import org.graalvm.compiler.nodes.spi.LoweringTool;
45 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
46
47 import jdk.vm.ci.meta.DeoptimizationAction;
48 import jdk.vm.ci.meta.DeoptimizationReason;
49 import jdk.vm.ci.meta.SpeculationLog;
50 import jdk.vm.ci.meta.Value;
51
52 @NodeInfo(cycles = CYCLES_2, cyclesRationale = "add+cmp", size = SIZE_2)
53 public abstract class IntegerExactArithmeticSplitNode extends ControlSplitNode implements Simplifiable, LIRLowerable {
54 public static final NodeClass<IntegerExactArithmeticSplitNode> TYPE = NodeClass.create(IntegerExactArithmeticSplitNode.class);
55
56 @Successor AbstractBeginNode next;
57 @Successor AbstractBeginNode overflowSuccessor;
58 @Input ValueNode x;
59 @Input ValueNode y;
60
61 protected IntegerExactArithmeticSplitNode(NodeClass<? extends IntegerExactArithmeticSplitNode> c, Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next,
62 AbstractBeginNode overflowSuccessor) {
63 super(c, stamp);
64 this.x = x;
65 this.y = y;
66 this.overflowSuccessor = overflowSuccessor;
67 this.next = next;
68 }
69
70 @Override
71 public AbstractBeginNode getPrimarySuccessor() {
72 return next;
73 }
74
75 @Override
76 public double probability(AbstractBeginNode successor) {
77 return successor == next ? 1 : 0;
78 }
79
80 @Override
81 public boolean setProbability(AbstractBeginNode successor, double value) {
82 // Successor probabilities for arithmetic split nodes are fixed.
83 return false;
84 }
85
86 public AbstractBeginNode getNext() {
87 return next;
88 }
89
90 public AbstractBeginNode getOverflowSuccessor() {
91 return overflowSuccessor;
92 }
93
94 public void setNext(AbstractBeginNode next) {
95 updatePredecessor(this.next, next);
96 this.next = next;
97 }
98
99 public void setOverflowSuccessor(AbstractBeginNode overflowSuccessor) {
100 updatePredecessor(this.overflowSuccessor, overflowSuccessor);
101 this.overflowSuccessor = overflowSuccessor;
102 }
103
104 public ValueNode getX() {
105 return x;
106 }
107
108 public ValueNode getY() {
109 return y;
110 }
111
112 @Override
113 public void generate(NodeLIRBuilderTool generator) {
114 generator.setResult(this, generateArithmetic(generator));
115 generator.emitOverflowCheckBranch(getOverflowSuccessor(), getNext(), stamp, probability(getOverflowSuccessor()));
116 }
117
118 protected abstract Value generateArithmetic(NodeLIRBuilderTool generator);
119
120 static void lower(LoweringTool tool, IntegerExactArithmeticNode node) {
121 if (node.asNode().graph().getGuardsStage() == StructuredGraph.GuardsStage.FIXED_DEOPTS) {
122 FloatingNode floatingNode = (FloatingNode) node;
123 FixedWithNextNode previous = tool.lastFixedNode();
124 FixedNode next = previous.next();
125 previous.setNext(null);
126 StructuredGraph graph = floatingNode.graph();
127 DeoptimizeNode deopt = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.ArithmeticException,
128 node.getSpeculation() == null ? SpeculationLog.NO_SPECULATION : graph.getSpeculationLog().speculate(node.getSpeculation())));
129 AbstractBeginNode normalBegin = graph.add(new BeginNode());
130 normalBegin.setNext(next);
131 IntegerExactArithmeticSplitNode split = node.createSplit(normalBegin, BeginNode.begin(deopt));
132 previous.setNext(split);
133 floatingNode.replaceAndDelete(split);
134 }
135 }
136
137 @Override
138 public int getSuccessorCount() {
139 return 2;
140 }
141 }