1 /*
2 * Copyright (c) 2011, 2012, 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 com.oracle.graal.hotspot;
24
25 import static com.oracle.graal.graph.UnsafeAccess.*;
26
27 import java.lang.reflect.*;
28 import java.util.*;
29
30 import com.oracle.graal.api.code.*;
31 import com.oracle.graal.api.meta.*;
32 import com.oracle.graal.api.runtime.*;
33 import com.oracle.graal.compiler.target.*;
34 import com.oracle.graal.hotspot.bridge.*;
35 import com.oracle.graal.hotspot.logging.*;
36 import com.oracle.graal.hotspot.meta.*;
37 import com.oracle.graal.nodes.spi.*;
38 import com.oracle.graal.phases.*;
39
40 /**
41 * Singleton class holding the instance of the {@link GraalRuntime}.
42 *
43 * The platform specific subclass is created by a call from the C++ HotSpot code.
44 */
45 public abstract class HotSpotGraalRuntime implements GraalRuntime {
46
47 private static HotSpotGraalRuntime instance;
48
49 /**
50 * Gets the singleton runtime instance object.
51 */
52 public static HotSpotGraalRuntime getInstance() {
53 return instance;
54 }
55
56 /**
57 * Called by the platform specific class exactly once to register the singleton instance.
58 */
59 protected static void setInstance(HotSpotGraalRuntime runtime) {
60 assert instance == null : "runtime already registered";
61 instance = runtime;
62
63 // Do deferred initialization
64
65 // Proxies for the VM/Compiler interfaces cannot be initialized
66 // in the constructor as proxy creation causes static
67 // initializers to be executed for all the types involved in the
68 // proxied methods. Some of these static initializers (e.g. in
69 // HotSpotMethodData) rely on the above instance field being set
70 // to retrieve config details.
71 VMToCompiler toCompiler = runtime.vmToCompiler;
72 CompilerToVM toVM = runtime.compilerToVm;
73
74 if (CountingProxy.ENABLED) {
75 toCompiler = CountingProxy.getProxy(VMToCompiler.class, toCompiler);
76 toVM = CountingProxy.getProxy(CompilerToVM.class, toVM);
77 }
78 if (Logger.ENABLED) {
79 toCompiler = LoggingProxy.getProxy(VMToCompiler.class, toCompiler);
80 toVM = LoggingProxy.getProxy(CompilerToVM.class, toVM);
81 }
82
83 runtime.vmToCompiler = toCompiler;
84 runtime.compilerToVm = toVM;
85 }
86
87 private static Kind wordKind;
88
89 /**
90 * Gets the kind of a word value.
91 */
92 public static Kind wordKind() {
93 assert wordKind != null;
94 return wordKind;
95 }
96
97 /**
98 * Reads a word value from a given address.
99 */
100 public static long unsafeReadWord(long address) {
101 if (wordKind == Kind.Long) {
102 return unsafe.getLong(address);
103 }
104 return unsafe.getInt(address);
105 }
106
107 /**
108 * Reads a word value from a given object.
109 */
110 public static long unsafeReadWord(Object object, long offset) {
111 if (wordKind == Kind.Long) {
112 return unsafe.getLong(object, offset);
113 }
114 return unsafe.getInt(object, offset);
115 }
116
117 protected/* final */CompilerToVM compilerToVm;
118 protected/* final */VMToCompiler vmToCompiler;
119
120 protected final HotSpotRuntime runtime;
121 protected final TargetDescription target;
122 protected final Replacements replacements;
123
124 private HotSpotRuntimeInterpreterInterface runtimeInterpreterInterface;
125 private volatile HotSpotGraphCache cache;
126
127 protected final HotSpotVMConfig config;
128 private final HotSpotBackend backend;
129
130 protected HotSpotGraalRuntime() {
131 CompilerToVM toVM = new CompilerToVMImpl();
132
133 // initialize VmToCompiler
134 VMToCompiler toCompiler = new VMToCompilerImpl(this);
135
136 compilerToVm = toVM;
137 vmToCompiler = toCompiler;
138 config = new HotSpotVMConfig();
139 compilerToVm.initializeConfiguration(config);
140 config.check();
141
142 // Set some global options:
143 GraalOptions.HotSpotPrintCompilation = config.printCompilation;
144 GraalOptions.HotSpotPrintInlining = config.printInlining;
145
146 if (Boolean.valueOf(System.getProperty("graal.printconfig"))) {
147 printConfig(config);
148 }
149
150 target = createTarget();
151 assert wordKind == null || wordKind.equals(target.wordKind);
152 wordKind = target.wordKind;
153
154 runtime = createRuntime();
155
156 // Replacements cannot have speculative optimizations since they have
157 // to be valid for the entire run of the VM.
158 Assumptions assumptions = new Assumptions(false);
159 replacements = new HotSpotReplacementsImpl(runtime, assumptions, runtime.getGraalRuntime().getTarget());
160
161 backend = createBackend();
162 GraalOptions.StackShadowPages = config.stackShadowPages;
163 if (GraalOptions.CacheGraphs) {
164 cache = new HotSpotGraphCache();
165 }
166 }
167
168 private static void printConfig(HotSpotVMConfig config) {
169 Field[] fields = config.getClass().getDeclaredFields();
170 Map<String, Field> sortedFields = new TreeMap<>();
171 for (Field f : fields) {
172 f.setAccessible(true);
173 sortedFields.put(f.getName(), f);
174 }
175 for (Field f : sortedFields.values()) {
176 try {
177 Logger.info(String.format("%9s %-40s = %s", f.getType().getSimpleName(), f.getName(), Logger.pretty(f.get(config))));
178 } catch (Exception e) {
179 }
180 }
181 }
182
183 protected abstract TargetDescription createTarget();
184
185 protected abstract HotSpotBackend createBackend();
186
187 protected abstract HotSpotRuntime createRuntime();
188
189 public HotSpotVMConfig getConfig() {
190 return config;
191 }
192
193 public TargetDescription getTarget() {
194 return target;
195 }
196
197 public HotSpotGraphCache getCache() {
198 return cache;
199 }
200
201 public CompilerToVM getCompilerToVM() {
202 return compilerToVm;
203 }
204
205 public VMToCompiler getVMToCompiler() {
206 return vmToCompiler;
207 }
208
209 public JavaType lookupType(String name, HotSpotResolvedObjectType accessingClass, boolean eagerResolve) {
210 if (name.length() == 1 && vmToCompiler instanceof VMToCompilerImpl) {
211 VMToCompilerImpl impl = (VMToCompilerImpl) vmToCompiler;
212 Kind kind = Kind.fromPrimitiveOrVoidTypeChar(name.charAt(0));
213 switch (kind) {
214 case Boolean:
215 return impl.typeBoolean;
216 case Byte:
217 return impl.typeByte;
218 case Char:
219 return impl.typeChar;
220 case Double:
221 return impl.typeDouble;
222 case Float:
223 return impl.typeFloat;
224 case Illegal:
225 break;
226 case Int:
227 return impl.typeInt;
228 case Long:
229 return impl.typeLong;
230 case Object:
231 break;
232 case Short:
233 return impl.typeShort;
234 case Void:
235 return impl.typeVoid;
236 }
237 }
238 return compilerToVm.lookupType(name, accessingClass, eagerResolve);
239 }
240
241 public HotSpotRuntimeInterpreterInterface getRuntimeInterpreterInterface() {
242 if (runtimeInterpreterInterface == null) {
243 runtimeInterpreterInterface = new HotSpotRuntimeInterpreterInterface(getRuntime());
244 }
245 return runtimeInterpreterInterface;
246 }
247
248 public HotSpotRuntime getRuntime() {
249 return runtime;
250 }
251
252 public Replacements getReplacements() {
253 return replacements;
254 }
255
256 public void evictDeoptedGraphs() {
257 if (cache != null) {
258 long[] deoptedGraphs = getCompilerToVM().getDeoptedLeafGraphIds();
259 if (deoptedGraphs != null) {
260 if (deoptedGraphs.length == 0) {
261 cache.clear();
262 } else {
263 cache.removeGraphs(deoptedGraphs);
264 }
265 }
266 }
267 }
268
269 @Override
270 public String getName() {
271 return getClass().getSimpleName();
272 }
273
274 @SuppressWarnings("unchecked")
275 @Override
276 public <T> T getCapability(Class<T> clazz) {
277 if (clazz == GraalCodeCacheProvider.class || clazz == CodeCacheProvider.class || clazz == MetaAccessProvider.class) {
278 return (T) getRuntime();
279 }
280 if (clazz == DisassemblerProvider.class || clazz == BytecodeDisassemblerProvider.class) {
281 return (T) getRuntime();
282 }
283 if (clazz == HotSpotRuntime.class) {
284 return (T) runtime;
285 }
286 if (clazz == Replacements.class) {
287 return (T) replacements;
288 }
289 if (clazz == Backend.class) {
290 return (T) getBackend();
291 }
292 return null;
293 }
294
295 public HotSpotBackend getBackend() {
296 return backend;
297 }
298 }