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.lir.aarch64; 26 27 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.COMPOSITE; 28 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.HINT; 29 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.REG; 30 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.STACK; 31 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.UNINITIALIZED; 32 import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant; 33 import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant; 34 import static jdk.vm.ci.aarch64.AArch64.sp; 35 import static jdk.vm.ci.aarch64.AArch64.zr; 36 import static jdk.vm.ci.code.ValueUtil.asAllocatableValue; 37 import static jdk.vm.ci.code.ValueUtil.asRegister; 38 import static jdk.vm.ci.code.ValueUtil.asStackSlot; 39 import static jdk.vm.ci.code.ValueUtil.isRegister; 40 import static jdk.vm.ci.code.ValueUtil.isStackSlot; 41 42 import org.graalvm.compiler.asm.aarch64.AArch64Address; 43 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler; 44 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler.ScratchRegister; 45 import org.graalvm.compiler.core.common.LIRKind; 46 import org.graalvm.compiler.core.common.type.DataPointerConstant; 47 import org.graalvm.compiler.debug.GraalError; 48 import org.graalvm.compiler.lir.LIRFrameState; 49 import org.graalvm.compiler.lir.LIRInstructionClass; 50 import org.graalvm.compiler.lir.Opcode; 51 import org.graalvm.compiler.lir.StandardOp; 52 import org.graalvm.compiler.lir.StandardOp.LoadConstantOp; 53 import org.graalvm.compiler.lir.StandardOp.NullCheck; 54 import org.graalvm.compiler.lir.StandardOp.ValueMoveOp; 55 import org.graalvm.compiler.lir.VirtualStackSlot; 56 import org.graalvm.compiler.lir.asm.CompilationResultBuilder; 57 58 import jdk.vm.ci.aarch64.AArch64Kind; 59 import jdk.vm.ci.code.Register; 60 import jdk.vm.ci.code.StackSlot; 61 import jdk.vm.ci.meta.AllocatableValue; 62 import jdk.vm.ci.meta.Constant; 63 import jdk.vm.ci.meta.JavaConstant; 64 import jdk.vm.ci.meta.PlatformKind; 65 import jdk.vm.ci.meta.Value; 66 67 public class AArch64Move { 68 69 public static class LoadInlineConstant extends AArch64LIRInstruction implements LoadConstantOp { 70 public static final LIRInstructionClass<LoadInlineConstant> TYPE = LIRInstructionClass.create(LoadInlineConstant.class); 71 72 private JavaConstant constant; 73 @Def({REG, STACK}) AllocatableValue result; 74 75 public LoadInlineConstant(JavaConstant constant, AllocatableValue result) { 76 super(TYPE); 77 this.constant = constant; 78 this.result = result; 195 } 196 } 197 } 198 199 public static class MembarOp extends AArch64LIRInstruction { 200 public static final LIRInstructionClass<MembarOp> TYPE = LIRInstructionClass.create(MembarOp.class); 201 202 // For future use. 203 @SuppressWarnings("unused") private final int barriers; 204 205 public MembarOp(int barriers) { 206 super(TYPE); 207 this.barriers = barriers; 208 } 209 210 @Override 211 // The odd-looking @SuppressWarnings("all") is here because of 212 // a compiler bug which warns that crb is unused, and also 213 // warns that @SuppressWarnings("unused") is unnecessary. 214 public void emitCode(@SuppressWarnings("all") CompilationResultBuilder crb, AArch64MacroAssembler masm) { 215 // As I understand it load acquire/store release have the same semantics as on IA64 216 // and allow us to handle LoadStore, LoadLoad and StoreStore without an explicit 217 // barrier. 218 // But Graal support to figure out if a load/store is volatile is non-existant so for 219 // now just use memory barriers everywhere. 220 // if ((barrier & MemoryBarriers.STORE_LOAD) != 0) { 221 masm.dmb(AArch64MacroAssembler.BarrierKind.ANY_ANY); 222 // } 223 } 224 } 225 226 abstract static class MemOp extends AArch64LIRInstruction implements StandardOp.ImplicitNullCheck { 227 228 protected final AArch64Kind kind; 229 @Use({COMPOSITE}) protected AArch64AddressValue addressValue; 230 @State protected LIRFrameState state; 231 232 MemOp(LIRInstructionClass<? extends MemOp> c, AArch64Kind kind, AArch64AddressValue address, LIRFrameState state) { 233 super(c); 234 this.kind = kind; 235 this.addressValue = address; 236 this.state = state; 237 } 238 239 protected abstract void emitMemAccess(CompilationResultBuilder crb, AArch64MacroAssembler masm); 240 241 @Override 242 public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) { | 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.lir.aarch64; 26 27 import static jdk.vm.ci.aarch64.AArch64.sp; 28 import static jdk.vm.ci.aarch64.AArch64.zr; 29 import static jdk.vm.ci.code.ValueUtil.asAllocatableValue; 30 import static jdk.vm.ci.code.ValueUtil.asRegister; 31 import static jdk.vm.ci.code.ValueUtil.asStackSlot; 32 import static jdk.vm.ci.code.ValueUtil.isRegister; 33 import static jdk.vm.ci.code.ValueUtil.isStackSlot; 34 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.COMPOSITE; 35 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.HINT; 36 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.REG; 37 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.STACK; 38 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.UNINITIALIZED; 39 import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant; 40 import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant; 41 42 import org.graalvm.compiler.asm.aarch64.AArch64Address; 43 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler; 44 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler.ScratchRegister; 45 import org.graalvm.compiler.core.common.LIRKind; 46 import org.graalvm.compiler.core.common.type.DataPointerConstant; 47 import org.graalvm.compiler.debug.GraalError; 48 import org.graalvm.compiler.lir.LIRFrameState; 49 import org.graalvm.compiler.lir.LIRInstructionClass; 50 import org.graalvm.compiler.lir.Opcode; 51 import org.graalvm.compiler.lir.StandardOp; 52 import org.graalvm.compiler.lir.StandardOp.LoadConstantOp; 53 import org.graalvm.compiler.lir.StandardOp.NullCheck; 54 import org.graalvm.compiler.lir.StandardOp.ValueMoveOp; 55 import org.graalvm.compiler.lir.VirtualStackSlot; 56 import org.graalvm.compiler.lir.asm.CompilationResultBuilder; 57 58 import jdk.vm.ci.aarch64.AArch64Kind; 59 import jdk.vm.ci.code.MemoryBarriers; 60 import jdk.vm.ci.code.Register; 61 import jdk.vm.ci.code.StackSlot; 62 import jdk.vm.ci.meta.AllocatableValue; 63 import jdk.vm.ci.meta.Constant; 64 import jdk.vm.ci.meta.JavaConstant; 65 import jdk.vm.ci.meta.PlatformKind; 66 import jdk.vm.ci.meta.Value; 67 68 public class AArch64Move { 69 70 public static class LoadInlineConstant extends AArch64LIRInstruction implements LoadConstantOp { 71 public static final LIRInstructionClass<LoadInlineConstant> TYPE = LIRInstructionClass.create(LoadInlineConstant.class); 72 73 private JavaConstant constant; 74 @Def({REG, STACK}) AllocatableValue result; 75 76 public LoadInlineConstant(JavaConstant constant, AllocatableValue result) { 77 super(TYPE); 78 this.constant = constant; 79 this.result = result; 196 } 197 } 198 } 199 200 public static class MembarOp extends AArch64LIRInstruction { 201 public static final LIRInstructionClass<MembarOp> TYPE = LIRInstructionClass.create(MembarOp.class); 202 203 // For future use. 204 @SuppressWarnings("unused") private final int barriers; 205 206 public MembarOp(int barriers) { 207 super(TYPE); 208 this.barriers = barriers; 209 } 210 211 @Override 212 // The odd-looking @SuppressWarnings("all") is here because of 213 // a compiler bug which warns that crb is unused, and also 214 // warns that @SuppressWarnings("unused") is unnecessary. 215 public void emitCode(@SuppressWarnings("all") CompilationResultBuilder crb, AArch64MacroAssembler masm) { 216 assert barriers >= MemoryBarriers.LOAD_LOAD && barriers <= (MemoryBarriers.STORE_STORE | MemoryBarriers.STORE_LOAD | MemoryBarriers.LOAD_STORE | MemoryBarriers.LOAD_LOAD); 217 switch (barriers) { 218 case MemoryBarriers.STORE_STORE: 219 masm.dmb(AArch64MacroAssembler.BarrierKind.STORE_STORE); 220 break; 221 case MemoryBarriers.LOAD_LOAD: 222 case MemoryBarriers.LOAD_STORE: 223 case MemoryBarriers.LOAD_LOAD | MemoryBarriers.LOAD_STORE: 224 masm.dmb(AArch64MacroAssembler.BarrierKind.LOAD_LOAD); 225 break; 226 default: 227 masm.dmb(AArch64MacroAssembler.BarrierKind.ANY_ANY); 228 break; 229 } 230 } 231 } 232 233 abstract static class MemOp extends AArch64LIRInstruction implements StandardOp.ImplicitNullCheck { 234 235 protected final AArch64Kind kind; 236 @Use({COMPOSITE}) protected AArch64AddressValue addressValue; 237 @State protected LIRFrameState state; 238 239 MemOp(LIRInstructionClass<? extends MemOp> c, AArch64Kind kind, AArch64AddressValue address, LIRFrameState state) { 240 super(c); 241 this.kind = kind; 242 this.addressValue = address; 243 this.state = state; 244 } 245 246 protected abstract void emitMemAccess(CompilationResultBuilder crb, AArch64MacroAssembler masm); 247 248 @Override 249 public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) { |