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 package org.graalvm.compiler.virtual.phases.ea;
24
25 import static org.graalvm.compiler.core.common.GraalOptions.MaximumEscapeAnalysisArrayLength;
26
27 import java.util.List;
28
29 import org.graalvm.compiler.core.common.spi.ConstantFieldProvider;
30 import org.graalvm.compiler.graph.Node;
31 import org.graalvm.compiler.graph.spi.CanonicalizerTool;
32 import org.graalvm.compiler.nodes.FixedNode;
33 import org.graalvm.compiler.nodes.FixedWithNextNode;
34 import org.graalvm.compiler.nodes.ValueNode;
35 import org.graalvm.compiler.nodes.calc.FloatingNode;
36 import org.graalvm.compiler.nodes.java.MonitorIdNode;
37 import org.graalvm.compiler.nodes.spi.LoweringProvider;
38 import org.graalvm.compiler.nodes.spi.VirtualizerTool;
39 import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
40 import org.graalvm.compiler.options.OptionValues;
41
42 import jdk.vm.ci.meta.Assumptions;
43 import jdk.vm.ci.meta.ConstantReflectionProvider;
44 import jdk.vm.ci.meta.JavaKind;
45 import jdk.vm.ci.meta.MetaAccessProvider;
46
47 /**
48 * Forwards calls from {@link VirtualizerTool} to the actual {@link PartialEscapeBlockState}.
49 */
50 class VirtualizerToolImpl implements VirtualizerTool, CanonicalizerTool {
51
52 private final MetaAccessProvider metaAccess;
53 private final ConstantReflectionProvider constantReflection;
54 private final ConstantFieldProvider constantFieldProvider;
55 private final PartialEscapeClosure<?> closure;
56 private final Assumptions assumptions;
57 private final OptionValues options;
58 private final LoweringProvider loweringProvider;
59
60 VirtualizerToolImpl(MetaAccessProvider metaAccess, ConstantReflectionProvider constantReflection, ConstantFieldProvider constantFieldProvider, PartialEscapeClosure<?> closure,
61 Assumptions assumptions, OptionValues options, LoweringProvider loweringProvider) {
62 this.metaAccess = metaAccess;
63 this.constantReflection = constantReflection;
64 this.constantFieldProvider = constantFieldProvider;
65 this.closure = closure;
66 this.assumptions = assumptions;
67 this.options = options;
68 this.loweringProvider = loweringProvider;
69 }
70
71 private boolean deleted;
72 private PartialEscapeBlockState<?> state;
73 private ValueNode current;
74 private FixedNode position;
75 private GraphEffectList effects;
76
77 @Override
78 public OptionValues getOptions() {
79 return options;
80 }
81
82 @Override
83 public MetaAccessProvider getMetaAccessProvider() {
84 return metaAccess;
85 }
86
87 @Override
88 public ConstantReflectionProvider getConstantReflectionProvider() {
89 return constantReflection;
90 }
91
92 @Override
93 public ConstantFieldProvider getConstantFieldProvider() {
94 return constantFieldProvider;
95 }
96
97 public void reset(PartialEscapeBlockState<?> newState, ValueNode newCurrent, FixedNode newPosition, GraphEffectList newEffects) {
98 deleted = false;
99 state = newState;
100 current = newCurrent;
101 position = newPosition;
102 effects = newEffects;
164 effects.deleteNode(current);
165 deleted = true;
166 }
167
168 @Override
169 public void replaceFirstInput(Node oldInput, Node replacement) {
170 effects.replaceFirstInput(current, oldInput, replacement);
171 }
172
173 @Override
174 public void addNode(ValueNode node) {
175 if (node instanceof FloatingNode) {
176 effects.addFloatingNode(node, "VirtualizerTool");
177 } else {
178 effects.addFixedNodeBefore((FixedWithNextNode) node, position);
179 }
180 }
181
182 @Override
183 public void createVirtualObject(VirtualObjectNode virtualObject, ValueNode[] entryState, List<MonitorIdNode> locks, boolean ensureVirtualized) {
184 VirtualUtil.trace(options, "{{%s}} ", current);
185 if (!virtualObject.isAlive()) {
186 effects.addFloatingNode(virtualObject, "newVirtualObject");
187 }
188 for (int i = 0; i < entryState.length; i++) {
189 ValueNode entry = entryState[i];
190 entryState[i] = entry instanceof VirtualObjectNode ? entry : closure.getAliasAndResolve(state, entry);
191 }
192 int id = virtualObject.getObjectId();
193 if (id == -1) {
194 id = closure.virtualObjects.size();
195 closure.virtualObjects.add(virtualObject);
196 virtualObject.setObjectId(id);
197 }
198 state.addObject(id, new ObjectState(entryState, locks, ensureVirtualized));
199 closure.addVirtualAlias(virtualObject, virtualObject);
200 PartialEscapeClosure.COUNTER_ALLOCATION_REMOVED.increment();
201 effects.addVirtualizationDelta(1);
202 }
203
204 @Override
205 public int getMaximumEntryCount() {
206 return MaximumEscapeAnalysisArrayLength.getValue(current.getOptions());
207 }
208
209 @Override
210 public void replaceWith(ValueNode node) {
211 if (node instanceof VirtualObjectNode) {
212 replaceWithVirtual((VirtualObjectNode) node);
213 } else {
214 replaceWithValue(node);
215 }
216 }
217
218 @Override
219 public boolean ensureMaterialized(VirtualObjectNode virtualObject) {
220 return closure.ensureMaterialized(state, virtualObject.getObjectId(), position, effects, PartialEscapeClosure.COUNTER_MATERIALIZATIONS_UNHANDLED);
|
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 package org.graalvm.compiler.virtual.phases.ea;
24
25 import static org.graalvm.compiler.core.common.GraalOptions.MaximumEscapeAnalysisArrayLength;
26
27 import java.util.List;
28
29 import org.graalvm.compiler.core.common.spi.ConstantFieldProvider;
30 import org.graalvm.compiler.debug.DebugContext;
31 import org.graalvm.compiler.graph.Node;
32 import org.graalvm.compiler.graph.spi.CanonicalizerTool;
33 import org.graalvm.compiler.nodes.FixedNode;
34 import org.graalvm.compiler.nodes.FixedWithNextNode;
35 import org.graalvm.compiler.nodes.ValueNode;
36 import org.graalvm.compiler.nodes.calc.FloatingNode;
37 import org.graalvm.compiler.nodes.java.MonitorIdNode;
38 import org.graalvm.compiler.nodes.spi.LoweringProvider;
39 import org.graalvm.compiler.nodes.spi.VirtualizerTool;
40 import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
41 import org.graalvm.compiler.options.OptionValues;
42
43 import jdk.vm.ci.meta.Assumptions;
44 import jdk.vm.ci.meta.ConstantReflectionProvider;
45 import jdk.vm.ci.meta.JavaKind;
46 import jdk.vm.ci.meta.MetaAccessProvider;
47
48 /**
49 * Forwards calls from {@link VirtualizerTool} to the actual {@link PartialEscapeBlockState}.
50 */
51 class VirtualizerToolImpl implements VirtualizerTool, CanonicalizerTool {
52
53 private final MetaAccessProvider metaAccess;
54 private final ConstantReflectionProvider constantReflection;
55 private final ConstantFieldProvider constantFieldProvider;
56 private final PartialEscapeClosure<?> closure;
57 private final Assumptions assumptions;
58 private final OptionValues options;
59 private final DebugContext debug;
60 private final LoweringProvider loweringProvider;
61
62 VirtualizerToolImpl(MetaAccessProvider metaAccess, ConstantReflectionProvider constantReflection, ConstantFieldProvider constantFieldProvider, PartialEscapeClosure<?> closure,
63 Assumptions assumptions, OptionValues options, DebugContext debug, LoweringProvider loweringProvider) {
64 this.metaAccess = metaAccess;
65 this.constantReflection = constantReflection;
66 this.constantFieldProvider = constantFieldProvider;
67 this.closure = closure;
68 this.assumptions = assumptions;
69 this.options = options;
70 this.debug = debug;
71 this.loweringProvider = loweringProvider;
72 }
73
74 private boolean deleted;
75 private PartialEscapeBlockState<?> state;
76 private ValueNode current;
77 private FixedNode position;
78 private GraphEffectList effects;
79
80 @Override
81 public OptionValues getOptions() {
82 return options;
83 }
84
85 @Override
86 public DebugContext getDebug() {
87 return debug;
88 }
89
90 @Override
91 public MetaAccessProvider getMetaAccessProvider() {
92 return metaAccess;
93 }
94
95 @Override
96 public ConstantReflectionProvider getConstantReflectionProvider() {
97 return constantReflection;
98 }
99
100 @Override
101 public ConstantFieldProvider getConstantFieldProvider() {
102 return constantFieldProvider;
103 }
104
105 public void reset(PartialEscapeBlockState<?> newState, ValueNode newCurrent, FixedNode newPosition, GraphEffectList newEffects) {
106 deleted = false;
107 state = newState;
108 current = newCurrent;
109 position = newPosition;
110 effects = newEffects;
172 effects.deleteNode(current);
173 deleted = true;
174 }
175
176 @Override
177 public void replaceFirstInput(Node oldInput, Node replacement) {
178 effects.replaceFirstInput(current, oldInput, replacement);
179 }
180
181 @Override
182 public void addNode(ValueNode node) {
183 if (node instanceof FloatingNode) {
184 effects.addFloatingNode(node, "VirtualizerTool");
185 } else {
186 effects.addFixedNodeBefore((FixedWithNextNode) node, position);
187 }
188 }
189
190 @Override
191 public void createVirtualObject(VirtualObjectNode virtualObject, ValueNode[] entryState, List<MonitorIdNode> locks, boolean ensureVirtualized) {
192 VirtualUtil.trace(options, debug, "{{%s}} ", current);
193 if (!virtualObject.isAlive()) {
194 effects.addFloatingNode(virtualObject, "newVirtualObject");
195 }
196 for (int i = 0; i < entryState.length; i++) {
197 ValueNode entry = entryState[i];
198 entryState[i] = entry instanceof VirtualObjectNode ? entry : closure.getAliasAndResolve(state, entry);
199 }
200 int id = virtualObject.getObjectId();
201 if (id == -1) {
202 id = closure.virtualObjects.size();
203 closure.virtualObjects.add(virtualObject);
204 virtualObject.setObjectId(id);
205 }
206 state.addObject(id, new ObjectState(entryState, locks, ensureVirtualized));
207 closure.addVirtualAlias(virtualObject, virtualObject);
208 PartialEscapeClosure.COUNTER_ALLOCATION_REMOVED.increment(debug);
209 effects.addVirtualizationDelta(1);
210 }
211
212 @Override
213 public int getMaximumEntryCount() {
214 return MaximumEscapeAnalysisArrayLength.getValue(current.getOptions());
215 }
216
217 @Override
218 public void replaceWith(ValueNode node) {
219 if (node instanceof VirtualObjectNode) {
220 replaceWithVirtual((VirtualObjectNode) node);
221 } else {
222 replaceWithValue(node);
223 }
224 }
225
226 @Override
227 public boolean ensureMaterialized(VirtualObjectNode virtualObject) {
228 return closure.ensureMaterialized(state, virtualObject.getObjectId(), position, effects, PartialEscapeClosure.COUNTER_MATERIALIZATIONS_UNHANDLED);
|