|
22759
|
1 /*
|
|
|
2 * Copyright (c) 2015, 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 jdk.vm.ci.aarch64;
|
|
|
24
|
|
|
25 import java.nio.ByteOrder;
|
|
|
26 import java.util.EnumSet;
|
|
|
27
|
|
|
28 import jdk.vm.ci.code.Architecture;
|
|
|
29 import jdk.vm.ci.code.Register;
|
|
|
30 import jdk.vm.ci.code.Register.RegisterCategory;
|
|
|
31 import jdk.vm.ci.meta.JavaKind;
|
|
|
32 import jdk.vm.ci.meta.PlatformKind;
|
|
|
33
|
|
|
34 /**
|
|
|
35 * Represents the AArch64 architecture.
|
|
|
36 */
|
|
|
37 public class AArch64 extends Architecture {
|
|
|
38
|
|
|
39 public static final RegisterCategory CPU = new RegisterCategory("CPU");
|
|
|
40
|
|
|
41 // General purpose CPU registers
|
|
|
42 public static final Register r0 = new Register(0, 0, "r0", CPU);
|
|
|
43 public static final Register r1 = new Register(1, 1, "r1", CPU);
|
|
|
44 public static final Register r2 = new Register(2, 2, "r2", CPU);
|
|
|
45 public static final Register r3 = new Register(3, 3, "r3", CPU);
|
|
|
46 public static final Register r4 = new Register(4, 4, "r4", CPU);
|
|
|
47 public static final Register r5 = new Register(5, 5, "r5", CPU);
|
|
|
48 public static final Register r6 = new Register(6, 6, "r6", CPU);
|
|
|
49 public static final Register r7 = new Register(7, 7, "r7", CPU);
|
|
|
50 public static final Register r8 = new Register(8, 8, "r8", CPU);
|
|
|
51 public static final Register r9 = new Register(9, 9, "r9", CPU);
|
|
|
52 public static final Register r10 = new Register(10, 10, "r10", CPU);
|
|
|
53 public static final Register r11 = new Register(11, 11, "r11", CPU);
|
|
|
54 public static final Register r12 = new Register(12, 12, "r12", CPU);
|
|
|
55 public static final Register r13 = new Register(13, 13, "r13", CPU);
|
|
|
56 public static final Register r14 = new Register(14, 14, "r14", CPU);
|
|
|
57 public static final Register r15 = new Register(15, 15, "r15", CPU);
|
|
|
58 public static final Register r16 = new Register(16, 16, "r16", CPU);
|
|
|
59 public static final Register r17 = new Register(17, 17, "r17", CPU);
|
|
|
60 public static final Register r18 = new Register(18, 18, "r18", CPU);
|
|
|
61 public static final Register r19 = new Register(19, 19, "r19", CPU);
|
|
|
62 public static final Register r20 = new Register(20, 20, "r20", CPU);
|
|
|
63 public static final Register r21 = new Register(21, 21, "r21", CPU);
|
|
|
64 public static final Register r22 = new Register(22, 22, "r22", CPU);
|
|
|
65 public static final Register r23 = new Register(23, 23, "r23", CPU);
|
|
|
66 public static final Register r24 = new Register(24, 24, "r24", CPU);
|
|
|
67 public static final Register r25 = new Register(25, 25, "r25", CPU);
|
|
|
68 public static final Register r26 = new Register(26, 26, "r26", CPU);
|
|
|
69 public static final Register r27 = new Register(27, 27, "r27", CPU);
|
|
|
70 public static final Register r28 = new Register(28, 28, "r28", CPU);
|
|
|
71 public static final Register r29 = new Register(29, 29, "r29", CPU);
|
|
|
72 public static final Register r30 = new Register(30, 30, "r30", CPU);
|
|
|
73 public static final Register r31 = new Register(31, 31, "r31", CPU);
|
|
|
74
|
|
|
75 public static final Register lr = r30;
|
|
|
76 public static final Register zr = r31;
|
|
|
77 public static final Register sp = r31;
|
|
|
78
|
|
|
79 // @formatter:off
|
|
|
80 public static final Register[] cpuRegisters = {
|
|
|
81 r0, r1, r2, r3, r4, r5, r6, r7,
|
|
|
82 r8, r9, r10, r11, r12, r13, r14, r15,
|
|
|
83 r16, r17, r18, r19, r20, r21, r22, r23,
|
|
|
84 r24, r25, r26, r27, r28, r29, r30, r31
|
|
|
85 };
|
|
|
86 // @formatter:on
|
|
|
87
|
|
|
88 public static final RegisterCategory SIMD = new RegisterCategory("SIMD");
|
|
|
89
|
|
|
90 // Simd registers
|
|
|
91 public static final Register v0 = new Register(32, 0, "v0", SIMD);
|
|
|
92 public static final Register v1 = new Register(33, 1, "v1", SIMD);
|
|
|
93 public static final Register v2 = new Register(34, 2, "v2", SIMD);
|
|
|
94 public static final Register v3 = new Register(35, 3, "v3", SIMD);
|
|
|
95 public static final Register v4 = new Register(36, 4, "v4", SIMD);
|
|
|
96 public static final Register v5 = new Register(37, 5, "v5", SIMD);
|
|
|
97 public static final Register v6 = new Register(38, 6, "v6", SIMD);
|
|
|
98 public static final Register v7 = new Register(39, 7, "v7", SIMD);
|
|
|
99 public static final Register v8 = new Register(40, 8, "v8", SIMD);
|
|
|
100 public static final Register v9 = new Register(41, 9, "v9", SIMD);
|
|
|
101 public static final Register v10 = new Register(42, 10, "v10", SIMD);
|
|
|
102 public static final Register v11 = new Register(43, 11, "v11", SIMD);
|
|
|
103 public static final Register v12 = new Register(44, 12, "v12", SIMD);
|
|
|
104 public static final Register v13 = new Register(45, 13, "v13", SIMD);
|
|
|
105 public static final Register v14 = new Register(46, 14, "v14", SIMD);
|
|
|
106 public static final Register v15 = new Register(47, 15, "v15", SIMD);
|
|
|
107 public static final Register v16 = new Register(48, 16, "v16", SIMD);
|
|
|
108 public static final Register v17 = new Register(49, 17, "v17", SIMD);
|
|
|
109 public static final Register v18 = new Register(50, 18, "v18", SIMD);
|
|
|
110 public static final Register v19 = new Register(51, 19, "v19", SIMD);
|
|
|
111 public static final Register v20 = new Register(52, 20, "v20", SIMD);
|
|
|
112 public static final Register v21 = new Register(53, 21, "v21", SIMD);
|
|
|
113 public static final Register v22 = new Register(54, 22, "v22", SIMD);
|
|
|
114 public static final Register v23 = new Register(55, 23, "v23", SIMD);
|
|
|
115 public static final Register v24 = new Register(56, 24, "v24", SIMD);
|
|
|
116 public static final Register v25 = new Register(57, 25, "v25", SIMD);
|
|
|
117 public static final Register v26 = new Register(58, 26, "v26", SIMD);
|
|
|
118 public static final Register v27 = new Register(59, 27, "v27", SIMD);
|
|
|
119 public static final Register v28 = new Register(60, 28, "v28", SIMD);
|
|
|
120 public static final Register v29 = new Register(61, 29, "v29", SIMD);
|
|
|
121 public static final Register v30 = new Register(62, 30, "v30", SIMD);
|
|
|
122 public static final Register v31 = new Register(63, 31, "v31", SIMD);
|
|
|
123
|
|
|
124 // @formatter:off
|
|
|
125 public static final Register[] simdRegisters = {
|
|
|
126 v0, v1, v2, v3, v4, v5, v6, v7,
|
|
|
127 v8, v9, v10, v11, v12, v13, v14, v15,
|
|
|
128 v16, v17, v18, v19, v20, v21, v22, v23,
|
|
|
129 v24, v25, v26, v27, v28, v29, v30, v31
|
|
|
130 };
|
|
|
131 // @formatter:on
|
|
|
132
|
|
|
133 // @formatter:off
|
|
|
134 public static final Register[] allRegisters = {
|
|
|
135 r0, r1, r2, r3, r4, r5, r6, r7,
|
|
|
136 r8, r9, r10, r11, r12, r13, r14, r15,
|
|
|
137 r16, r17, r18, r19, r20, r21, r22, r23,
|
|
|
138 r24, r25, r26, r27, r28, r29, r30, r31,
|
|
|
139
|
|
|
140 v0, v1, v2, v3, v4, v5, v6, v7,
|
|
|
141 v8, v9, v10, v11, v12, v13, v14, v15,
|
|
|
142 v16, v17, v18, v19, v20, v21, v22, v23,
|
|
|
143 v24, v25, v26, v27, v28, v29, v30, v31
|
|
|
144 };
|
|
|
145 // @formatter:on
|
|
|
146
|
|
|
147 /**
|
|
|
148 * Basic set of CPU features mirroring what is returned from the cpuid instruction. See:
|
|
|
149 * {@code VM_Version::cpuFeatureFlags}.
|
|
|
150 */
|
|
|
151 public static enum CPUFeature {
|
|
|
152 FP,
|
|
|
153 ASIMD,
|
|
|
154 EVTSTRM,
|
|
|
155 AES,
|
|
|
156 PMULL,
|
|
|
157 SHA1,
|
|
|
158 SHA2,
|
|
|
159 CRC32,
|
|
|
160 A53MAC,
|
|
|
161 DMB_ATOMICS
|
|
|
162 }
|
|
|
163
|
|
|
164 private final EnumSet<CPUFeature> features;
|
|
|
165
|
|
|
166 /**
|
|
|
167 * Set of flags to control code emission.
|
|
|
168 */
|
|
|
169 public static enum Flag {
|
|
|
170 UseBarriersForVolatile,
|
|
|
171 UseCRC32,
|
|
|
172 UseNeon
|
|
|
173 }
|
|
|
174
|
|
|
175 private final EnumSet<Flag> flags;
|
|
|
176
|
|
|
177 public AArch64(EnumSet<CPUFeature> features, EnumSet<Flag> flags) {
|
|
|
178 super("aarch64", AArch64Kind.QWORD, ByteOrder.LITTLE_ENDIAN, true, allRegisters, 0, 0, 0);
|
|
|
179 this.features = features;
|
|
|
180 this.flags = flags;
|
|
|
181 assert features.contains(CPUFeature.FP) : "minimum config for aarch64";
|
|
|
182 }
|
|
|
183
|
|
|
184 public EnumSet<CPUFeature> getFeatures() {
|
|
|
185 return features;
|
|
|
186 }
|
|
|
187
|
|
|
188 public EnumSet<Flag> getFlags() {
|
|
|
189 return flags;
|
|
|
190 }
|
|
|
191
|
|
|
192 @Override
|
|
|
193 public PlatformKind getPlatformKind(JavaKind javaKind) {
|
|
|
194 switch (javaKind) {
|
|
|
195 case Boolean:
|
|
|
196 case Byte:
|
|
|
197 return AArch64Kind.BYTE;
|
|
|
198 case Short:
|
|
|
199 case Char:
|
|
|
200 return AArch64Kind.WORD;
|
|
|
201 case Int:
|
|
|
202 return AArch64Kind.DWORD;
|
|
|
203 case Long:
|
|
|
204 case Object:
|
|
|
205 return AArch64Kind.QWORD;
|
|
|
206 case Float:
|
|
|
207 return AArch64Kind.SINGLE;
|
|
|
208 case Double:
|
|
|
209 return AArch64Kind.DOUBLE;
|
|
|
210 default:
|
|
|
211 return null;
|
|
|
212 }
|
|
|
213 }
|
|
|
214
|
|
|
215 @Override
|
|
|
216 public boolean canStoreValue(RegisterCategory category, PlatformKind platformKind) {
|
|
|
217 AArch64Kind kind = (AArch64Kind) platformKind;
|
|
|
218 if (kind.isInteger()) {
|
|
|
219 return category.equals(CPU);
|
|
|
220 } else if (kind.isSIMD()) {
|
|
|
221 return category.equals(SIMD);
|
|
|
222 }
|
|
|
223 return false;
|
|
|
224 }
|
|
|
225
|
|
|
226 @Override
|
|
|
227 public AArch64Kind getLargestStorableKind(RegisterCategory category) {
|
|
|
228 if (category.equals(CPU)) {
|
|
|
229 return AArch64Kind.QWORD;
|
|
|
230 } else if (category.equals(SIMD)) {
|
|
|
231 return AArch64Kind.V128_QWORD;
|
|
|
232 } else {
|
|
|
233 return null;
|
|
|
234 }
|
|
|
235 }
|
|
|
236 }
|
