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) {
|