1 /*
2 * Copyright (c) 2013, 2019, 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.hotspot.aarch64;
26
27 import static java.lang.reflect.Modifier.isStatic;
28 import static jdk.vm.ci.aarch64.AArch64.lr;
29 import static jdk.vm.ci.aarch64.AArch64.r10;
30 import static jdk.vm.ci.aarch64.AArch64.sp;
31 import static jdk.vm.ci.aarch64.AArch64.zr;
32 import static jdk.vm.ci.code.ValueUtil.asRegister;
33 import static jdk.vm.ci.hotspot.aarch64.AArch64HotSpotRegisterConfig.fp;
34 import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC;
35 import static org.graalvm.compiler.core.common.GraalOptions.ZapStackOnMethodEntry;
36
37 import jdk.internal.vm.compiler.collections.EconomicSet;
38 import org.graalvm.compiler.asm.Assembler;
39 import org.graalvm.compiler.asm.BranchTargetOutOfBoundsException;
40 import org.graalvm.compiler.asm.Label;
41 import org.graalvm.compiler.asm.aarch64.AArch64Address;
42 import org.graalvm.compiler.asm.aarch64.AArch64Assembler;
43 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler;
44 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler.ScratchRegister;
45 import org.graalvm.compiler.code.CompilationResult;
46 import org.graalvm.compiler.core.aarch64.AArch64NodeMatchRules;
47 import org.graalvm.compiler.core.common.LIRKind;
48 import org.graalvm.compiler.core.common.alloc.RegisterAllocationConfig;
49 import org.graalvm.compiler.core.common.spi.ForeignCallLinkage;
50 import org.graalvm.compiler.core.gen.LIRGenerationProvider;
51 import org.graalvm.compiler.debug.DebugContext;
52 import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
53 import org.graalvm.compiler.hotspot.HotSpotDataBuilder;
54 import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider;
55 import org.graalvm.compiler.hotspot.HotSpotHostBackend;
56 import org.graalvm.compiler.hotspot.HotSpotLIRGenerationResult;
57 import org.graalvm.compiler.hotspot.meta.HotSpotConstantLoadAction;
58 import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
59 import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
60 import org.graalvm.compiler.hotspot.stubs.Stub;
61 import org.graalvm.compiler.lir.LIR;
62 import org.graalvm.compiler.lir.aarch64.AArch64Call;
63 import org.graalvm.compiler.lir.aarch64.AArch64FrameMap;
64 import org.graalvm.compiler.lir.aarch64.AArch64FrameMapBuilder;
65 import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
66 import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;
67 import org.graalvm.compiler.lir.asm.DataBuilder;
68 import org.graalvm.compiler.lir.asm.FrameContext;
69 import org.graalvm.compiler.lir.framemap.FrameMap;
70 import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
71 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
72 import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
73 import org.graalvm.compiler.nodes.StructuredGraph;
74 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
75 import org.graalvm.compiler.serviceprovider.GraalUnsafeAccess;
76
77 import jdk.vm.ci.aarch64.AArch64Kind;
78 import jdk.vm.ci.code.CallingConvention;
79 import jdk.vm.ci.code.CompilationRequest;
80 import jdk.vm.ci.code.InstalledCode;
81 import jdk.vm.ci.code.Register;
82 import jdk.vm.ci.code.RegisterConfig;
83 import jdk.vm.ci.code.StackSlot;
84 import jdk.vm.ci.code.site.Mark;
85 import jdk.vm.ci.hotspot.HotSpotCallingConventionType;
86 import jdk.vm.ci.hotspot.HotSpotSentinelConstant;
87 import jdk.vm.ci.hotspot.aarch64.AArch64HotSpotRegisterConfig;
88 import jdk.vm.ci.meta.JavaKind;
89 import jdk.vm.ci.meta.JavaType;
90 import jdk.vm.ci.meta.ResolvedJavaMethod;
91 import sun.misc.Unsafe;
92
93 /**
94 * HotSpot AArch64 specific backend.
95 */
96 public class AArch64HotSpotBackend extends HotSpotHostBackend implements LIRGenerationProvider {
97
98 public AArch64HotSpotBackend(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, HotSpotProviders providers) {
99 super(config, runtime, providers);
100 }
101
102 @Override
103 protected FrameMapBuilder newFrameMapBuilder(RegisterConfig registerConfig) {
104 RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
105 FrameMap frameMap = new AArch64FrameMap(getCodeCache(), registerConfigNonNull, this);
106 return new AArch64FrameMapBuilder(frameMap, getCodeCache(), registerConfigNonNull);
107 }
108
109 @Override
110 public LIRGeneratorTool newLIRGenerator(LIRGenerationResult lirGenRes) {
111 return new AArch64HotSpotLIRGenerator(getProviders(), config, lirGenRes);
112 }
113
114 @Override
115 public NodeLIRBuilderTool newNodeLIRBuilder(StructuredGraph graph, LIRGeneratorTool lirGen) {
116 return new AArch64HotSpotNodeLIRBuilder(graph, lirGen, new AArch64NodeMatchRules(lirGen));
117 }
118
119 @Override
120 protected void bangStackWithOffset(CompilationResultBuilder crb, int bangOffset) {
121 AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
122 try (ScratchRegister sc = masm.getScratchRegister()) {
123 Register scratch = sc.getRegister();
124 AArch64Address address = masm.makeAddress(sp, -bangOffset, scratch, 8, /* allowOverwrite */false);
125 masm.str(64, zr, address);
126 }
127 }
128
129 @Override
130 public InstalledCode createInstalledCode(DebugContext debug,
131 ResolvedJavaMethod method,
132 CompilationRequest compilationRequest,
133 CompilationResult compilationResult,
134 InstalledCode predefinedInstalledCode,
135 boolean isDefault,
136 Object[] context) {
137 boolean isStub = (method == null);
138 boolean isAOT = compilationResult.isImmutablePIC();
139 if (!isStub && !isAOT) {
140 // Non-stub compilation results are installed into HotSpot as nmethods. As AArch64 has
141 // a constraint that the instruction at nmethod verified entry point should be a nop or
142 // jump, AArch64HotSpotBackend always generate a nop placeholder before the code body
143 // for non-AOT compilations. See AArch64HotSpotBackend.emitInvalidatePlaceholder(). This
144 // assert checks if the nop placeholder is generated at all required places, including
145 // in manually assembled code in CodeGenTest cases.
146 assert hasInvalidatePlaceholder(compilationResult);
147 }
148 return super.createInstalledCode(debug, method, compilationRequest, compilationResult, predefinedInstalledCode, isDefault, context);
149 }
150
151 private boolean hasInvalidatePlaceholder(CompilationResult compilationResult) {
152 byte[] targetCode = compilationResult.getTargetCode();
153 int verifiedEntryOffset = 0;
154 for (Mark mark : compilationResult.getMarks()) {
155 Object markId = mark.id;
156 if (markId instanceof Integer && (int) markId == config.MARKID_VERIFIED_ENTRY) {
157 // The nmethod verified entry is located at some pc offset.
158 verifiedEntryOffset = mark.pcOffset;
159 break;
160 }
161 }
162 Unsafe unsafe = GraalUnsafeAccess.getUnsafe();
163 int instruction = unsafe.getIntVolatile(targetCode, unsafe.arrayBaseOffset(byte[].class) + verifiedEntryOffset);
164 AArch64MacroAssembler masm = new AArch64MacroAssembler(getTarget());
165 masm.nop();
166 return instruction == masm.getInt(0);
167 }
168
169 private class HotSpotFrameContext implements FrameContext {
170 final boolean isStub;
171
172 HotSpotFrameContext(boolean isStub) {
173 this.isStub = isStub;
174 }
175
176 @Override
177 public void enter(CompilationResultBuilder crb) {
178 FrameMap frameMap = crb.frameMap;
179 final int frameSize = frameMap.frameSize();
180 final int totalFrameSize = frameMap.totalFrameSize();
181 assert frameSize + 2 * crb.target.arch.getWordSize() == totalFrameSize : "total framesize should be framesize + 2 words";
182 AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
183 if (!isStub) {
184 emitStackOverflowCheck(crb);
185 }
186 crb.blockComment("[method prologue]");
187
188 try (ScratchRegister sc = masm.getScratchRegister()) {
189 int wordSize = crb.target.arch.getWordSize();
190 Register rscratch1 = sc.getRegister();
191 assert totalFrameSize > 0;
192 if (frameSize < 1 << 9) {
193 masm.sub(64, sp, sp, totalFrameSize);
194 masm.stp(64, fp, lr, AArch64Address.createScaledImmediateAddress(sp, frameSize / wordSize));
195 } else {
196 masm.stp(64, fp, lr, AArch64Address.createPreIndexedImmediateAddress(sp, -2));
197 if (frameSize < 1 << 12) {
198 masm.sub(64, sp, sp, totalFrameSize - 2 * wordSize);
199 } else {
200 masm.mov(rscratch1, totalFrameSize - 2 * wordSize);
201 masm.sub(64, sp, sp, rscratch1);
202 }
203 }
204 }
205 if (ZapStackOnMethodEntry.getValue(crb.getOptions())) {
206 try (ScratchRegister sc = masm.getScratchRegister()) {
207 Register scratch = sc.getRegister();
208 int longSize = 8;
209 masm.mov(64, scratch, sp);
210 AArch64Address address = AArch64Address.createPostIndexedImmediateAddress(scratch, longSize);
211 try (ScratchRegister sc2 = masm.getScratchRegister()) {
212 Register value = sc2.getRegister();
213 masm.mov(value, 0xBADDECAFFC0FFEEL);
214 for (int i = 0; i < frameSize; i += longSize) {
215 masm.str(64, value, address);
216 }
217 }
218
219 }
220 }
221 crb.blockComment("[code body]");
222 }
223
224 @Override
225 public void leave(CompilationResultBuilder crb) {
226 AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
227 FrameMap frameMap = crb.frameMap;
228 final int totalFrameSize = frameMap.totalFrameSize();
229
230 crb.blockComment("[method epilogue]");
231 try (ScratchRegister sc = masm.getScratchRegister()) {
232 int wordSize = crb.target.arch.getWordSize();
233 Register rscratch1 = sc.getRegister();
234 final int frameSize = frameMap.frameSize();
235 assert totalFrameSize > 0;
236 if (frameSize < 1 << 9) {
237 masm.ldp(64, fp, lr, AArch64Address.createScaledImmediateAddress(sp, frameSize / wordSize));
238 masm.add(64, sp, sp, totalFrameSize);
239 } else {
240 if (frameSize < 1 << 12) {
241 masm.add(64, sp, sp, totalFrameSize - 2 * wordSize);
242 } else {
243 masm.mov(rscratch1, totalFrameSize - 2 * wordSize);
244 masm.add(64, sp, sp, rscratch1);
245 }
246 masm.ldp(64, fp, lr, AArch64Address.createPostIndexedImmediateAddress(sp, 2));
247 }
248 }
249
250 }
251
252 @Override
253 public boolean hasFrame() {
254 return true;
255 }
256
257 }
258
259 @Override
260 public CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult lirGenRen, FrameMap frameMap, CompilationResult compilationResult, CompilationResultBuilderFactory factory) {
261 HotSpotLIRGenerationResult gen = (HotSpotLIRGenerationResult) lirGenRen;
262 LIR lir = gen.getLIR();
263 assert gen.getDeoptimizationRescueSlot() == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame";
264
265 Stub stub = gen.getStub();
266 Assembler masm = new AArch64MacroAssembler(getTarget());
267 HotSpotFrameContext frameContext = new HotSpotFrameContext(stub != null);
268
269 DataBuilder dataBuilder = new HotSpotDataBuilder(getCodeCache().getTarget());
270 CompilationResultBuilder crb = factory.createBuilder(getCodeCache(), getForeignCalls(), frameMap, masm, dataBuilder, frameContext, lir.getOptions(), lir.getDebug(), compilationResult,
271 Register.None);
272 crb.setTotalFrameSize(frameMap.totalFrameSize());
273 crb.setMaxInterpreterFrameSize(gen.getMaxInterpreterFrameSize());
274 StackSlot deoptimizationRescueSlot = gen.getDeoptimizationRescueSlot();
275 if (deoptimizationRescueSlot != null && stub == null) {
276 crb.compilationResult.setCustomStackAreaOffset(deoptimizationRescueSlot);
277 }
278
279 if (stub != null) {
280 updateStub(stub, gen, frameMap);
281 }
282 return crb;
283 }
284
285 @Override
286 public void emitCode(CompilationResultBuilder crb, LIR lir, ResolvedJavaMethod installedCodeOwner) {
287 Label verifiedStub = new Label();
288 crb.buildLabelOffsets(lir);
289 try {
290 emitCode(crb, lir, installedCodeOwner, verifiedStub);
291 } catch (BranchTargetOutOfBoundsException e) {
292 // A branch estimation was wrong, now retry with conservative label ranges, this
293 // should always work
294 crb.setConservativeLabelRanges();
295 crb.resetForEmittingCode();
296 lir.resetLabels();
297 verifiedStub.reset();
298 emitCode(crb, lir, installedCodeOwner, verifiedStub);
299 }
300 }
301
302 private void emitCode(CompilationResultBuilder crb, LIR lir, ResolvedJavaMethod installedCodeOwner, Label verifiedStub) {
303 AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
304 FrameMap frameMap = crb.frameMap;
305 RegisterConfig regConfig = frameMap.getRegisterConfig();
306 emitCodePrefix(crb, installedCodeOwner, masm, regConfig, verifiedStub);
307 emitCodeBody(crb, lir, masm);
308 emitCodeSuffix(crb, masm, frameMap);
309 }
310
311 private void emitCodePrefix(CompilationResultBuilder crb, ResolvedJavaMethod installedCodeOwner, AArch64MacroAssembler masm, RegisterConfig regConfig, Label verifiedStub) {
312 HotSpotProviders providers = getProviders();
313 if (installedCodeOwner != null && !isStatic(installedCodeOwner.getModifiers())) {
314 crb.recordMark(config.MARKID_UNVERIFIED_ENTRY);
315 CallingConvention cc = regConfig.getCallingConvention(HotSpotCallingConventionType.JavaCallee, null, new JavaType[]{providers.getMetaAccess().lookupJavaType(Object.class)}, this);
316 // See definition of IC_Klass in c1_LIRAssembler_aarch64.cpp
317 // equal to scratch(1) careful!
318 Register inlineCacheKlass = AArch64HotSpotRegisterConfig.inlineCacheRegister;
319 Register receiver = asRegister(cc.getArgument(0));
320 int transferSize = config.useCompressedClassPointers ? 4 : 8;
321 AArch64Address klassAddress = masm.makeAddress(receiver, config.hubOffset, transferSize);
322
323 // Are r10 and r11 available scratch registers here? One would hope so.
324 Register klass = r10;
325 if (config.useCompressedClassPointers) {
326 masm.ldr(32, klass, klassAddress);
327 AArch64HotSpotMove.decodeKlassPointer(crb, masm, klass, klass, config.getKlassEncoding(), config);
328 } else {
329 masm.ldr(64, klass, klassAddress);
330 }
331 masm.cmp(64, inlineCacheKlass, klass);
332 /*
333 * Conditional jumps have a much lower range than unconditional ones, which can be a
334 * problem because the miss handler could be out of range.
335 */
336 masm.branchConditionally(AArch64Assembler.ConditionFlag.EQ, verifiedStub);
337 AArch64Call.directJmp(crb, masm, getForeignCalls().lookupForeignCall(IC_MISS_HANDLER));
338 }
339 masm.align(config.codeEntryAlignment);
340 crb.recordMark(config.MARKID_OSR_ENTRY);
341 masm.bind(verifiedStub);
342 crb.recordMark(config.MARKID_VERIFIED_ENTRY);
343
344 if (GeneratePIC.getValue(crb.getOptions())) {
345 // Check for method state
346 HotSpotFrameContext frameContext = (HotSpotFrameContext) crb.frameContext;
347 if (!frameContext.isStub) {
348 crb.recordInlineDataInCodeWithNote(new HotSpotSentinelConstant(LIRKind.value(AArch64Kind.QWORD), JavaKind.Long), HotSpotConstantLoadAction.MAKE_NOT_ENTRANT);
349 try (ScratchRegister sc = masm.getScratchRegister()) {
350 Register scratch = sc.getRegister();
351 masm.addressOf(scratch);
352 masm.ldr(64, scratch, AArch64Address.createBaseRegisterOnlyAddress(scratch));
353 Label noCall = new Label();
354 masm.cbz(64, scratch, noCall);
355 AArch64Call.directJmp(crb, masm, getForeignCalls().lookupForeignCall(WRONG_METHOD_HANDLER));
356 masm.bind(noCall);
357 }
358 }
359 }
360 }
361
362 private static void emitCodeBody(CompilationResultBuilder crb, LIR lir, AArch64MacroAssembler masm) {
363 emitInvalidatePlaceholder(crb, masm);
364 crb.emit(lir);
365 }
366
367 /**
368 * Insert a nop at the start of the prolog so we can patch in a branch if we need to invalidate
369 * the method later.
370 *
371 * @see "http://mail.openjdk.java.net/pipermail/aarch64-port-dev/2013-September/000273.html"
372 */
373 public static void emitInvalidatePlaceholder(CompilationResultBuilder crb, AArch64MacroAssembler masm) {
374 if (!GeneratePIC.getValue(crb.getOptions())) {
375 crb.blockComment("[nop for method invalidation]");
376 masm.nop();
377 }
378 }
379
380 private void emitCodeSuffix(CompilationResultBuilder crb, AArch64MacroAssembler masm, FrameMap frameMap) {
381 HotSpotProviders providers = getProviders();
382 HotSpotFrameContext frameContext = (HotSpotFrameContext) crb.frameContext;
383 if (!frameContext.isStub) {
384 HotSpotForeignCallsProvider foreignCalls = providers.getForeignCalls();
385 try (ScratchRegister sc = masm.getScratchRegister()) {
386 Register scratch = sc.getRegister();
387 crb.recordMark(config.MARKID_EXCEPTION_HANDLER_ENTRY);
388 ForeignCallLinkage linkage = foreignCalls.lookupForeignCall(EXCEPTION_HANDLER);
389 Register helper = AArch64Call.isNearCall(linkage) ? null : scratch;
390 AArch64Call.directCall(crb, masm, linkage, helper, null);
391 }
392 crb.recordMark(config.MARKID_DEOPT_HANDLER_ENTRY);
393 ForeignCallLinkage linkage = foreignCalls.lookupForeignCall(DEOPTIMIZATION_HANDLER);
394 masm.adr(lr, 0); // Warning: the argument is an offset from the instruction!
395 AArch64Call.directJmp(crb, masm, linkage);
396 } else {
397 // No need to emit the stubs for entries back into the method since
398 // it has no calls that can cause such "return" entries
399 assert !frameMap.accessesCallerFrame();
400 }
401 }
402
403 @Override
404 public RegisterAllocationConfig newRegisterAllocationConfig(RegisterConfig registerConfig, String[] allocationRestrictedTo) {
405 RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
406 return new AArch64HotSpotRegisterAllocationConfig(registerConfigNonNull, allocationRestrictedTo);
407 }
408
409 @Override
410 public EconomicSet<Register> translateToCallerRegisters(EconomicSet<Register> calleeRegisters) {
411 return calleeRegisters;
412 }
413 }