1 /* 2 * Copyright (c) 2013, 2018, 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.core.aarch64; 26 27 import static jdk.vm.ci.aarch64.AArch64.sp; 28 import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant; 29 import static org.graalvm.compiler.lir.LIRValueUtil.isIntConstant; 30 import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant; 31 32 import java.util.function.Function; 33 34 import org.graalvm.compiler.asm.aarch64.AArch64Address.AddressingMode; 35 import org.graalvm.compiler.asm.aarch64.AArch64Assembler.ConditionFlag; 36 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler; 37 import org.graalvm.compiler.core.common.LIRKind; 38 import org.graalvm.compiler.core.common.calc.Condition; 39 import org.graalvm.compiler.core.common.spi.LIRKindTool; 40 import org.graalvm.compiler.debug.GraalError; 41 import org.graalvm.compiler.lir.LIRFrameState; 42 import org.graalvm.compiler.lir.LIRValueUtil; 43 import org.graalvm.compiler.lir.LabelRef; 44 import org.graalvm.compiler.lir.StandardOp; 45 import org.graalvm.compiler.lir.SwitchStrategy; 46 import org.graalvm.compiler.lir.Variable; 47 import org.graalvm.compiler.lir.aarch64.AArch64AddressValue; 48 import org.graalvm.compiler.lir.aarch64.AArch64ArithmeticOp; 49 import org.graalvm.compiler.lir.aarch64.AArch64ArrayCompareToOp; 50 import org.graalvm.compiler.lir.aarch64.AArch64ArrayEqualsOp; 51 import org.graalvm.compiler.lir.aarch64.AArch64ByteSwapOp; 52 import org.graalvm.compiler.lir.aarch64.AArch64Compare; 53 import org.graalvm.compiler.lir.aarch64.AArch64ControlFlow; 54 import org.graalvm.compiler.lir.aarch64.AArch64ControlFlow.BranchOp; 55 import org.graalvm.compiler.lir.aarch64.AArch64ControlFlow.CondMoveOp; 56 import org.graalvm.compiler.lir.aarch64.AArch64ControlFlow.CondSetOp; 57 import org.graalvm.compiler.lir.aarch64.AArch64ControlFlow.StrategySwitchOp; 58 import org.graalvm.compiler.lir.aarch64.AArch64ControlFlow.TableSwitchOp; 59 import org.graalvm.compiler.lir.aarch64.AArch64LIRFlagsVersioned; 60 import org.graalvm.compiler.lir.aarch64.AArch64Move; 61 import org.graalvm.compiler.lir.aarch64.AArch64AtomicMove.AtomicReadAndAddOp; 62 import org.graalvm.compiler.lir.aarch64.AArch64AtomicMove.AtomicReadAndAddLSEOp; 63 import org.graalvm.compiler.lir.aarch64.AArch64AtomicMove.CompareAndSwapOp; 64 import org.graalvm.compiler.lir.aarch64.AArch64AtomicMove.AtomicReadAndWriteOp; 65 import org.graalvm.compiler.lir.aarch64.AArch64Move.MembarOp; 66 import org.graalvm.compiler.lir.aarch64.AArch64PauseOp; 67 import org.graalvm.compiler.lir.aarch64.AArch64SpeculativeBarrier; 68 import org.graalvm.compiler.lir.gen.LIRGenerationResult; 69 import org.graalvm.compiler.lir.gen.LIRGenerator; 70 import org.graalvm.compiler.phases.util.Providers; 71 72 import jdk.vm.ci.aarch64.AArch64; 73 import jdk.vm.ci.aarch64.AArch64Kind; 74 import jdk.vm.ci.code.CallingConvention; 75 import jdk.vm.ci.code.RegisterValue; 76 import jdk.vm.ci.meta.AllocatableValue; 77 import jdk.vm.ci.meta.JavaConstant; 78 import jdk.vm.ci.meta.JavaKind; 79 import jdk.vm.ci.meta.PlatformKind; 80 import jdk.vm.ci.meta.PrimitiveConstant; 81 import jdk.vm.ci.meta.Value; 82 import jdk.vm.ci.meta.ValueKind; 83 84 public abstract class AArch64LIRGenerator extends LIRGenerator { 85 86 public AArch64LIRGenerator(LIRKindTool lirKindTool, AArch64ArithmeticLIRGenerator arithmeticLIRGen, MoveFactory moveFactory, Providers providers, LIRGenerationResult lirGenRes) { 87 super(lirKindTool, arithmeticLIRGen, moveFactory, providers, lirGenRes); 88 } 89 90 /** 91 * Checks whether the supplied constant can be used without loading it into a register for store 92 * operations, i.e., on the right hand side of a memory access. 93 * 94 * @param c The constant to check. 95 * @return True if the constant can be used directly, false if the constant needs to be in a 96 * register. 97 */ 98 protected static final boolean canStoreConstant(JavaConstant c) { 99 // Our own code never calls this since we can't make a definite statement about whether or 100 // not we can inline a constant without knowing what kind of operation we execute. Let's be 101 // optimistic here and fix up mistakes later. 102 return true; 103 } 104 105 /** 106 * If val denotes the stackpointer, move it to another location. This is necessary since most 107 * ops cannot handle the stackpointer as input or output. 108 */ 109 public AllocatableValue moveSp(AllocatableValue val) { 110 if (val instanceof RegisterValue && ((RegisterValue) val).getRegister().equals(sp)) { 111 assert val.getPlatformKind() == AArch64Kind.QWORD : "Stackpointer must be long"; 112 return emitMove(val); 113 } 114 return val; 115 } 116 117 /** 118 * AArch64 cannot use anything smaller than a word in any instruction other than load and store. 119 */ 120 @Override 121 public <K extends ValueKind<K>> K toRegisterKind(K kind) { 122 switch ((AArch64Kind) kind.getPlatformKind()) { 123 case BYTE: 124 case WORD: 125 return kind.changeType(AArch64Kind.DWORD); 126 default: 127 return kind; 128 } 129 } 130 131 @Override 132 public void emitNullCheck(Value address, LIRFrameState state) { 133 append(new AArch64Move.NullCheckOp(asAddressValue(address), state)); 134 } 135 136 @Override 137 public Variable emitAddress(AllocatableValue stackslot) { 138 Variable result = newVariable(LIRKind.value(target().arch.getWordKind())); 139 append(new AArch64Move.StackLoadAddressOp(result, stackslot)); 140 return result; 141 } 142 143 public AArch64AddressValue asAddressValue(Value address) { 144 if (address instanceof AArch64AddressValue) { 145 return (AArch64AddressValue) address; 146 } else { 147 return new AArch64AddressValue(address.getValueKind(), asAllocatable(address), Value.ILLEGAL, 0, 1, AddressingMode.BASE_REGISTER_ONLY); 148 } 149 } 150 151 @Override 152 public Variable emitLogicCompareAndSwap(LIRKind accessKind, Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue) { 153 Variable prevValue = newVariable(expectedValue.getValueKind()); 154 Variable scratch = newVariable(LIRKind.value(AArch64Kind.DWORD)); 155 append(new CompareAndSwapOp(prevValue, loadReg(expectedValue), loadReg(newValue), asAllocatable(address), scratch)); 156 assert trueValue.getValueKind().equals(falseValue.getValueKind()); 157 Variable result = newVariable(trueValue.getValueKind()); 158 append(new CondMoveOp(result, ConditionFlag.EQ, asAllocatable(trueValue), asAllocatable(falseValue))); 159 return result; 160 } 161 162 @Override 163 public Variable emitValueCompareAndSwap(LIRKind accessKind, Value address, Value expectedValue, Value newValue) { 164 Variable result = newVariable(newValue.getValueKind()); 165 Variable scratch = newVariable(LIRKind.value(AArch64Kind.WORD)); 166 append(new CompareAndSwapOp(result, loadNonCompareConst(expectedValue), loadReg(newValue), asAllocatable(address), scratch)); 167 return result; 168 } 169 170 @Override 171 public Value emitAtomicReadAndWrite(Value address, ValueKind<?> kind, Value newValue) { 172 Variable result = newVariable(kind); 173 Variable scratch = newVariable(kind); 174 append(new AtomicReadAndWriteOp((AArch64Kind) kind.getPlatformKind(), asAllocatable(result), asAllocatable(address), asAllocatable(newValue), asAllocatable(scratch))); 175 return result; 176 } 177 178 @Override 179 public Value emitAtomicReadAndAdd(Value address, ValueKind<?> kind, Value delta) { 180 Variable result = newVariable(kind); 181 if (AArch64LIRFlagsVersioned.useLSE(target().arch)) { 182 append(new AtomicReadAndAddLSEOp((AArch64Kind) kind.getPlatformKind(), asAllocatable(result), asAllocatable(address), asAllocatable(delta))); 183 } else { 184 append(new AtomicReadAndAddOp((AArch64Kind) kind.getPlatformKind(), asAllocatable(result), asAllocatable(address), delta)); 185 } 186 return result; 187 } 188 189 @Override 190 public void emitMembar(int barriers) { 191 int necessaryBarriers = target().arch.requiredBarriers(barriers); 192 if (target().isMP && necessaryBarriers != 0) { 193 append(new MembarOp(necessaryBarriers)); 194 } 195 } 196 197 @Override 198 public void emitJump(LabelRef label) { 199 assert label != null; 200 append(new StandardOp.JumpOp(label)); 201 } 202 203 @Override 204 public void emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, LIRKind cmpKind, double overflowProbability) { 205 append(new AArch64ControlFlow.BranchOp(ConditionFlag.VS, overflow, noOverflow, overflowProbability)); 206 } 207 208 /** 209 * Branches to label if (left & right) == 0. If negated is true branchse on non-zero instead. 210 * 211 * @param left Integer kind. Non null. 212 * @param right Integer kind. Non null. 213 * @param trueDestination destination if left & right == 0. Non null. 214 * @param falseDestination destination if left & right != 0. Non null 215 * @param trueSuccessorProbability hoistoric probability that comparison is true 216 */ 217 @Override 218 public void emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueSuccessorProbability) { 219 assert ((AArch64Kind) left.getPlatformKind()).isInteger() && left.getPlatformKind() == right.getPlatformKind(); 220 ((AArch64ArithmeticLIRGenerator) getArithmetic()).emitBinary(LIRKind.combine(left, right), AArch64ArithmeticOp.ANDS, true, left, right); 221 append(new AArch64ControlFlow.BranchOp(ConditionFlag.EQ, trueDestination, falseDestination, trueSuccessorProbability)); 222 } 223 224 /** 225 * Conditionally move trueValue into new variable if cond + unorderedIsTrue is true, else 226 * falseValue. 227 * 228 * @param left Arbitrary value. Has to have same type as right. Non null. 229 * @param right Arbitrary value. Has to have same type as left. Non null. 230 * @param cond condition that decides whether to move trueValue or falseValue into result. Non 231 * null. 232 * @param unorderedIsTrue defines whether floating-point comparisons consider unordered true or 233 * not. Ignored for integer comparisons. 234 * @param trueValue arbitrary value same type as falseValue. Non null. 235 * @param falseValue arbitrary value same type as trueValue. Non null. 236 * @return value containing trueValue if cond + unorderedIsTrue is true, else falseValue. Non 237 * null. 238 */ 239 @Override 240 public Variable emitConditionalMove(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue) { 241 boolean mirrored = emitCompare(cmpKind, left, right, cond, unorderedIsTrue); 242 Condition finalCondition = mirrored ? cond.mirror() : cond; 243 boolean finalUnorderedIsTrue = mirrored ? !unorderedIsTrue : unorderedIsTrue; 244 ConditionFlag cmpCondition = toConditionFlag(((AArch64Kind) cmpKind).isInteger(), finalCondition, finalUnorderedIsTrue); 245 Variable result = newVariable(trueValue.getValueKind()); 246 247 if (isIntConstant(trueValue, 1) && isIntConstant(falseValue, 0)) { 248 append(new CondSetOp(result, cmpCondition)); 249 } else if (isIntConstant(trueValue, 0) && isIntConstant(falseValue, 1)) { 250 append(new CondSetOp(result, cmpCondition.negate())); 251 } else { 252 append(new CondMoveOp(result, cmpCondition, loadReg(trueValue), loadReg(falseValue))); 253 } 254 return result; 255 } 256 257 @Override 258 public void emitCompareBranch(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef trueDestination, LabelRef falseDestination, 259 double trueDestinationProbability) { 260 boolean mirrored = emitCompare(cmpKind, left, right, cond, unorderedIsTrue); 261 Condition finalCondition = mirrored ? cond.mirror() : cond; 262 boolean finalUnorderedIsTrue = mirrored ? !unorderedIsTrue : unorderedIsTrue; 263 ConditionFlag cmpCondition = toConditionFlag(((AArch64Kind) cmpKind).isInteger(), finalCondition, finalUnorderedIsTrue); 264 append(new BranchOp(cmpCondition, trueDestination, falseDestination, trueDestinationProbability)); 265 } 266 267 private static ConditionFlag toConditionFlag(boolean isInt, Condition cond, boolean unorderedIsTrue) { 268 return isInt ? toIntConditionFlag(cond) : toFloatConditionFlag(cond, unorderedIsTrue); 269 } 270 271 /** 272 * Takes a Condition and unorderedIsTrue flag and returns the correct Aarch64 specific 273 * ConditionFlag. Note: This is only correct if the emitCompare code for floats has correctly 274 * handled the case of 'EQ && unorderedIsTrue', respectively 'NE && !unorderedIsTrue'! 275 */ 276 private static ConditionFlag toFloatConditionFlag(Condition cond, boolean unorderedIsTrue) { 277 switch (cond) { 278 case LT: 279 return unorderedIsTrue ? ConditionFlag.LT : ConditionFlag.LO; 280 case LE: 281 return unorderedIsTrue ? ConditionFlag.LE : ConditionFlag.LS; 282 case GE: 283 return unorderedIsTrue ? ConditionFlag.PL : ConditionFlag.GE; 284 case GT: 285 return unorderedIsTrue ? ConditionFlag.HI : ConditionFlag.GT; 286 case EQ: 287 return ConditionFlag.EQ; 288 case NE: 289 return ConditionFlag.NE; 290 default: 291 throw GraalError.shouldNotReachHere(); 292 } 293 } 294 295 /** 296 * Takes a Condition and returns the correct Aarch64 specific ConditionFlag. 297 */ 298 private static ConditionFlag toIntConditionFlag(Condition cond) { 299 switch (cond) { 300 case EQ: 301 return ConditionFlag.EQ; 302 case NE: 303 return ConditionFlag.NE; 304 case LT: 305 return ConditionFlag.LT; 306 case LE: 307 return ConditionFlag.LE; 308 case GT: 309 return ConditionFlag.GT; 310 case GE: 311 return ConditionFlag.GE; 312 case AE: 313 return ConditionFlag.HS; 314 case BE: 315 return ConditionFlag.LS; 316 case AT: 317 return ConditionFlag.HI; 318 case BT: 319 return ConditionFlag.LO; 320 default: 321 throw GraalError.shouldNotReachHere(); 322 } 323 } 324 325 /** 326 * This method emits the compare instruction, and may reorder the operands. It returns true if 327 * it did so. 328 * 329 * @param a the left operand of the comparison. Has to have same type as b. Non null. 330 * @param b the right operand of the comparison. Has to have same type as a. Non null. 331 * @return true if mirrored (i.e. "b cmp a" instead of "a cmp b" was done). 332 */ 333 protected boolean emitCompare(PlatformKind cmpKind, Value a, Value b, Condition condition, boolean unorderedIsTrue) { 334 Value left; 335 Value right; 336 boolean mirrored; 337 AArch64Kind kind = (AArch64Kind) cmpKind; 338 if (kind.isInteger()) { 339 Value aExt = a; 340 Value bExt = b; 341 342 int compareBytes = cmpKind.getSizeInBytes(); 343 // AArch64 compares 32 or 64 bits: sign extend a and b as required. 344 if (compareBytes < a.getPlatformKind().getSizeInBytes()) { 345 aExt = arithmeticLIRGen.emitSignExtend(a, compareBytes * 8, 64); 346 } 347 if (compareBytes < b.getPlatformKind().getSizeInBytes()) { 348 bExt = arithmeticLIRGen.emitSignExtend(b, compareBytes * 8, 64); 349 } 350 351 if (LIRValueUtil.isVariable(bExt)) { 352 left = load(bExt); 353 right = loadNonConst(aExt); 354 mirrored = true; 355 } else { 356 left = load(aExt); 357 right = loadNonConst(bExt); 358 mirrored = false; 359 } 360 append(new AArch64Compare.CompareOp(left, loadNonCompareConst(right))); 361 } else if (kind.isSIMD()) { 362 if (AArch64Compare.FloatCompareOp.isFloatCmpConstant(a, condition, unorderedIsTrue)) { 363 left = load(b); 364 right = a; 365 mirrored = true; 366 } else if (AArch64Compare.FloatCompareOp.isFloatCmpConstant(b, condition, unorderedIsTrue)) { 367 left = load(a); 368 right = b; 369 mirrored = false; 370 } else { 371 left = load(a); 372 right = loadReg(b); 373 mirrored = false; 374 } 375 append(new AArch64Compare.FloatCompareOp(left, asAllocatable(right), condition, unorderedIsTrue)); 376 } else { 377 throw GraalError.shouldNotReachHere(); 378 } 379 return mirrored; 380 } 381 382 /** 383 * If value is a constant that cannot be used directly with a gpCompare instruction load it into 384 * a register and return the register, otherwise return constant value unchanged. 385 */ 386 protected Value loadNonCompareConst(Value value) { 387 if (!isCompareConstant(value)) { 388 return loadReg(value); 389 } 390 return value; 391 } 392 393 /** 394 * Checks whether value can be used directly with a gpCompare instruction. This is <b>not</b> 395 * the same as {@link AArch64ArithmeticLIRGenerator#isArithmeticConstant(JavaConstant)}, because 396 * 0.0 is a valid compare constant for floats, while there are no arithmetic constants for 397 * floats. 398 * 399 * @param value any type. Non null. 400 * @return true if value can be used directly in comparison instruction, false otherwise. 401 */ 402 public boolean isCompareConstant(Value value) { 403 if (isJavaConstant(value)) { 404 JavaConstant constant = asJavaConstant(value); 405 if (constant instanceof PrimitiveConstant) { 406 final long longValue = constant.asLong(); 407 long maskedValue; 408 switch (constant.getJavaKind()) { 409 case Boolean: 410 case Byte: 411 maskedValue = longValue & 0xFF; 412 break; 413 case Char: 414 case Short: 415 maskedValue = longValue & 0xFFFF; 416 break; 417 case Int: 418 maskedValue = longValue & 0xFFFF_FFFF; 419 break; 420 case Long: 421 maskedValue = longValue; 422 break; 423 default: 424 throw GraalError.shouldNotReachHere(); 425 } 426 return AArch64MacroAssembler.isArithmeticImmediate(maskedValue); 427 } else { 428 return constant.isDefaultForKind(); 429 } 430 } 431 return false; 432 } 433 434 /** 435 * Moves trueValue into result if (left & right) == 0, else falseValue. 436 * 437 * @param left Integer kind. Non null. 438 * @param right Integer kind. Non null. 439 * @param trueValue Integer kind. Non null. 440 * @param falseValue Integer kind. Non null. 441 * @return virtual register containing trueValue if (left & right) == 0, else falseValue. 442 */ 443 @Override 444 public Variable emitIntegerTestMove(Value left, Value right, Value trueValue, Value falseValue) { 445 assert ((AArch64Kind) left.getPlatformKind()).isInteger() && ((AArch64Kind) right.getPlatformKind()).isInteger(); 446 assert ((AArch64Kind) trueValue.getPlatformKind()).isInteger() && ((AArch64Kind) falseValue.getPlatformKind()).isInteger(); 447 ((AArch64ArithmeticLIRGenerator) getArithmetic()).emitBinary(left.getValueKind(), AArch64ArithmeticOp.ANDS, true, left, right); 448 Variable result = newVariable(trueValue.getValueKind()); 449 450 if (isIntConstant(trueValue, 1) && isIntConstant(falseValue, 0)) { 451 append(new CondSetOp(result, ConditionFlag.EQ)); 452 } else if (isIntConstant(trueValue, 0) && isIntConstant(falseValue, 1)) { 453 append(new CondSetOp(result, ConditionFlag.NE)); 454 } else { 455 append(new CondMoveOp(result, ConditionFlag.EQ, load(trueValue), load(falseValue))); 456 } 457 return result; 458 } 459 460 @Override 461 public void emitStrategySwitch(SwitchStrategy strategy, Variable key, LabelRef[] keyTargets, LabelRef defaultTarget) { 462 append(createStrategySwitchOp(strategy, keyTargets, defaultTarget, key, newVariable(key.getValueKind()), AArch64LIRGenerator::toIntConditionFlag)); 463 } 464 465 protected StrategySwitchOp createStrategySwitchOp(SwitchStrategy strategy, LabelRef[] keyTargets, LabelRef defaultTarget, Variable key, AllocatableValue scratchValue, 466 Function<Condition, ConditionFlag> converter) { 467 return new StrategySwitchOp(strategy, keyTargets, defaultTarget, key, scratchValue, converter); 468 } 469 470 @Override 471 protected void emitTableSwitch(int lowKey, LabelRef defaultTarget, LabelRef[] targets, Value key) { 472 append(new TableSwitchOp(lowKey, defaultTarget, targets, key, newVariable(LIRKind.value(target().arch.getWordKind())), newVariable(key.getValueKind()))); 473 } 474 475 @Override 476 public Variable emitByteSwap(Value input) { 477 Variable result = newVariable(LIRKind.combine(input)); 478 append(new AArch64ByteSwapOp(result, input)); 479 return result; 480 } 481 482 @Override 483 public Variable emitArrayCompareTo(JavaKind kind1, JavaKind kind2, Value array1, Value array2, Value length1, Value length2) { 484 LIRKind resultKind = LIRKind.value(AArch64Kind.DWORD); 485 // DMS TODO: check calling conversion and registers used 486 RegisterValue res = AArch64.r0.asValue(resultKind); 487 RegisterValue cnt1 = AArch64.r1.asValue(length1.getValueKind()); 488 RegisterValue cnt2 = AArch64.r2.asValue(length2.getValueKind()); 489 emitMove(cnt1, length1); 490 emitMove(cnt2, length2); 491 append(new AArch64ArrayCompareToOp(this, kind1, kind2, res, array1, array2, cnt1, cnt2)); 492 Variable result = newVariable(resultKind); 493 emitMove(result, res); 494 return result; 495 } 496 497 @Override 498 public Variable emitArrayEquals(JavaKind kind, Value array1, Value array2, Value length, int constantLength, boolean directPointers) { 499 Variable result = newVariable(LIRKind.value(AArch64Kind.DWORD)); 500 append(new AArch64ArrayEqualsOp(this, kind, result, array1, array2, asAllocatable(length), directPointers)); 501 return result; 502 } 503 504 @Override 505 protected JavaConstant zapValueForKind(PlatformKind kind) { 506 long dead = 0xDEADDEADDEADDEADL; 507 switch ((AArch64Kind) kind) { 508 case BYTE: 509 return JavaConstant.forByte((byte) dead); 510 case WORD: 511 return JavaConstant.forShort((short) dead); 512 case DWORD: 513 return JavaConstant.forInt((int) dead); 514 case QWORD: 515 return JavaConstant.forLong(dead); 516 case SINGLE: 517 return JavaConstant.forFloat(Float.intBitsToFloat((int) dead)); 518 case DOUBLE: 519 return JavaConstant.forDouble(Double.longBitsToDouble(dead)); 520 default: 521 throw GraalError.shouldNotReachHere(); 522 } 523 } 524 525 /** 526 * Loads value into virtual register. Contrary to {@link #load(Value)} this handles 527 * RegisterValues (i.e. values corresponding to fixed physical registers) correctly, by not 528 * creating an unnecessary move into a virtual register. 529 * 530 * This avoids generating the following code: mov x0, x19 # x19 is fixed thread register ldr x0, 531 * [x0] instead of: ldr x0, [x19]. 532 */ 533 protected AllocatableValue loadReg(Value val) { 534 if (!(val instanceof Variable || val instanceof RegisterValue)) { 535 return emitMove(val); 536 } 537 return (AllocatableValue) val; 538 } 539 540 @Override 541 public void emitPause() { 542 append(new AArch64PauseOp()); 543 } 544 545 public abstract void emitCCall(long address, CallingConvention nativeCallingConvention, Value[] args); 546 547 @Override 548 public void emitSpeculationFence() { 549 append(new AArch64SpeculativeBarrier()); 550 } 551 }