1 /*
2 * Copyright (c) 2013, 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 jdk.vm.ci.hotspot;
24
25 import java.util.Map;
26
27 import jdk.vm.ci.code.BailoutException;
28 import jdk.vm.ci.code.BytecodeFrame;
29 import jdk.vm.ci.code.CodeCacheProvider;
30 import jdk.vm.ci.code.CompiledCode;
31 import jdk.vm.ci.code.InstalledCode;
32 import jdk.vm.ci.code.RegisterConfig;
33 import jdk.vm.ci.code.TargetDescription;
34 import jdk.vm.ci.code.site.Call;
35 import jdk.vm.ci.code.site.Mark;
36 import jdk.vm.ci.meta.ResolvedJavaMethod;
37 import jdk.vm.ci.meta.SpeculationLog;
38
39 /**
40 * HotSpot implementation of {@link CodeCacheProvider}.
41 */
42 public class HotSpotCodeCacheProvider implements CodeCacheProvider {
43
44 protected final HotSpotJVMCIRuntimeProvider runtime;
45 protected final HotSpotVMConfig config;
46 protected final TargetDescription target;
47 protected final RegisterConfig regConfig;
48
49 public HotSpotCodeCacheProvider(HotSpotJVMCIRuntimeProvider runtime, HotSpotVMConfig config, TargetDescription target, RegisterConfig regConfig) {
50 this.runtime = runtime;
51 this.config = config;
52 this.target = target;
53 this.regConfig = regConfig;
54 }
55
56 @Override
57 public String getMarkName(Mark mark) {
58 int markId = (int) mark.id;
59 HotSpotVMConfigStore store = runtime.getConfigStore();
60 for (Map.Entry<String, Long> e : store.getConstants().entrySet()) {
61 String name = e.getKey();
62 if (name.startsWith("MARKID_") && e.getValue() == markId) {
63 return name;
64 }
65 }
66 return CodeCacheProvider.super.getMarkName(mark);
67 }
68
69 /**
70 * Decodes a call target to a mnemonic if possible.
71 */
72 @Override
73 public String getTargetName(Call call) {
74 if (call.target instanceof HotSpotForeignCallTarget) {
75 long address = ((HotSpotForeignCallTarget) call.target).address;
76 HotSpotVMConfigStore store = runtime.getConfigStore();
77 for (Map.Entry<String, VMField> e : store.getFields().entrySet()) {
78 VMField field = e.getValue();
79 if (field.isStatic() && field.value != null && field.value instanceof Long && ((Long) field.value) == address) {
80 return e.getValue() + ":0x" + Long.toHexString(address);
81 }
82 }
83 }
84 return CodeCacheProvider.super.getTargetName(call);
85 }
86
87 @Override
88 public RegisterConfig getRegisterConfig() {
89 return regConfig;
90 }
91
92 @Override
93 public int getMinimumOutgoingSize() {
94 return runtime.getConfig().runtimeCallStackSize;
95 }
96
97 private InstalledCode logOrDump(InstalledCode installedCode, CompiledCode compiledCode) {
98 ((HotSpotJVMCIRuntime) runtime).notifyInstall(this, installedCode, compiledCode);
99 return installedCode;
100 }
101
102 public InstalledCode installCode(ResolvedJavaMethod method, CompiledCode compiledCode, InstalledCode installedCode, SpeculationLog log, boolean isDefault) {
103 InstalledCode resultInstalledCode;
104 if (installedCode == null) {
105 if (method == null) {
106 // Must be a stub
107 resultInstalledCode = new HotSpotRuntimeStub(((HotSpotCompiledCode) compiledCode).getName());
108 } else {
109 resultInstalledCode = new HotSpotNmethod((HotSpotResolvedJavaMethod) method, ((HotSpotCompiledCode) compiledCode).getName(), isDefault);
110 }
111 } else {
112 resultInstalledCode = installedCode;
113 }
114
115 HotSpotSpeculationLog speculationLog = (log != null && log.hasSpeculations()) ? (HotSpotSpeculationLog) log : null;
116
117 int result = runtime.getCompilerToVM().installCode(target, (HotSpotCompiledCode) compiledCode, resultInstalledCode, speculationLog);
118 if (result != config.codeInstallResultOk) {
119 String resultDesc = config.getCodeInstallResultDescription(result);
120 if (compiledCode instanceof HotSpotCompiledNmethod) {
121 HotSpotCompiledNmethod compiledNmethod = (HotSpotCompiledNmethod) compiledCode;
122 String msg = compiledNmethod.getInstallationFailureMessage();
123 if (msg != null) {
124 msg = String.format("Code installation failed: %s%n%s", resultDesc, msg);
125 } else {
126 msg = String.format("Code installation failed: %s", resultDesc);
127 }
128 if (result == config.codeInstallResultDependenciesInvalid) {
129 throw new AssertionError(resultDesc + " " + msg);
130 }
131 throw new BailoutException(result != config.codeInstallResultDependenciesFailed, msg);
132 } else {
133 throw new BailoutException("Error installing %s: %s", ((HotSpotCompiledCode) compiledCode).getName(), resultDesc);
134 }
135 }
136 return logOrDump(resultInstalledCode, compiledCode);
137 }
138
139 public void invalidateInstalledCode(InstalledCode installedCode) {
140 runtime.getCompilerToVM().invalidateInstalledCode(installedCode);
141 }
142
143 @Override
144 public TargetDescription getTarget() {
145 return target;
146 }
147
148 public String disassemble(InstalledCode code) {
149 if (code.isValid()) {
150 return runtime.getCompilerToVM().disassembleCodeBlob(code);
151 }
152 return null;
153 }
154
155 public SpeculationLog createSpeculationLog() {
156 return new HotSpotSpeculationLog();
157 }
158
159 public long getMaxCallTargetOffset(long address) {
160 return runtime.getCompilerToVM().getMaxCallTargetOffset(address);
161 }
162
163 public boolean shouldDebugNonSafepoints() {
164 return runtime.getCompilerToVM().shouldDebugNonSafepoints();
165 }
166
167 public int interpreterFrameSize(BytecodeFrame pos) {
168 return runtime.getCompilerToVM().interpreterFrameSize(pos);
169 }
170
171 /**
172 * Resets all compilation statistics.
173 */
174 public void resetCompilationStatistics() {
175 runtime.getCompilerToVM().resetCompilationStatistics();
176 }
177 }