Mercurial > hg > graal-jvmci-8
comparison jvmci/jdk.vm.ci.aarch64/src/jdk/vm/ci/aarch64/AArch64.java @ 22759:577a4a8caa72
8143072: [JVMCI] Port JVMCI to AArch64
author | twisti |
---|---|
date | Thu, 24 Dec 2015 09:50:27 -1000 |
parents | |
children | 7d014b014ce7 |
comparison
equal
deleted
inserted
replaced
22758:a130b51efb07 | 22759:577a4a8caa72 |
---|---|
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 } |