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 org.graalvm.compiler.hotspot.aarch64;
  24 
  25 import static org.graalvm.compiler.core.common.GraalOptions.ZapStackOnMethodEntry;
  26 import static java.lang.reflect.Modifier.isStatic;
  27 import static jdk.vm.ci.aarch64.AArch64.lr;
  28 import static jdk.vm.ci.aarch64.AArch64.r10;
  29 import static jdk.vm.ci.aarch64.AArch64.sp;
  30 import static jdk.vm.ci.aarch64.AArch64.zr;
  31 import static jdk.vm.ci.code.ValueUtil.asRegister;
  32 import static jdk.vm.ci.hotspot.aarch64.AArch64HotSpotRegisterConfig.fp;
  33 
  34 import java.util.Set;
  35 
  36 import org.graalvm.compiler.asm.Assembler;
  37 import org.graalvm.compiler.asm.Label;
  38 import org.graalvm.compiler.asm.aarch64.AArch64Address;
  39 import org.graalvm.compiler.asm.aarch64.AArch64Assembler;
  40 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler;
  41 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler.ScratchRegister;
  42 import org.graalvm.compiler.code.CompilationResult;
  43 import org.graalvm.compiler.core.aarch64.AArch64NodeMatchRules;
  44 import org.graalvm.compiler.core.common.CompilationIdentifier;
  45 import org.graalvm.compiler.core.common.alloc.RegisterAllocationConfig;
  46 import org.graalvm.compiler.core.common.spi.ForeignCallLinkage;
  47 import org.graalvm.compiler.hotspot.HotSpotDataBuilder;
  48 import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider;
  49 import org.graalvm.compiler.hotspot.HotSpotHostBackend;
  50 import org.graalvm.compiler.hotspot.HotSpotLIRGenerationResult;
  51 import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
  52 import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
  53 import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
  54 import org.graalvm.compiler.hotspot.stubs.Stub;
  55 import org.graalvm.compiler.lir.LIR;
  56 import org.graalvm.compiler.lir.aarch64.AArch64Call;
  57 import org.graalvm.compiler.lir.aarch64.AArch64FrameMap;
  58 import org.graalvm.compiler.lir.aarch64.AArch64FrameMapBuilder;
  59 import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
  60 import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;
  61 import org.graalvm.compiler.lir.asm.DataBuilder;
  62 import org.graalvm.compiler.lir.asm.FrameContext;
  63 import org.graalvm.compiler.lir.framemap.FrameMap;
  64 import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
  65 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
  66 import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
  67 import org.graalvm.compiler.nodes.StructuredGraph;
  68 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
  69 
  70 import jdk.vm.ci.code.CallingConvention;
  71 import jdk.vm.ci.code.Register;
  72 import jdk.vm.ci.code.RegisterConfig;
  73 import jdk.vm.ci.code.StackSlot;
  74 import jdk.vm.ci.hotspot.HotSpotCallingConventionType;
  75 import jdk.vm.ci.hotspot.aarch64.AArch64HotSpotRegisterConfig;
  76 import jdk.vm.ci.meta.JavaType;
  77 import jdk.vm.ci.meta.ResolvedJavaMethod;
  78 
  79 /**
  80  * HotSpot AArch64 specific backend.
  81  */
  82 public class AArch64HotSpotBackend extends HotSpotHostBackend {
  83 
  84     public AArch64HotSpotBackend(GraalHotSpotVMConfig config, HotSpotGraalRuntimeProvider runtime, HotSpotProviders providers) {
  85         super(config, runtime, providers);
  86     }
  87 
  88     @Override
  89     public FrameMapBuilder newFrameMapBuilder(RegisterConfig registerConfig) {
  90         RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
  91         return new AArch64FrameMapBuilder(newFrameMap(registerConfigNonNull), getCodeCache(), registerConfigNonNull);
  92     }
  93 
  94     @Override
  95     public FrameMap newFrameMap(RegisterConfig registerConfig) {
  96         return new AArch64FrameMap(getCodeCache(), registerConfig, this);
  97     }
  98 
  99     @Override
 100     public LIRGeneratorTool newLIRGenerator(LIRGenerationResult lirGenRes) {
 101         return new AArch64HotSpotLIRGenerator(getProviders(), config, lirGenRes);
 102     }
 103 
 104     @Override
 105     public LIRGenerationResult newLIRGenerationResult(CompilationIdentifier compilationId, LIR lir, FrameMapBuilder frameMapBuilder, StructuredGraph graph, Object stub) {
 106         return new HotSpotLIRGenerationResult(compilationId, lir, frameMapBuilder, makeCallingConvention(graph, (Stub) stub), stub);
 107     }
 108 
 109     @Override
 110     public NodeLIRBuilderTool newNodeLIRBuilder(StructuredGraph graph, LIRGeneratorTool lirGen) {
 111         return new AArch64HotSpotNodeLIRBuilder(graph, lirGen, new AArch64NodeMatchRules(lirGen));
 112     }
 113 
 114     @Override
 115     protected void bangStackWithOffset(CompilationResultBuilder crb, int bangOffset) {
 116         AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
 117         try (ScratchRegister sc = masm.getScratchRegister()) {
 118             Register scratch = sc.getRegister();
 119             AArch64Address address = masm.makeAddress(sp, -bangOffset, scratch, 8, /* allowOverwrite */false);
 120             masm.str(64, zr, address);
 121         }
 122     }
 123 
 124     private class HotSpotFrameContext implements FrameContext {
 125         final boolean isStub;
 126 
 127         HotSpotFrameContext(boolean isStub) {
 128             this.isStub = isStub;
 129         }
 130 
 131         @Override
 132         public void enter(CompilationResultBuilder crb) {
 133             FrameMap frameMap = crb.frameMap;
 134             final int frameSize = frameMap.frameSize();
 135             final int totalFrameSize = frameMap.totalFrameSize();
 136             assert frameSize + 2 * crb.target.arch.getWordSize() == totalFrameSize : "total framesize should be framesize + 2 words";
 137             AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
 138             if (!isStub) {
 139                 emitStackOverflowCheck(crb);
 140             }
 141             crb.blockComment("[method prologue]");
 142 
 143             if (ZapStackOnMethodEntry.getValue()) {
 144                 try (ScratchRegister sc = masm.getScratchRegister()) {
 145                     Register scratch = sc.getRegister();
 146                     int intSize = 4;
 147                     AArch64Address address = AArch64Address.createPreIndexedImmediateAddress(scratch, -intSize);
 148                     try (ScratchRegister sc2 = masm.getScratchRegister()) {
 149                         Register value = sc2.getRegister();
 150                         masm.mov(value, 0xC1C1C1C1);
 151                         for (int i = 0; i < frameSize; i += intSize) {
 152                             masm.str(32, value, address);
 153                         }
 154                     }
 155                     masm.mov(64, sp, scratch);
 156                 }
 157             } else {
 158                 if (AArch64MacroAssembler.isArithmeticImmediate(totalFrameSize)) {
 159                     masm.sub(64, sp, sp, totalFrameSize);
 160                 } else {
 161                     try (ScratchRegister sc2 = masm.getScratchRegister()) {
 162                         Register scratch2 = sc2.getRegister();
 163                         masm.mov(scratch2, totalFrameSize);
 164                         masm.sub(64, sp, sp, scratch2);
 165                     }
 166                 }
 167             }
 168 
 169             AArch64Address address2 = AArch64Address.createPairUnscaledImmediateAddress(sp, frameSize / 8); // XXX
 170             masm.stp(64, fp, lr, address2);
 171 
 172             crb.blockComment("[code body]");
 173         }
 174 
 175         @Override
 176         public void leave(CompilationResultBuilder crb) {
 177             AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
 178             FrameMap frameMap = crb.frameMap;
 179             final int frameSize = frameMap.frameSize();
 180             final int totalFrameSize = frameMap.totalFrameSize();
 181 
 182             crb.blockComment("[method epilogue]");
 183 
 184             AArch64Address address2 = AArch64Address.createPairUnscaledImmediateAddress(sp, frameSize / 8); // XXX
 185             masm.ldp(64, fp, lr, address2);
 186 
 187             if (AArch64MacroAssembler.isArithmeticImmediate(totalFrameSize)) {
 188                 masm.add(64, sp, sp, totalFrameSize);
 189             } else {
 190                 try (ScratchRegister sc = masm.getScratchRegister()) {
 191                     Register scratch = sc.getRegister();
 192                     masm.mov(scratch, totalFrameSize);
 193                     masm.add(64, sp, sp, scratch);
 194                 }
 195             }
 196         }
 197 
 198         @Override
 199         public boolean hasFrame() {
 200             return true;
 201         }
 202 
 203     }
 204 
 205     @Override
 206     protected Assembler createAssembler(FrameMap frameMap) {
 207         return new AArch64MacroAssembler(getTarget());
 208     }
 209 
 210     @Override
 211     public CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult lirGenRen, FrameMap frameMap, CompilationResult compilationResult, CompilationResultBuilderFactory factory) {
 212         HotSpotLIRGenerationResult gen = (HotSpotLIRGenerationResult) lirGenRen;
 213         LIR lir = gen.getLIR();
 214         assert gen.getDeoptimizationRescueSlot() == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame";
 215 
 216         Stub stub = gen.getStub();
 217         Assembler masm = createAssembler(frameMap);
 218         HotSpotFrameContext frameContext = new HotSpotFrameContext(stub != null);
 219 
 220         DataBuilder dataBuilder = new HotSpotDataBuilder(getCodeCache().getTarget());
 221         CompilationResultBuilder crb = factory.createBuilder(getCodeCache(), getForeignCalls(), frameMap, masm, dataBuilder, frameContext, compilationResult);
 222         crb.setTotalFrameSize(frameMap.totalFrameSize());
 223         crb.setMaxInterpreterFrameSize(gen.getMaxInterpreterFrameSize());
 224         StackSlot deoptimizationRescueSlot = gen.getDeoptimizationRescueSlot();
 225         if (deoptimizationRescueSlot != null && stub == null) {
 226             crb.compilationResult.setCustomStackAreaOffset(deoptimizationRescueSlot);
 227         }
 228 
 229         if (stub != null) {
 230             Set<Register> destroyedCallerRegisters = gatherDestroyedCallerRegisters(lir);
 231             updateStub(stub, destroyedCallerRegisters, gen.getCalleeSaveInfo(), frameMap);
 232         }
 233         return crb;
 234     }
 235 
 236     @Override
 237     public void emitCode(CompilationResultBuilder crb, LIR lir, ResolvedJavaMethod installedCodeOwner) {
 238         AArch64MacroAssembler masm = (AArch64MacroAssembler) crb.asm;
 239         FrameMap frameMap = crb.frameMap;
 240         RegisterConfig regConfig = frameMap.getRegisterConfig();
 241         Label verifiedStub = new Label();
 242 
 243         emitCodePrefix(crb, installedCodeOwner, masm, regConfig, verifiedStub);
 244         emitCodeBody(crb, lir, masm);
 245         emitCodeSuffix(crb, masm, frameMap);
 246     }
 247 
 248     private void emitCodePrefix(CompilationResultBuilder crb, ResolvedJavaMethod installedCodeOwner, AArch64MacroAssembler masm, RegisterConfig regConfig, Label verifiedStub) {
 249         HotSpotProviders providers = getProviders();
 250         if (installedCodeOwner != null && !isStatic(installedCodeOwner.getModifiers())) {
 251             crb.recordMark(config.MARKID_UNVERIFIED_ENTRY);
 252             CallingConvention cc = regConfig.getCallingConvention(HotSpotCallingConventionType.JavaCallee, null, new JavaType[]{providers.getMetaAccess().lookupJavaType(Object.class)}, this);
 253             // See definition of IC_Klass in c1_LIRAssembler_aarch64.cpp
 254             // equal to scratch(1) careful!
 255             Register inlineCacheKlass = AArch64HotSpotRegisterConfig.inlineCacheRegister;
 256             Register receiver = asRegister(cc.getArgument(0));
 257             int transferSize = config.useCompressedClassPointers ? 4 : 8;
 258             AArch64Address klassAddress = masm.makeAddress(receiver, config.hubOffset, transferSize);
 259 
 260             // Are r10 and r11 available scratch registers here? One would hope so.
 261             Register klass = r10;
 262             if (config.useCompressedClassPointers) {
 263                 masm.ldr(32, klass, klassAddress);
 264                 AArch64HotSpotMove.decodeKlassPointer(masm, klass, klass, providers.getRegisters().getHeapBaseRegister(), config.getKlassEncoding());
 265             } else {
 266                 masm.ldr(64, klass, klassAddress);
 267             }
 268             masm.cmp(64, inlineCacheKlass, klass);
 269             /*
 270              * Conditional jumps have a much lower range than unconditional ones, which can be a
 271              * problem because the miss handler could be out of range.
 272              */
 273             masm.branchConditionally(AArch64Assembler.ConditionFlag.EQ, verifiedStub);
 274             AArch64Call.directJmp(crb, masm, getForeignCalls().lookupForeignCall(IC_MISS_HANDLER));
 275         }
 276         masm.align(config.codeEntryAlignment);
 277         crb.recordMark(config.MARKID_OSR_ENTRY);
 278         masm.bind(verifiedStub);
 279         crb.recordMark(config.MARKID_VERIFIED_ENTRY);
 280     }
 281 
 282     private static void emitCodeBody(CompilationResultBuilder crb, LIR lir, AArch64MacroAssembler masm) {
 283         /*
 284          * Insert a nop at the start of the prolog so we can patch in a branch if we need to
 285          * invalidate the method later.
 286          */
 287         crb.blockComment("[nop for method invalidation]");
 288         masm.nop();
 289 
 290         crb.emit(lir);
 291     }
 292 
 293     private void emitCodeSuffix(CompilationResultBuilder crb, AArch64MacroAssembler masm, FrameMap frameMap) {
 294         HotSpotProviders providers = getProviders();
 295         HotSpotFrameContext frameContext = (HotSpotFrameContext) crb.frameContext;
 296         if (!frameContext.isStub) {
 297             try (ScratchRegister sc = masm.getScratchRegister()) {
 298                 Register scratch = sc.getRegister();
 299                 HotSpotForeignCallsProvider foreignCalls = providers.getForeignCalls();
 300                 crb.recordMark(config.MARKID_EXCEPTION_HANDLER_ENTRY);
 301                 ForeignCallLinkage linkage = foreignCalls.lookupForeignCall(EXCEPTION_HANDLER);
 302                 Register helper = AArch64Call.isNearCall(linkage) ? null : scratch;
 303                 AArch64Call.directCall(crb, masm, linkage, helper, null);
 304 
 305                 crb.recordMark(config.MARKID_DEOPT_HANDLER_ENTRY);
 306                 linkage = foreignCalls.lookupForeignCall(DEOPTIMIZATION_HANDLER);
 307                 helper = AArch64Call.isNearCall(linkage) ? null : scratch;
 308                 AArch64Call.directCall(crb, masm, linkage, helper, null);
 309             }
 310         } else {
 311             // No need to emit the stubs for entries back into the method since
 312             // it has no calls that can cause such "return" entries
 313             assert !frameMap.accessesCallerFrame();
 314         }
 315     }
 316 
 317     @Override
 318     public RegisterAllocationConfig newRegisterAllocationConfig(RegisterConfig registerConfig) {
 319         RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
 320         return new AArch64HotSpotRegisterAllocationConfig(registerConfigNonNull);
 321     }
 322 
 323     @Override
 324     public Set<Register> translateToCallerRegisters(Set<Register> calleeRegisters) {
 325         return calleeRegisters;
 326     }
 327 }