Mercurial > hg > graal-jvmci-8

comparison jvmci/jdk.vm.ci.aarch64/src/jdk/vm/ci/aarch64/AArch64.java @ 22759:577a4a8caa72

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 }