1 /*
   2  * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2018, Red Hat Inc. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 
  26 
  27 package org.graalvm.compiler.hotspot.aarch64;
  28 
  29 import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC;
  30 import static org.graalvm.compiler.hotspot.HotSpotBackend.INITIALIZE_KLASS_BY_SYMBOL;
  31 import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_DYNAMIC_INVOKE;
  32 import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_KLASS_BY_SYMBOL;
  33 import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_METHOD_BY_SYMBOL_AND_LOAD_COUNTERS;
  34 import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_STRING_BY_SYMBOL;
  35 import static org.graalvm.compiler.hotspot.meta.HotSpotConstantLoadAction.INITIALIZE;
  36 import static org.graalvm.compiler.hotspot.meta.HotSpotConstantLoadAction.LOAD_COUNTERS;
  37 import static org.graalvm.compiler.hotspot.meta.HotSpotConstantLoadAction.RESOLVE;
  38 import static org.graalvm.compiler.lir.LIRValueUtil.asConstant;
  39 import static org.graalvm.compiler.lir.LIRValueUtil.isConstantValue;
  40 
  41 import java.util.function.Function;
  42 
  43 import org.graalvm.compiler.asm.Label;
  44 import org.graalvm.compiler.asm.aarch64.AArch64Address.AddressingMode;
  45 import org.graalvm.compiler.asm.aarch64.AArch64Assembler.ConditionFlag;
  46 import org.graalvm.compiler.asm.aarch64.AArch64Assembler.PrefetchMode;
  47 import org.graalvm.compiler.core.aarch64.AArch64ArithmeticLIRGenerator;
  48 import org.graalvm.compiler.core.aarch64.AArch64LIRGenerator;
  49 import org.graalvm.compiler.core.aarch64.AArch64LIRKindTool;
  50 import org.graalvm.compiler.core.common.CompressEncoding;
  51 import org.graalvm.compiler.core.common.LIRKind;
  52 import org.graalvm.compiler.core.common.calc.Condition;
  53 import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor;
  54 import org.graalvm.compiler.core.common.spi.ForeignCallLinkage;
  55 import org.graalvm.compiler.core.common.spi.LIRKindTool;
  56 import org.graalvm.compiler.debug.GraalError;
  57 import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
  58 import org.graalvm.compiler.hotspot.HotSpotBackend;
  59 import org.graalvm.compiler.hotspot.HotSpotDebugInfoBuilder;
  60 import org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage;
  61 import org.graalvm.compiler.hotspot.HotSpotLIRGenerationResult;
  62 import org.graalvm.compiler.hotspot.HotSpotLIRGenerator;
  63 import org.graalvm.compiler.hotspot.HotSpotLockStack;
  64 import org.graalvm.compiler.hotspot.meta.HotSpotConstantLoadAction;
  65 import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
  66 import org.graalvm.compiler.hotspot.meta.HotSpotRegistersProvider;
  67 import org.graalvm.compiler.hotspot.stubs.Stub;
  68 import org.graalvm.compiler.lir.LIRFrameState;
  69 import org.graalvm.compiler.lir.LIRInstruction;
  70 import org.graalvm.compiler.lir.LabelRef;
  71 import org.graalvm.compiler.lir.StandardOp.SaveRegistersOp;
  72 import org.graalvm.compiler.lir.SwitchStrategy;
  73 import org.graalvm.compiler.lir.Variable;
  74 import org.graalvm.compiler.lir.VirtualStackSlot;
  75 import org.graalvm.compiler.lir.aarch64.AArch64AddressValue;
  76 import org.graalvm.compiler.lir.aarch64.AArch64CCall;
  77 import org.graalvm.compiler.lir.aarch64.AArch64Call;
  78 import org.graalvm.compiler.lir.aarch64.AArch64ControlFlow.StrategySwitchOp;
  79 import org.graalvm.compiler.lir.aarch64.AArch64FrameMapBuilder;
  80 import org.graalvm.compiler.lir.aarch64.AArch64Move;
  81 import org.graalvm.compiler.lir.aarch64.AArch64Move.StoreOp;
  82 import org.graalvm.compiler.lir.aarch64.AArch64PrefetchOp;
  83 import org.graalvm.compiler.lir.aarch64.AArch64RestoreRegistersOp;
  84 import org.graalvm.compiler.lir.aarch64.AArch64SaveRegistersOp;
  85 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
  86 import org.graalvm.compiler.options.OptionValues;
  87 
  88 import jdk.vm.ci.aarch64.AArch64;
  89 import jdk.vm.ci.aarch64.AArch64Kind;
  90 import jdk.vm.ci.code.CallingConvention;
  91 import jdk.vm.ci.code.Register;
  92 import jdk.vm.ci.code.RegisterValue;
  93 import jdk.vm.ci.code.StackSlot;
  94 import jdk.vm.ci.hotspot.HotSpotCompressedNullConstant;
  95 import jdk.vm.ci.hotspot.HotSpotMetaspaceConstant;
  96 import jdk.vm.ci.hotspot.HotSpotObjectConstant;
  97 import jdk.vm.ci.meta.AllocatableValue;
  98 import jdk.vm.ci.meta.Constant;
  99 import jdk.vm.ci.meta.DeoptimizationAction;
 100 import jdk.vm.ci.meta.DeoptimizationReason;
 101 import jdk.vm.ci.meta.JavaConstant;
 102 import jdk.vm.ci.meta.JavaKind;
 103 import jdk.vm.ci.meta.PlatformKind;
 104 import jdk.vm.ci.meta.SpeculationLog;
 105 import jdk.vm.ci.meta.Value;
 106 
 107 /**
 108  * LIR generator specialized for AArch64 HotSpot.
 109  */
 110 public class AArch64HotSpotLIRGenerator extends AArch64LIRGenerator implements HotSpotLIRGenerator {
 111 
 112     final GraalHotSpotVMConfig config;
 113     private HotSpotDebugInfoBuilder debugInfoBuilder;
 114 
 115     protected AArch64HotSpotLIRGenerator(HotSpotProviders providers, GraalHotSpotVMConfig config, LIRGenerationResult lirGenRes) {
 116         this(new AArch64LIRKindTool(), new AArch64ArithmeticLIRGenerator(), new AArch64HotSpotMoveFactory(), providers, config, lirGenRes);
 117     }
 118 
 119     protected AArch64HotSpotLIRGenerator(LIRKindTool lirKindTool, AArch64ArithmeticLIRGenerator arithmeticLIRGen, MoveFactory moveFactory, HotSpotProviders providers, GraalHotSpotVMConfig config,
 120                     LIRGenerationResult lirGenRes) {
 121         super(lirKindTool, arithmeticLIRGen, moveFactory, providers, lirGenRes);
 122         this.config = config;
 123     }
 124 
 125     @Override
 126     public HotSpotProviders getProviders() {
 127         return (HotSpotProviders) super.getProviders();
 128     }
 129 
 130     @Override
 131     public boolean needOnlyOopMaps() {
 132         // Stubs only need oop maps
 133         return getResult().getStub() != null;
 134     }
 135 
 136     private LIRFrameState currentRuntimeCallInfo;
 137 
 138     @Override
 139     protected void emitForeignCallOp(ForeignCallLinkage linkage, Value result, Value[] arguments, Value[] temps, LIRFrameState info) {
 140         currentRuntimeCallInfo = info;
 141         if (AArch64Call.isNearCall(linkage)) {
 142             append(new AArch64Call.DirectNearForeignCallOp(linkage, result, arguments, temps, info, label));
 143         } else {
 144             append(new AArch64Call.DirectFarForeignCallOp(linkage, result, arguments, temps, info, label));
 145         }
 146     }
 147 
 148     @Override
 149     public void emitTailcall(Value[] args, Value address) {
 150         throw GraalError.unimplemented();
 151     }
 152 
 153     @Override
 154     public void emitCCall(long address, CallingConvention nativeCallingConvention, Value[] args) {
 155         Value[] argLocations = new Value[args.length];
 156         getResult().getFrameMapBuilder().callsMethod(nativeCallingConvention);
 157         for (int i = 0; i < args.length; i++) {
 158             Value arg = args[i];
 159             AllocatableValue loc = nativeCallingConvention.getArgument(i);
 160             emitMove(loc, arg);
 161             argLocations[i] = loc;
 162         }
 163         Value ptr = emitLoadConstant(LIRKind.value(AArch64Kind.QWORD), JavaConstant.forLong(address));
 164         append(new AArch64CCall(nativeCallingConvention.getReturn(), ptr, argLocations));
 165     }
 166 
 167     /**
 168      * @param savedRegisters the registers saved by this operation which may be subject to pruning
 169      * @param savedRegisterLocations the slots to which the registers are saved
 170      * @param supportsRemove determines if registers can be pruned
 171      */
 172     protected AArch64SaveRegistersOp emitSaveRegisters(Register[] savedRegisters, AllocatableValue[] savedRegisterLocations, boolean supportsRemove) {
 173         AArch64SaveRegistersOp save = new AArch64SaveRegistersOp(savedRegisters, savedRegisterLocations, supportsRemove);
 174         append(save);
 175         return save;
 176     }
 177 
 178     /**
 179      * Allocate a stack slot for saving a register.
 180      */
 181     protected VirtualStackSlot allocateSaveRegisterLocation(Register register) {
 182         PlatformKind kind = target().arch.getLargestStorableKind(register.getRegisterCategory());
 183         if (kind.getVectorLength() > 1) {
 184             // we don't use vector registers, so there is no need to save them
 185             kind = AArch64Kind.QWORD;
 186         }
 187         return getResult().getFrameMapBuilder().allocateSpillSlot(LIRKind.value(kind));
 188     }
 189 
 190     /**
 191      * Adds a node to the graph that saves all allocatable registers to the stack.
 192      *
 193      * @param supportsRemove determines if registers can be pruned
 194      * @return the register save node
 195      */
 196     private AArch64SaveRegistersOp emitSaveAllRegisters(Register[] savedRegisters, boolean supportsRemove) {
 197         AllocatableValue[] savedRegisterLocations = new AllocatableValue[savedRegisters.length];
 198         for (int i = 0; i < savedRegisters.length; i++) {
 199             savedRegisterLocations[i] = allocateSaveRegisterLocation(savedRegisters[i]);
 200         }
 201         return emitSaveRegisters(savedRegisters, savedRegisterLocations, supportsRemove);
 202     }
 203 
 204     protected void emitRestoreRegisters(AArch64SaveRegistersOp save) {
 205         append(new AArch64RestoreRegistersOp(save.getSlots().clone(), save));
 206     }
 207 
 208     @Override
 209     public VirtualStackSlot getLockSlot(int lockDepth) {
 210         return getLockStack().makeLockSlot(lockDepth);
 211     }
 212 
 213     private HotSpotLockStack getLockStack() {
 214         assert debugInfoBuilder != null && debugInfoBuilder.lockStack() != null;
 215         return debugInfoBuilder.lockStack();
 216     }
 217 
 218     @Override
 219     public void emitCompareBranch(PlatformKind cmpKind, Value x, Value y, Condition cond, boolean unorderedIsTrue, LabelRef trueDestination, LabelRef falseDestination,
 220                     double trueDestinationProbability) {
 221         Value localX = x;
 222         Value localY = y;
 223         if (localX instanceof HotSpotObjectConstant) {
 224             localX = load(localX);
 225         }
 226         if (localY instanceof HotSpotObjectConstant) {
 227             localY = load(localY);
 228         }
 229         super.emitCompareBranch(cmpKind, localX, localY, cond, unorderedIsTrue, trueDestination, falseDestination, trueDestinationProbability);
 230     }
 231 
 232     @Override
 233     protected boolean emitCompare(PlatformKind cmpKind, Value a, Value b, Condition condition, boolean unorderedIsTrue) {
 234         Value localA = a;
 235         Value localB = b;
 236         if (isConstantValue(a)) {
 237             Constant c = asConstant(a);
 238             if (HotSpotCompressedNullConstant.COMPRESSED_NULL.equals(c)) {
 239                 localA = AArch64.zr.asValue(LIRKind.value(AArch64Kind.DWORD));
 240             } else if (c instanceof HotSpotObjectConstant) {
 241                 localA = load(localA);
 242             }
 243         }
 244         if (isConstantValue(b)) {
 245             Constant c = asConstant(b);
 246             if (HotSpotCompressedNullConstant.COMPRESSED_NULL.equals(c)) {
 247                 localB = AArch64.zr.asValue(LIRKind.value(AArch64Kind.DWORD));
 248             } else if (c instanceof HotSpotObjectConstant) {
 249                 localB = load(localB);
 250             }
 251         }
 252         return super.emitCompare(cmpKind, localA, localB, condition, unorderedIsTrue);
 253     }
 254 
 255     @Override
 256     public Value emitCompress(Value pointer, CompressEncoding encoding, boolean nonNull) {
 257         LIRKind inputKind = pointer.getValueKind(LIRKind.class);
 258         LIRKindTool lirKindTool = getLIRKindTool();
 259         assert inputKind.getPlatformKind() == AArch64Kind.QWORD;
 260         if (inputKind.isReference(0)) {
 261             // oop
 262             Variable result = newVariable(LIRKind.compressedReference(AArch64Kind.DWORD));
 263             append(new AArch64HotSpotMove.CompressPointer(result, asAllocatable(pointer), getProviders().getRegisters().getHeapBaseRegister().asValue(), encoding, nonNull));
 264             return result;
 265         } else {
 266             // metaspace pointer
 267             Variable result = newVariable(LIRKind.value(AArch64Kind.DWORD));
 268             AllocatableValue base = Value.ILLEGAL;
 269             OptionValues options = getResult().getLIR().getOptions();
 270             if (encoding.hasBase() || GeneratePIC.getValue(options)) {
 271                 if (GeneratePIC.getValue(options)) {
 272                     Variable baseAddress = newVariable(lirKindTool.getWordKind());
 273                     AArch64HotSpotMove.BaseMove move = new AArch64HotSpotMove.BaseMove(baseAddress, config);
 274                     append(move);
 275                     base = baseAddress;
 276                 } else {
 277                     base = emitLoadConstant(LIRKind.value(AArch64Kind.QWORD), JavaConstant.forLong(encoding.getBase()));
 278                 }
 279             }
 280             append(new AArch64HotSpotMove.CompressPointer(result, asAllocatable(pointer), base, encoding, nonNull));
 281             return result;
 282         }
 283     }
 284 
 285     @Override
 286     public Value emitUncompress(Value pointer, CompressEncoding encoding, boolean nonNull) {
 287         LIRKind inputKind = pointer.getValueKind(LIRKind.class);
 288         assert inputKind.getPlatformKind() == AArch64Kind.DWORD;
 289         if (inputKind.isReference(0)) {
 290             // oop
 291             Variable result = newVariable(LIRKind.reference(AArch64Kind.QWORD));
 292             append(new AArch64HotSpotMove.UncompressPointer(result, asAllocatable(pointer), getProviders().getRegisters().getHeapBaseRegister().asValue(), encoding, nonNull));
 293             return result;
 294         } else {
 295             // metaspace pointer
 296             Variable result = newVariable(LIRKind.value(AArch64Kind.QWORD));
 297             AllocatableValue base = Value.ILLEGAL;
 298             OptionValues options = getResult().getLIR().getOptions();
 299             if (encoding.hasBase() || GeneratePIC.getValue(options)) {
 300                 if (GeneratePIC.getValue(options)) {
 301                     Variable baseAddress = newVariable(LIRKind.value(AArch64Kind.QWORD));
 302                     AArch64HotSpotMove.BaseMove move = new AArch64HotSpotMove.BaseMove(baseAddress, config);
 303                     append(move);
 304                     base = baseAddress;
 305                 } else {
 306                     base = emitLoadConstant(LIRKind.value(AArch64Kind.QWORD), JavaConstant.forLong(encoding.getBase()));
 307                 }
 308             }
 309             append(new AArch64HotSpotMove.UncompressPointer(result, asAllocatable(pointer), base, encoding, nonNull));
 310             return result;
 311         }
 312     }
 313 
 314     @Override
 315     public void emitNullCheck(Value address, LIRFrameState state) {
 316         if (address.getValueKind().getPlatformKind() == AArch64Kind.DWORD) {
 317             CompressEncoding encoding = config.getOopEncoding();
 318             Value uncompressed = emitUncompress(address, encoding, false);
 319             append(new AArch64Move.NullCheckOp(asAddressValue(uncompressed), state));
 320         } else {
 321             super.emitNullCheck(address, state);
 322         }
 323     }
 324 
 325     @Override
 326     public void emitPrefetchAllocate(Value address) {
 327         append(new AArch64PrefetchOp(asAddressValue(address), PrefetchMode.PSTL1KEEP));
 328     }
 329 
 330     @Override
 331     public void beforeRegisterAllocation() {
 332         super.beforeRegisterAllocation();
 333         boolean hasDebugInfo = getResult().getLIR().hasDebugInfo();
 334         if (hasDebugInfo) {
 335             getResult().setDeoptimizationRescueSlot(((AArch64FrameMapBuilder) getResult().getFrameMapBuilder()).allocateDeoptimizationRescueSlot());
 336         }
 337 
 338         getResult().setMaxInterpreterFrameSize(debugInfoBuilder.maxInterpreterFrameSize());
 339     }
 340 
 341     private Label label;
 342 
 343     @Override
 344     public Variable emitForeignCall(ForeignCallLinkage linkage, LIRFrameState state, Value... args) {
 345         HotSpotForeignCallLinkage hotspotLinkage = (HotSpotForeignCallLinkage) linkage;
 346         boolean destroysRegisters = hotspotLinkage.destroysRegisters();
 347 
 348         AArch64SaveRegistersOp save = null;
 349         Stub stub = getStub();
 350         if (destroysRegisters) {
 351             if (stub != null && stub.preservesRegisters()) {
 352                 Register[] savedRegisters = getRegisterConfig().getAllocatableRegisters().toArray();
 353                 save = emitSaveAllRegisters(savedRegisters, true);
 354             }
 355         }
 356 
 357         Variable result;
 358         LIRFrameState debugInfo = null;
 359         if (hotspotLinkage.needsDebugInfo()) {
 360             debugInfo = state;
 361             assert debugInfo != null || getStub() != null;
 362         }
 363 
 364         if (destroysRegisters || hotspotLinkage.needsJavaFrameAnchor()) {
 365             HotSpotRegistersProvider registers = getProviders().getRegisters();
 366             Register thread = registers.getThreadRegister();
 367             Variable scratch = newVariable(LIRKind.value(target().arch.getWordKind()));
 368 
 369             // We need a label for the return address.
 370             label = new Label();
 371 
 372             append(new AArch64HotSpotCRuntimeCallPrologueOp(config.threadLastJavaSpOffset(), config.threadLastJavaPcOffset(), thread, scratch, label));
 373             result = super.emitForeignCall(hotspotLinkage, debugInfo, args);
 374             append(new AArch64HotSpotCRuntimeCallEpilogueOp(config.threadLastJavaSpOffset(), config.threadLastJavaPcOffset(), thread, label));
 375 
 376             // Clear it out so it's not being reused later.
 377             label = null;
 378         } else {
 379             result = super.emitForeignCall(hotspotLinkage, debugInfo, args);
 380         }
 381 
 382         if (destroysRegisters) {
 383             if (stub != null) {
 384                 if (stub.preservesRegisters()) {
 385                     HotSpotLIRGenerationResult generationResult = getResult();
 386                     LIRFrameState key = currentRuntimeCallInfo;
 387                     if (key == null) {
 388                         key = LIRFrameState.NO_STATE;
 389                     }
 390                     assert !generationResult.getCalleeSaveInfo().containsKey(key);
 391                     generationResult.getCalleeSaveInfo().put(key, save);
 392                     emitRestoreRegisters(save);
 393                 }
 394             }
 395         }
 396 
 397         return result;
 398     }
 399 
 400     @Override
 401     public void emitDeoptimizeCaller(DeoptimizationAction action, DeoptimizationReason reason) {
 402         Value actionAndReason = emitJavaConstant(getMetaAccess().encodeDeoptActionAndReason(action, reason, 0));
 403         Value speculation = emitJavaConstant(getMetaAccess().encodeSpeculation(SpeculationLog.NO_SPECULATION));
 404         moveDeoptValuesToThread(actionAndReason, speculation);
 405         append(new AArch64HotSpotDeoptimizeCallerOp(config));
 406     }
 407 
 408     @Override
 409     public void emitDeoptimize(Value actionAndReason, Value failedSpeculation, LIRFrameState state) {
 410         moveDeoptValuesToThread(actionAndReason, failedSpeculation);
 411         append(new AArch64HotSpotDeoptimizeOp(state));
 412     }
 413 
 414     private void moveDeoptValuesToThread(Value actionAndReason, Value speculation) {
 415         moveValueToThread(actionAndReason, config.pendingDeoptimizationOffset);
 416         moveValueToThread(speculation, config.pendingFailedSpeculationOffset);
 417     }
 418 
 419     private void moveValueToThread(Value value, int offset) {
 420         LIRKind wordKind = LIRKind.value(target().arch.getWordKind());
 421         RegisterValue thread = getProviders().getRegisters().getThreadRegister().asValue(wordKind);
 422         final int transferSize = value.getValueKind().getPlatformKind().getSizeInBytes();
 423         AArch64AddressValue address = new AArch64AddressValue(value.getValueKind(), thread, Value.ILLEGAL, offset, transferSize, AddressingMode.IMMEDIATE_SCALED);
 424         append(new StoreOp((AArch64Kind) value.getPlatformKind(), address, loadReg(value), null));
 425     }
 426 
 427     @Override
 428     public void emitUnwind(Value exception) {
 429         ForeignCallLinkage linkage = getForeignCalls().lookupForeignCall(HotSpotBackend.UNWIND_EXCEPTION_TO_CALLER);
 430         CallingConvention outgoingCc = linkage.getOutgoingCallingConvention();
 431         assert outgoingCc.getArgumentCount() == 2;
 432         RegisterValue exceptionParameter = (RegisterValue) outgoingCc.getArgument(0);
 433         emitMove(exceptionParameter, exception);
 434         append(new AArch64HotSpotUnwindOp(config, exceptionParameter));
 435     }
 436 
 437     @Override
 438     public Value emitLoadObjectAddress(Constant constant) {
 439         HotSpotObjectConstant objectConstant = (HotSpotObjectConstant) constant;
 440         LIRKind kind = objectConstant.isCompressed() ? getLIRKindTool().getNarrowOopKind() : getLIRKindTool().getObjectKind();
 441         Variable result = newVariable(kind);
 442         append(new AArch64HotSpotLoadAddressOp(result, constant, HotSpotConstantLoadAction.RESOLVE));
 443         return result;
 444     }
 445 
 446     @Override
 447     public Value emitLoadMetaspaceAddress(Constant constant, HotSpotConstantLoadAction action) {
 448         HotSpotMetaspaceConstant metaspaceConstant = (HotSpotMetaspaceConstant) constant;
 449         LIRKind kind = metaspaceConstant.isCompressed() ? getLIRKindTool().getNarrowPointerKind() : getLIRKindTool().getWordKind();
 450         Variable result = newVariable(kind);
 451         append(new AArch64HotSpotLoadAddressOp(result, constant, action));
 452         return result;
 453     }
 454 
 455     private Value emitConstantRetrieval(ForeignCallDescriptor foreignCall, Object[] notes, Constant[] constants, AllocatableValue[] constantDescriptions, LIRFrameState frameState) {
 456         ForeignCallLinkage linkage = getForeignCalls().lookupForeignCall(foreignCall);
 457         append(new AArch64HotSpotConstantRetrievalOp(constants, constantDescriptions, frameState, linkage, notes));
 458         AllocatableValue result = linkage.getOutgoingCallingConvention().getReturn();
 459         return emitMove(result);
 460     }
 461 
 462     private Value emitConstantRetrieval(ForeignCallDescriptor foreignCall, HotSpotConstantLoadAction action, Constant constant, AllocatableValue[] constantDescriptions, LIRFrameState frameState) {
 463         Constant[] constants = new Constant[]{constant};
 464         Object[] notes = new Object[]{action};
 465         return emitConstantRetrieval(foreignCall, notes, constants, constantDescriptions, frameState);
 466     }
 467 
 468     @Override
 469     public Value emitResolveDynamicInvoke(Constant appendix, LIRFrameState frameState) {
 470         AllocatableValue[] constantDescriptions = new AllocatableValue[0];
 471         return emitConstantRetrieval(RESOLVE_DYNAMIC_INVOKE, INITIALIZE, appendix, constantDescriptions, frameState);
 472     }
 473 
 474     @Override
 475     public Value emitLoadConfigValue(int markId, LIRKind kind) {
 476         Variable result = newVariable(kind);
 477         append(new AArch64HotSpotLoadConfigValueOp(markId, result));
 478         return result;
 479     }
 480 
 481     private Value emitConstantRetrieval(ForeignCallDescriptor foreignCall, HotSpotConstantLoadAction action, Constant constant, Value constantDescription, LIRFrameState frameState) {
 482         AllocatableValue[] constantDescriptions = new AllocatableValue[]{asAllocatable(constantDescription)};
 483         return emitConstantRetrieval(foreignCall, action, constant, constantDescriptions, frameState);
 484     }
 485 
 486     @Override
 487     public Value emitObjectConstantRetrieval(Constant constant, Value constantDescription, LIRFrameState frameState) {
 488         return emitConstantRetrieval(RESOLVE_STRING_BY_SYMBOL, RESOLVE, constant, constantDescription, frameState);
 489     }
 490 
 491     @Override
 492     public Value emitMetaspaceConstantRetrieval(Constant constant, Value constantDescription, LIRFrameState frameState) {
 493         return emitConstantRetrieval(RESOLVE_KLASS_BY_SYMBOL, RESOLVE, constant, constantDescription, frameState);
 494     }
 495 
 496     @Override
 497     public void emitReturn(JavaKind kind, Value input) {
 498         AllocatableValue operand = Value.ILLEGAL;
 499         if (input != null) {
 500             operand = resultOperandFor(kind, input.getValueKind());
 501             emitMove(operand, input);
 502         }
 503         Register thread = getProviders().getRegisters().getThreadRegister();
 504         append(new AArch64HotSpotReturnOp(operand, getStub() != null, config, thread, getResult().requiresReservedStackAccessCheck()));
 505     }
 506 
 507     @Override
 508     public Value emitKlassInitializationAndRetrieval(Constant constant, Value constantDescription, LIRFrameState frameState) {
 509         return emitConstantRetrieval(INITIALIZE_KLASS_BY_SYMBOL, INITIALIZE, constant, constantDescription, frameState);
 510     }
 511 
 512     @Override
 513     public Value emitResolveMethodAndLoadCounters(Constant method, Value klassHint, Value methodDescription, LIRFrameState frameState) {
 514         AllocatableValue[] constantDescriptions = new AllocatableValue[]{asAllocatable(klassHint), asAllocatable(methodDescription)};
 515         return emitConstantRetrieval(RESOLVE_METHOD_BY_SYMBOL_AND_LOAD_COUNTERS, LOAD_COUNTERS, method, constantDescriptions, frameState);
 516     }
 517 
 518     /**
 519      * Gets the {@link Stub} this generator is generating code for or {@code null} if a stub is not
 520      * being generated.
 521      */
 522     public Stub getStub() {
 523         return getResult().getStub();
 524     }
 525 
 526     @Override
 527     public HotSpotLIRGenerationResult getResult() {
 528         return ((HotSpotLIRGenerationResult) super.getResult());
 529     }
 530 
 531     @Override
 532     protected StrategySwitchOp createStrategySwitchOp(SwitchStrategy strategy, LabelRef[] keyTargets, LabelRef defaultTarget, Variable key, AllocatableValue scratchValue,
 533                     Function<Condition, ConditionFlag> converter) {
 534         return new AArch64HotSpotStrategySwitchOp(strategy, keyTargets, defaultTarget, key, scratchValue, converter);
 535     }
 536 
 537     public void setDebugInfoBuilder(HotSpotDebugInfoBuilder debugInfoBuilder) {
 538         this.debugInfoBuilder = debugInfoBuilder;
 539     }
 540 
 541     @Override
 542     public SaveRegistersOp createZapRegisters(Register[] zappedRegisters, JavaConstant[] zapValues) {
 543         throw GraalError.unimplemented();
 544     }
 545 
 546     @Override
 547     public LIRInstruction createZapArgumentSpace(StackSlot[] zappedStack, JavaConstant[] zapValues) {
 548         throw GraalError.unimplemented();
 549     }
 550 }