1 /*
2 * Copyright (c) 2011, 2016, 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 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
41 import jdk.vm.ci.meta.Assumptions;
42 import jdk.vm.ci.meta.ConstantReflectionProvider;
43 import jdk.vm.ci.meta.JavaKind;
44 import jdk.vm.ci.meta.MetaAccessProvider;
45
46 class VirtualizerToolImpl implements VirtualizerTool, CanonicalizerTool {
47
48 private final MetaAccessProvider metaAccess;
49 private final ConstantReflectionProvider constantReflection;
50 private final ConstantFieldProvider constantFieldProvider;
51 private final PartialEscapeClosure<?> closure;
52 private final Assumptions assumptions;
53 private final LoweringProvider loweringProvider;
54
55 VirtualizerToolImpl(MetaAccessProvider metaAccess, ConstantReflectionProvider constantReflection, ConstantFieldProvider constantFieldProvider, PartialEscapeClosure<?> closure,
56 Assumptions assumptions, LoweringProvider loweringProvider) {
57 this.metaAccess = metaAccess;
58 this.constantReflection = constantReflection;
59 this.constantFieldProvider = constantFieldProvider;
60 this.closure = closure;
61 this.assumptions = assumptions;
62 this.loweringProvider = loweringProvider;
63 }
64
65 private boolean deleted;
66 private PartialEscapeBlockState<?> state;
67 private ValueNode current;
68 private FixedNode position;
69 private GraphEffectList effects;
70
71 @Override
72 public MetaAccessProvider getMetaAccessProvider() {
73 return metaAccess;
74 }
75
76 @Override
77 public ConstantReflectionProvider getConstantReflectionProvider() {
78 return constantReflection;
79 }
80
81 @Override
82 public ConstantFieldProvider getConstantFieldProvider() {
83 return constantFieldProvider;
84 }
85
86 public void reset(PartialEscapeBlockState<?> newState, ValueNode newCurrent, FixedNode newPosition, GraphEffectList newEffects) {
87 deleted = false;
88 state = newState;
89 current = newCurrent;
90 position = newPosition;
91 effects = newEffects;
92 }
93
94 public boolean isDeleted() {
95 return deleted;
96 }
97
98 @Override
99 public ValueNode getAlias(ValueNode value) {
100 return closure.getAliasAndResolve(state, value);
101 }
102
103 @Override
104 public ValueNode getEntry(VirtualObjectNode virtualObject, int index) {
105 return state.getObjectState(virtualObject).getEntry(index);
106 }
107
108 @Override
109 public void setVirtualEntry(VirtualObjectNode virtual, int index, ValueNode value, boolean unsafe) {
110 ObjectState obj = state.getObjectState(virtual);
111 assert obj.isVirtual() : "not virtual: " + obj;
112 ValueNode newValue;
113 if (value == null) {
114 newValue = null;
115 } else {
116 newValue = closure.getAliasAndResolve(state, value);
117 assert unsafe || obj.getEntry(index) == null || obj.getEntry(index).getStackKind() == newValue.getStackKind() || (isObjectEntry(obj.getEntry(index)) && isObjectEntry(newValue));
118 }
119 state.setEntry(virtual.getObjectId(), index, newValue);
120 }
121
122 @Override
123 public void setEnsureVirtualized(VirtualObjectNode virtualObject, boolean ensureVirtualized) {
124 int id = virtualObject.getObjectId();
125 state.setEnsureVirtualized(id, ensureVirtualized);
126 }
127
128 @Override
129 public boolean getEnsureVirtualized(VirtualObjectNode virtualObject) {
130 return state.getObjectState(virtualObject).getEnsureVirtualized();
131 }
132
133 private static boolean isObjectEntry(ValueNode value) {
134 return value.getStackKind() == JavaKind.Object || value instanceof VirtualObjectNode;
135 }
136
137 @Override
138 public void replaceWithVirtual(VirtualObjectNode virtual) {
139 closure.addAndMarkAlias(virtual, current);
140 effects.deleteNode(current);
141 deleted = true;
142 }
143
144 @Override
145 public void replaceWithValue(ValueNode replacement) {
146 effects.replaceAtUsages(current, closure.getScalarAlias(replacement));
147 closure.addScalarAlias(current, replacement);
148 deleted = true;
149 }
150
151 @Override
152 public void delete() {
153 effects.deleteNode(current);
154 deleted = true;
155 }
156
157 @Override
158 public void replaceFirstInput(Node oldInput, Node replacement) {
159 effects.replaceFirstInput(current, oldInput, replacement);
160 }
161
162 @Override
163 public void addNode(ValueNode node) {
164 if (node instanceof FloatingNode) {
165 effects.addFloatingNode(node, "VirtualizerTool");
166 } else {
167 effects.addFixedNodeBefore((FixedWithNextNode) node, position);
168 }
169 }
170
171 @Override
172 public void createVirtualObject(VirtualObjectNode virtualObject, ValueNode[] entryState, List<MonitorIdNode> locks, boolean ensureVirtualized) {
173 VirtualUtil.trace("{{%s}} ", current);
174 if (!virtualObject.isAlive()) {
175 effects.addFloatingNode(virtualObject, "newVirtualObject");
176 }
177 for (int i = 0; i < entryState.length; i++) {
178 ValueNode entry = entryState[i];
179 entryState[i] = entry instanceof VirtualObjectNode ? entry : closure.getAliasAndResolve(state, entry);
180 }
181 int id = virtualObject.getObjectId();
182 if (id == -1) {
183 id = closure.virtualObjects.size();
184 closure.virtualObjects.add(virtualObject);
185 virtualObject.setObjectId(id);
186 }
187 state.addObject(id, new ObjectState(entryState, locks, ensureVirtualized));
188 closure.addAndMarkAlias(virtualObject, virtualObject);
189 PartialEscapeClosure.COUNTER_ALLOCATION_REMOVED.increment();
190 }
191
192 @Override
193 public int getMaximumEntryCount() {
194 return MaximumEscapeAnalysisArrayLength.getValue();
195 }
196
197 @Override
198 public void replaceWith(ValueNode node) {
199 if (node instanceof VirtualObjectNode) {
200 replaceWithVirtual((VirtualObjectNode) node);
201 } else {
202 replaceWithValue(node);
203 }
204 }
205
206 @Override
207 public boolean ensureMaterialized(VirtualObjectNode virtualObject) {
208 return closure.ensureMaterialized(state, virtualObject.getObjectId(), position, effects, PartialEscapeClosure.COUNTER_MATERIALIZATIONS_UNHANDLED);
209 }
210
211 @Override
212 public void addLock(VirtualObjectNode virtualObject, MonitorIdNode monitorId) {
213 int id = virtualObject.getObjectId();
214 state.addLock(id, monitorId);
215 }
216
217 @Override
218 public MonitorIdNode removeLock(VirtualObjectNode virtualObject) {
219 int id = virtualObject.getObjectId();
220 return state.removeLock(id);
221 }
222
223 @Override
224 public MetaAccessProvider getMetaAccess() {
225 return metaAccess;
226 }
227
228 @Override
229 public ConstantReflectionProvider getConstantReflection() {
230 return constantReflection;
231 }
232
233 @Override
234 public boolean canonicalizeReads() {
235 return false;
236 }
237
238 @Override
239 public boolean allUsagesAvailable() {
240 return true;
241 }
242
243 @Override
244 public Assumptions getAssumptions() {
245 return assumptions;
246 }
247
248 @Override
249 public boolean supportSubwordCompare(int bits) {
250 if (loweringProvider != null) {
251 return loweringProvider.supportSubwordCompare(bits);
252 } else {
253 return false;
254 }
255 }
256 }