1 // Copyright 2015, VIXL authors
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are met:
6 //
7 // * Redistributions of source code must retain the above copyright notice,
8 // this list of conditions and the following disclaimer.
9 // * Redistributions in binary form must reproduce the above copyright notice,
10 // this list of conditions and the following disclaimer in the documentation
11 // and/or other materials provided with the distribution.
12 // * Neither the name of ARM Limited nor the names of its contributors may be
13 // used to endorse or promote products derived from this software without
14 // specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27
28 #include "test-disasm-aarch64.h"
29
30 #include <cstdio>
31 #include <cstring>
32 #include <string>
33
34 #include "test-runner.h"
35
36 #include "aarch64/disasm-aarch64.h"
37 #include "aarch64/macro-assembler-aarch64.h"
38
39 namespace vixl {
40 namespace aarch64 {
41
TEST(bootstrap)42 TEST(bootstrap) {
43 SETUP();
44
45 // Instructions generated by C compiler, disassembled by objdump, and
46 // reformatted to suit our disassembly style.
47 COMPARE(dci(0xa9ba7bfd), "stp x29, x30, [sp, #-96]!");
48 COMPARE(dci(0x910003fd), "mov x29, sp");
49 COMPARE(dci(0x9100e3a0), "add x0, x29, #0x38 (56)");
50 COMPARE(dci(0xb900001f), "str wzr, [x0]");
51 COMPARE(dci(0x528000e1), "mov w1, #0x7");
52 COMPARE(dci(0xb9001c01), "str w1, [x0, #28]");
53 COMPARE(dci(0x390043a0), "strb w0, [x29, #16]");
54 COMPARE(dci(0x790027a0), "strh w0, [x29, #18]");
55 COMPARE(dci(0xb9400400), "ldr w0, [x0, #4]");
56 COMPARE(dci(0x0b000021), "add w1, w1, w0");
57 COMPARE(dci(0x531b6800), "lsl w0, w0, #5");
58 COMPARE(dci(0x521e0400), "eor w0, w0, #0xc");
59 COMPARE(dci(0x72af0f00), "movk w0, #0x7878, lsl #16");
60 COMPARE(dci(0xd360fc00), "lsr x0, x0, #32");
61 COMPARE(dci(0x13037c01), "asr w1, w0, #3");
62 COMPARE(dci(0x4b000021), "sub w1, w1, w0");
63 COMPARE(dci(0x2a0103e0), "mov w0, w1");
64 COMPARE(dci(0x93407c00), "sxtw x0, w0");
65 COMPARE(dci(0x2a000020), "orr w0, w1, w0");
66 COMPARE(dci(0xa8c67bfd), "ldp x29, x30, [sp], #96");
67
68 CLEANUP();
69 }
70
71
TEST(mov_mvn)72 TEST(mov_mvn) {
73 SETUP();
74
75 COMPARE_MACRO(Mov(w0, Operand(0x1234)), "mov w0, #0x1234");
76 COMPARE_MACRO(Mov(x1, Operand(0x1234)), "mov x1, #0x1234");
77 COMPARE_MACRO(Mov(w2, Operand(w3)), "mov w2, w3");
78 COMPARE_MACRO(Mov(x4, Operand(x5)), "mov x4, x5");
79 COMPARE_MACRO(Mov(w6, Operand(w7, LSL, 5)), "lsl w6, w7, #5");
80 COMPARE_MACRO(Mov(x8, Operand(x9, ASR, 42)), "asr x8, x9, #42");
81 COMPARE_MACRO(Mov(w10, Operand(w11, UXTB)), "uxtb w10, w11");
82 COMPARE_MACRO(Mov(x12, Operand(x13, UXTB, 1)), "ubfiz x12, x13, #1, #8");
83 COMPARE_MACRO(Mov(w14, Operand(w15, SXTH, 2)), "sbfiz w14, w15, #2, #16");
84 COMPARE_MACRO(Mov(x16, Operand(x17, SXTW, 3)), "sbfiz x16, x17, #3, #32");
85
86 COMPARE_MACRO(Mvn(w0, Operand(0x101)), "mov w0, #0xfffffefe");
87 COMPARE_MACRO(Mvn(x1, Operand(0xfff1)), "mov x1, #0xffffffffffff000e");
88 COMPARE_MACRO(Mvn(w2, Operand(w3)), "mvn w2, w3");
89 COMPARE_MACRO(Mvn(x4, Operand(x5)), "mvn x4, x5");
90 COMPARE_MACRO(Mvn(w6, Operand(w7, LSL, 12)), "mvn w6, w7, lsl #12");
91 COMPARE_MACRO(Mvn(x8, Operand(x9, ASR, 63)), "mvn x8, x9, asr #63");
92
93 CLEANUP();
94 }
95
TEST(mvn_macro)96 TEST(mvn_macro) {
97 SETUP();
98
99 // Mvn uses the destination register as a scratch if it can. This only occurs
100 // when `operand.IsExtendedRegister()`.
101 COMPARE_MACRO(Mvn(x0, Operand(w1, SXTW)),
102 "sxtw x0, w1\n"
103 "mvn x0, x0");
104 COMPARE_MACRO(Mvn(x0, Operand(x0, SXTW)),
105 "sxtw x0, w0\n"
106 "mvn x0, x0");
107 }
108
109
TEST(move_immediate)110 TEST(move_immediate) {
111 SETUP();
112
113 COMPARE(movz(w0, 0x1234), "mov w0, #0x1234");
114 COMPARE(movz(x1, 0xabcd0000), "mov x1, #0xabcd0000");
115 COMPARE(movz(x2, 0x555500000000), "mov x2, #0x555500000000");
116 COMPARE(movz(x3, 0xaaaa000000000000), "mov x3, #0xaaaa000000000000");
117 COMPARE(movz(x4, 0xabcd, 16), "mov x4, #0xabcd0000");
118 COMPARE(movz(x5, 0x5555, 32), "mov x5, #0x555500000000");
119 COMPARE(movz(x6, 0xaaaa, 48), "mov x6, #0xaaaa000000000000");
120
121 COMPARE(movk(w7, 0x1234), "movk w7, #0x1234");
122 COMPARE(movk(x8, 0xabcd0000), "movk x8, #0xabcd, lsl #16");
123 COMPARE(movk(x9, 0x555500000000), "movk x9, #0x5555, lsl #32");
124 COMPARE(movk(x10, 0xaaaa000000000000), "movk x10, #0xaaaa, lsl #48");
125 COMPARE(movk(w11, 0xabcd, 16), "movk w11, #0xabcd, lsl #16");
126 COMPARE(movk(x12, 0x5555, 32), "movk x12, #0x5555, lsl #32");
127 COMPARE(movk(x13, 0xaaaa, 48), "movk x13, #0xaaaa, lsl #48");
128
129 COMPARE(movn(w14, 0x1234), "mov w14, #0xffffedcb");
130 COMPARE(movn(x15, 0xabcd0000), "mov x15, #0xffffffff5432ffff");
131 COMPARE(movn(x16, 0x555500000000), "mov x16, #0xffffaaaaffffffff");
132 COMPARE(movn(x17, 0xaaaa000000000000), "mov x17, #0x5555ffffffffffff");
133 COMPARE(movn(w18, 0xabcd, 16), "mov w18, #0x5432ffff");
134 COMPARE(movn(x19, 0x5555, 32), "mov x19, #0xffffaaaaffffffff");
135 COMPARE(movn(x20, 0xaaaa, 48), "mov x20, #0x5555ffffffffffff");
136
137 COMPARE(mov(w14, 0x1234), "mov w14, #0x1234");
138 COMPARE(mov(x15, 0xabcd0000), "mov x15, #0xabcd0000");
139 COMPARE(mov(x16, 0xaaaa000000000000), "mov x16, #0xaaaa000000000000");
140 COMPARE(mov(w17, 0xaaaaffff), "mov w17, #0xaaaaffff");
141 COMPARE(mov(x18, 0xffffaaaaffffffff), "mov x18, #0xffffaaaaffffffff");
142 COMPARE(mov(x19, 0xffffffffffffffff), "mov x19, #0xffffffffffffffff");
143 COMPARE(mov(x20, 0xc001c001c001c001), "mov x20, #0xc001c001c001c001");
144 COMPARE(mov(sp, 0xfefefefefefefefe), "mov sp, #0xfefefefefefefefe");
145
146 COMPARE(movk(w21, 0), "movk w21, #0x0");
147 COMPARE(movk(x22, 0, 0), "movk x22, #0x0");
148 COMPARE(movk(w23, 0, 16), "movk w23, #0x0, lsl #16");
149 COMPARE(movk(x24, 0, 32), "movk x24, #0x0, lsl #32");
150 COMPARE(movk(x25, 0, 48), "movk x25, #0x0, lsl #48");
151
152 COMPARE(movz(x26, 0, 48), "movz x26, #0x0");
153 COMPARE(movn(x27, 0, 48), "movn x27, #0x0");
154 COMPARE(movn(w28, 0xffff), "movn w28, #0xffff");
155
156 CLEANUP();
157 }
158
159
TEST(move_immediate_2)160 TEST(move_immediate_2) {
161 SETUP();
162
163 // Move instructions expected for certain immediates. This is really a macro
164 // assembler test, to ensure it generates immediates efficiently.
165 COMPARE_MACRO(Mov(w0, 0), "mov w0, #0x0");
166 COMPARE_MACRO(Mov(w0, 0x0000ffff), "mov w0, #0xffff");
167 COMPARE_MACRO(Mov(w0, 0x00010000), "mov w0, #0x10000");
168 COMPARE_MACRO(Mov(w0, 0xffff0000), "mov w0, #0xffff0000");
169 COMPARE_MACRO(Mov(w0, 0x0001ffff), "mov w0, #0x1ffff");
170 COMPARE_MACRO(Mov(w0, 0xffff8000), "mov w0, #0xffff8000");
171 COMPARE_MACRO(Mov(w0, 0xfffffffe), "mov w0, #0xfffffffe");
172 COMPARE_MACRO(Mov(w0, 0xffffffff), "mov w0, #0xffffffff");
173 COMPARE_MACRO(Mov(w0, 0x00ffff00), "mov w0, #0xffff00");
174 COMPARE_MACRO(Mov(w0, 0xfffe7fff), "mov w0, #0xfffe7fff");
175 COMPARE_MACRO(Mov(w0, 0xfffeffff), "mov w0, #0xfffeffff");
176 COMPARE_MACRO(Mov(w0, 0xffff7fff), "mov w0, #0xffff7fff");
177
178 COMPARE_MACRO(Mov(x0, 0), "mov x0, #0x0");
179 COMPARE_MACRO(Mov(x0, 0x0000ffff), "mov x0, #0xffff");
180 COMPARE_MACRO(Mov(x0, 0x00010000), "mov x0, #0x10000");
181 COMPARE_MACRO(Mov(x0, 0xffff0000), "mov x0, #0xffff0000");
182 COMPARE_MACRO(Mov(x0, 0x0001ffff), "mov x0, #0x1ffff");
183 COMPARE_MACRO(Mov(x0, 0xffff8000), "mov x0, #0xffff8000");
184 COMPARE_MACRO(Mov(x0, 0xfffffffe), "mov x0, #0xfffffffe");
185 COMPARE_MACRO(Mov(x0, 0xffffffff), "mov x0, #0xffffffff");
186 COMPARE_MACRO(Mov(x0, 0x00ffff00), "mov x0, #0xffff00");
187 COMPARE_MACRO(Mov(x0, 0xffff000000000000), "mov x0, #0xffff000000000000");
188 COMPARE_MACRO(Mov(x0, 0x0000ffff00000000), "mov x0, #0xffff00000000");
189 COMPARE_MACRO(Mov(x0, 0x00000000ffff0000), "mov x0, #0xffff0000");
190 COMPARE_MACRO(Mov(x0, 0xffffffffffff0000), "mov x0, #0xffffffffffff0000");
191 COMPARE_MACRO(Mov(x0, 0xffffffff0000ffff), "mov x0, #0xffffffff0000ffff");
192 COMPARE_MACRO(Mov(x0, 0xffff0000ffffffff), "mov x0, #0xffff0000ffffffff");
193 COMPARE_MACRO(Mov(x0, 0x0000ffffffffffff), "mov x0, #0xffffffffffff");
194 COMPARE_MACRO(Mov(x0, 0xfffe7fffffffffff), "mov x0, #0xfffe7fffffffffff");
195 COMPARE_MACRO(Mov(x0, 0xfffeffffffffffff), "mov x0, #0xfffeffffffffffff");
196 COMPARE_MACRO(Mov(x0, 0xffff7fffffffffff), "mov x0, #0xffff7fffffffffff");
197 COMPARE_MACRO(Mov(x0, 0xfffffffe7fffffff), "mov x0, #0xfffffffe7fffffff");
198 COMPARE_MACRO(Mov(x0, 0xfffffffeffffffff), "mov x0, #0xfffffffeffffffff");
199 COMPARE_MACRO(Mov(x0, 0xffffffff7fffffff), "mov x0, #0xffffffff7fffffff");
200 COMPARE_MACRO(Mov(x0, 0xfffffffffffe7fff), "mov x0, #0xfffffffffffe7fff");
201 COMPARE_MACRO(Mov(x0, 0xfffffffffffeffff), "mov x0, #0xfffffffffffeffff");
202 COMPARE_MACRO(Mov(x0, 0xffffffffffff7fff), "mov x0, #0xffffffffffff7fff");
203 COMPARE_MACRO(Mov(x0, 0xffffffffffffffff), "mov x0, #0xffffffffffffffff");
204
205 COMPARE_MACRO(Movk(w0, 0x1234, 0), "movk w0, #0x1234");
206 COMPARE_MACRO(Movk(x1, 0x2345, 0), "movk x1, #0x2345");
207 COMPARE_MACRO(Movk(w2, 0x3456, 16), "movk w2, #0x3456, lsl #16");
208 COMPARE_MACRO(Movk(x3, 0x4567, 16), "movk x3, #0x4567, lsl #16");
209 COMPARE_MACRO(Movk(x4, 0x5678, 32), "movk x4, #0x5678, lsl #32");
210 COMPARE_MACRO(Movk(x5, 0x6789, 48), "movk x5, #0x6789, lsl #48");
211
212 CLEANUP();
213 }
214
215
TEST(add_immediate)216 TEST(add_immediate) {
217 SETUP();
218
219 COMPARE(add(w0, w1, Operand(0xff)), "add w0, w1, #0xff (255)");
220 COMPARE(add(x2, x3, Operand(0x3ff)), "add x2, x3, #0x3ff (1023)");
221 COMPARE(add(w4, w5, Operand(0xfff)), "add w4, w5, #0xfff (4095)");
222 COMPARE(add(x6, x7, Operand(0x1000)), "add x6, x7, #0x1000 (4096)");
223 COMPARE(add(w8, w9, Operand(0xff000)), "add w8, w9, #0xff000 (1044480)");
224 COMPARE(add(x10, x11, Operand(0x3ff000)),
225 "add x10, x11, #0x3ff000 (4190208)");
226 COMPARE(add(w12, w13, Operand(0xfff000)),
227 "add w12, w13, #0xfff000 (16773120)");
228 COMPARE(adds(w14, w15, Operand(0xff)), "adds w14, w15, #0xff (255)");
229 COMPARE(adds(x16, x17, Operand(0xaa000)), "adds x16, x17, #0xaa000 (696320)");
230
231 COMPARE(cmn(w18, Operand(0xff)), "cmn w18, #0xff (255)");
232 COMPARE(cmn(x19, Operand(0xff000)), "cmn x19, #0xff000 (1044480)");
233 COMPARE(add(w0, wsp, Operand(0)), "mov w0, wsp");
234 COMPARE(add(sp, x0, Operand(0)), "mov sp, x0");
235
236 COMPARE(add(w1, wsp, Operand(8)), "add w1, wsp, #0x8 (8)");
237 COMPARE(add(x2, sp, Operand(16)), "add x2, sp, #0x10 (16)");
238 COMPARE(add(wsp, wsp, Operand(42)), "add wsp, wsp, #0x2a (42)");
239 COMPARE(cmn(sp, Operand(24)), "cmn sp, #0x18 (24)");
240 COMPARE(adds(wzr, wsp, Operand(9)), "cmn wsp, #0x9 (9)");
241
242 CLEANUP();
243 }
244
245
TEST(sub_immediate)246 TEST(sub_immediate) {
247 SETUP();
248
249 COMPARE(sub(w0, w1, Operand(0xff)), "sub w0, w1, #0xff (255)");
250 COMPARE(sub(x2, x3, Operand(0x3ff)), "sub x2, x3, #0x3ff (1023)");
251 COMPARE(sub(w4, w5, Operand(0xfff)), "sub w4, w5, #0xfff (4095)");
252 COMPARE(sub(x6, x7, Operand(0x1000)), "sub x6, x7, #0x1000 (4096)");
253 COMPARE(sub(w8, w9, Operand(0xff000)), "sub w8, w9, #0xff000 (1044480)");
254 COMPARE(sub(x10, x11, Operand(0x3ff000)),
255 "sub x10, x11, #0x3ff000 (4190208)");
256 COMPARE(sub(w12, w13, Operand(0xfff000)),
257 "sub w12, w13, #0xfff000 (16773120)");
258 COMPARE(subs(w14, w15, Operand(0xff)), "subs w14, w15, #0xff (255)");
259 COMPARE(subs(x16, x17, Operand(0xaa000)), "subs x16, x17, #0xaa000 (696320)");
260 COMPARE(cmp(w18, Operand(0xff)), "cmp w18, #0xff (255)");
261 COMPARE(cmp(x19, Operand(0xff000)), "cmp x19, #0xff000 (1044480)");
262
263 COMPARE(sub(w1, wsp, Operand(8)), "sub w1, wsp, #0x8 (8)");
264 COMPARE(sub(x2, sp, Operand(16)), "sub x2, sp, #0x10 (16)");
265 COMPARE(sub(wsp, wsp, Operand(42)), "sub wsp, wsp, #0x2a (42)");
266 COMPARE(cmp(sp, Operand(24)), "cmp sp, #0x18 (24)");
267 COMPARE(subs(wzr, wsp, Operand(9)), "cmp wsp, #0x9 (9)");
268
269 CLEANUP();
270 }
271
272
TEST(add_shifted)273 TEST(add_shifted) {
274 SETUP();
275
276 COMPARE(add(w0, w1, Operand(w2)), "add w0, w1, w2");
277 COMPARE(add(x3, x4, Operand(x5)), "add x3, x4, x5");
278 COMPARE(add(w6, w7, Operand(w8, LSL, 1)), "add w6, w7, w8, lsl #1");
279 COMPARE(add(x9, x10, Operand(x11, LSL, 2)), "add x9, x10, x11, lsl #2");
280 COMPARE(add(w12, w13, Operand(w14, LSR, 3)), "add w12, w13, w14, lsr #3");
281 COMPARE(add(x15, x16, Operand(x17, LSR, 4)), "add x15, x16, x17, lsr #4");
282 COMPARE(add(w18, w19, Operand(w20, ASR, 5)), "add w18, w19, w20, asr #5");
283 COMPARE(add(x21, x22, Operand(x23, ASR, 6)), "add x21, x22, x23, asr #6");
284 COMPARE(cmn(w24, Operand(w25)), "cmn w24, w25");
285 COMPARE(cmn(x26, Operand(x27, LSL, 63)), "cmn x26, x27, lsl #63");
286
287 COMPARE(add(x0, sp, Operand(x1)), "add x0, sp, x1");
288 COMPARE(add(w2, wsp, Operand(w3)), "add w2, wsp, w3");
289 COMPARE(add(x4, sp, Operand(x5, LSL, 1)), "add x4, sp, x5, lsl #1");
290 COMPARE(add(x4, xzr, Operand(x5, LSL, 1)), "add x4, xzr, x5, lsl #1");
291 COMPARE(add(w6, wsp, Operand(w7, LSL, 3)), "add w6, wsp, w7, lsl #3");
292 COMPARE(adds(xzr, sp, Operand(x8, LSL, 4)), "cmn sp, x8, lsl #4");
293 COMPARE(adds(xzr, xzr, Operand(x8, LSL, 5)), "cmn xzr, x8, lsl #5");
294
295 CLEANUP();
296 }
297
298
TEST(sub_shifted)299 TEST(sub_shifted) {
300 SETUP();
301
302 COMPARE(sub(w0, w1, Operand(w2)), "sub w0, w1, w2");
303 COMPARE(sub(x3, x4, Operand(x5)), "sub x3, x4, x5");
304 COMPARE(sub(w6, w7, Operand(w8, LSL, 1)), "sub w6, w7, w8, lsl #1");
305 COMPARE(sub(x9, x10, Operand(x11, LSL, 2)), "sub x9, x10, x11, lsl #2");
306 COMPARE(sub(w12, w13, Operand(w14, LSR, 3)), "sub w12, w13, w14, lsr #3");
307 COMPARE(sub(x15, x16, Operand(x17, LSR, 4)), "sub x15, x16, x17, lsr #4");
308 COMPARE(sub(w18, w19, Operand(w20, ASR, 5)), "sub w18, w19, w20, asr #5");
309 COMPARE(sub(x21, x22, Operand(x23, ASR, 6)), "sub x21, x22, x23, asr #6");
310 COMPARE(cmp(w24, Operand(w25)), "cmp w24, w25");
311 COMPARE(cmp(x26, Operand(x27, LSL, 63)), "cmp x26, x27, lsl #63");
312 COMPARE(neg(w28, Operand(w29)), "neg w28, w29");
313 COMPARE(neg(x30, Operand(x0, LSR, 62)), "neg x30, x0, lsr #62");
314 COMPARE(negs(w1, Operand(w2)), "negs w1, w2");
315 COMPARE(negs(x3, Operand(x4, ASR, 61)), "negs x3, x4, asr #61");
316
317 COMPARE(sub(x0, sp, Operand(x1)), "sub x0, sp, x1");
318 COMPARE(sub(w2, wsp, Operand(w3)), "sub w2, wsp, w3");
319 COMPARE(sub(x4, sp, Operand(x5, LSL, 1)), "sub x4, sp, x5, lsl #1");
320 COMPARE(sub(x4, xzr, Operand(x5, LSL, 1)), "neg x4, x5, lsl #1");
321 COMPARE(sub(w6, wsp, Operand(w7, LSL, 3)), "sub w6, wsp, w7, lsl #3");
322 COMPARE(subs(xzr, sp, Operand(x8, LSL, 4)), "cmp sp, x8, lsl #4");
323 COMPARE(subs(xzr, xzr, Operand(x8, LSL, 5)), "cmp xzr, x8, lsl #5");
324
325 CLEANUP();
326 }
327
328
TEST(add_extended)329 TEST(add_extended) {
330 SETUP();
331
332 COMPARE(add(w0, w1, Operand(w2, UXTB)), "add w0, w1, w2, uxtb");
333 COMPARE(adds(x3, x4, Operand(w5, UXTB, 1)), "adds x3, x4, w5, uxtb #1");
334 COMPARE(add(w6, w7, Operand(w8, UXTH, 2)), "add w6, w7, w8, uxth #2");
335 COMPARE(adds(x9, x10, Operand(x11, UXTW, 3)), "adds x9, x10, w11, uxtw #3");
336 COMPARE(add(x12, x13, Operand(x14, UXTX, 4)), "add x12, x13, x14, uxtx #4");
337 COMPARE(adds(w15, w16, Operand(w17, SXTB, 4)), "adds w15, w16, w17, sxtb #4");
338 COMPARE(add(x18, x19, Operand(x20, SXTB, 3)), "add x18, x19, w20, sxtb #3");
339 COMPARE(adds(w21, w22, Operand(w23, SXTH, 2)), "adds w21, w22, w23, sxth #2");
340 COMPARE(add(x24, x25, Operand(x26, SXTW, 1)), "add x24, x25, w26, sxtw #1");
341 COMPARE(adds(x27, x28, Operand(x29, SXTX)), "adds x27, x28, x29, sxtx");
342 COMPARE(cmn(w0, Operand(w1, UXTB, 2)), "cmn w0, w1, uxtb #2");
343 COMPARE(cmn(x2, Operand(x3, SXTH, 4)), "cmn x2, w3, sxth #4");
344
345 COMPARE(add(w0, wsp, Operand(w1, UXTB)), "add w0, wsp, w1, uxtb");
346 COMPARE(add(x2, sp, Operand(x3, UXTH, 1)), "add x2, sp, w3, uxth #1");
347 COMPARE(add(wsp, wsp, Operand(w4, UXTW, 2)), "add wsp, wsp, w4, lsl #2");
348 COMPARE(cmn(sp, Operand(xzr, UXTX, 3)), "cmn sp, xzr, lsl #3");
349 COMPARE(cmn(sp, Operand(xzr, LSL, 4)), "cmn sp, xzr, lsl #4");
350
351 CLEANUP();
352 }
353
354
TEST(sub_extended)355 TEST(sub_extended) {
356 SETUP();
357
358 COMPARE(sub(w0, w1, Operand(w2, UXTB)), "sub w0, w1, w2, uxtb");
359 COMPARE(subs(x3, x4, Operand(w5, UXTB, 1)), "subs x3, x4, w5, uxtb #1");
360 COMPARE(sub(w6, w7, Operand(w8, UXTH, 2)), "sub w6, w7, w8, uxth #2");
361 COMPARE(subs(x9, x10, Operand(x11, UXTW, 3)), "subs x9, x10, w11, uxtw #3");
362 COMPARE(sub(x12, x13, Operand(x14, UXTX, 4)), "sub x12, x13, x14, uxtx #4");
363 COMPARE(subs(w15, w16, Operand(w17, SXTB, 4)), "subs w15, w16, w17, sxtb #4");
364 COMPARE(sub(x18, x19, Operand(x20, SXTB, 3)), "sub x18, x19, w20, sxtb #3");
365 COMPARE(subs(w21, w22, Operand(w23, SXTH, 2)), "subs w21, w22, w23, sxth #2");
366 COMPARE(sub(x24, x25, Operand(x26, SXTW, 1)), "sub x24, x25, w26, sxtw #1");
367 COMPARE(subs(x27, x28, Operand(x29, SXTX)), "subs x27, x28, x29, sxtx");
368 COMPARE(cmp(w0, Operand(w1, SXTB, 1)), "cmp w0, w1, sxtb #1");
369 COMPARE(cmp(x2, Operand(x3, UXTH, 3)), "cmp x2, w3, uxth #3");
370
371 COMPARE(sub(w0, wsp, Operand(w1, UXTB)), "sub w0, wsp, w1, uxtb");
372 COMPARE(sub(x2, sp, Operand(x3, UXTH, 1)), "sub x2, sp, w3, uxth #1");
373 COMPARE(sub(wsp, wsp, Operand(w4, UXTW, 2)), "sub wsp, wsp, w4, lsl #2");
374 COMPARE(cmp(sp, Operand(xzr, UXTX, 3)), "cmp sp, xzr, lsl #3");
375 COMPARE(cmp(sp, Operand(xzr, LSL, 4)), "cmp sp, xzr, lsl #4");
376
377 CLEANUP();
378 }
379
380
TEST(adc_subc_ngc)381 TEST(adc_subc_ngc) {
382 SETUP();
383
384 COMPARE(adc(w0, w1, Operand(w2)), "adc w0, w1, w2");
385 COMPARE(adc(x3, x4, Operand(x5)), "adc x3, x4, x5");
386 COMPARE(adcs(w6, w7, Operand(w8)), "adcs w6, w7, w8");
387 COMPARE(adcs(x9, x10, Operand(x11)), "adcs x9, x10, x11");
388 COMPARE(sbc(w12, w13, Operand(w14)), "sbc w12, w13, w14");
389 COMPARE(sbc(x15, x16, Operand(x17)), "sbc x15, x16, x17");
390 COMPARE(sbcs(w18, w19, Operand(w20)), "sbcs w18, w19, w20");
391 COMPARE(sbcs(x21, x22, Operand(x23)), "sbcs x21, x22, x23");
392 COMPARE(ngc(w24, Operand(w25)), "ngc w24, w25");
393 COMPARE(ngc(x26, Operand(x27)), "ngc x26, x27");
394 COMPARE(ngcs(w28, Operand(w29)), "ngcs w28, w29");
395 COMPARE(ngcs(x30, Operand(x0)), "ngcs x30, x0");
396
397 CLEANUP();
398 }
399
400
TEST(rmif)401 TEST(rmif) {
402 SETUP();
403
404 COMPARE(rmif(x0, 3, ZCVFlag), "rmif x0, #3, #nZCV");
405 COMPARE(rmif(x1, 63, NCFlag), "rmif x1, #63, #NzCv");
406
407 CLEANUP();
408 }
409
410
TEST(setf8_setf16)411 TEST(setf8_setf16) {
412 SETUP();
413
414 COMPARE(setf8(w0), "setf8 w0");
415 COMPARE(setf16(w1), "setf16 w1");
416
417 CLEANUP();
418 }
419
420
TEST(mul_and_div)421 TEST(mul_and_div) {
422 SETUP();
423
424 COMPARE(mul(w0, w1, w2), "mul w0, w1, w2");
425 COMPARE(mul(x3, x4, x5), "mul x3, x4, x5");
426 COMPARE(mul(w30, w0, w1), "mul w30, w0, w1");
427 COMPARE(mul(x30, x0, x1), "mul x30, x0, x1");
428 COMPARE(mneg(w0, w1, w2), "mneg w0, w1, w2");
429 COMPARE(mneg(x3, x4, x5), "mneg x3, x4, x5");
430 COMPARE(mneg(w30, w0, w1), "mneg w30, w0, w1");
431 COMPARE(mneg(x30, x0, x1), "mneg x30, x0, x1");
432 COMPARE(smull(x0, w0, w1), "smull x0, w0, w1");
433 COMPARE(smull(x30, w30, w0), "smull x30, w30, w0");
434 COMPARE(smulh(x0, x1, x2), "smulh x0, x1, x2");
435 COMPARE(umulh(x0, x2, x1), "umulh x0, x2, x1");
436
437 COMPARE(sdiv(w0, w1, w2), "sdiv w0, w1, w2");
438 COMPARE(sdiv(x3, x4, x5), "sdiv x3, x4, x5");
439 COMPARE(udiv(w6, w7, w8), "udiv w6, w7, w8");
440 COMPARE(udiv(x9, x10, x11), "udiv x9, x10, x11");
441
442 CLEANUP();
443 }
444
445
TEST(madd)446 TEST(madd) {
447 SETUP();
448
449 COMPARE(madd(w0, w1, w2, w3), "madd w0, w1, w2, w3");
450 COMPARE(madd(w30, w21, w22, w16), "madd w30, w21, w22, w16");
451 COMPARE(madd(x0, x1, x2, x3), "madd x0, x1, x2, x3");
452 COMPARE(madd(x30, x21, x22, x16), "madd x30, x21, x22, x16");
453
454 COMPARE(smaddl(x0, w1, w2, x3), "smaddl x0, w1, w2, x3");
455 COMPARE(smaddl(x30, w21, w22, x16), "smaddl x30, w21, w22, x16");
456 COMPARE(umaddl(x0, w1, w2, x3), "umaddl x0, w1, w2, x3");
457 COMPARE(umaddl(x30, w21, w22, x16), "umaddl x30, w21, w22, x16");
458 COMPARE(umull(x0, w1, w2), "umull x0, w1, w2");
459 COMPARE(umull(x30, w21, w22), "umull x30, w21, w22");
460
461 CLEANUP();
462 }
463
464
TEST(msub)465 TEST(msub) {
466 SETUP();
467
468 COMPARE(msub(w0, w1, w2, w3), "msub w0, w1, w2, w3");
469 COMPARE(msub(w30, w21, w22, w16), "msub w30, w21, w22, w16");
470 COMPARE(msub(x0, x1, x2, x3), "msub x0, x1, x2, x3");
471 COMPARE(msub(x30, x21, x22, x16), "msub x30, x21, x22, x16");
472
473 COMPARE(smsubl(x0, w1, w2, x3), "smsubl x0, w1, w2, x3");
474 COMPARE(smsubl(x30, w21, w22, x16), "smsubl x30, w21, w22, x16");
475 COMPARE(umsubl(x0, w1, w2, x3), "umsubl x0, w1, w2, x3");
476 COMPARE(umsubl(x30, w21, w22, x16), "umsubl x30, w21, w22, x16");
477
478 CLEANUP();
479 }
480
481
TEST(dp_1_source)482 TEST(dp_1_source) {
483 SETUP();
484
485 COMPARE(rbit(w0, w1), "rbit w0, w1");
486 COMPARE(rbit(x2, x3), "rbit x2, x3");
487 COMPARE(rev16(w4, w5), "rev16 w4, w5");
488 COMPARE(rev16(x6, x7), "rev16 x6, x7");
489 COMPARE(rev32(x8, x9), "rev32 x8, x9");
490 COMPARE(rev64(x10, x11), "rev x10, x11");
491 COMPARE(rev(w12, w13), "rev w12, w13");
492 COMPARE(rev(x14, x15), "rev x14, x15");
493 COMPARE(clz(w16, w17), "clz w16, w17");
494 COMPARE(clz(x18, x19), "clz x18, x19");
495 COMPARE(cls(w20, w21), "cls w20, w21");
496 COMPARE(cls(x22, x23), "cls x22, x23");
497 COMPARE(pacia(x24, x25), "pacia x24, x25");
498 COMPARE(pacia(x26, sp), "pacia x26, sp");
499 COMPARE(pacib(x27, x28), "pacib x27, x28");
500 COMPARE(pacib(x29, sp), "pacib x29, sp");
501 COMPARE(pacda(x30, x0), "pacda x30, x0");
502 COMPARE(pacda(x1, sp), "pacda x1, sp");
503 COMPARE(pacdb(x2, x3), "pacdb x2, x3");
504 COMPARE(pacdb(x4, sp), "pacdb x4, sp");
505 COMPARE(paciza(x5), "paciza x5");
506 COMPARE(pacizb(x6), "pacizb x6");
507 COMPARE(pacdza(x7), "pacdza x7");
508 COMPARE(pacdzb(x8), "pacdzb x8");
509 COMPARE(autia(x9, x10), "autia x9, x10");
510 COMPARE(autia(x11, sp), "autia x11, sp");
511 COMPARE(autib(x12, x13), "autib x12, x13");
512 COMPARE(autib(x14, sp), "autib x14, sp");
513 COMPARE(autda(x15, x16), "autda x15, x16");
514 COMPARE(autda(x17, sp), "autda x17, sp");
515 COMPARE(autdb(x18, x19), "autdb x18, x19");
516 COMPARE(autdb(x20, sp), "autdb x20, sp");
517 COMPARE(autiza(x21), "autiza x21");
518 COMPARE(autizb(x22), "autizb x22");
519 COMPARE(autdza(x23), "autdza x23");
520
521 CLEANUP();
522 }
523
524
TEST(bitfield)525 TEST(bitfield) {
526 SETUP();
527
528 COMPARE(sxtb(w0, w1), "sxtb w0, w1");
529 COMPARE(sxtb(x2, x3), "sxtb x2, w3");
530 COMPARE(sxth(w4, w5), "sxth w4, w5");
531 COMPARE(sxth(x6, x7), "sxth x6, w7");
532 COMPARE(sxtw(x8, x9), "sxtw x8, w9");
533 COMPARE(sxtb(x0, w1), "sxtb x0, w1");
534 COMPARE(sxth(x2, w3), "sxth x2, w3");
535 COMPARE(sxtw(x4, w5), "sxtw x4, w5");
536
537 COMPARE(uxtb(w10, w11), "uxtb w10, w11");
538 COMPARE(uxtb(x12, x13), "uxtb x12, w13");
539 COMPARE(uxth(w14, w15), "uxth w14, w15");
540 COMPARE(uxth(x16, x17), "uxth x16, w17");
541 COMPARE(uxtw(x18, x19), "ubfx x18, x19, #0, #32");
542
543 COMPARE(asr(w20, w21, 10), "asr w20, w21, #10");
544 COMPARE(asr(x22, x23, 20), "asr x22, x23, #20");
545 COMPARE(lsr(w24, w25, 10), "lsr w24, w25, #10");
546 COMPARE(lsr(x26, x27, 20), "lsr x26, x27, #20");
547 COMPARE(lsl(w28, w29, 10), "lsl w28, w29, #10");
548 COMPARE(lsl(x30, x0, 20), "lsl x30, x0, #20");
549
550 COMPARE(sbfiz(w1, w2, 1, 20), "sbfiz w1, w2, #1, #20");
551 COMPARE(sbfiz(x3, x4, 2, 19), "sbfiz x3, x4, #2, #19");
552 COMPARE(sbfx(w5, w6, 3, 18), "sbfx w5, w6, #3, #18");
553 COMPARE(sbfx(x7, x8, 4, 17), "sbfx x7, x8, #4, #17");
554 COMPARE(bfi(w9, w10, 5, 16), "bfi w9, w10, #5, #16");
555 COMPARE(bfi(x11, x12, 6, 15), "bfi x11, x12, #6, #15");
556 COMPARE(bfxil(w13, w14, 7, 14), "bfxil w13, w14, #7, #14");
557 COMPARE(bfxil(x15, x16, 8, 13), "bfxil x15, x16, #8, #13");
558 COMPARE(ubfiz(w17, w18, 9, 12), "ubfiz w17, w18, #9, #12");
559 COMPARE(ubfiz(x19, x20, 10, 11), "ubfiz x19, x20, #10, #11");
560 COMPARE(ubfx(w21, w22, 11, 10), "ubfx w21, w22, #11, #10");
561 COMPARE(ubfx(x23, x24, 12, 9), "ubfx x23, x24, #12, #9");
562 COMPARE(bfc(w25, 13, 8), "bfc w25, #13, #8");
563 COMPARE(bfc(x26, 14, 7), "bfc x26, #14, #7");
564
565 CLEANUP();
566 }
567
TEST(bitfield_regression_test)568 TEST(bitfield_regression_test) {
569 SETUP();
570
571 COMPARE(dci(0x533ae450), "unallocated (Unallocated)");
572 COMPARE(dci(0x133c464c), "unallocated (Unallocated)");
573 COMPARE(dci(0x133c4e6d), "unallocated (Unallocated)");
574 COMPARE(dci(0x133c5e45), "unallocated (Unallocated)");
575 COMPARE(dci(0x1335853c), "unallocated (Unallocated)");
576 COMPARE(dci(0x1335a73d), "unallocated (Unallocated)");
577
578 CLEANUP();
579 }
580
581
TEST(crc32b)582 TEST(crc32b) {
583 SETUP();
584
585 COMPARE(crc32b(w0, w1, w2), "crc32b w0, w1, w2");
586 COMPARE(crc32b(w0, w11, w22), "crc32b w0, w11, w22");
587 COMPARE(crc32b(w10, w20, w30), "crc32b w10, w20, w30");
588
589 CLEANUP();
590 }
591
592
TEST(crc32h)593 TEST(crc32h) {
594 SETUP();
595
596 COMPARE(crc32h(w1, w2, w3), "crc32h w1, w2, w3");
597 COMPARE(crc32h(w2, w13, w23), "crc32h w2, w13, w23");
598 COMPARE(crc32h(w11, w12, w15), "crc32h w11, w12, w15");
599
600 CLEANUP();
601 }
602
603
TEST(crc32w)604 TEST(crc32w) {
605 SETUP();
606
607 COMPARE(crc32w(w2, w3, w4), "crc32w w2, w3, w4");
608 COMPARE(crc32w(w3, w14, w24), "crc32w w3, w14, w24");
609 COMPARE(crc32w(w13, w13, w16), "crc32w w13, w13, w16");
610
611 CLEANUP();
612 }
613
614
TEST(crc32x)615 TEST(crc32x) {
616 SETUP();
617
618 COMPARE(crc32x(w3, w4, x5), "crc32x w3, w4, x5");
619 COMPARE(crc32x(w4, w15, x25), "crc32x w4, w15, x25");
620 COMPARE(crc32x(w14, w14, x30), "crc32x w14, w14, x30");
621
622 CLEANUP();
623 }
624
625
TEST(crc32cb)626 TEST(crc32cb) {
627 SETUP();
628
629 COMPARE(crc32cb(w4, w5, w6), "crc32cb w4, w5, w6");
630 COMPARE(crc32cb(w5, w16, w26), "crc32cb w5, w16, w26");
631 COMPARE(crc32cb(w15, w15, w5), "crc32cb w15, w15, w5");
632
633 CLEANUP();
634 }
635
636
TEST(crc32ch)637 TEST(crc32ch) {
638 SETUP();
639
640 COMPARE(crc32ch(w5, w6, w7), "crc32ch w5, w6, w7");
641 COMPARE(crc32ch(w6, w17, w27), "crc32ch w6, w17, w27");
642 COMPARE(crc32ch(w16, w16, w2), "crc32ch w16, w16, w2");
643
644 CLEANUP();
645 }
646
647
TEST(crc32cw)648 TEST(crc32cw) {
649 SETUP();
650
651 COMPARE(crc32cw(w6, w7, w8), "crc32cw w6, w7, w8");
652 COMPARE(crc32cw(w7, w18, w28), "crc32cw w7, w18, w28");
653 COMPARE(crc32cw(w17, w17, w3), "crc32cw w17, w17, w3");
654
655 CLEANUP();
656 }
657
658
TEST(crc32cx)659 TEST(crc32cx) {
660 SETUP();
661
662 COMPARE(crc32cx(w7, w8, x9), "crc32cx w7, w8, x9");
663 COMPARE(crc32cx(w8, w19, x29), "crc32cx w8, w19, x29");
664 COMPARE(crc32cx(w18, w18, x4), "crc32cx w18, w18, x4");
665
666 CLEANUP();
667 }
668
669
TEST(extract)670 TEST(extract) {
671 SETUP();
672
673 COMPARE(extr(w0, w1, w2, 0), "extr w0, w1, w2, #0");
674 COMPARE(extr(x3, x4, x5, 1), "extr x3, x4, x5, #1");
675 COMPARE(extr(w6, w7, w8, 31), "extr w6, w7, w8, #31");
676 COMPARE(extr(x9, x10, x11, 63), "extr x9, x10, x11, #63");
677 COMPARE(extr(w12, w13, w13, 10), "ror w12, w13, #10");
678 COMPARE(extr(x14, x15, x15, 42), "ror x14, x15, #42");
679
680 CLEANUP();
681 }
682
683
TEST(logical_immediate)684 TEST(logical_immediate) {
685 SETUP();
686 #define RESULT_SIZE (256)
687
688 char result[RESULT_SIZE];
689
690 // Test immediate encoding - 64-bit destination.
691 // 64-bit patterns.
692 uint64_t value = 0x7fffffff;
693 for (int i = 0; i < 64; i++) {
694 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
695 COMPARE(and_(x0, x0, Operand(value)), result);
696 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
697 }
698
699 // 32-bit patterns.
700 value = 0x00003fff00003fff;
701 for (int i = 0; i < 32; i++) {
702 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
703 COMPARE(and_(x0, x0, Operand(value)), result);
704 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
705 }
706
707 // 16-bit patterns.
708 value = 0x001f001f001f001f;
709 for (int i = 0; i < 16; i++) {
710 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
711 COMPARE(and_(x0, x0, Operand(value)), result);
712 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
713 }
714
715 // 8-bit patterns.
716 value = 0x0e0e0e0e0e0e0e0e;
717 for (int i = 0; i < 8; i++) {
718 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
719 COMPARE(and_(x0, x0, Operand(value)), result);
720 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
721 }
722
723 // 4-bit patterns.
724 value = 0x6666666666666666;
725 for (int i = 0; i < 4; i++) {
726 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
727 COMPARE(and_(x0, x0, Operand(value)), result);
728 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
729 }
730
731 // 2-bit patterns.
732 COMPARE(and_(x0, x0, Operand(0x5555555555555555)),
733 "and x0, x0, #0x5555555555555555");
734 COMPARE(and_(x0, x0, Operand(0xaaaaaaaaaaaaaaaa)),
735 "and x0, x0, #0xaaaaaaaaaaaaaaaa");
736
737 // Test immediate encoding - 32-bit destination.
738 COMPARE(and_(w0, w0, Operand(0xff8007ff)),
739 "and w0, w0, #0xff8007ff"); // 32-bit pattern.
740 COMPARE(and_(w0, w0, Operand(0xf87ff87f)),
741 "and w0, w0, #0xf87ff87f"); // 16-bit pattern.
742 COMPARE(and_(w0, w0, Operand(0x87878787)),
743 "and w0, w0, #0x87878787"); // 8-bit pattern.
744 COMPARE(and_(w0, w0, Operand(0x66666666)),
745 "and w0, w0, #0x66666666"); // 4-bit pattern.
746 COMPARE(and_(w0, w0, Operand(0x55555555)),
747 "and w0, w0, #0x55555555"); // 2-bit pattern.
748
749 // Test other instructions.
750 COMPARE(tst(w1, Operand(0x11111111)), "tst w1, #0x11111111");
751 COMPARE(tst(x2, Operand(0x8888888888888888)), "tst x2, #0x8888888888888888");
752 COMPARE(orr(w7, w8, Operand(0xaaaaaaaa)), "orr w7, w8, #0xaaaaaaaa");
753 COMPARE(orr(x9, x10, Operand(0x5555555555555555)),
754 "orr x9, x10, #0x5555555555555555");
755 COMPARE(eor(w15, w16, Operand(0x00000001)), "eor w15, w16, #0x1");
756 COMPARE(eor(x17, x18, Operand(0x0000000000000003)), "eor x17, x18, #0x3");
757 COMPARE(ands(w23, w24, Operand(0x0000000f)), "ands w23, w24, #0xf");
758 COMPARE(ands(x25, x26, Operand(0x800000000000000f)),
759 "ands x25, x26, #0x800000000000000f");
760
761 // Test inverse.
762 COMPARE(bic(w3, w4, Operand(0x20202020)), "and w3, w4, #0xdfdfdfdf");
763 COMPARE(bic(x5, x6, Operand(0x4040404040404040)),
764 "and x5, x6, #0xbfbfbfbfbfbfbfbf");
765 COMPARE(orn(w11, w12, Operand(0x40004000)), "orr w11, w12, #0xbfffbfff");
766 COMPARE(orn(x13, x14, Operand(0x8181818181818181)),
767 "orr x13, x14, #0x7e7e7e7e7e7e7e7e");
768 COMPARE(eon(w19, w20, Operand(0x80000001)), "eor w19, w20, #0x7ffffffe");
769 COMPARE(eon(x21, x22, Operand(0xc000000000000003)),
770 "eor x21, x22, #0x3ffffffffffffffc");
771 COMPARE(bics(w27, w28, Operand(0xfffffff7)), "ands w27, w28, #0x8");
772 COMPARE(bics(x29, x0, Operand(0xfffffffeffffffff)),
773 "ands x29, x0, #0x100000000");
774
775 // Test stack pointer.
776 COMPARE(and_(wsp, wzr, Operand(7)), "and wsp, wzr, #0x7");
777 COMPARE(ands(xzr, xzr, Operand(7)), "tst xzr, #0x7");
778 COMPARE(orr(sp, xzr, Operand(15)), "orr sp, xzr, #0xf");
779 COMPARE(eor(wsp, w0, Operand(31)), "eor wsp, w0, #0x1f");
780
781 // Test move aliases.
782 COMPARE(orr(w0, wzr, Operand(0x00000780)), "orr w0, wzr, #0x780");
783 COMPARE(orr(w1, wzr, Operand(0x00007800)), "orr w1, wzr, #0x7800");
784 COMPARE(orr(w2, wzr, Operand(0x00078000)), "mov w2, #0x78000");
785 COMPARE(orr(w3, wzr, Operand(0x00780000)), "orr w3, wzr, #0x780000");
786 COMPARE(orr(w4, wzr, Operand(0x07800000)), "orr w4, wzr, #0x7800000");
787 COMPARE(orr(x5, xzr, Operand(0xffffffffffffc001)),
788 "orr x5, xzr, #0xffffffffffffc001");
789 COMPARE(orr(x6, xzr, Operand(0xfffffffffffc001f)),
790 "mov x6, #0xfffffffffffc001f");
791 COMPARE(orr(x7, xzr, Operand(0xffffffffffc001ff)),
792 "mov x7, #0xffffffffffc001ff");
793 COMPARE(orr(x8, xzr, Operand(0xfffffffffc001fff)),
794 "mov x8, #0xfffffffffc001fff");
795 COMPARE(orr(x9, xzr, Operand(0xffffffffc001ffff)),
796 "orr x9, xzr, #0xffffffffc001ffff");
797
798 CLEANUP();
799 }
800
801
TEST(logical_shifted)802 TEST(logical_shifted) {
803 SETUP();
804
805 COMPARE(and_(w0, w1, Operand(w2)), "and w0, w1, w2");
806 COMPARE(and_(x3, x4, Operand(x5, LSL, 1)), "and x3, x4, x5, lsl #1");
807 COMPARE(and_(w6, w7, Operand(w8, LSR, 2)), "and w6, w7, w8, lsr #2");
808 COMPARE(and_(x9, x10, Operand(x11, ASR, 3)), "and x9, x10, x11, asr #3");
809 COMPARE(and_(w12, w13, Operand(w14, ROR, 4)), "and w12, w13, w14, ror #4");
810
811 COMPARE(bic(w15, w16, Operand(w17)), "bic w15, w16, w17");
812 COMPARE(bic(x18, x19, Operand(x20, LSL, 5)), "bic x18, x19, x20, lsl #5");
813 COMPARE(bic(w21, w22, Operand(w23, LSR, 6)), "bic w21, w22, w23, lsr #6");
814 COMPARE(bic(x24, x25, Operand(x26, ASR, 7)), "bic x24, x25, x26, asr #7");
815 COMPARE(bic(w27, w28, Operand(w29, ROR, 8)), "bic w27, w28, w29, ror #8");
816
817 COMPARE(orr(w0, w1, Operand(w2)), "orr w0, w1, w2");
818 COMPARE(orr(x3, x4, Operand(x5, LSL, 9)), "orr x3, x4, x5, lsl #9");
819 COMPARE(orr(w6, w7, Operand(w8, LSR, 10)), "orr w6, w7, w8, lsr #10");
820 COMPARE(orr(x9, x10, Operand(x11, ASR, 11)), "orr x9, x10, x11, asr #11");
821 COMPARE(orr(w12, w13, Operand(w14, ROR, 12)), "orr w12, w13, w14, ror #12");
822
823 COMPARE(orn(w15, w16, Operand(w17)), "orn w15, w16, w17");
824 COMPARE(orn(x18, x19, Operand(x20, LSL, 13)), "orn x18, x19, x20, lsl #13");
825 COMPARE(orn(w21, w22, Operand(w23, LSR, 14)), "orn w21, w22, w23, lsr #14");
826 COMPARE(orn(x24, x25, Operand(x26, ASR, 15)), "orn x24, x25, x26, asr #15");
827 COMPARE(orn(w27, w28, Operand(w29, ROR, 16)), "orn w27, w28, w29, ror #16");
828
829 COMPARE(eor(w0, w1, Operand(w2)), "eor w0, w1, w2");
830 COMPARE(eor(x3, x4, Operand(x5, LSL, 17)), "eor x3, x4, x5, lsl #17");
831 COMPARE(eor(w6, w7, Operand(w8, LSR, 18)), "eor w6, w7, w8, lsr #18");
832 COMPARE(eor(x9, x10, Operand(x11, ASR, 19)), "eor x9, x10, x11, asr #19");
833 COMPARE(eor(w12, w13, Operand(w14, ROR, 20)), "eor w12, w13, w14, ror #20");
834
835 COMPARE(eon(w15, w16, Operand(w17)), "eon w15, w16, w17");
836 COMPARE(eon(x18, x19, Operand(x20, LSL, 21)), "eon x18, x19, x20, lsl #21");
837 COMPARE(eon(w21, w22, Operand(w23, LSR, 22)), "eon w21, w22, w23, lsr #22");
838 COMPARE(eon(x24, x25, Operand(x26, ASR, 23)), "eon x24, x25, x26, asr #23");
839 COMPARE(eon(w27, w28, Operand(w29, ROR, 24)), "eon w27, w28, w29, ror #24");
840
841 COMPARE(ands(w0, w1, Operand(w2)), "ands w0, w1, w2");
842 COMPARE(ands(x3, x4, Operand(x5, LSL, 1)), "ands x3, x4, x5, lsl #1");
843 COMPARE(ands(w6, w7, Operand(w8, LSR, 2)), "ands w6, w7, w8, lsr #2");
844 COMPARE(ands(x9, x10, Operand(x11, ASR, 3)), "ands x9, x10, x11, asr #3");
845 COMPARE(ands(w12, w13, Operand(w14, ROR, 4)), "ands w12, w13, w14, ror #4");
846
847 COMPARE(bics(w15, w16, Operand(w17)), "bics w15, w16, w17");
848 COMPARE(bics(x18, x19, Operand(x20, LSL, 5)), "bics x18, x19, x20, lsl #5");
849 COMPARE(bics(w21, w22, Operand(w23, LSR, 6)), "bics w21, w22, w23, lsr #6");
850 COMPARE(bics(x24, x25, Operand(x26, ASR, 7)), "bics x24, x25, x26, asr #7");
851 COMPARE(bics(w27, w28, Operand(w29, ROR, 8)), "bics w27, w28, w29, ror #8");
852
853 COMPARE(tst(w0, Operand(w1)), "tst w0, w1");
854 COMPARE(tst(w2, Operand(w3, ROR, 10)), "tst w2, w3, ror #10");
855 COMPARE(tst(x0, Operand(x1)), "tst x0, x1");
856 COMPARE(tst(x2, Operand(x3, ROR, 42)), "tst x2, x3, ror #42");
857
858 COMPARE(orn(w0, wzr, Operand(w1)), "mvn w0, w1");
859 COMPARE(orn(w2, wzr, Operand(w3, ASR, 5)), "mvn w2, w3, asr #5");
860 COMPARE(orn(x0, xzr, Operand(x1)), "mvn x0, x1");
861 COMPARE(orn(x2, xzr, Operand(x3, ASR, 42)), "mvn x2, x3, asr #42");
862
863 COMPARE(orr(w0, wzr, Operand(w1)), "mov w0, w1");
864 COMPARE(orr(x0, xzr, Operand(x1)), "mov x0, x1");
865 COMPARE(orr(w16, wzr, Operand(w17, LSL, 1)), "orr w16, wzr, w17, lsl #1");
866 COMPARE(orr(x16, xzr, Operand(x17, ASR, 2)), "orr x16, xzr, x17, asr #2");
867
868 CLEANUP();
869 }
870
871
TEST(dp_2_source)872 TEST(dp_2_source) {
873 SETUP();
874
875 COMPARE(lslv(w0, w1, w2), "lsl w0, w1, w2");
876 COMPARE(lslv(x3, x4, x5), "lsl x3, x4, x5");
877 COMPARE(lsrv(w6, w7, w8), "lsr w6, w7, w8");
878 COMPARE(lsrv(x9, x10, x11), "lsr x9, x10, x11");
879 COMPARE(asrv(w12, w13, w14), "asr w12, w13, w14");
880 COMPARE(asrv(x15, x16, x17), "asr x15, x16, x17");
881 COMPARE(rorv(w18, w19, w20), "ror w18, w19, w20");
882 COMPARE(rorv(x21, x22, x23), "ror x21, x22, x23");
883 COMPARE(pacga(x24, x25, x26), "pacga x24, x25, x26");
884 COMPARE(pacga(x27, x28, sp), "pacga x27, x28, sp");
885
886 CLEANUP();
887 }
888
889
TEST(adr)890 TEST(adr) {
891 SETUP();
892
893 COMPARE_PREFIX(adr(x0, INT64_C(0)), "adr x0, #+0x0");
894 COMPARE_PREFIX(adr(x1, 1), "adr x1, #+0x1");
895 COMPARE_PREFIX(adr(x2, -1), "adr x2, #-0x1");
896 COMPARE_PREFIX(adr(x3, 4), "adr x3, #+0x4");
897 COMPARE_PREFIX(adr(x4, -4), "adr x4, #-0x4");
898 COMPARE_PREFIX(adr(x5, 0x000fffff), "adr x5, #+0xfffff");
899 COMPARE_PREFIX(adr(x6, -0x00100000), "adr x6, #-0x100000");
900 COMPARE_PREFIX(adr(xzr, INT64_C(0)), "adr xzr, #+0x0");
901
902 CLEANUP();
903 }
904
905
TEST(adrp)906 TEST(adrp) {
907 SETUP();
908
909 COMPARE_PREFIX(adrp(x0, INT64_C(0)), "adrp x0, #+0x0");
910 COMPARE_PREFIX(adrp(x1, 1), "adrp x1, #+0x1000");
911 COMPARE_PREFIX(adrp(x2, -1), "adrp x2, #-0x1000");
912 COMPARE_PREFIX(adrp(x3, 4), "adrp x3, #+0x4000");
913 COMPARE_PREFIX(adrp(x4, -4), "adrp x4, #-0x4000");
914 COMPARE_PREFIX(adrp(x5, 0x000fffff), "adrp x5, #+0xfffff000");
915 COMPARE_PREFIX(adrp(x6, -0x00100000), "adrp x6, #-0x100000000");
916 COMPARE_PREFIX(adrp(xzr, INT64_C(0)), "adrp xzr, #+0x0");
917
918 CLEANUP();
919 }
920
921
TEST(branch)922 TEST(branch) {
923 SETUP();
924
925 #define INST_OFF(x) (INT64_C(x) >> kInstructionSizeLog2)
926 COMPARE_PREFIX(b(INST_OFF(0x4)), "b #+0x4");
927 COMPARE_PREFIX(b(INST_OFF(-0x4)), "b #-0x4");
928 COMPARE_PREFIX(b(INST_OFF(0x7fffffc)), "b #+0x7fffffc");
929 COMPARE_PREFIX(b(INST_OFF(-0x8000000)), "b #-0x8000000");
930 COMPARE_PREFIX(b(INST_OFF(0xffffc), eq), "b.eq #+0xffffc");
931 COMPARE_PREFIX(b(INST_OFF(-0x100000), mi), "b.mi #-0x100000");
932 COMPARE_PREFIX(b(INST_OFF(0xffffc), al), "b.al #+0xffffc");
933 COMPARE_PREFIX(b(INST_OFF(-0x100000), nv), "b.nv #-0x100000");
934 COMPARE_PREFIX(bl(INST_OFF(0x4)), "bl #+0x4");
935 COMPARE_PREFIX(bl(INST_OFF(-0x4)), "bl #-0x4");
936 COMPARE_PREFIX(bl(INST_OFF(0xffffc)), "bl #+0xffffc");
937 COMPARE_PREFIX(bl(INST_OFF(-0x100000)), "bl #-0x100000");
938 COMPARE_PREFIX(cbz(w0, INST_OFF(0xffffc)), "cbz w0, #+0xffffc");
939 COMPARE_PREFIX(cbz(x1, INST_OFF(-0x100000)), "cbz x1, #-0x100000");
940 COMPARE_PREFIX(cbnz(w2, INST_OFF(0xffffc)), "cbnz w2, #+0xffffc");
941 COMPARE_PREFIX(cbnz(x3, INST_OFF(-0x100000)), "cbnz x3, #-0x100000");
942 COMPARE_PREFIX(tbz(w4, 0, INST_OFF(0x7ffc)), "tbz w4, #0, #+0x7ffc");
943 COMPARE_PREFIX(tbz(x5, 63, INST_OFF(-0x8000)), "tbz x5, #63, #-0x8000");
944 COMPARE_PREFIX(tbz(w6, 31, INST_OFF(0)), "tbz w6, #31, #+0x0");
945 COMPARE_PREFIX(tbz(x7, 31, INST_OFF(0x4)), "tbz w7, #31, #+0x4");
946 COMPARE_PREFIX(tbz(x8, 32, INST_OFF(0x8)), "tbz x8, #32, #+0x8");
947 COMPARE_PREFIX(tbnz(w8, 0, INST_OFF(0x7ffc)), "tbnz w8, #0, #+0x7ffc");
948 COMPARE_PREFIX(tbnz(x9, 63, INST_OFF(-0x8000)), "tbnz x9, #63, #-0x8000");
949 COMPARE_PREFIX(tbnz(w10, 31, INST_OFF(0)), "tbnz w10, #31, #+0x0");
950 COMPARE_PREFIX(tbnz(x11, 31, INST_OFF(0x4)), "tbnz w11, #31, #+0x4");
951 COMPARE_PREFIX(tbnz(x12, 32, INST_OFF(0x8)), "tbnz x12, #32, #+0x8");
952 COMPARE(br(x0), "br x0");
953 COMPARE(blr(x1), "blr x1");
954 COMPARE(ret(x2), "ret x2");
955 COMPARE(ret(lr), "ret");
956
957 COMPARE(braaz(x0), "braaz x0");
958 COMPARE(brabz(x1), "brabz x1");
959 COMPARE(blraaz(x2), "blraaz x2");
960 COMPARE(blrabz(x3), "blrabz x3");
961 COMPARE(retaa(), "retaa");
962 COMPARE(retab(), "retab");
963 COMPARE(braa(x4, x5), "braa x4, x5");
964 COMPARE(braa(x6, sp), "braa x6, sp");
965 COMPARE(brab(x7, x8), "brab x7, x8");
966 COMPARE(brab(x9, sp), "brab x9, sp");
967 COMPARE(blraa(x10, x11), "blraa x10, x11");
968 COMPARE(blraa(x12, sp), "blraa x12, sp");
969 COMPARE(blrab(x13, x14), "blrab x13, x14");
970 COMPARE(blrab(x15, sp), "blrab x15, sp");
971
972 CLEANUP();
973 }
974
TEST(mte_load_store)975 TEST(mte_load_store) {
976 SETUP();
977
978 COMPARE(ldg(x0, MemOperand(sp)), "ldg x0, [sp]");
979 COMPARE(ldg(x22, MemOperand(x3, 32)), "ldg x22, [x3, #32]");
980 COMPARE(st2g(x3, MemOperand(sp)), "st2g x3, [sp]");
981 COMPARE(st2g(sp, MemOperand(sp, -320)), "st2g sp, [sp, #-320]");
982 COMPARE(st2g(x30, MemOperand(x4, 160, PreIndex)), "st2g x30, [x4, #160]!");
983 COMPARE(st2g(x22, MemOperand(x24, 1600, PostIndex)),
984 "st2g x22, [x24], #1600");
985 COMPARE(stg(x0, MemOperand(x1)), "stg x0, [x1]");
986 COMPARE(stg(x2, MemOperand(x3, 16)), "stg x2, [x3, #16]");
987 COMPARE(stg(sp, MemOperand(x1, -16, PreIndex)), "stg sp, [x1, #-16]!");
988 COMPARE(stg(x4, MemOperand(sp, -256, PostIndex)), "stg x4, [sp], #-256");
989 COMPARE(stgp(x29, x14, MemOperand(sp)), "stgp x29, x14, [sp]");
990 COMPARE(stgp(x3, x4, MemOperand(x3, -1024)), "stgp x3, x4, [x3, #-1024]");
991 COMPARE(stgp(x17, x7, MemOperand(x18, -64, PreIndex)),
992 "stgp x17, x7, [x18, #-64]!");
993 COMPARE(stgp(x5, x21, MemOperand(sp, 1008, PostIndex)),
994 "stgp x5, x21, [sp], #1008");
995 COMPARE(stzg(x20, MemOperand(x1)), "stzg x20, [x1]");
996 COMPARE(stzg(x22, MemOperand(x3, -32)), "stzg x22, [x3, #-32]");
997 COMPARE(stzg(sp, MemOperand(x1, 32, PreIndex)), "stzg sp, [x1, #32]!");
998 COMPARE(stzg(x5, MemOperand(sp, -2560, PostIndex)), "stzg x5, [sp], #-2560");
999 COMPARE(stz2g(x6, MemOperand(x21)), "stz2g x6, [x21]");
1000 COMPARE(stz2g(x18, MemOperand(x13, 16)), "stz2g x18, [x13, #16]");
1001 COMPARE(stz2g(sp, MemOperand(sp, -384, PreIndex)), "stz2g sp, [sp, #-384]!");
1002 COMPARE(stz2g(sp, MemOperand(x7, -256, PostIndex)), "stz2g sp, [x7], #-256");
1003
1004 COMPARE_MACRO(Ldg(x10, MemOperand(x17)), "ldg x10, [x17]");
1005 COMPARE_MACRO(Ldg(x15, MemOperand(sp, -4096)), "ldg x15, [sp, #-4096]");
1006 COMPARE_MACRO(St2g(x3, MemOperand(x15)), "st2g x3, [x15]");
1007 COMPARE_MACRO(St2g(sp, MemOperand(sp, -1600)), "st2g sp, [sp, #-1600]");
1008 COMPARE_MACRO(St2g(x30, MemOperand(x4, 3216, PreIndex)),
1009 "st2g x30, [x4, #3216]!");
1010 COMPARE_MACRO(St2g(x18, MemOperand(x2, 352, PostIndex)),
1011 "st2g x18, [x2], #352");
1012 COMPARE_MACRO(Stg(x10, MemOperand(x17)), "stg x10, [x17]");
1013 COMPARE_MACRO(Stg(sp, MemOperand(x3, -4096)), "stg sp, [x3, #-4096]");
1014 COMPARE_MACRO(Stg(sp, MemOperand(sp, 4080, PreIndex)),
1015 "stg sp, [sp, #4080]!");
1016 COMPARE_MACRO(Stg(x14, MemOperand(x20, 1024, PostIndex)),
1017 "stg x14, [x20], #1024");
1018 COMPARE_MACRO(Stgp(x3, x5, MemOperand(x7)), "stgp x3, x5, [x7]");
1019 COMPARE_MACRO(Stgp(x8, x4, MemOperand(x2, -496)), "stgp x8, x4, [x2, #-496]");
1020 COMPARE_MACRO(Stgp(x27, x7, MemOperand(sp, -672, PreIndex)),
1021 "stgp x27, x7, [sp, #-672]!");
1022 COMPARE_MACRO(Stgp(x14, x16, MemOperand(x0, 576, PostIndex)),
1023 "stgp x14, x16, [x0], #576");
1024 COMPARE_MACRO(Stz2g(x22, MemOperand(x12)), "stz2g x22, [x12]");
1025 COMPARE_MACRO(Stz2g(sp, MemOperand(sp, -704)), "stz2g sp, [sp, #-704]");
1026 COMPARE_MACRO(Stz2g(x3, MemOperand(x4, 272, PreIndex)),
1027 "stz2g x3, [x4, #272]!");
1028 COMPARE_MACRO(Stz2g(sp, MemOperand(sp, 1024, PostIndex)),
1029 "stz2g sp, [sp], #1024");
1030 COMPARE_MACRO(Stzg(x17, MemOperand(x11)), "stzg x17, [x11]");
1031 COMPARE_MACRO(Stzg(x29, MemOperand(x3, -3552)), "stzg x29, [x3, #-3552]");
1032 COMPARE_MACRO(Stzg(x2, MemOperand(x15, 784, PreIndex)),
1033 "stzg x2, [x15, #784]!");
1034 COMPARE_MACRO(Stzg(x8, MemOperand(x3, 1488, PostIndex)),
1035 "stzg x8, [x3], #1488");
1036 CLEANUP();
1037 }
1038
TEST(load_store)1039 TEST(load_store) {
1040 SETUP();
1041
1042 COMPARE(ldr(w0, MemOperand(x1)), "ldr w0, [x1]");
1043 COMPARE(ldr(w2, MemOperand(x3, 4)), "ldr w2, [x3, #4]");
1044 COMPARE(ldr(w4, MemOperand(x5, 16380)), "ldr w4, [x5, #16380]");
1045 COMPARE(ldr(x6, MemOperand(x7)), "ldr x6, [x7]");
1046 COMPARE(ldr(x8, MemOperand(x9, 8)), "ldr x8, [x9, #8]");
1047 COMPARE(ldr(x10, MemOperand(x11, 32760)), "ldr x10, [x11, #32760]");
1048 COMPARE(str(w12, MemOperand(x13)), "str w12, [x13]");
1049 COMPARE(str(w14, MemOperand(x15, 4)), "str w14, [x15, #4]");
1050 COMPARE(str(w16, MemOperand(x17, 16380)), "str w16, [x17, #16380]");
1051 COMPARE(str(x18, MemOperand(x19)), "str x18, [x19]");
1052 COMPARE(str(x20, MemOperand(x21, 8)), "str x20, [x21, #8]");
1053 COMPARE(str(x22, MemOperand(x23, 32760)), "str x22, [x23, #32760]");
1054
1055 COMPARE(ldr(w0, MemOperand(x1, 4, PreIndex)), "ldr w0, [x1, #4]!");
1056 COMPARE(ldr(w2, MemOperand(x3, 255, PreIndex)), "ldr w2, [x3, #255]!");
1057 COMPARE(ldr(w4, MemOperand(x5, -256, PreIndex)), "ldr w4, [x5, #-256]!");
1058 COMPARE(ldr(x6, MemOperand(x7, 8, PreIndex)), "ldr x6, [x7, #8]!");
1059 COMPARE(ldr(x8, MemOperand(x9, 255, PreIndex)), "ldr x8, [x9, #255]!");
1060 COMPARE(ldr(x10, MemOperand(x11, -256, PreIndex)), "ldr x10, [x11, #-256]!");
1061 COMPARE(str(w12, MemOperand(x13, 4, PreIndex)), "str w12, [x13, #4]!");
1062 COMPARE(str(w14, MemOperand(x15, 255, PreIndex)), "str w14, [x15, #255]!");
1063 COMPARE(str(w16, MemOperand(x17, -256, PreIndex)), "str w16, [x17, #-256]!");
1064 COMPARE(str(x18, MemOperand(x19, 8, PreIndex)), "str x18, [x19, #8]!");
1065 COMPARE(str(x20, MemOperand(x21, 255, PreIndex)), "str x20, [x21, #255]!");
1066 COMPARE(str(x22, MemOperand(x23, -256, PreIndex)), "str x22, [x23, #-256]!");
1067 COMPARE(str(x24, MemOperand(x25, 0, PreIndex)), "str x24, [x25, #0]!");
1068 COMPARE(str(w26, MemOperand(x27, 0, PreIndex)), "str w26, [x27, #0]!");
1069
1070 COMPARE(ldr(w0, MemOperand(x1, 4, PostIndex)), "ldr w0, [x1], #4");
1071 COMPARE(ldr(w2, MemOperand(x3, 255, PostIndex)), "ldr w2, [x3], #255");
1072 COMPARE(ldr(w4, MemOperand(x5, -256, PostIndex)), "ldr w4, [x5], #-256");
1073 COMPARE(ldr(x6, MemOperand(x7, 8, PostIndex)), "ldr x6, [x7], #8");
1074 COMPARE(ldr(x8, MemOperand(x9, 255, PostIndex)), "ldr x8, [x9], #255");
1075 COMPARE(ldr(x10, MemOperand(x11, -256, PostIndex)), "ldr x10, [x11], #-256");
1076 COMPARE(str(w12, MemOperand(x13, 4, PostIndex)), "str w12, [x13], #4");
1077 COMPARE(str(w14, MemOperand(x15, 255, PostIndex)), "str w14, [x15], #255");
1078 COMPARE(str(w16, MemOperand(x17, -256, PostIndex)), "str w16, [x17], #-256");
1079 COMPARE(str(x18, MemOperand(x19, 8, PostIndex)), "str x18, [x19], #8");
1080 COMPARE(str(x20, MemOperand(x21, 255, PostIndex)), "str x20, [x21], #255");
1081 COMPARE(str(x22, MemOperand(x23, -256, PostIndex)), "str x22, [x23], #-256");
1082 COMPARE(str(x24, MemOperand(x25, 0, PostIndex)), "str x24, [x25], #0");
1083 COMPARE(str(w26, MemOperand(x27, 0, PostIndex)), "str w26, [x27], #0");
1084
1085 COMPARE(ldr(w24, MemOperand(sp)), "ldr w24, [sp]");
1086 COMPARE(ldr(x25, MemOperand(sp, 8)), "ldr x25, [sp, #8]");
1087 COMPARE(str(w26, MemOperand(sp, 4, PreIndex)), "str w26, [sp, #4]!");
1088 COMPARE(str(x27, MemOperand(sp, -8, PostIndex)), "str x27, [sp], #-8");
1089
1090 COMPARE(ldrsw(x0, MemOperand(x1)), "ldrsw x0, [x1]");
1091 COMPARE(ldrsw(x2, MemOperand(x3, 8)), "ldrsw x2, [x3, #8]");
1092 COMPARE(ldrsw(x4, MemOperand(x5, 42, PreIndex)), "ldrsw x4, [x5, #42]!");
1093 COMPARE(ldrsw(x6, MemOperand(x7, -11, PostIndex)), "ldrsw x6, [x7], #-11");
1094
1095 CLEANUP();
1096 }
1097
1098
TEST(load_store_regoffset)1099 TEST(load_store_regoffset) {
1100 SETUP();
1101
1102 COMPARE(ldr(w0, MemOperand(x1, w2, UXTW)), "ldr w0, [x1, w2, uxtw]");
1103 COMPARE(ldr(w3, MemOperand(x4, w5, UXTW, 2)), "ldr w3, [x4, w5, uxtw #2]");
1104 COMPARE(ldr(w6, MemOperand(x7, x8)), "ldr w6, [x7, x8]");
1105 COMPARE(ldr(w9, MemOperand(x10, x11, LSL, 2)), "ldr w9, [x10, x11, lsl #2]");
1106 COMPARE(ldr(w12, MemOperand(x13, w14, SXTW)), "ldr w12, [x13, w14, sxtw]");
1107 COMPARE(ldr(w15, MemOperand(x16, w17, SXTW, 2)),
1108 "ldr w15, [x16, w17, sxtw #2]");
1109 COMPARE(ldr(w18, MemOperand(x19, x20, SXTX)), "ldr w18, [x19, x20, sxtx]");
1110 COMPARE(ldr(w21, MemOperand(x22, x23, SXTX, 2)),
1111 "ldr w21, [x22, x23, sxtx #2]");
1112 COMPARE(ldr(x0, MemOperand(x1, w2, UXTW)), "ldr x0, [x1, w2, uxtw]");
1113 COMPARE(ldr(x3, MemOperand(x4, w5, UXTW, 3)), "ldr x3, [x4, w5, uxtw #3]");
1114 COMPARE(ldr(x6, MemOperand(x7, x8)), "ldr x6, [x7, x8]");
1115 COMPARE(ldr(x9, MemOperand(x10, x11, LSL, 3)), "ldr x9, [x10, x11, lsl #3]");
1116 COMPARE(ldr(x12, MemOperand(x13, w14, SXTW)), "ldr x12, [x13, w14, sxtw]");
1117 COMPARE(ldr(x15, MemOperand(x16, w17, SXTW, 3)),
1118 "ldr x15, [x16, w17, sxtw #3]");
1119 COMPARE(ldr(x18, MemOperand(x19, x20, SXTX)), "ldr x18, [x19, x20, sxtx]");
1120 COMPARE(ldr(x21, MemOperand(x22, x23, SXTX, 3)),
1121 "ldr x21, [x22, x23, sxtx #3]");
1122
1123 COMPARE(str(w0, MemOperand(x1, w2, UXTW)), "str w0, [x1, w2, uxtw]");
1124 COMPARE(str(w3, MemOperand(x4, w5, UXTW, 2)), "str w3, [x4, w5, uxtw #2]");
1125 COMPARE(str(w6, MemOperand(x7, x8)), "str w6, [x7, x8]");
1126 COMPARE(str(w9, MemOperand(x10, x11, LSL, 2)), "str w9, [x10, x11, lsl #2]");
1127 COMPARE(str(w12, MemOperand(x13, w14, SXTW)), "str w12, [x13, w14, sxtw]");
1128 COMPARE(str(w15, MemOperand(x16, w17, SXTW, 2)),
1129 "str w15, [x16, w17, sxtw #2]");
1130 COMPARE(str(w18, MemOperand(x19, x20, SXTX)), "str w18, [x19, x20, sxtx]");
1131 COMPARE(str(w21, MemOperand(x22, x23, SXTX, 2)),
1132 "str w21, [x22, x23, sxtx #2]");
1133 COMPARE(str(x0, MemOperand(x1, w2, UXTW)), "str x0, [x1, w2, uxtw]");
1134 COMPARE(str(x3, MemOperand(x4, w5, UXTW, 3)), "str x3, [x4, w5, uxtw #3]");
1135 COMPARE(str(x6, MemOperand(x7, x8)), "str x6, [x7, x8]");
1136 COMPARE(str(x9, MemOperand(x10, x11, LSL, 3)), "str x9, [x10, x11, lsl #3]");
1137 COMPARE(str(x12, MemOperand(x13, w14, SXTW)), "str x12, [x13, w14, sxtw]");
1138 COMPARE(str(x15, MemOperand(x16, w17, SXTW, 3)),
1139 "str x15, [x16, w17, sxtw #3]");
1140 COMPARE(str(x18, MemOperand(x19, x20, SXTX)), "str x18, [x19, x20, sxtx]");
1141 COMPARE(str(x21, MemOperand(x22, x23, SXTX, 3)),
1142 "str x21, [x22, x23, sxtx #3]");
1143
1144 COMPARE(ldrb(w0, MemOperand(x1, w2, UXTW)), "ldrb w0, [x1, w2, uxtw]");
1145 COMPARE(ldrb(w6, MemOperand(x7, x8)), "ldrb w6, [x7, x8]");
1146 COMPARE(ldrb(w12, MemOperand(x13, w14, SXTW)), "ldrb w12, [x13, w14, sxtw]");
1147 COMPARE(ldrb(w18, MemOperand(x19, x20, SXTX)), "ldrb w18, [x19, x20, sxtx]");
1148 COMPARE(strb(w0, MemOperand(x1, w2, UXTW)), "strb w0, [x1, w2, uxtw]");
1149 COMPARE(strb(w6, MemOperand(x7, x8)), "strb w6, [x7, x8]");
1150 COMPARE(strb(w12, MemOperand(x13, w14, SXTW)), "strb w12, [x13, w14, sxtw]");
1151 COMPARE(strb(w18, MemOperand(x19, x20, SXTX)), "strb w18, [x19, x20, sxtx]");
1152
1153 COMPARE(ldrh(w0, MemOperand(x1, w2, UXTW)), "ldrh w0, [x1, w2, uxtw]");
1154 COMPARE(ldrh(w3, MemOperand(x4, w5, UXTW, 1)), "ldrh w3, [x4, w5, uxtw #1]");
1155 COMPARE(ldrh(w6, MemOperand(x7, x8)), "ldrh w6, [x7, x8]");
1156 COMPARE(ldrh(w9, MemOperand(x10, x11, LSL, 1)),
1157 "ldrh w9, [x10, x11, lsl #1]");
1158 COMPARE(ldrh(w12, MemOperand(x13, w14, SXTW)), "ldrh w12, [x13, w14, sxtw]");
1159 COMPARE(ldrh(w15, MemOperand(x16, w17, SXTW, 1)),
1160 "ldrh w15, [x16, w17, sxtw #1]");
1161 COMPARE(ldrh(w18, MemOperand(x19, x20, SXTX)), "ldrh w18, [x19, x20, sxtx]");
1162 COMPARE(ldrh(w21, MemOperand(x22, x23, SXTX, 1)),
1163 "ldrh w21, [x22, x23, sxtx #1]");
1164 COMPARE(strh(w0, MemOperand(x1, w2, UXTW)), "strh w0, [x1, w2, uxtw]");
1165 COMPARE(strh(w3, MemOperand(x4, w5, UXTW, 1)), "strh w3, [x4, w5, uxtw #1]");
1166 COMPARE(strh(w6, MemOperand(x7, x8)), "strh w6, [x7, x8]");
1167 COMPARE(strh(w9, MemOperand(x10, x11, LSL, 1)),
1168 "strh w9, [x10, x11, lsl #1]");
1169 COMPARE(strh(w12, MemOperand(x13, w14, SXTW)), "strh w12, [x13, w14, sxtw]");
1170 COMPARE(strh(w15, MemOperand(x16, w17, SXTW, 1)),
1171 "strh w15, [x16, w17, sxtw #1]");
1172 COMPARE(strh(w18, MemOperand(x19, x20, SXTX)), "strh w18, [x19, x20, sxtx]");
1173 COMPARE(strh(w21, MemOperand(x22, x23, SXTX, 1)),
1174 "strh w21, [x22, x23, sxtx #1]");
1175
1176 COMPARE(ldr(x0, MemOperand(sp, wzr, SXTW)), "ldr x0, [sp, wzr, sxtw]");
1177 COMPARE(str(x1, MemOperand(sp, xzr)), "str x1, [sp, xzr]");
1178
1179 CLEANUP();
1180 }
1181
1182
TEST(load_store_byte)1183 TEST(load_store_byte) {
1184 SETUP();
1185
1186 COMPARE(ldrb(w0, MemOperand(x1)), "ldrb w0, [x1]");
1187 COMPARE(ldrb(x2, MemOperand(x3)), "ldrb w2, [x3]");
1188 COMPARE(ldrb(w4, MemOperand(x5, 4095)), "ldrb w4, [x5, #4095]");
1189 COMPARE(ldrb(w6, MemOperand(x7, 255, PreIndex)), "ldrb w6, [x7, #255]!");
1190 COMPARE(ldrb(w8, MemOperand(x9, -256, PreIndex)), "ldrb w8, [x9, #-256]!");
1191 COMPARE(ldrb(w10, MemOperand(x11, 255, PostIndex)), "ldrb w10, [x11], #255");
1192 COMPARE(ldrb(w12, MemOperand(x13, -256, PostIndex)),
1193 "ldrb w12, [x13], #-256");
1194 COMPARE(ldrb(w14, MemOperand(x15, 0, PreIndex)), "ldrb w14, [x15, #0]!");
1195 COMPARE(ldrb(w16, MemOperand(x17, 0, PostIndex)), "ldrb w16, [x17], #0");
1196 COMPARE(strb(w14, MemOperand(x15)), "strb w14, [x15]");
1197 COMPARE(strb(x16, MemOperand(x17)), "strb w16, [x17]");
1198 COMPARE(strb(w18, MemOperand(x19, 4095)), "strb w18, [x19, #4095]");
1199 COMPARE(strb(w20, MemOperand(x21, 255, PreIndex)), "strb w20, [x21, #255]!");
1200 COMPARE(strb(w22, MemOperand(x23, -256, PreIndex)),
1201 "strb w22, [x23, #-256]!");
1202 COMPARE(strb(w24, MemOperand(x25, 255, PostIndex)), "strb w24, [x25], #255");
1203 COMPARE(strb(w26, MemOperand(x27, -256, PostIndex)),
1204 "strb w26, [x27], #-256");
1205 COMPARE(strb(w27, MemOperand(x28, 0, PreIndex)), "strb w27, [x28, #0]!");
1206 COMPARE(strb(w29, MemOperand(x30, 0, PostIndex)), "strb w29, [x30], #0");
1207 COMPARE(ldrb(w28, MemOperand(sp, 3, PostIndex)), "ldrb w28, [sp], #3");
1208 COMPARE(strb(x29, MemOperand(sp, -42, PreIndex)), "strb w29, [sp, #-42]!");
1209 COMPARE(ldrsb(w0, MemOperand(x1)), "ldrsb w0, [x1]");
1210 COMPARE(ldrsb(x2, MemOperand(x3, 8)), "ldrsb x2, [x3, #8]");
1211 COMPARE(ldrsb(w4, MemOperand(x5, 42, PreIndex)), "ldrsb w4, [x5, #42]!");
1212 COMPARE(ldrsb(x6, MemOperand(x7, -11, PostIndex)), "ldrsb x6, [x7], #-11");
1213 COMPARE(ldrsb(w8, MemOperand(x9, 0, PreIndex)), "ldrsb w8, [x9, #0]!");
1214 COMPARE(ldrsb(x10, MemOperand(x11, 0, PostIndex)), "ldrsb x10, [x11], #0");
1215
1216 CLEANUP();
1217 }
1218
1219
TEST(load_store_half)1220 TEST(load_store_half) {
1221 SETUP();
1222
1223 COMPARE(ldrh(w0, MemOperand(x1)), "ldrh w0, [x1]");
1224 COMPARE(ldrh(x2, MemOperand(x3)), "ldrh w2, [x3]");
1225 COMPARE(ldrh(w4, MemOperand(x5, 8190)), "ldrh w4, [x5, #8190]");
1226 COMPARE(ldrh(w6, MemOperand(x7, 255, PreIndex)), "ldrh w6, [x7, #255]!");
1227 COMPARE(ldrh(w8, MemOperand(x9, -256, PreIndex)), "ldrh w8, [x9, #-256]!");
1228 COMPARE(ldrh(w10, MemOperand(x11, 255, PostIndex)), "ldrh w10, [x11], #255");
1229 COMPARE(ldrh(w12, MemOperand(x13, -256, PostIndex)),
1230 "ldrh w12, [x13], #-256");
1231 COMPARE(ldrh(w14, MemOperand(x15, 0, PreIndex)), "ldrh w14, [x15, #0]!");
1232 COMPARE(ldrh(w16, MemOperand(x17, 0, PostIndex)), "ldrh w16, [x17], #0");
1233 COMPARE(strh(w14, MemOperand(x15)), "strh w14, [x15]");
1234 COMPARE(strh(x16, MemOperand(x17)), "strh w16, [x17]");
1235 COMPARE(strh(w18, MemOperand(x19, 8190)), "strh w18, [x19, #8190]");
1236 COMPARE(strh(w20, MemOperand(x21, 255, PreIndex)), "strh w20, [x21, #255]!");
1237 COMPARE(strh(w22, MemOperand(x23, -256, PreIndex)),
1238 "strh w22, [x23, #-256]!");
1239 COMPARE(strh(w24, MemOperand(x25, 255, PostIndex)), "strh w24, [x25], #255");
1240 COMPARE(strh(w26, MemOperand(x27, -256, PostIndex)),
1241 "strh w26, [x27], #-256");
1242 COMPARE(strh(w27, MemOperand(x28, 0, PreIndex)), "strh w27, [x28, #0]!");
1243 COMPARE(strh(w29, MemOperand(x30, 0, PostIndex)), "strh w29, [x30], #0");
1244 COMPARE(ldrh(w28, MemOperand(sp, 3, PostIndex)), "ldrh w28, [sp], #3");
1245 COMPARE(strh(x29, MemOperand(sp, -42, PreIndex)), "strh w29, [sp, #-42]!");
1246 COMPARE(ldrh(w30, MemOperand(x0, 255)), "ldurh w30, [x0, #255]");
1247 COMPARE(ldrh(x1, MemOperand(x2, -256)), "ldurh w1, [x2, #-256]");
1248 COMPARE(strh(w3, MemOperand(x4, 255)), "sturh w3, [x4, #255]");
1249 COMPARE(strh(x5, MemOperand(x6, -256)), "sturh w5, [x6, #-256]");
1250 COMPARE(ldrsh(w0, MemOperand(x1)), "ldrsh w0, [x1]");
1251 COMPARE(ldrsh(w2, MemOperand(x3, 8)), "ldrsh w2, [x3, #8]");
1252 COMPARE(ldrsh(w4, MemOperand(x5, 42, PreIndex)), "ldrsh w4, [x5, #42]!");
1253 COMPARE(ldrsh(x6, MemOperand(x7, -11, PostIndex)), "ldrsh x6, [x7], #-11");
1254 COMPARE(ldrsh(w8, MemOperand(x9, 0, PreIndex)), "ldrsh w8, [x9, #0]!");
1255 COMPARE(ldrsh(x10, MemOperand(x11, 0, PostIndex)), "ldrsh x10, [x11], #0");
1256
1257 CLEANUP();
1258 }
1259
TEST(load_store_unscaled)1260 TEST(load_store_unscaled) {
1261 SETUP();
1262
1263 // If an unscaled-offset instruction is requested, it is used, even if the
1264 // offset could be encoded in a scaled-offset instruction.
1265 COMPARE(ldurb(w0, MemOperand(x1)), "ldurb w0, [x1]");
1266 COMPARE(ldurb(x2, MemOperand(x3, 1)), "ldurb w2, [x3, #1]");
1267 COMPARE(ldurb(w4, MemOperand(x5, 255)), "ldurb w4, [x5, #255]");
1268 COMPARE(sturb(w14, MemOperand(x15)), "sturb w14, [x15]");
1269 COMPARE(sturb(x16, MemOperand(x17, 1)), "sturb w16, [x17, #1]");
1270 COMPARE(sturb(w18, MemOperand(x19, 255)), "sturb w18, [x19, #255]");
1271 COMPARE(ldursb(w0, MemOperand(x1)), "ldursb w0, [x1]");
1272 COMPARE(ldursb(w2, MemOperand(x3, 1)), "ldursb w2, [x3, #1]");
1273 COMPARE(ldursb(x2, MemOperand(x3, 255)), "ldursb x2, [x3, #255]");
1274
1275 COMPARE(ldurh(w0, MemOperand(x1)), "ldurh w0, [x1]");
1276 COMPARE(ldurh(x2, MemOperand(x3, 2)), "ldurh w2, [x3, #2]");
1277 COMPARE(ldurh(w4, MemOperand(x5, 254)), "ldurh w4, [x5, #254]");
1278 COMPARE(sturh(w14, MemOperand(x15)), "sturh w14, [x15]");
1279 COMPARE(sturh(x16, MemOperand(x17, 2)), "sturh w16, [x17, #2]");
1280 COMPARE(sturh(w18, MemOperand(x19, 254)), "sturh w18, [x19, #254]");
1281 COMPARE(ldursh(w0, MemOperand(x1)), "ldursh w0, [x1]");
1282 COMPARE(ldursh(w2, MemOperand(x3, 2)), "ldursh w2, [x3, #2]");
1283 COMPARE(ldursh(x4, MemOperand(x5, 254)), "ldursh x4, [x5, #254]");
1284
1285 COMPARE(ldur(w0, MemOperand(x1)), "ldur w0, [x1]");
1286 COMPARE(ldur(w2, MemOperand(x3, 4)), "ldur w2, [x3, #4]");
1287 COMPARE(ldur(w4, MemOperand(x5, 248)), "ldur w4, [x5, #248]");
1288 COMPARE(stur(w12, MemOperand(x13)), "stur w12, [x13]");
1289 COMPARE(stur(w14, MemOperand(x15, 4)), "stur w14, [x15, #4]");
1290 COMPARE(stur(w16, MemOperand(x17, 248)), "stur w16, [x17, #248]");
1291 COMPARE(ldursw(x0, MemOperand(x1)), "ldursw x0, [x1]");
1292 COMPARE(ldursw(x2, MemOperand(x3, 4)), "ldursw x2, [x3, #4]");
1293 COMPARE(ldursw(x4, MemOperand(x5, 248)), "ldursw x4, [x5, #248]");
1294
1295 COMPARE(ldur(x6, MemOperand(x7)), "ldur x6, [x7]");
1296 COMPARE(ldur(x8, MemOperand(x9, 8)), "ldur x8, [x9, #8]");
1297 COMPARE(ldur(x10, MemOperand(x11, 248)), "ldur x10, [x11, #248]");
1298 COMPARE(stur(x18, MemOperand(x19)), "stur x18, [x19]");
1299 COMPARE(stur(x20, MemOperand(x21, 8)), "stur x20, [x21, #8]");
1300 COMPARE(stur(x22, MemOperand(x23, 248)), "stur x22, [x23, #248]");
1301
1302 COMPARE(ldur(b0, MemOperand(x1)), "ldur b0, [x1]");
1303 COMPARE(ldur(h2, MemOperand(x3, -1)), "ldur h2, [x3, #-1]");
1304 COMPARE(ldur(s4, MemOperand(x5, 2)), "ldur s4, [x5, #2]");
1305 COMPARE(ldur(d6, MemOperand(x7, -3)), "ldur d6, [x7, #-3]");
1306 COMPARE(ldur(q8, MemOperand(x9, 4)), "ldur q8, [x9, #4]");
1307 COMPARE(stur(b10, MemOperand(x11)), "stur b10, [x11]");
1308 COMPARE(stur(h12, MemOperand(x13, -1)), "stur h12, [x13, #-1]");
1309 COMPARE(stur(s14, MemOperand(x15, 2)), "stur s14, [x15, #2]");
1310 COMPARE(stur(d16, MemOperand(x17, -3)), "stur d16, [x17, #-3]");
1311 COMPARE(stur(q18, MemOperand(x19, 4)), "stur q18, [x19, #4]");
1312
1313 // Normal loads and stores are converted to unscaled loads and stores if the
1314 // offset requires it.
1315 COMPARE(ldr(w0, MemOperand(x1, 1)), "ldur w0, [x1, #1]");
1316 COMPARE(ldr(w2, MemOperand(x3, -1)), "ldur w2, [x3, #-1]");
1317 COMPARE(ldr(w4, MemOperand(x5, 255)), "ldur w4, [x5, #255]");
1318 COMPARE(ldr(w6, MemOperand(x7, -256)), "ldur w6, [x7, #-256]");
1319 COMPARE(ldr(x8, MemOperand(x9, 1)), "ldur x8, [x9, #1]");
1320 COMPARE(ldr(x10, MemOperand(x11, -1)), "ldur x10, [x11, #-1]");
1321 COMPARE(ldr(x12, MemOperand(x13, 255)), "ldur x12, [x13, #255]");
1322 COMPARE(ldr(x14, MemOperand(x15, -256)), "ldur x14, [x15, #-256]");
1323 COMPARE(str(w16, MemOperand(x17, 1)), "stur w16, [x17, #1]");
1324 COMPARE(str(w18, MemOperand(x19, -1)), "stur w18, [x19, #-1]");
1325 COMPARE(str(w20, MemOperand(x21, 255)), "stur w20, [x21, #255]");
1326 COMPARE(str(w22, MemOperand(x23, -256)), "stur w22, [x23, #-256]");
1327 COMPARE(str(x24, MemOperand(x25, 1)), "stur x24, [x25, #1]");
1328 COMPARE(str(x26, MemOperand(x27, -1)), "stur x26, [x27, #-1]");
1329 COMPARE(str(x28, MemOperand(x29, 255)), "stur x28, [x29, #255]");
1330 COMPARE(str(x30, MemOperand(x0, -256)), "stur x30, [x0, #-256]");
1331 COMPARE(ldr(w0, MemOperand(sp, 1)), "ldur w0, [sp, #1]");
1332 COMPARE(str(x1, MemOperand(sp, -1)), "stur x1, [sp, #-1]");
1333 COMPARE(ldrb(w2, MemOperand(x3, -2)), "ldurb w2, [x3, #-2]");
1334 COMPARE(ldrsb(w4, MemOperand(x5, -3)), "ldursb w4, [x5, #-3]");
1335 COMPARE(ldrsb(x6, MemOperand(x7, -4)), "ldursb x6, [x7, #-4]");
1336 COMPARE(ldrh(w8, MemOperand(x9, -5)), "ldurh w8, [x9, #-5]");
1337 COMPARE(ldrsh(w10, MemOperand(x11, -6)), "ldursh w10, [x11, #-6]");
1338 COMPARE(ldrsh(x12, MemOperand(x13, -7)), "ldursh x12, [x13, #-7]");
1339 COMPARE(ldrsw(x14, MemOperand(x15, -8)), "ldursw x14, [x15, #-8]");
1340
1341 CLEANUP();
1342 }
1343
1344
TEST(load_store_unscaled_option)1345 TEST(load_store_unscaled_option) {
1346 SETUP();
1347
1348 // Just like load_store_unscaled, but specify the scaling option explicitly.
1349 LoadStoreScalingOption options[] = {PreferUnscaledOffset,
1350 RequireUnscaledOffset};
1351
1352 for (size_t i = 0; i < sizeof(options) / sizeof(options[0]); i++) {
1353 LoadStoreScalingOption option = options[i];
1354
1355 // If an unscaled-offset instruction is requested, it is used, even if the
1356 // offset could be encoded in a scaled-offset instruction.
1357 COMPARE(ldurb(w0, MemOperand(x1), option), "ldurb w0, [x1]");
1358 COMPARE(ldurb(x2, MemOperand(x3, 1), option), "ldurb w2, [x3, #1]");
1359 COMPARE(ldurb(w4, MemOperand(x5, 255), option), "ldurb w4, [x5, #255]");
1360 COMPARE(sturb(w14, MemOperand(x15), option), "sturb w14, [x15]");
1361 COMPARE(sturb(x16, MemOperand(x17, 1), option), "sturb w16, [x17, #1]");
1362 COMPARE(sturb(w18, MemOperand(x19, 255), option), "sturb w18, [x19, #255]");
1363 COMPARE(ldursb(w0, MemOperand(x1), option), "ldursb w0, [x1]");
1364 COMPARE(ldursb(w2, MemOperand(x3, 1), option), "ldursb w2, [x3, #1]");
1365 COMPARE(ldursb(x2, MemOperand(x3, 255), option), "ldursb x2, [x3, #255]");
1366
1367 COMPARE(ldurh(w0, MemOperand(x1), option), "ldurh w0, [x1]");
1368 COMPARE(ldurh(x2, MemOperand(x3, 2), option), "ldurh w2, [x3, #2]");
1369 COMPARE(ldurh(w4, MemOperand(x5, 254), option), "ldurh w4, [x5, #254]");
1370 COMPARE(sturh(w14, MemOperand(x15), option), "sturh w14, [x15]");
1371 COMPARE(sturh(x16, MemOperand(x17, 2), option), "sturh w16, [x17, #2]");
1372 COMPARE(sturh(w18, MemOperand(x19, 254), option), "sturh w18, [x19, #254]");
1373 COMPARE(ldursh(w0, MemOperand(x1), option), "ldursh w0, [x1]");
1374 COMPARE(ldursh(w2, MemOperand(x3, 2), option), "ldursh w2, [x3, #2]");
1375 COMPARE(ldursh(x4, MemOperand(x5, 254), option), "ldursh x4, [x5, #254]");
1376
1377 COMPARE(ldur(w0, MemOperand(x1), option), "ldur w0, [x1]");
1378 COMPARE(ldur(w2, MemOperand(x3, 4), option), "ldur w2, [x3, #4]");
1379 COMPARE(ldur(w4, MemOperand(x5, 248), option), "ldur w4, [x5, #248]");
1380 COMPARE(stur(w12, MemOperand(x13), option), "stur w12, [x13]");
1381 COMPARE(stur(w14, MemOperand(x15, 4), option), "stur w14, [x15, #4]");
1382 COMPARE(stur(w16, MemOperand(x17, 248), option), "stur w16, [x17, #248]");
1383 COMPARE(ldursw(x0, MemOperand(x1), option), "ldursw x0, [x1]");
1384 COMPARE(ldursw(x2, MemOperand(x3, 4), option), "ldursw x2, [x3, #4]");
1385 COMPARE(ldursw(x4, MemOperand(x5, 248), option), "ldursw x4, [x5, #248]");
1386
1387 COMPARE(ldur(x6, MemOperand(x7), option), "ldur x6, [x7]");
1388 COMPARE(ldur(x8, MemOperand(x9, 8), option), "ldur x8, [x9, #8]");
1389 COMPARE(ldur(x10, MemOperand(x11, 248), option), "ldur x10, [x11, #248]");
1390 COMPARE(stur(x18, MemOperand(x19), option), "stur x18, [x19]");
1391 COMPARE(stur(x20, MemOperand(x21, 8), option), "stur x20, [x21, #8]");
1392 COMPARE(stur(x22, MemOperand(x23, 248), option), "stur x22, [x23, #248]");
1393
1394 COMPARE(ldur(b0, MemOperand(x1), option), "ldur b0, [x1]");
1395 COMPARE(ldur(h2, MemOperand(x3, 2), option), "ldur h2, [x3, #2]");
1396 COMPARE(ldur(s4, MemOperand(x5, 4), option), "ldur s4, [x5, #4]");
1397 COMPARE(ldur(d6, MemOperand(x7, 8), option), "ldur d6, [x7, #8]");
1398 COMPARE(ldur(q8, MemOperand(x9, 16), option), "ldur q8, [x9, #16]");
1399 COMPARE(stur(b10, MemOperand(x11), option), "stur b10, [x11]");
1400 COMPARE(stur(h12, MemOperand(x13, 2), option), "stur h12, [x13, #2]");
1401 COMPARE(stur(s14, MemOperand(x15, 4), option), "stur s14, [x15, #4]");
1402 COMPARE(stur(d16, MemOperand(x17, 8), option), "stur d16, [x17, #8]");
1403 COMPARE(stur(q18, MemOperand(x19, 16), option), "stur q18, [x19, #16]");
1404 }
1405
1406 // Normal loads and stores are converted to unscaled loads and stores if the
1407 // offset requires it. PreferScaledOffset is the default for these cases, so
1408 // the behaviour here is the same when no option is specified.
1409 LoadStoreScalingOption option = PreferScaledOffset;
1410 COMPARE(ldr(w0, MemOperand(x1, 1), option), "ldur w0, [x1, #1]");
1411 COMPARE(ldr(w2, MemOperand(x3, -1), option), "ldur w2, [x3, #-1]");
1412 COMPARE(ldr(w4, MemOperand(x5, 255), option), "ldur w4, [x5, #255]");
1413 COMPARE(ldr(w6, MemOperand(x7, -256), option), "ldur w6, [x7, #-256]");
1414 COMPARE(ldr(x8, MemOperand(x9, 1), option), "ldur x8, [x9, #1]");
1415 COMPARE(ldr(x10, MemOperand(x11, -1), option), "ldur x10, [x11, #-1]");
1416 COMPARE(ldr(x12, MemOperand(x13, 255), option), "ldur x12, [x13, #255]");
1417 COMPARE(ldr(x14, MemOperand(x15, -256), option), "ldur x14, [x15, #-256]");
1418 COMPARE(str(w16, MemOperand(x17, 1), option), "stur w16, [x17, #1]");
1419 COMPARE(str(w18, MemOperand(x19, -1), option), "stur w18, [x19, #-1]");
1420 COMPARE(str(w20, MemOperand(x21, 255), option), "stur w20, [x21, #255]");
1421 COMPARE(str(w22, MemOperand(x23, -256), option), "stur w22, [x23, #-256]");
1422 COMPARE(str(x24, MemOperand(x25, 1), option), "stur x24, [x25, #1]");
1423 COMPARE(str(x26, MemOperand(x27, -1), option), "stur x26, [x27, #-1]");
1424 COMPARE(str(x28, MemOperand(x29, 255), option), "stur x28, [x29, #255]");
1425 COMPARE(str(x30, MemOperand(x0, -256), option), "stur x30, [x0, #-256]");
1426 COMPARE(ldr(w0, MemOperand(sp, 1), option), "ldur w0, [sp, #1]");
1427 COMPARE(str(x1, MemOperand(sp, -1), option), "stur x1, [sp, #-1]");
1428 COMPARE(ldrb(w2, MemOperand(x3, -2), option), "ldurb w2, [x3, #-2]");
1429 COMPARE(ldrsb(w4, MemOperand(x5, -3), option), "ldursb w4, [x5, #-3]");
1430 COMPARE(ldrsb(x6, MemOperand(x7, -4), option), "ldursb x6, [x7, #-4]");
1431 COMPARE(ldrh(w8, MemOperand(x9, -5), option), "ldurh w8, [x9, #-5]");
1432 COMPARE(ldrsh(w10, MemOperand(x11, -6), option), "ldursh w10, [x11, #-6]");
1433 COMPARE(ldrsh(x12, MemOperand(x13, -7), option), "ldursh x12, [x13, #-7]");
1434 COMPARE(ldrsw(x14, MemOperand(x15, -8), option), "ldursw x14, [x15, #-8]");
1435 COMPARE(ldr(b0, MemOperand(x1, 1), option), "ldr b0, [x1, #1]");
1436 COMPARE(ldr(h2, MemOperand(x3, 1), option), "ldur h2, [x3, #1]");
1437 COMPARE(ldr(s4, MemOperand(x5, 3), option), "ldur s4, [x5, #3]");
1438 COMPARE(ldr(d6, MemOperand(x7, 7), option), "ldur d6, [x7, #7]");
1439 COMPARE(ldr(q8, MemOperand(x9, 15), option), "ldur q8, [x9, #15]");
1440 COMPARE(str(b10, MemOperand(x11, 1), option), "str b10, [x11, #1]");
1441 COMPARE(str(h12, MemOperand(x13, 1), option), "stur h12, [x13, #1]");
1442 COMPARE(str(s14, MemOperand(x15, 3), option), "stur s14, [x15, #3]");
1443 COMPARE(str(d16, MemOperand(x17, 7), option), "stur d16, [x17, #7]");
1444 COMPARE(str(q18, MemOperand(x19, 15), option), "stur q18, [x19, #15]");
1445
1446 CLEANUP();
1447 }
1448
1449
TEST(load_store_pair)1450 TEST(load_store_pair) {
1451 SETUP();
1452
1453 COMPARE(ldp(w0, w1, MemOperand(x2)), "ldp w0, w1, [x2]");
1454 COMPARE(ldp(x3, x4, MemOperand(x5)), "ldp x3, x4, [x5]");
1455 COMPARE(ldp(w6, w7, MemOperand(x8, 4)), "ldp w6, w7, [x8, #4]");
1456 COMPARE(ldp(x9, x10, MemOperand(x11, 8)), "ldp x9, x10, [x11, #8]");
1457 COMPARE(ldp(w12, w13, MemOperand(x14, 252)), "ldp w12, w13, [x14, #252]");
1458 COMPARE(ldp(x15, x16, MemOperand(x17, 504)), "ldp x15, x16, [x17, #504]");
1459 COMPARE(ldp(w18, w19, MemOperand(x20, -256)), "ldp w18, w19, [x20, #-256]");
1460 COMPARE(ldp(x21, x22, MemOperand(x23, -512)), "ldp x21, x22, [x23, #-512]");
1461 COMPARE(ldp(w24, w25, MemOperand(x26, 252, PreIndex)),
1462 "ldp w24, w25, [x26, #252]!");
1463 COMPARE(ldp(x27, x28, MemOperand(x29, 504, PreIndex)),
1464 "ldp x27, x28, [x29, #504]!");
1465 COMPARE(ldp(w30, w0, MemOperand(x1, -256, PreIndex)),
1466 "ldp w30, w0, [x1, #-256]!");
1467 COMPARE(ldp(x2, x3, MemOperand(x4, -512, PreIndex)),
1468 "ldp x2, x3, [x4, #-512]!");
1469 COMPARE(ldp(w5, w6, MemOperand(x7, 252, PostIndex)),
1470 "ldp w5, w6, [x7], #252");
1471 COMPARE(ldp(x8, x9, MemOperand(x10, 504, PostIndex)),
1472 "ldp x8, x9, [x10], #504");
1473 COMPARE(ldp(w11, w12, MemOperand(x13, -256, PostIndex)),
1474 "ldp w11, w12, [x13], #-256");
1475 COMPARE(ldp(x14, x15, MemOperand(x16, -512, PostIndex)),
1476 "ldp x14, x15, [x16], #-512");
1477 COMPARE(ldp(x0, x1, MemOperand(x2, 0, PostIndex)), "ldp x0, x1, [x2], #0");
1478 COMPARE(ldp(w3, w4, MemOperand(x5, 0, PreIndex)), "ldp w3, w4, [x5, #0]!");
1479
1480 COMPARE(ldp(s17, s18, MemOperand(x19)), "ldp s17, s18, [x19]");
1481 COMPARE(ldp(s20, s21, MemOperand(x22, 252)), "ldp s20, s21, [x22, #252]");
1482 COMPARE(ldp(s23, s24, MemOperand(x25, -256)), "ldp s23, s24, [x25, #-256]");
1483 COMPARE(ldp(s26, s27, MemOperand(x28, 252, PreIndex)),
1484 "ldp s26, s27, [x28, #252]!");
1485 COMPARE(ldp(s29, s30, MemOperand(x29, -256, PreIndex)),
1486 "ldp s29, s30, [x29, #-256]!");
1487 COMPARE(ldp(s31, s0, MemOperand(x1, 252, PostIndex)),
1488 "ldp s31, s0, [x1], #252");
1489 COMPARE(ldp(s2, s3, MemOperand(x4, -256, PostIndex)),
1490 "ldp s2, s3, [x4], #-256");
1491 COMPARE(ldp(d17, d18, MemOperand(x19)), "ldp d17, d18, [x19]");
1492 COMPARE(ldp(d20, d21, MemOperand(x22, 504)), "ldp d20, d21, [x22, #504]");
1493 COMPARE(ldp(d23, d24, MemOperand(x25, -512)), "ldp d23, d24, [x25, #-512]");
1494 COMPARE(ldp(d26, d27, MemOperand(x28, 504, PreIndex)),
1495 "ldp d26, d27, [x28, #504]!");
1496 COMPARE(ldp(d29, d30, MemOperand(x29, -512, PreIndex)),
1497 "ldp d29, d30, [x29, #-512]!");
1498 COMPARE(ldp(d31, d0, MemOperand(x1, 504, PostIndex)),
1499 "ldp d31, d0, [x1], #504");
1500 COMPARE(ldp(d2, d3, MemOperand(x4, -512, PostIndex)),
1501 "ldp d2, d3, [x4], #-512");
1502 COMPARE(ldp(s0, s1, MemOperand(x2, 0, PostIndex)), "ldp s0, s1, [x2], #0");
1503 COMPARE(ldp(d3, d4, MemOperand(x5, 0, PreIndex)), "ldp d3, d4, [x5, #0]!");
1504
1505 COMPARE(ldp(q5, q6, MemOperand(x7)), "ldp q5, q6, [x7]");
1506 COMPARE(ldp(q8, q9, MemOperand(x10, 1008)), "ldp q8, q9, [x10, #1008]");
1507 COMPARE(ldp(q11, q12, MemOperand(x13, -1024)), "ldp q11, q12, [x13, #-1024]");
1508 COMPARE(ldp(q14, q15, MemOperand(x16, 1008, PreIndex)),
1509 "ldp q14, q15, [x16, #1008]!");
1510 COMPARE(ldp(q17, q18, MemOperand(x19, -1024, PreIndex)),
1511 "ldp q17, q18, [x19, #-1024]!");
1512 COMPARE(ldp(q20, q21, MemOperand(x22, 1008, PostIndex)),
1513 "ldp q20, q21, [x22], #1008");
1514 COMPARE(ldp(q23, q24, MemOperand(x25, -1024, PostIndex)),
1515 "ldp q23, q24, [x25], #-1024");
1516 COMPARE(ldp(q6, q7, MemOperand(x8, 0, PreIndex)), "ldp q6, q7, [x8, #0]!");
1517
1518 COMPARE(stp(w0, w1, MemOperand(x2)), "stp w0, w1, [x2]");
1519 COMPARE(stp(x3, x4, MemOperand(x5)), "stp x3, x4, [x5]");
1520 COMPARE(stp(w6, w7, MemOperand(x8, 4)), "stp w6, w7, [x8, #4]");
1521 COMPARE(stp(x9, x10, MemOperand(x11, 8)), "stp x9, x10, [x11, #8]");
1522 COMPARE(stp(w12, w13, MemOperand(x14, 252)), "stp w12, w13, [x14, #252]");
1523 COMPARE(stp(x15, x16, MemOperand(x17, 504)), "stp x15, x16, [x17, #504]");
1524 COMPARE(stp(w18, w19, MemOperand(x20, -256)), "stp w18, w19, [x20, #-256]");
1525 COMPARE(stp(x21, x22, MemOperand(x23, -512)), "stp x21, x22, [x23, #-512]");
1526 COMPARE(stp(w24, w25, MemOperand(x26, 252, PreIndex)),
1527 "stp w24, w25, [x26, #252]!");
1528 COMPARE(stp(x27, x28, MemOperand(x29, 504, PreIndex)),
1529 "stp x27, x28, [x29, #504]!");
1530 COMPARE(stp(w30, w0, MemOperand(x1, -256, PreIndex)),
1531 "stp w30, w0, [x1, #-256]!");
1532 COMPARE(stp(x2, x3, MemOperand(x4, -512, PreIndex)),
1533 "stp x2, x3, [x4, #-512]!");
1534 COMPARE(stp(w5, w6, MemOperand(x7, 252, PostIndex)),
1535 "stp w5, w6, [x7], #252");
1536 COMPARE(stp(x8, x9, MemOperand(x10, 504, PostIndex)),
1537 "stp x8, x9, [x10], #504");
1538 COMPARE(stp(w11, w12, MemOperand(x13, -256, PostIndex)),
1539 "stp w11, w12, [x13], #-256");
1540 COMPARE(stp(x14, x15, MemOperand(x16, -512, PostIndex)),
1541 "stp x14, x15, [x16], #-512");
1542 COMPARE(stp(x0, x1, MemOperand(x2, 0, PostIndex)), "stp x0, x1, [x2], #0");
1543 COMPARE(stp(w3, w4, MemOperand(x5, 0, PreIndex)), "stp w3, w4, [x5, #0]!");
1544
1545 COMPARE(stp(s17, s18, MemOperand(x19)), "stp s17, s18, [x19]");
1546 COMPARE(stp(s20, s21, MemOperand(x22, 252)), "stp s20, s21, [x22, #252]");
1547 COMPARE(stp(s23, s24, MemOperand(x25, -256)), "stp s23, s24, [x25, #-256]");
1548 COMPARE(stp(s26, s27, MemOperand(x28, 252, PreIndex)),
1549 "stp s26, s27, [x28, #252]!");
1550 COMPARE(stp(s29, s30, MemOperand(x29, -256, PreIndex)),
1551 "stp s29, s30, [x29, #-256]!");
1552 COMPARE(stp(s31, s0, MemOperand(x1, 252, PostIndex)),
1553 "stp s31, s0, [x1], #252");
1554 COMPARE(stp(s2, s3, MemOperand(x4, -256, PostIndex)),
1555 "stp s2, s3, [x4], #-256");
1556 COMPARE(stp(d17, d18, MemOperand(x19)), "stp d17, d18, [x19]");
1557 COMPARE(stp(d20, d21, MemOperand(x22, 504)), "stp d20, d21, [x22, #504]");
1558 COMPARE(stp(d23, d24, MemOperand(x25, -512)), "stp d23, d24, [x25, #-512]");
1559 COMPARE(stp(d26, d27, MemOperand(x28, 504, PreIndex)),
1560 "stp d26, d27, [x28, #504]!");
1561 COMPARE(stp(d29, d30, MemOperand(x29, -512, PreIndex)),
1562 "stp d29, d30, [x29, #-512]!");
1563 COMPARE(stp(d31, d0, MemOperand(x1, 504, PostIndex)),
1564 "stp d31, d0, [x1], #504");
1565 COMPARE(stp(d2, d3, MemOperand(x4, -512, PostIndex)),
1566 "stp d2, d3, [x4], #-512");
1567 COMPARE(stp(s0, s1, MemOperand(x2, 0, PostIndex)), "stp s0, s1, [x2], #0");
1568 COMPARE(stp(d3, d4, MemOperand(x5, 0, PreIndex)), "stp d3, d4, [x5, #0]!");
1569
1570 COMPARE(stp(q5, q6, MemOperand(x7)), "stp q5, q6, [x7]");
1571 COMPARE(stp(q8, q9, MemOperand(x10, 1008)), "stp q8, q9, [x10, #1008]");
1572 COMPARE(stp(q11, q12, MemOperand(x13, -1024)), "stp q11, q12, [x13, #-1024]");
1573 COMPARE(stp(q14, q15, MemOperand(x16, 1008, PreIndex)),
1574 "stp q14, q15, [x16, #1008]!");
1575 COMPARE(stp(q17, q18, MemOperand(x19, -1024, PreIndex)),
1576 "stp q17, q18, [x19, #-1024]!");
1577 COMPARE(stp(q20, q21, MemOperand(x22, 1008, PostIndex)),
1578 "stp q20, q21, [x22], #1008");
1579 COMPARE(stp(q23, q24, MemOperand(x25, -1024, PostIndex)),
1580 "stp q23, q24, [x25], #-1024");
1581 COMPARE(stp(q6, q7, MemOperand(x8, 0, PreIndex)), "stp q6, q7, [x8, #0]!");
1582
1583 COMPARE(ldp(w16, w17, MemOperand(sp, 4, PostIndex)),
1584 "ldp w16, w17, [sp], #4");
1585 COMPARE(stp(x18, x19, MemOperand(sp, -8, PreIndex)),
1586 "stp x18, x19, [sp, #-8]!");
1587 COMPARE(ldp(s30, s31, MemOperand(sp, 12, PostIndex)),
1588 "ldp s30, s31, [sp], #12");
1589 COMPARE(stp(d30, d31, MemOperand(sp, -16)), "stp d30, d31, [sp, #-16]");
1590 COMPARE(ldp(q30, q31, MemOperand(sp, 32, PostIndex)),
1591 "ldp q30, q31, [sp], #32");
1592
1593 COMPARE(ldpsw(x0, x1, MemOperand(x2)), "ldpsw x0, x1, [x2]");
1594 COMPARE(ldpsw(x3, x4, MemOperand(x5, 16)), "ldpsw x3, x4, [x5, #16]");
1595 COMPARE(ldpsw(x6, x7, MemOperand(x8, -32, PreIndex)),
1596 "ldpsw x6, x7, [x8, #-32]!");
1597 COMPARE(ldpsw(x9, x10, MemOperand(x11, 128, PostIndex)),
1598 "ldpsw x9, x10, [x11], #128");
1599 COMPARE(ldpsw(x0, x1, MemOperand(x10, 0, PreIndex)),
1600 "ldpsw x0, x1, [x10, #0]!");
1601 COMPARE(ldpsw(x2, x3, MemOperand(x10, 0, PostIndex)),
1602 "ldpsw x2, x3, [x10], #0");
1603
1604 CLEANUP();
1605 }
1606
1607
TEST(load_pauth)1608 TEST(load_pauth) {
1609 SETUP();
1610
1611 COMPARE(ldraa(x0, MemOperand(x1)), "ldraa x0, [x1]");
1612 COMPARE(ldraa(x2, MemOperand(sp)), "ldraa x2, [sp]");
1613 COMPARE(ldraa(x3, MemOperand(x4, 64)), "ldraa x3, [x4, #64]");
1614 COMPARE(ldraa(x5, MemOperand(sp, 512)), "ldraa x5, [sp, #512]");
1615 COMPARE(ldraa(x6, MemOperand(x7, -256)), "ldraa x6, [x7, #-256]");
1616 COMPARE(ldraa(x8, MemOperand(sp, -1024)), "ldraa x8, [sp, #-1024]");
1617 COMPARE(ldraa(x9, MemOperand(x10, 2048, PreIndex)),
1618 "ldraa x9, [x10, #2048]!");
1619
1620 COMPARE(ldrab(x9, MemOperand(x10)), "ldrab x9, [x10]");
1621 COMPARE(ldrab(x11, MemOperand(sp)), "ldrab x11, [sp]");
1622 COMPARE(ldrab(x12, MemOperand(x13, 64)), "ldrab x12, [x13, #64]");
1623 COMPARE(ldrab(x14, MemOperand(sp, 512)), "ldrab x14, [sp, #512]");
1624 COMPARE(ldrab(x15, MemOperand(x16, -256)), "ldrab x15, [x16, #-256]");
1625 COMPARE(ldrab(x17, MemOperand(sp, -1024)), "ldrab x17, [sp, #-1024]");
1626 COMPARE(ldrab(x18, MemOperand(x19, 2048, PreIndex)),
1627 "ldrab x18, [x19, #2048]!");
1628
1629 CLEANUP();
1630 }
1631
1632
TEST(load_store_exclusive)1633 TEST(load_store_exclusive) {
1634 SETUP();
1635
1636 COMPARE(stxrb(w0, w1, MemOperand(x2)), "stxrb w0, w1, [x2]");
1637 COMPARE(stxrb(x3, w4, MemOperand(sp)), "stxrb w3, w4, [sp]");
1638 COMPARE(stxrb(w5, x6, MemOperand(x7)), "stxrb w5, w6, [x7]");
1639 COMPARE(stxrb(x8, x9, MemOperand(sp)), "stxrb w8, w9, [sp]");
1640 COMPARE(stxrh(w10, w11, MemOperand(x12)), "stxrh w10, w11, [x12]");
1641 COMPARE(stxrh(x13, w14, MemOperand(sp)), "stxrh w13, w14, [sp]");
1642 COMPARE(stxrh(w15, x16, MemOperand(x17)), "stxrh w15, w16, [x17]");
1643 COMPARE(stxrh(x18, x19, MemOperand(sp)), "stxrh w18, w19, [sp]");
1644 COMPARE(stxr(w20, w21, MemOperand(x22)), "stxr w20, w21, [x22]");
1645 COMPARE(stxr(x23, w24, MemOperand(sp)), "stxr w23, w24, [sp]");
1646 COMPARE(stxr(w25, x26, MemOperand(x27)), "stxr w25, x26, [x27]");
1647 COMPARE(stxr(x28, x29, MemOperand(sp)), "stxr w28, x29, [sp]");
1648 COMPARE(ldxrb(w30, MemOperand(x0)), "ldxrb w30, [x0]");
1649 COMPARE(ldxrb(w1, MemOperand(sp)), "ldxrb w1, [sp]");
1650 COMPARE(ldxrb(x2, MemOperand(x3)), "ldxrb w2, [x3]");
1651 COMPARE(ldxrb(x4, MemOperand(sp)), "ldxrb w4, [sp]");
1652 COMPARE(ldxrh(w5, MemOperand(x6)), "ldxrh w5, [x6]");
1653 COMPARE(ldxrh(w7, MemOperand(sp)), "ldxrh w7, [sp]");
1654 COMPARE(ldxrh(x8, MemOperand(x9)), "ldxrh w8, [x9]");
1655 COMPARE(ldxrh(x10, MemOperand(sp)), "ldxrh w10, [sp]");
1656 COMPARE(ldxr(w11, MemOperand(x12)), "ldxr w11, [x12]");
1657 COMPARE(ldxr(w13, MemOperand(sp)), "ldxr w13, [sp]");
1658 COMPARE(ldxr(x14, MemOperand(x15)), "ldxr x14, [x15]");
1659 COMPARE(ldxr(x16, MemOperand(sp)), "ldxr x16, [sp]");
1660 COMPARE(stxp(w17, w18, w19, MemOperand(x20)), "stxp w17, w18, w19, [x20]");
1661 COMPARE(stxp(x21, w22, w23, MemOperand(sp)), "stxp w21, w22, w23, [sp]");
1662 COMPARE(stxp(w24, x25, x26, MemOperand(x27)), "stxp w24, x25, x26, [x27]");
1663 COMPARE(stxp(x28, x29, x30, MemOperand(sp)), "stxp w28, x29, x30, [sp]");
1664 COMPARE(ldxp(w0, w1, MemOperand(x2)), "ldxp w0, w1, [x2]");
1665 COMPARE(ldxp(w3, w4, MemOperand(sp)), "ldxp w3, w4, [sp]");
1666 COMPARE(ldxp(x5, x6, MemOperand(x7)), "ldxp x5, x6, [x7]");
1667 COMPARE(ldxp(x8, x9, MemOperand(sp)), "ldxp x8, x9, [sp]");
1668 COMPARE(stlxrb(w10, w11, MemOperand(x12)), "stlxrb w10, w11, [x12]");
1669 COMPARE(stlxrb(x13, w14, MemOperand(sp)), "stlxrb w13, w14, [sp]");
1670 COMPARE(stlxrb(w15, x16, MemOperand(x17)), "stlxrb w15, w16, [x17]");
1671 COMPARE(stlxrb(x18, x19, MemOperand(sp)), "stlxrb w18, w19, [sp]");
1672 COMPARE(stlxrh(w20, w21, MemOperand(x22)), "stlxrh w20, w21, [x22]");
1673 COMPARE(stlxrh(x23, w24, MemOperand(sp)), "stlxrh w23, w24, [sp]");
1674 COMPARE(stlxrh(w25, x26, MemOperand(x27)), "stlxrh w25, w26, [x27]");
1675 COMPARE(stlxrh(x28, x29, MemOperand(sp)), "stlxrh w28, w29, [sp]");
1676 COMPARE(stlxr(w30, w0, MemOperand(x1)), "stlxr w30, w0, [x1]");
1677 COMPARE(stlxr(x2, w3, MemOperand(sp)), "stlxr w2, w3, [sp]");
1678 COMPARE(stlxr(w4, x5, MemOperand(x6)), "stlxr w4, x5, [x6]");
1679 COMPARE(stlxr(x7, x8, MemOperand(sp)), "stlxr w7, x8, [sp]");
1680 COMPARE(ldaxrb(w9, MemOperand(x10)), "ldaxrb w9, [x10]");
1681 COMPARE(ldaxrb(w11, MemOperand(sp)), "ldaxrb w11, [sp]");
1682 COMPARE(ldaxrb(x12, MemOperand(x13)), "ldaxrb w12, [x13]");
1683 COMPARE(ldaxrb(x14, MemOperand(sp)), "ldaxrb w14, [sp]");
1684 COMPARE(ldaxrh(w15, MemOperand(x16)), "ldaxrh w15, [x16]");
1685 COMPARE(ldaxrh(w17, MemOperand(sp)), "ldaxrh w17, [sp]");
1686 COMPARE(ldaxrh(x18, MemOperand(x19)), "ldaxrh w18, [x19]");
1687 COMPARE(ldaxrh(x20, MemOperand(sp)), "ldaxrh w20, [sp]");
1688 COMPARE(ldaxr(w21, MemOperand(x22)), "ldaxr w21, [x22]");
1689 COMPARE(ldaxr(w23, MemOperand(sp)), "ldaxr w23, [sp]");
1690 COMPARE(ldaxr(x24, MemOperand(x25)), "ldaxr x24, [x25]");
1691 COMPARE(ldaxr(x26, MemOperand(sp)), "ldaxr x26, [sp]");
1692 COMPARE(stlxp(w27, w28, w29, MemOperand(x30)), "stlxp w27, w28, w29, [x30]");
1693 COMPARE(stlxp(x0, w1, w2, MemOperand(sp)), "stlxp w0, w1, w2, [sp]");
1694 COMPARE(stlxp(w3, x4, x5, MemOperand(x6)), "stlxp w3, x4, x5, [x6]");
1695 COMPARE(stlxp(x7, x8, x9, MemOperand(sp)), "stlxp w7, x8, x9, [sp]");
1696 COMPARE(ldaxp(w10, w11, MemOperand(x12)), "ldaxp w10, w11, [x12]");
1697 COMPARE(ldaxp(w13, w14, MemOperand(sp)), "ldaxp w13, w14, [sp]");
1698 COMPARE(ldaxp(x15, x16, MemOperand(x17)), "ldaxp x15, x16, [x17]");
1699 COMPARE(ldaxp(x18, x19, MemOperand(sp)), "ldaxp x18, x19, [sp]");
1700 COMPARE(stlrb(w20, MemOperand(x21)), "stlrb w20, [x21]");
1701 COMPARE(stlrb(w22, MemOperand(sp)), "stlrb w22, [sp]");
1702 COMPARE(stlrb(x23, MemOperand(x24)), "stlrb w23, [x24]");
1703 COMPARE(stlrb(x25, MemOperand(sp)), "stlrb w25, [sp]");
1704 COMPARE(stlrh(w26, MemOperand(x27)), "stlrh w26, [x27]");
1705 COMPARE(stlrh(w28, MemOperand(sp)), "stlrh w28, [sp]");
1706 COMPARE(stlrh(x29, MemOperand(x30)), "stlrh w29, [x30]");
1707 COMPARE(stlrh(x0, MemOperand(sp)), "stlrh w0, [sp]");
1708 COMPARE(stlr(w1, MemOperand(x2)), "stlr w1, [x2]");
1709 COMPARE(stlr(w3, MemOperand(sp)), "stlr w3, [sp]");
1710 COMPARE(stlr(x4, MemOperand(x5)), "stlr x4, [x5]");
1711 COMPARE(stlr(x6, MemOperand(sp)), "stlr x6, [sp]");
1712 COMPARE(stllrb(w7, MemOperand(x8)), "stllrb w7, [x8]");
1713 COMPARE(stllrb(w9, MemOperand(sp)), "stllrb w9, [sp]");
1714 COMPARE(stllrb(x10, MemOperand(x11)), "stllrb w10, [x11]");
1715 COMPARE(stllrb(x12, MemOperand(sp)), "stllrb w12, [sp]");
1716 COMPARE(stllrh(w13, MemOperand(x14)), "stllrh w13, [x14]");
1717 COMPARE(stllrh(w15, MemOperand(sp)), "stllrh w15, [sp]");
1718 COMPARE(stllrh(x16, MemOperand(x17)), "stllrh w16, [x17]");
1719 COMPARE(stllrh(x18, MemOperand(sp)), "stllrh w18, [sp]");
1720 COMPARE(stllr(w19, MemOperand(x20)), "stllr w19, [x20]");
1721 COMPARE(stllr(w21, MemOperand(sp)), "stllr w21, [sp]");
1722 COMPARE(stllr(x22, MemOperand(x23)), "stllr x22, [x23]");
1723 COMPARE(stllr(x24, MemOperand(sp)), "stllr x24, [sp]");
1724 COMPARE(ldarb(w25, MemOperand(x26)), "ldarb w25, [x26]");
1725 COMPARE(ldarb(w27, MemOperand(sp)), "ldarb w27, [sp]");
1726 COMPARE(ldarb(x28, MemOperand(x29)), "ldarb w28, [x29]");
1727 COMPARE(ldarb(x30, MemOperand(sp)), "ldarb w30, [sp]");
1728 COMPARE(ldarh(w0, MemOperand(x1)), "ldarh w0, [x1]");
1729 COMPARE(ldarh(w2, MemOperand(sp)), "ldarh w2, [sp]");
1730 COMPARE(ldarh(x3, MemOperand(x4)), "ldarh w3, [x4]");
1731 COMPARE(ldarh(x5, MemOperand(sp)), "ldarh w5, [sp]");
1732 COMPARE(ldar(w6, MemOperand(x7)), "ldar w6, [x7]");
1733 COMPARE(ldar(w8, MemOperand(sp)), "ldar w8, [sp]");
1734 COMPARE(ldar(x9, MemOperand(x10)), "ldar x9, [x10]");
1735 COMPARE(ldar(x11, MemOperand(sp)), "ldar x11, [sp]");
1736 COMPARE(ldlarb(w12, MemOperand(x13)), "ldlarb w12, [x13]");
1737 COMPARE(ldlarb(w14, MemOperand(sp)), "ldlarb w14, [sp]");
1738 COMPARE(ldlarb(x15, MemOperand(x16)), "ldlarb w15, [x16]");
1739 COMPARE(ldlarb(x17, MemOperand(sp)), "ldlarb w17, [sp]");
1740 COMPARE(ldlarh(w18, MemOperand(x19)), "ldlarh w18, [x19]");
1741 COMPARE(ldlarh(w20, MemOperand(sp)), "ldlarh w20, [sp]");
1742 COMPARE(ldlarh(x21, MemOperand(x22)), "ldlarh w21, [x22]");
1743 COMPARE(ldlarh(x23, MemOperand(sp)), "ldlarh w23, [sp]");
1744 COMPARE(ldlar(w24, MemOperand(x25)), "ldlar w24, [x25]");
1745 COMPARE(ldlar(w26, MemOperand(sp)), "ldlar w26, [sp]");
1746 COMPARE(ldlar(x27, MemOperand(x28)), "ldlar x27, [x28]");
1747 COMPARE(ldlar(x29, MemOperand(sp)), "ldlar x29, [sp]");
1748
1749 COMPARE(cas(w30, w0, MemOperand(x1)), "cas w30, w0, [x1]");
1750 COMPARE(cas(w2, w3, MemOperand(sp)), "cas w2, w3, [sp]");
1751 COMPARE(cas(x4, x5, MemOperand(x6)), "cas x4, x5, [x6]");
1752 COMPARE(cas(x7, x8, MemOperand(sp)), "cas x7, x8, [sp]");
1753 COMPARE(casa(w9, w10, MemOperand(x11)), "casa w9, w10, [x11]");
1754 COMPARE(casa(w12, w13, MemOperand(sp)), "casa w12, w13, [sp]");
1755 COMPARE(casa(x14, x15, MemOperand(x16)), "casa x14, x15, [x16]");
1756 COMPARE(casa(x17, x18, MemOperand(sp)), "casa x17, x18, [sp]");
1757 COMPARE(casl(w19, w20, MemOperand(x21)), "casl w19, w20, [x21]");
1758 COMPARE(casl(w22, w23, MemOperand(sp)), "casl w22, w23, [sp]");
1759 COMPARE(casl(x24, x25, MemOperand(x26)), "casl x24, x25, [x26]");
1760 COMPARE(casl(x27, x28, MemOperand(sp)), "casl x27, x28, [sp]");
1761 COMPARE(casal(w29, w30, MemOperand(x0)), "casal w29, w30, [x0]");
1762 COMPARE(casal(w1, w2, MemOperand(sp)), "casal w1, w2, [sp]");
1763 COMPARE(casal(x3, x4, MemOperand(x5)), "casal x3, x4, [x5]");
1764 COMPARE(casal(x6, x7, MemOperand(sp)), "casal x6, x7, [sp]");
1765 COMPARE(casb(w8, w9, MemOperand(x10)), "casb w8, w9, [x10]");
1766 COMPARE(casb(w11, w12, MemOperand(sp)), "casb w11, w12, [sp]");
1767 COMPARE(casab(w13, w14, MemOperand(x15)), "casab w13, w14, [x15]");
1768 COMPARE(casab(w16, w17, MemOperand(sp)), "casab w16, w17, [sp]");
1769 COMPARE(caslb(w18, w19, MemOperand(x20)), "caslb w18, w19, [x20]");
1770 COMPARE(caslb(w21, w22, MemOperand(sp)), "caslb w21, w22, [sp]");
1771 COMPARE(casalb(w23, w24, MemOperand(x25)), "casalb w23, w24, [x25]");
1772 COMPARE(casalb(w26, w27, MemOperand(sp)), "casalb w26, w27, [sp]");
1773 COMPARE(cash(w28, w29, MemOperand(x30)), "cash w28, w29, [x30]");
1774 COMPARE(cash(w0, w1, MemOperand(sp)), "cash w0, w1, [sp]");
1775 COMPARE(casah(w2, w3, MemOperand(x4)), "casah w2, w3, [x4]");
1776 COMPARE(casah(w5, w6, MemOperand(sp)), "casah w5, w6, [sp]");
1777 COMPARE(caslh(w7, w8, MemOperand(x9)), "caslh w7, w8, [x9]");
1778 COMPARE(caslh(w10, w11, MemOperand(sp)), "caslh w10, w11, [sp]");
1779 COMPARE(casalh(w12, w13, MemOperand(x14)), "casalh w12, w13, [x14]");
1780 COMPARE(casalh(w15, w16, MemOperand(sp)), "casalh w15, w16, [sp]");
1781 COMPARE(casp(w18, w19, w20, w21, MemOperand(x22)),
1782 "casp w18, w19, w20, w21, [x22]");
1783 COMPARE(casp(w24, w25, w26, w27, MemOperand(sp)),
1784 "casp w24, w25, w26, w27, [sp]");
1785 COMPARE(casp(x28, x29, x0, x1, MemOperand(x2)),
1786 "casp x28, x29, x0, x1, [x2]");
1787 COMPARE(casp(x4, x5, x6, x7, MemOperand(sp)), "casp x4, x5, x6, x7, [sp]");
1788 COMPARE(caspa(w8, w9, w10, w11, MemOperand(x12)),
1789 "caspa w8, w9, w10, w11, [x12]");
1790 COMPARE(caspa(w14, w15, w16, w17, MemOperand(sp)),
1791 "caspa w14, w15, w16, w17, [sp]");
1792 COMPARE(caspa(x18, x19, x20, x21, MemOperand(x22)),
1793 "caspa x18, x19, x20, x21, [x22]");
1794 COMPARE(caspa(x24, x25, x26, x27, MemOperand(sp)),
1795 "caspa x24, x25, x26, x27, [sp]");
1796 COMPARE(caspl(w28, w29, w0, w1, MemOperand(x2)),
1797 "caspl w28, w29, w0, w1, [x2]");
1798 COMPARE(caspl(w4, w5, w6, w7, MemOperand(sp)), "caspl w4, w5, w6, w7, [sp]");
1799 COMPARE(caspl(x8, x9, x10, x11, MemOperand(x12)),
1800 "caspl x8, x9, x10, x11, [x12]");
1801 COMPARE(caspl(x14, x15, x16, x17, MemOperand(sp)),
1802 "caspl x14, x15, x16, x17, [sp]");
1803 COMPARE(caspal(w18, w19, w20, w21, MemOperand(x22)),
1804 "caspal w18, w19, w20, w21, [x22]");
1805 COMPARE(caspal(w24, w25, w26, w27, MemOperand(sp)),
1806 "caspal w24, w25, w26, w27, [sp]");
1807 COMPARE(caspal(x28, x29, x0, x1, MemOperand(x2)),
1808 "caspal x28, x29, x0, x1, [x2]");
1809 COMPARE(caspal(x4, x5, x6, x7, MemOperand(sp)),
1810 "caspal x4, x5, x6, x7, [sp]");
1811
1812
1813 CLEANUP();
1814 }
1815
1816 // clang-format off
1817 #define ATOMIC_MEMORY_DISASM_LIST(V, DEF) \
1818 V(DEF, add, "add") \
1819 V(DEF, clr, "clr") \
1820 V(DEF, eor, "eor") \
1821 V(DEF, set, "set") \
1822 V(DEF, smax, "smax") \
1823 V(DEF, smin, "smin") \
1824 V(DEF, umax, "umax") \
1825 V(DEF, umin, "umin")
1826
1827 #define ATOMIC_MEMORY_DISASM_STORE_X_MODES(V, NAME, STR) \
1828 V(NAME, STR) \
1829 V(NAME##l, STR "l")
1830
1831
1832 #define ATOMIC_MEMORY_DISASM_STORE_W_MODES(V, NAME, STR) \
1833 ATOMIC_MEMORY_DISASM_STORE_X_MODES(V, NAME, STR) \
1834 V(NAME##b, STR "b") \
1835 V(NAME##lb, STR "lb") \
1836 V(NAME##h, STR "h") \
1837 V(NAME##lh, STR "lh")
1838
1839 #define ATOMIC_MEMORY_DISASM_LOAD_X_MODES(V, NAME, STR) \
1840 ATOMIC_MEMORY_DISASM_STORE_X_MODES(V, NAME, STR) \
1841 V(NAME##a, STR "a") \
1842 V(NAME##al, STR "al")
1843
1844 #define ATOMIC_MEMORY_DISASM_LOAD_W_MODES(V, NAME, STR) \
1845 ATOMIC_MEMORY_DISASM_LOAD_X_MODES(V, NAME, STR) \
1846 V(NAME##ab, STR "ab") \
1847 V(NAME##alb, STR "alb") \
1848 V(NAME##ah, STR "ah") \
1849 V(NAME##alh, STR "alh")
1850 // clang-format on
1851
TEST(atomic_memory)1852 TEST(atomic_memory) {
1853 SETUP();
1854
1855 // These macros generate tests for all the variations of the atomic memory
1856 // operations, e.g. ldadd, ldadda, ldaddb, staddl, etc.
1857
1858 #define AM_LOAD_X_TESTS(N, MN) \
1859 COMPARE(ld##N(x0, x1, MemOperand(x2)), "ld" MN " x0, x1, [x2]"); \
1860 COMPARE(ld##N(x3, x4, MemOperand(sp)), "ld" MN " x3, x4, [sp]");
1861 #define AM_LOAD_W_TESTS(N, MN) \
1862 COMPARE(ld##N(w0, w1, MemOperand(x2)), "ld" MN " w0, w1, [x2]"); \
1863 COMPARE(ld##N(w3, w4, MemOperand(sp)), "ld" MN " w3, w4, [sp]");
1864 #define AM_STORE_X_TESTS(N, MN) \
1865 COMPARE(st##N(x0, MemOperand(x1)), "st" MN " x0, [x1]"); \
1866 COMPARE(st##N(x2, MemOperand(sp)), "st" MN " x2, [sp]");
1867 #define AM_STORE_W_TESTS(N, MN) \
1868 COMPARE(st##N(w0, MemOperand(x1)), "st" MN " w0, [x1]"); \
1869 COMPARE(st##N(w2, MemOperand(sp)), "st" MN " w2, [sp]");
1870
1871 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_LOAD_X_MODES, AM_LOAD_X_TESTS)
1872 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_LOAD_W_MODES, AM_LOAD_W_TESTS)
1873 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_STORE_X_MODES,
1874 AM_STORE_X_TESTS)
1875 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_STORE_W_MODES,
1876 AM_STORE_W_TESTS)
1877
1878 #define AM_SWP_X_TESTS(N, MN) \
1879 COMPARE(N(x0, x1, MemOperand(x2)), MN " x0, x1, [x2]"); \
1880 COMPARE(N(x3, x4, MemOperand(sp)), MN " x3, x4, [sp]");
1881 #define AM_SWP_W_TESTS(N, MN) \
1882 COMPARE(N(w0, w1, MemOperand(x2)), MN " w0, w1, [x2]"); \
1883 COMPARE(N(w3, w4, MemOperand(sp)), MN " w3, w4, [sp]");
1884
1885
1886 ATOMIC_MEMORY_DISASM_LOAD_X_MODES(AM_SWP_X_TESTS, swp, "swp")
1887 ATOMIC_MEMORY_DISASM_LOAD_W_MODES(AM_SWP_W_TESTS, swp, "swp")
1888
1889 #undef AM_LOAD_X_TESTS
1890 #undef AM_LOAD_W_TESTS
1891 #undef AM_STORE_X_TESTS
1892 #undef AM_STORE_W_TESTS
1893 #undef AM_SWP_X_TESTS
1894 #undef AM_SWP_W_TESTS
1895
1896 COMPARE(ldaprb(w0, MemOperand(x1)), "ldaprb w0, [x1]");
1897 COMPARE(ldaprb(w2, MemOperand(sp)), "ldaprb w2, [sp]");
1898 COMPARE(ldaprh(w3, MemOperand(x4)), "ldaprh w3, [x4]");
1899 COMPARE(ldaprh(w5, MemOperand(sp)), "ldaprh w5, [sp]");
1900 COMPARE(ldapr(w6, MemOperand(x7)), "ldapr w6, [x7]");
1901 COMPARE(ldapr(w8, MemOperand(sp)), "ldapr w8, [sp]");
1902 COMPARE(ldapr(x9, MemOperand(x10)), "ldapr x9, [x10]");
1903 COMPARE(ldapr(x11, MemOperand(sp)), "ldapr x11, [sp]");
1904
1905 CLEANUP();
1906 }
1907
TEST(load_store_rcpc_unscaled_offset)1908 TEST(load_store_rcpc_unscaled_offset) {
1909 SETUP();
1910
1911 COMPARE(ldapurb(w0, MemOperand(x1)), "ldapurb w0, [x1]");
1912 COMPARE(ldapurb(w2, MemOperand(x3, 13)), "ldapurb w2, [x3, #13]");
1913 COMPARE(ldapursb(w4, MemOperand(x5, 129)), "ldapursb w4, [x5, #129]");
1914 COMPARE(ldapursb(x6, MemOperand(sp, 64)), "ldapursb x6, [sp, #64]");
1915 COMPARE(ldapurh(w7, MemOperand(x8)), "ldapurh w7, [x8]");
1916 COMPARE(ldapurh(w9, MemOperand(x10, 13)), "ldapurh w9, [x10, #13]");
1917 COMPARE(ldapursh(w11, MemOperand(x12, 129)), "ldapursh w11, [x12, #129]");
1918 COMPARE(ldapursh(x13, MemOperand(sp, 64)), "ldapursh x13, [sp, #64]");
1919 COMPARE(ldapur(w14, MemOperand(x15)), "ldapur w14, [x15]");
1920 COMPARE(ldapur(w16, MemOperand(x17, 13)), "ldapur w16, [x17, #13]");
1921 COMPARE(ldapursw(x18, MemOperand(sp, 64)), "ldapursw x18, [sp, #64]");
1922 COMPARE(ldapur(x19, MemOperand(x20)), "ldapur x19, [x20]");
1923 COMPARE(ldapur(x21, MemOperand(sp, 64)), "ldapur x21, [sp, #64]");
1924
1925 COMPARE(stlurb(w22, MemOperand(x23)), "stlurb w22, [x23]");
1926 COMPARE(stlurb(w24, MemOperand(sp, 64)), "stlurb w24, [sp, #64]");
1927 COMPARE(stlurh(w25, MemOperand(x26)), "stlurh w25, [x26]");
1928 COMPARE(stlurh(w27, MemOperand(sp, 64)), "stlurh w27, [sp, #64]");
1929 COMPARE(stlur(w28, MemOperand(x29)), "stlur w28, [x29]");
1930 COMPARE(stlur(w0, MemOperand(sp, 64)), "stlur w0, [sp, #64]");
1931 COMPARE(stlur(x1, MemOperand(x2)), "stlur x1, [x2]");
1932 COMPARE(stlur(x3, MemOperand(sp, 64)), "stlur x3, [sp, #64]");
1933
1934
1935 COMPARE_MACRO(Ldaprb(w0, MemOperand(x1)), "ldaprb w0, [x1]");
1936 COMPARE_MACRO(Ldaprb(w2, MemOperand(x3, 13)), "ldapurb w2, [x3, #13]");
1937 COMPARE_MACRO(Ldaprh(w4, MemOperand(x5)), "ldaprh w4, [x5]");
1938 COMPARE_MACRO(Ldaprh(w6, MemOperand(x7, 13)), "ldapurh w6, [x7, #13]");
1939 COMPARE_MACRO(Ldapr(w8, MemOperand(x9)), "ldapr w8, [x9]");
1940 COMPARE_MACRO(Ldapr(w10, MemOperand(x11, 13)), "ldapur w10, [x11, #13]");
1941 COMPARE_MACRO(Ldapr(x12, MemOperand(x13)), "ldapr x12, [x13]");
1942 COMPARE_MACRO(Ldapr(x14, MemOperand(sp, 64)), "ldapur x14, [sp, #64]");
1943
1944 COMPARE_MACRO(Stlrb(w15, MemOperand(x16)), "stlrb w15, [x16]");
1945 COMPARE_MACRO(Stlrb(w17, MemOperand(sp, 64)), "stlurb w17, [sp, #64]");
1946 COMPARE_MACRO(Stlrh(w18, MemOperand(x19)), "stlrh w18, [x19]");
1947 COMPARE_MACRO(Stlrh(w20, MemOperand(sp, 64)), "stlurh w20, [sp, #64]");
1948 COMPARE_MACRO(Stlr(w21, MemOperand(x22)), "stlr w21, [x22]");
1949 COMPARE_MACRO(Stlr(w23, MemOperand(sp, 64)), "stlur w23, [sp, #64]");
1950 COMPARE_MACRO(Stlr(x24, MemOperand(x25)), "stlr x24, [x25]");
1951 COMPARE_MACRO(Stlr(x26, MemOperand(sp, 64)), "stlur x26, [sp, #64]");
1952
1953 CLEANUP();
1954 }
1955
1956
TEST(load_store_pair_nontemp)1957 TEST(load_store_pair_nontemp) {
1958 SETUP();
1959
1960 COMPARE(ldnp(w0, w1, MemOperand(x2)), "ldnp w0, w1, [x2]");
1961 COMPARE(stnp(w3, w4, MemOperand(x5, 252)), "stnp w3, w4, [x5, #252]");
1962 COMPARE(ldnp(w6, w7, MemOperand(x8, -256)), "ldnp w6, w7, [x8, #-256]");
1963 COMPARE(stnp(x9, x10, MemOperand(x11)), "stnp x9, x10, [x11]");
1964 COMPARE(ldnp(x12, x13, MemOperand(x14, 504)), "ldnp x12, x13, [x14, #504]");
1965 COMPARE(stnp(x15, x16, MemOperand(x17, -512)), "stnp x15, x16, [x17, #-512]");
1966 COMPARE(ldnp(s18, s19, MemOperand(x20)), "ldnp s18, s19, [x20]");
1967 COMPARE(stnp(s21, s22, MemOperand(x23, 252)), "stnp s21, s22, [x23, #252]");
1968 COMPARE(ldnp(s24, s25, MemOperand(x26, -256)), "ldnp s24, s25, [x26, #-256]");
1969 COMPARE(stnp(d27, d28, MemOperand(x29)), "stnp d27, d28, [x29]");
1970 COMPARE(ldnp(d30, d31, MemOperand(x0, 504)), "ldnp d30, d31, [x0, #504]");
1971 COMPARE(stnp(d1, d2, MemOperand(x3, -512)), "stnp d1, d2, [x3, #-512]");
1972 COMPARE(ldnp(q4, q5, MemOperand(x6)), "ldnp q4, q5, [x6]");
1973 COMPARE(stnp(q7, q8, MemOperand(x9, 1008)), "stnp q7, q8, [x9, #1008]");
1974 COMPARE(ldnp(q10, q11, MemOperand(x12, -1024)),
1975 "ldnp q10, q11, [x12, #-1024]");
1976
1977 CLEANUP();
1978 }
1979
1980
TEST(load_literal_macro)1981 TEST(load_literal_macro) {
1982 SETUP();
1983
1984 // In each case, the literal will be placed at PC+8:
1985 // ldr x10, pc+8 // Test instruction.
1986 // ldr xzr, pc+12 // Pool marker.
1987 // .word64 #0x1234567890abcdef // Test literal.
1988
1989 COMPARE_MACRO_PREFIX(Ldr(x10, 0x1234567890abcdef), "ldr x10, pc+8");
1990 COMPARE_MACRO_PREFIX(Ldr(w20, 0xfedcba09), "ldr w20, pc+8");
1991 COMPARE_MACRO_PREFIX(Ldr(d11, 1.234), "ldr d11, pc+8");
1992 COMPARE_MACRO_PREFIX(Ldr(s22, 2.5f), "ldr s22, pc+8");
1993 COMPARE_MACRO_PREFIX(Ldrsw(x21, 0x80000000), "ldrsw x21, pc+8");
1994
1995 CLEANUP();
1996 }
1997
1998
TEST(load_literal)1999 TEST(load_literal) {
2000 SETUP();
2001
2002 COMPARE_PREFIX(ldr(x20, INT64_C(0)), "ldr x20, pc+0");
2003 COMPARE_PREFIX(ldr(x20, 1), "ldr x20, pc+4");
2004 COMPARE_PREFIX(ldr(x20, -1), "ldr x20, pc-4");
2005 COMPARE_PREFIX(ldr(x20, 0x3ffff), "ldr x20, pc+1048572");
2006 COMPARE_PREFIX(ldr(x20, -0x40000), "ldr x20, pc-1048576");
2007 COMPARE_PREFIX(ldr(w21, INT64_C(0)), "ldr w21, pc+0");
2008 COMPARE_PREFIX(ldr(w21, 1), "ldr w21, pc+4");
2009 COMPARE_PREFIX(ldr(w21, -1), "ldr w21, pc-4");
2010 COMPARE_PREFIX(ldr(w21, 0x3ffff), "ldr w21, pc+1048572");
2011 COMPARE_PREFIX(ldr(w21, -0x40000), "ldr w21, pc-1048576");
2012 COMPARE_PREFIX(ldr(d22, INT64_C(0)), "ldr d22, pc+0");
2013 COMPARE_PREFIX(ldr(d22, 1), "ldr d22, pc+4");
2014 COMPARE_PREFIX(ldr(d22, -1), "ldr d22, pc-4");
2015 COMPARE_PREFIX(ldr(d22, 0x3ffff), "ldr d22, pc+1048572");
2016 COMPARE_PREFIX(ldr(d22, -0x40000), "ldr d22, pc-1048576");
2017 COMPARE_PREFIX(ldr(s23, INT64_C(0)), "ldr s23, pc+0");
2018 COMPARE_PREFIX(ldr(s23, 1), "ldr s23, pc+4");
2019 COMPARE_PREFIX(ldr(s23, -1), "ldr s23, pc-4");
2020 COMPARE_PREFIX(ldr(s23, 0x3ffff), "ldr s23, pc+1048572");
2021 COMPARE_PREFIX(ldr(s23, -0x40000), "ldr s23, pc-1048576");
2022 COMPARE_PREFIX(ldrsw(x24, INT64_C(0)), "ldrsw x24, pc+0");
2023 COMPARE_PREFIX(ldrsw(x24, 1), "ldrsw x24, pc+4");
2024 COMPARE_PREFIX(ldrsw(x24, -1), "ldrsw x24, pc-4");
2025 COMPARE_PREFIX(ldrsw(x24, 0x3ffff), "ldrsw x24, pc+1048572");
2026 COMPARE_PREFIX(ldrsw(x24, -0x40000), "ldrsw x24, pc-1048576");
2027
2028 CLEANUP();
2029 }
2030
2031
TEST(prfm_operations)2032 TEST(prfm_operations) {
2033 SETUP();
2034
2035 // Test every encodable prefetch operation.
2036 const char* expected[] = {"prfm pldl1keep, ", "prfm pldl1strm, ",
2037 "prfm pldl2keep, ", "prfm pldl2strm, ",
2038 "prfm pldl3keep, ", "prfm pldl3strm, ",
2039 "prfm #0b00110, ", "prfm #0b00111, ",
2040 "prfm plil1keep, ", "prfm plil1strm, ",
2041 "prfm plil2keep, ", "prfm plil2strm, ",
2042 "prfm plil3keep, ", "prfm plil3strm, ",
2043 "prfm #0b01110, ", "prfm #0b01111, ",
2044 "prfm pstl1keep, ", "prfm pstl1strm, ",
2045 "prfm pstl2keep, ", "prfm pstl2strm, ",
2046 "prfm pstl3keep, ", "prfm pstl3strm, ",
2047 "prfm #0b10110, ", "prfm #0b10111, "};
2048
2049 for (int op = 0; op < (1 << ImmPrefetchOperation_width); op++) {
2050 // Prefetch operations of the form 0b11xxx are allocated to another
2051 // instruction.
2052 if (op >= 0b11000) continue;
2053
2054 COMPARE_PREFIX(prfm(op, INT64_C(0)), expected[op]);
2055 COMPARE_PREFIX(prfm(op, MemOperand(x0, 0)), expected[op]);
2056 COMPARE_PREFIX(prfm(op, MemOperand(x0, x1)), expected[op]);
2057 }
2058
2059 CLEANUP();
2060 }
2061
2062
TEST(prfum_operations)2063 TEST(prfum_operations) {
2064 SETUP();
2065
2066 // Test every encodable prefetch operation.
2067 const char* expected[] = {
2068 "prfum pldl1keep, ", "prfum pldl1strm, ", "prfum pldl2keep, ",
2069 "prfum pldl2strm, ", "prfum pldl3keep, ", "prfum pldl3strm, ",
2070 "prfum #0b00110, ", "prfum #0b00111, ", "prfum plil1keep, ",
2071 "prfum plil1strm, ", "prfum plil2keep, ", "prfum plil2strm, ",
2072 "prfum plil3keep, ", "prfum plil3strm, ", "prfum #0b01110, ",
2073 "prfum #0b01111, ", "prfum pstl1keep, ", "prfum pstl1strm, ",
2074 "prfum pstl2keep, ", "prfum pstl2strm, ", "prfum pstl3keep, ",
2075 "prfum pstl3strm, ", "prfum #0b10110, ", "prfum #0b10111, ",
2076 "prfum #0b11000, ", "prfum #0b11001, ", "prfum #0b11010, ",
2077 "prfum #0b11011, ", "prfum #0b11100, ", "prfum #0b11101, ",
2078 "prfum #0b11110, ", "prfum #0b11111, ",
2079 };
2080 const int expected_count = sizeof(expected) / sizeof(expected[0]);
2081 VIXL_STATIC_ASSERT((1 << ImmPrefetchOperation_width) == expected_count);
2082
2083 for (int op = 0; op < (1 << ImmPrefetchOperation_width); op++) {
2084 COMPARE_PREFIX(prfum(op, MemOperand(x0, 0)), expected[op]);
2085 }
2086
2087 CLEANUP();
2088 }
2089
2090
TEST(prfm_offset)2091 TEST(prfm_offset) {
2092 SETUP();
2093
2094 COMPARE(prfm(PLDL1KEEP, MemOperand(x1)), "prfm pldl1keep, [x1]");
2095 COMPARE(prfm(PLDL1STRM, MemOperand(x3, 8)), "prfm pldl1strm, [x3, #8]");
2096 COMPARE(prfm(PLDL2KEEP, MemOperand(x5, 32760)),
2097 "prfm pldl2keep, [x5, #32760]");
2098
2099 COMPARE(prfm(PLDL2STRM, MemOperand(sp)), "prfm pldl2strm, [sp]");
2100 COMPARE(prfm(PLDL3KEEP, MemOperand(sp, 8)), "prfm pldl3keep, [sp, #8]");
2101 COMPARE(prfm(PLDL3STRM, MemOperand(sp, 32760)),
2102 "prfm pldl3strm, [sp, #32760]");
2103
2104 CLEANUP();
2105 }
2106
2107
TEST(prfm_regoffset)2108 TEST(prfm_regoffset) {
2109 SETUP();
2110
2111 COMPARE(prfm(PLIL1KEEP, MemOperand(x1, x2)), "prfm plil1keep, [x1, x2]");
2112 COMPARE(prfm(PLIL1STRM, MemOperand(x3, w4, SXTW)),
2113 "prfm plil1strm, [x3, w4, sxtw]");
2114 COMPARE(prfm(PLIL2KEEP, MemOperand(x5, x6, LSL, 3)),
2115 "prfm plil2keep, [x5, x6, lsl #3]");
2116
2117 COMPARE(prfm(PLIL2STRM, MemOperand(sp, xzr)), "prfm plil2strm, [sp, xzr]");
2118 COMPARE(prfm(PLIL3KEEP, MemOperand(sp, wzr, SXTW)),
2119 "prfm plil3keep, [sp, wzr, sxtw]");
2120 COMPARE(prfm(PLIL3STRM, MemOperand(sp, xzr, LSL, 3)),
2121 "prfm plil3strm, [sp, xzr, lsl #3]");
2122
2123 CLEANUP();
2124 }
2125
2126
TEST(prfm_literal)2127 TEST(prfm_literal) {
2128 SETUP();
2129
2130 COMPARE_PREFIX(prfm(PSTL1KEEP, INT64_C(0)), "prfm pstl1keep, pc+0");
2131 COMPARE_PREFIX(prfm(PSTL1STRM, 1), "prfm pstl1strm, pc+4");
2132 COMPARE_PREFIX(prfm(PSTL2KEEP, -1), "prfm pstl2keep, pc-4");
2133 COMPARE_PREFIX(prfm(PSTL2STRM, 0x3ffff), "prfm pstl2strm, pc+1048572");
2134 COMPARE_PREFIX(prfm(PSTL3KEEP, -0x3ffff), "prfm pstl3keep, pc-1048572");
2135 COMPARE_PREFIX(prfm(PSTL3STRM, -0x40000), "prfm pstl3strm, pc-1048576");
2136
2137 CLEANUP();
2138 }
2139
2140
TEST(prfm_unscaled)2141 TEST(prfm_unscaled) {
2142 SETUP();
2143
2144 // If an unscaled-offset instruction is requested, it is used, even if the
2145 // offset could be encoded in a scaled-offset instruction.
2146 COMPARE(prfum(PLDL1KEEP, MemOperand(x1)), "prfum pldl1keep, [x1]");
2147 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8)), "prfum pldl1strm, [x1, #8]");
2148 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248)), "prfum pldl2keep, [x1, #248]");
2149
2150 // Normal offsets are converted to unscaled offsets if necssary.
2151 COMPARE(prfm(PLDL2STRM, MemOperand(x1, 1)), "prfum pldl2strm, [x1, #1]");
2152 COMPARE(prfm(PLDL3KEEP, MemOperand(x1, -1)), "prfum pldl3keep, [x1, #-1]");
2153 COMPARE(prfm(PLDL3STRM, MemOperand(x1, 255)), "prfum pldl3strm, [x1, #255]");
2154 COMPARE(prfm(PLDL3STRM, MemOperand(x1, -256)),
2155 "prfum pldl3strm, [x1, #-256]");
2156
2157 CLEANUP();
2158 }
2159
2160
TEST(prfm_unscaled_option)2161 TEST(prfm_unscaled_option) {
2162 SETUP();
2163
2164 // Just like prfm_unscaled, but specify the scaling option explicitly.
2165
2166 // Require unscaled-offset forms.
2167 LoadStoreScalingOption option = RequireUnscaledOffset;
2168
2169 COMPARE(prfum(PLDL1KEEP, MemOperand(x1), option), "prfum pldl1keep, [x1]");
2170 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8), option),
2171 "prfum pldl1strm, [x1, #8]");
2172 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248), option),
2173 "prfum pldl2keep, [x1, #248]");
2174 COMPARE(prfum(PLDL2STRM, MemOperand(x1, 1), option),
2175 "prfum pldl2strm, [x1, #1]");
2176 COMPARE(prfum(PLDL3KEEP, MemOperand(x1, -1), option),
2177 "prfum pldl3keep, [x1, #-1]");
2178 COMPARE(prfum(PLDL3STRM, MemOperand(x1, 255), option),
2179 "prfum pldl3strm, [x1, #255]");
2180 COMPARE(prfum(PLIL1KEEP, MemOperand(x1, -256), option),
2181 "prfum plil1keep, [x1, #-256]");
2182
2183 // Require scaled-offset forms..
2184 option = RequireScaledOffset;
2185
2186 COMPARE(prfm(PLDL1KEEP, MemOperand(x1), option), "prfm pldl1keep, [x1]");
2187 COMPARE(prfm(PLDL1STRM, MemOperand(x1, 8), option),
2188 "prfm pldl1strm, [x1, #8]");
2189 COMPARE(prfm(PLDL2KEEP, MemOperand(x1, 248), option),
2190 "prfm pldl2keep, [x1, #248]");
2191 COMPARE(prfm(PLIL2STRM, MemOperand(x1, 256), option),
2192 "prfm plil2strm, [x1, #256]");
2193 COMPARE(prfm(PLIL3KEEP, MemOperand(x1, 32760), option),
2194 "prfm plil3keep, [x1, #32760]");
2195
2196 // Prefer unscaled-offset forms, but allow scaled-offset forms if necessary.
2197 option = PreferUnscaledOffset;
2198
2199 COMPARE(prfum(PLDL1KEEP, MemOperand(x1), option), "prfum pldl1keep, [x1]");
2200 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8), option),
2201 "prfum pldl1strm, [x1, #8]");
2202 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248), option),
2203 "prfum pldl2keep, [x1, #248]");
2204 COMPARE(prfum(PLDL2STRM, MemOperand(x1, 1), option),
2205 "prfum pldl2strm, [x1, #1]");
2206 COMPARE(prfum(PLDL3KEEP, MemOperand(x1, -1), option),
2207 "prfum pldl3keep, [x1, #-1]");
2208 COMPARE(prfum(PLDL3STRM, MemOperand(x1, 255), option),
2209 "prfum pldl3strm, [x1, #255]");
2210 COMPARE(prfum(PLIL1KEEP, MemOperand(x1, -256), option),
2211 "prfum plil1keep, [x1, #-256]");
2212 COMPARE(prfum(PLIL1STRM, MemOperand(x1, 256), option),
2213 "prfm plil1strm, [x1, #256]");
2214 COMPARE(prfum(PLIL2KEEP, MemOperand(x1, 32760), option),
2215 "prfm plil2keep, [x1, #32760]");
2216
2217 // Prefer scaled-offset forms, but allow unscaled-offset forms if necessary.
2218 option = PreferScaledOffset;
2219
2220 COMPARE(prfm(PLDL1KEEP, MemOperand(x1), option), "prfm pldl1keep, [x1]");
2221 COMPARE(prfm(PLDL1STRM, MemOperand(x1, 8), option),
2222 "prfm pldl1strm, [x1, #8]");
2223 COMPARE(prfm(PLDL2KEEP, MemOperand(x1, 248), option),
2224 "prfm pldl2keep, [x1, #248]");
2225 COMPARE(prfm(PLDL2STRM, MemOperand(x1, 1), option),
2226 "prfum pldl2strm, [x1, #1]");
2227 COMPARE(prfm(PLDL3KEEP, MemOperand(x1, -1), option),
2228 "prfum pldl3keep, [x1, #-1]");
2229 COMPARE(prfm(PLDL3STRM, MemOperand(x1, 255), option),
2230 "prfum pldl3strm, [x1, #255]");
2231 COMPARE(prfm(PLIL1KEEP, MemOperand(x1, -256), option),
2232 "prfum plil1keep, [x1, #-256]");
2233 COMPARE(prfm(PLIL1STRM, MemOperand(x1, 256), option),
2234 "prfm plil1strm, [x1, #256]");
2235 COMPARE(prfm(PLIL2KEEP, MemOperand(x1, 32760), option),
2236 "prfm plil2keep, [x1, #32760]");
2237
2238 CLEANUP();
2239 }
2240
2241
TEST(cond_select)2242 TEST(cond_select) {
2243 SETUP();
2244
2245 COMPARE(csel(w0, w1, w2, eq), "csel w0, w1, w2, eq");
2246 COMPARE(csel(x3, x4, x5, ne), "csel x3, x4, x5, ne");
2247 COMPARE(csinc(w6, w7, w8, hs), "csinc w6, w7, w8, hs");
2248 COMPARE(csinc(x9, x10, x11, lo), "csinc x9, x10, x11, lo");
2249 COMPARE(csinv(w12, w13, w14, mi), "csinv w12, w13, w14, mi");
2250 COMPARE(csinv(x15, x16, x17, pl), "csinv x15, x16, x17, pl");
2251 COMPARE(csneg(w18, w19, w20, vs), "csneg w18, w19, w20, vs");
2252 COMPARE(csneg(x21, x22, x23, vc), "csneg x21, x22, x23, vc");
2253 COMPARE(cset(w24, hi), "cset w24, hi");
2254 COMPARE(cset(x25, ls), "cset x25, ls");
2255 COMPARE(csetm(w26, ge), "csetm w26, ge");
2256 COMPARE(csetm(x27, lt), "csetm x27, lt");
2257 COMPARE(cinc(w28, w29, gt), "cinc w28, w29, gt");
2258 COMPARE(cinc(x30, x0, le), "cinc x30, x0, le");
2259 COMPARE(cinv(w1, w2, eq), "cinv w1, w2, eq");
2260 COMPARE(cinv(x3, x4, ne), "cinv x3, x4, ne");
2261 COMPARE(cneg(w5, w6, hs), "cneg w5, w6, hs");
2262 COMPARE(cneg(x7, x8, lo), "cneg x7, x8, lo");
2263
2264 COMPARE(csel(x0, x1, x2, al), "csel x0, x1, x2, al");
2265 COMPARE(csel(x1, x2, x3, nv), "csel x1, x2, x3, nv");
2266 COMPARE(csinc(x2, x3, x4, al), "csinc x2, x3, x4, al");
2267 COMPARE(csinc(x3, x4, x5, nv), "csinc x3, x4, x5, nv");
2268 COMPARE(csinv(x4, x5, x6, al), "csinv x4, x5, x6, al");
2269 COMPARE(csinv(x5, x6, x7, nv), "csinv x5, x6, x7, nv");
2270 COMPARE(csneg(x6, x7, x8, al), "csneg x6, x7, x8, al");
2271 COMPARE(csneg(x7, x8, x9, nv), "csneg x7, x8, x9, nv");
2272
2273 CLEANUP();
2274 }
2275
2276
TEST(cond_select_macro)2277 TEST(cond_select_macro) {
2278 SETUP();
2279
2280 // In the tests below we also test the `GetCselSynthesisInformation()` helper.
2281 // These tests are here (rather than in test-assembler-aarch64.cc) because the
2282 // disassembly makes it easy to see whether or not the inputs are synthesised.
2283 bool synthesises_left = false;
2284 bool synthesises_right = false;
2285
2286 COMPARE_MACRO(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq");
2287 MacroAssembler::GetCselSynthesisInformation(w0,
2288 w1,
2289 -1,
2290 &synthesises_left,
2291 &synthesises_right);
2292 VIXL_CHECK(!synthesises_left && !synthesises_right);
2293
2294 COMPARE_MACRO(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne");
2295 MacroAssembler::GetCselSynthesisInformation(w2,
2296 w3,
2297 wzr,
2298 &synthesises_left,
2299 &synthesises_right);
2300 VIXL_CHECK(!synthesises_left && !synthesises_right);
2301
2302 COMPARE_MACRO(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs");
2303 MacroAssembler::GetCselSynthesisInformation(w4,
2304 w5,
2305 1,
2306 &synthesises_left,
2307 &synthesises_right);
2308 VIXL_CHECK(!synthesises_left && !synthesises_right);
2309
2310 COMPARE_MACRO(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo");
2311 MacroAssembler::GetCselSynthesisInformation(x6,
2312 x7,
2313 xzr,
2314 &synthesises_left,
2315 &synthesises_right);
2316 VIXL_CHECK(!synthesises_left && !synthesises_right);
2317
2318 COMPARE_MACRO(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi");
2319 MacroAssembler::GetCselSynthesisInformation(x8,
2320 x9,
2321 xzr,
2322 &synthesises_left,
2323 &synthesises_right);
2324 VIXL_CHECK(!synthesises_left && !synthesises_right);
2325
2326 COMPARE_MACRO(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl");
2327 MacroAssembler::GetCselSynthesisInformation(x10,
2328 x11,
2329 xzr,
2330 &synthesises_left,
2331 &synthesises_right);
2332 VIXL_CHECK(!synthesises_left && !synthesises_right);
2333
2334 COMPARE_MACRO(Csel(x12, 0, 0, eq), "mov x12, #0x0");
2335 MacroAssembler::GetCselSynthesisInformation(x12,
2336 0,
2337 0,
2338 &synthesises_left,
2339 &synthesises_right);
2340 VIXL_CHECK(!synthesises_left && !synthesises_right);
2341
2342 COMPARE_MACRO(Csel(w13, 0, 1, eq), "cset w13, ne");
2343 MacroAssembler::GetCselSynthesisInformation(w13,
2344 0,
2345 1,
2346 &synthesises_left,
2347 &synthesises_right);
2348 VIXL_CHECK(!synthesises_left && !synthesises_right);
2349
2350 COMPARE_MACRO(Csel(x14, 1, 0, eq), "cset x14, eq");
2351 MacroAssembler::GetCselSynthesisInformation(x14,
2352 1,
2353 0,
2354 &synthesises_left,
2355 &synthesises_right);
2356 VIXL_CHECK(!synthesises_left && !synthesises_right);
2357
2358 COMPARE_MACRO(Csel(w15, 0, -1, eq), "csetm w15, ne");
2359 MacroAssembler::GetCselSynthesisInformation(w15,
2360 0,
2361 -1,
2362 &synthesises_left,
2363 &synthesises_right);
2364 VIXL_CHECK(!synthesises_left && !synthesises_right);
2365
2366 COMPARE_MACRO(Csel(x18, -1, 0, eq), "csetm x18, eq");
2367 MacroAssembler::GetCselSynthesisInformation(x18,
2368 -1,
2369 0,
2370 &synthesises_left,
2371 &synthesises_right);
2372 VIXL_CHECK(!synthesises_left && !synthesises_right);
2373
2374 COMPARE_MACRO(Csel(w19, -1, 1, eq),
2375 "mov w19, #0x1\n"
2376 "cneg w19, w19, eq");
2377 MacroAssembler::GetCselSynthesisInformation(w19,
2378 -1,
2379 1,
2380 &synthesises_left,
2381 &synthesises_right);
2382 VIXL_CHECK(!synthesises_left && synthesises_right);
2383
2384 COMPARE_MACRO(Csel(x20, 1, -1, eq),
2385 "mov x20, #0xffffffffffffffff\n"
2386 "cneg x20, x20, eq");
2387 MacroAssembler::GetCselSynthesisInformation(x20,
2388 1,
2389 -1,
2390 &synthesises_left,
2391 &synthesises_right);
2392 VIXL_CHECK(!synthesises_left && synthesises_right);
2393
2394 COMPARE_MACRO(Csel(w21, 0xaa, 0xbb, eq),
2395 "mov w16, #0xaa\n"
2396 "mov w17, #0xbb\n"
2397 "csel w21, w16, w17, eq");
2398 MacroAssembler::GetCselSynthesisInformation(w21,
2399 0xaa,
2400 0xbb,
2401 &synthesises_left,
2402 &synthesises_right);
2403 VIXL_CHECK(synthesises_left && synthesises_right);
2404
2405 COMPARE_MACRO(Csel(x22, 0xaa, -0xbb, eq),
2406 "mov x16, #0xaa\n"
2407 "mov x17, #0xffffffffffffff45\n"
2408 "csel x22, x16, x17, eq");
2409 MacroAssembler::GetCselSynthesisInformation(x22,
2410 0xaa,
2411 -0xbb,
2412 &synthesises_left,
2413 &synthesises_right);
2414 VIXL_CHECK(synthesises_left && synthesises_right);
2415
2416 COMPARE_MACRO(Csel(w23, 0, 0xaa, eq),
2417 "mov w16, #0xaa\n"
2418 "csel w23, w16, wzr, ne");
2419 MacroAssembler::GetCselSynthesisInformation(w23,
2420 0,
2421 0xaa,
2422 &synthesises_left,
2423 &synthesises_right);
2424 VIXL_CHECK(!synthesises_left && synthesises_right);
2425
2426 COMPARE_MACRO(Csel(x24, -0xaa, 0, eq),
2427 "mov x16, #0xffffffffffffff56\n"
2428 "csel x24, x16, xzr, eq");
2429 MacroAssembler::GetCselSynthesisInformation(x24,
2430 -0xaa,
2431 0,
2432 &synthesises_left,
2433 &synthesises_right);
2434 VIXL_CHECK(synthesises_left && !synthesises_right);
2435
2436 COMPARE_MACRO(Csel(w25, 0xcc, -0xcc, eq),
2437 "mov w25, #0xffffff34\n"
2438 "cneg w25, w25, eq");
2439 MacroAssembler::GetCselSynthesisInformation(w25,
2440 0xcc,
2441 -0xcc,
2442 &synthesises_left,
2443 &synthesises_right);
2444 VIXL_CHECK(!synthesises_left && synthesises_right);
2445
2446 COMPARE_MACRO(Csel(x26, -0xcc, 0xcc, eq),
2447 "mov x26, #0xcc\n"
2448 "cneg x26, x26, eq");
2449 MacroAssembler::GetCselSynthesisInformation(w25,
2450 -0xcc,
2451 0xcc,
2452 &synthesises_left,
2453 &synthesises_right);
2454 VIXL_CHECK(!synthesises_left && synthesises_right);
2455
2456 // Test with `Operand` inputs.
2457 COMPARE_MACRO(Csel(x0, x1, Operand(x2, LSL, 3), eq),
2458 "lsl x16, x2, #3\n"
2459 "csel x0, x1, x16, eq");
2460 MacroAssembler::GetCselSynthesisInformation(x0,
2461 x1,
2462 Operand(x2, LSL, 3),
2463 &synthesises_left,
2464 &synthesises_right);
2465 VIXL_CHECK(!synthesises_left && synthesises_right);
2466
2467 COMPARE_MACRO(Csel(x3, x4, Operand(x5, SXTH), eq),
2468 "sxth x16, w5\n"
2469 "csel x3, x4, x16, eq");
2470 MacroAssembler::GetCselSynthesisInformation(x3,
2471 x4,
2472 Operand(x5, SXTH),
2473 &synthesises_left,
2474 &synthesises_right);
2475 VIXL_CHECK(!synthesises_left && synthesises_right);
2476
2477 COMPARE_MACRO(Csel(x6, Operand(x7, LSL, 7), x8, eq),
2478 "lsl x16, x7, #7\n"
2479 "csel x6, x16, x8, eq");
2480 MacroAssembler::GetCselSynthesisInformation(x6,
2481 Operand(x7, LSL, 7),
2482 x8,
2483 &synthesises_left,
2484 &synthesises_right);
2485 VIXL_CHECK(synthesises_left && !synthesises_right);
2486
2487 COMPARE_MACRO(Csel(x9, Operand(x10, SXTH), x11, eq),
2488 "sxth x16, w10\n"
2489 "csel x9, x16, x11, eq");
2490 MacroAssembler::GetCselSynthesisInformation(x9,
2491 Operand(x10, SXTH),
2492 x11,
2493 &synthesises_left,
2494 &synthesises_right);
2495 VIXL_CHECK(synthesises_left && !synthesises_right);
2496
2497 COMPARE_MACRO(Csel(x12, Operand(x13, LSL, 13), Operand(x14, SXTB), eq),
2498 "lsl x16, x13, #13\n"
2499 "sxtb x17, w14\n"
2500 "csel x12, x16, x17, eq");
2501 MacroAssembler::GetCselSynthesisInformation(x12,
2502 Operand(x13, LSL, 13),
2503 Operand(x14, SXTB),
2504 &synthesises_left,
2505 &synthesises_right);
2506 VIXL_CHECK(synthesises_left && synthesises_right);
2507
2508 COMPARE_MACRO(Csel(x15, 0, Operand(x18, LSR, 18), eq),
2509 "lsr x16, x18, #18\n"
2510 "csel x15, x16, xzr, ne");
2511 MacroAssembler::GetCselSynthesisInformation(x15,
2512 0,
2513 Operand(x18, LSR, 18),
2514 &synthesises_left,
2515 &synthesises_right);
2516 VIXL_CHECK(!synthesises_left && synthesises_right);
2517
2518 // Test with the zero register.
2519 COMPARE_MACRO(Csel(w19, wzr, wzr, eq), "mov w19, #0x0");
2520 MacroAssembler::GetCselSynthesisInformation(w19,
2521 wzr,
2522 wzr,
2523 &synthesises_left,
2524 &synthesises_right);
2525 VIXL_CHECK(!synthesises_left && !synthesises_right);
2526
2527 COMPARE_MACRO(Csel(x20, x21, xzr, eq), "csel x20, x21, xzr, eq");
2528 MacroAssembler::GetCselSynthesisInformation(x20,
2529 x21,
2530 xzr,
2531 &synthesises_left,
2532 &synthesises_right);
2533 VIXL_CHECK(!synthesises_left && !synthesises_right);
2534
2535 COMPARE_MACRO(Csel(w22, wzr, w23, eq), "csel w22, w23, wzr, ne");
2536 MacroAssembler::GetCselSynthesisInformation(w22,
2537 wzr,
2538 w23,
2539 &synthesises_left,
2540 &synthesises_right);
2541 VIXL_CHECK(!synthesises_left && !synthesises_right);
2542
2543 COMPARE_MACRO(Csel(x24, xzr, 0, eq), "mov x24, #0x0");
2544 MacroAssembler::GetCselSynthesisInformation(x24,
2545 xzr,
2546 0,
2547 &synthesises_left,
2548 &synthesises_right);
2549 VIXL_CHECK(!synthesises_left && !synthesises_right);
2550
2551 COMPARE_MACRO(Csel(w25, wzr, 1, eq), "cset w25, ne");
2552 MacroAssembler::GetCselSynthesisInformation(w25,
2553 wzr,
2554 1,
2555 &synthesises_left,
2556 &synthesises_right);
2557 VIXL_CHECK(!synthesises_left && !synthesises_right);
2558
2559
2560 CLEANUP();
2561 }
2562
2563
TEST(cond_cmp)2564 TEST(cond_cmp) {
2565 SETUP();
2566
2567 COMPARE(ccmn(w0, w1, NZCVFlag, eq), "ccmn w0, w1, #NZCV, eq");
2568 COMPARE(ccmn(x2, x3, NZCFlag, ne), "ccmn x2, x3, #NZCv, ne");
2569 COMPARE(ccmp(w4, w5, NZVFlag, hs), "ccmp w4, w5, #NZcV, hs");
2570 COMPARE(ccmp(x6, x7, NZFlag, lo), "ccmp x6, x7, #NZcv, lo");
2571 COMPARE(ccmn(w8, 31, NFlag, mi), "ccmn w8, #31, #Nzcv, mi");
2572 COMPARE(ccmn(x9, 30, NCFlag, pl), "ccmn x9, #30, #NzCv, pl");
2573 COMPARE(ccmp(w10, 29, NVFlag, vs), "ccmp w10, #29, #NzcV, vs");
2574 COMPARE(ccmp(x11, 28, NFlag, vc), "ccmp x11, #28, #Nzcv, vc");
2575 COMPARE(ccmn(w12, w13, NoFlag, al), "ccmn w12, w13, #nzcv, al");
2576 COMPARE(ccmp(x14, 27, ZVFlag, nv), "ccmp x14, #27, #nZcV, nv");
2577
2578 CLEANUP();
2579 }
2580
2581
TEST(cond_cmp_macro)2582 TEST(cond_cmp_macro) {
2583 SETUP();
2584
2585 COMPARE_MACRO(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi");
2586 COMPARE_MACRO(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge");
2587 COMPARE_MACRO(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt");
2588 COMPARE_MACRO(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls");
2589
2590 CLEANUP();
2591 }
2592
2593
TEST(system_clrex)2594 TEST(system_clrex) {
2595 SETUP();
2596
2597 COMPARE(clrex(0), "clrex #0x0");
2598 COMPARE(clrex(14), "clrex #0xe");
2599 COMPARE(clrex(15), "clrex");
2600 COMPARE(clrex(), "clrex");
2601
2602 CLEANUP();
2603 }
2604
2605
TEST(system_mrs)2606 TEST(system_mrs) {
2607 SETUP();
2608
2609 COMPARE(mrs(x0, NZCV), "mrs x0, nzcv");
2610 COMPARE(mrs(x30, NZCV), "mrs x30, nzcv");
2611 COMPARE(mrs(x15, FPCR), "mrs x15, fpcr");
2612 COMPARE(mrs(x20, RNDR), "mrs x20, rndr");
2613 COMPARE(mrs(x5, RNDRRS), "mrs x5, rndrrs");
2614
2615 // Test mrs that use system registers we haven't named.
2616 COMPARE(dci(MRS | (0x5555 << 5)), "mrs x0, S3_2_c10_c10_5");
2617 COMPARE(dci(0xd53e1000), "mrs x0, S3_6_c1_c0_0");
2618
2619 CLEANUP();
2620 }
2621
2622
TEST(system_msr)2623 TEST(system_msr) {
2624 SETUP();
2625
2626 COMPARE(msr(NZCV, x0), "msr nzcv, x0");
2627 COMPARE(msr(NZCV, x30), "msr nzcv, x30");
2628 COMPARE(msr(FPCR, x15), "msr fpcr, x15");
2629
2630 // Test msr that use system registers we haven't named.
2631 COMPARE(dci(MSR | (0x1234 << 5)), "msr S2_2_c4_c6_4, x0");
2632 COMPARE(dci(0xd51e1000), "msr S3_6_c1_c0_0, x0");
2633
2634 CLEANUP();
2635 }
2636
2637
TEST(system_pstate)2638 TEST(system_pstate) {
2639 SETUP();
2640
2641 COMPARE(cfinv(), "cfinv");
2642 COMPARE(axflag(), "axflag");
2643 COMPARE(xaflag(), "xaflag");
2644
2645 CLEANUP();
2646 }
2647
2648
TEST(system_sys)2649 TEST(system_sys) {
2650 SETUP();
2651
2652 COMPARE(sys(0x3, 0x7, 0x5, 0x1, x1), "ic ivau, x1");
2653 COMPARE(sys(0x3, 0x7, 0xa, 0x1, x2), "dc cvac, x2");
2654 COMPARE(sys(0x3, 0x7, 0xb, 0x1, x3), "dc cvau, x3");
2655 COMPARE(sys(0x3, 0x7, 0xe, 0x1, x4), "dc civac, x4");
2656 COMPARE(sys(0x3, 0x7, 0xc, 0x1, x5), "dc cvap, x5");
2657 COMPARE(sys(0x3, 0x7, 0xd, 0x1, x6), "dc cvadp, x6");
2658 COMPARE(sys(0x3, 0x7, 0x4, 0x1, x0), "dc zva, x0");
2659 COMPARE(sys(0x0, 0x0, 0x0, 0x0, x0), "sys #0, C0, C0, #0, x0");
2660 COMPARE(sys(0x1, 0x2, 0x5, 0x2, x5), "sys #1, C2, C5, #2, x5");
2661 COMPARE(sys(0x2, 0x8, 0xa, 0x3, x6), "sys #2, C8, C10, #3, x6");
2662 COMPARE(sys(0x2, 0xf, 0xf, 0x1, xzr), "sys #2, C15, C15, #1");
2663 COMPARE(sys(0x2, 0xf, 0xf, 0x1), "sys #2, C15, C15, #1");
2664
2665 CLEANUP();
2666 }
2667
2668
TEST(system_ic)2669 TEST(system_ic) {
2670 SETUP();
2671
2672 COMPARE(ic(IVAU, x0), "ic ivau, x0");
2673 COMPARE(ic(IVAU, x1), "ic ivau, x1");
2674 COMPARE(ic(IVAU, xzr), "ic ivau, xzr");
2675
2676 CLEANUP();
2677 }
2678
2679
TEST(system_dc)2680 TEST(system_dc) {
2681 SETUP();
2682
2683 COMPARE(dc(CVAC, x2), "dc cvac, x2");
2684 COMPARE(dc(CVAU, x3), "dc cvau, x3");
2685 COMPARE(dc(CVAP, x4), "dc cvap, x4");
2686 COMPARE(dc(CIVAC, x5), "dc civac, x5");
2687 COMPARE(dc(CVADP, x6), "dc cvadp, x6");
2688 COMPARE(dc(ZVA, x0), "dc zva, x0");
2689 COMPARE(dc(ZVA, xzr), "dc zva, xzr");
2690
2691 CLEANUP();
2692 }
2693
TEST(system_dc_mte)2694 TEST(system_dc_mte) {
2695 SETUP();
2696
2697 COMPARE(dc(GVA, x0), "dc gva, x0");
2698 COMPARE(dc(GZVA, x1), "dc gzva, x1");
2699 COMPARE(dc(CGVAC, x2), "dc cgvac, x2");
2700 COMPARE(dc(CGDVAC, x3), "dc cgdvac, x3");
2701 COMPARE(dc(CGVAP, x3), "dc cgvap, x3");
2702 COMPARE(dc(CGDVAP, x3), "dc cgdvap, x3");
2703 COMPARE(dc(CIGVAC, x4), "dc cigvac, x4");
2704 COMPARE(dc(CIGDVAC, x4), "dc cigdvac, x4");
2705
2706 CLEANUP();
2707 }
2708
TEST(system_nop)2709 TEST(system_nop) {
2710 SETUP();
2711
2712 COMPARE(nop(), "nop");
2713 COMPARE_MACRO(Nop(), "nop");
2714
2715 CLEANUP();
2716 }
2717
2718
TEST(system_pauth)2719 TEST(system_pauth) {
2720 SETUP();
2721
2722 COMPARE(pacia1716(), "pacia1716");
2723 COMPARE(pacib1716(), "pacib1716");
2724 COMPARE(paciaz(), "paciaz");
2725 COMPARE(pacibz(), "pacibz");
2726 COMPARE(paciasp(), "paciasp");
2727 COMPARE(pacibsp(), "pacibsp");
2728 COMPARE(autia1716(), "autia1716");
2729 COMPARE(autib1716(), "autib1716");
2730 COMPARE(autiaz(), "autiaz");
2731 COMPARE(autibz(), "autibz");
2732 COMPARE(autiasp(), "autiasp");
2733 COMPARE(autibsp(), "autibsp");
2734 COMPARE(xpaclri(), "xpaclri");
2735
2736 CLEANUP();
2737 }
2738
2739
TEST(unreachable)2740 TEST(unreachable) {
2741 SETUP();
2742
2743 VIXL_ASSERT(kUnreachableOpcode == 0xdeb0);
2744 #ifdef VIXL_INCLUDE_SIMULATOR_AARCH64
2745 COMPARE_MACRO(Unreachable(), "hlt #0xdeb0");
2746 #else
2747 COMPARE_MACRO(Unreachable(), "udf #0xdeb0");
2748 #endif
2749
2750 CLEANUP();
2751 }
2752
2753
2754 #ifdef VIXL_INCLUDE_SIMULATOR_AARCH64
TEST(trace)2755 TEST(trace) {
2756 SETUP();
2757
2758 VIXL_ASSERT(kTraceOpcode == 0xdeb2);
2759
2760 // All Trace calls should produce the same instruction.
2761 COMPARE_MACRO_PREFIX(Trace(LOG_ALL, TRACE_ENABLE), "hlt #0xdeb2");
2762 COMPARE_MACRO_PREFIX(Trace(LOG_REGS, TRACE_DISABLE), "hlt #0xdeb2");
2763
2764 CLEANUP();
2765 }
2766 #endif
2767
2768
2769 #ifdef VIXL_INCLUDE_SIMULATOR_AARCH64
TEST(log)2770 TEST(log) {
2771 SETUP();
2772
2773 VIXL_ASSERT(kLogOpcode == 0xdeb3);
2774
2775 // All Log calls should produce the same instruction.
2776 COMPARE_MACRO_PREFIX(Log(LOG_ALL), "hlt #0xdeb3");
2777 COMPARE_MACRO_PREFIX(Log(LOG_SYSREGS), "hlt #0xdeb3");
2778
2779 CLEANUP();
2780 }
2781 #endif
2782
2783
TEST(hlt)2784 TEST(hlt) {
2785 SETUP();
2786
2787 COMPARE(hlt(0), "hlt #0x0");
2788 COMPARE(hlt(1), "hlt #0x1");
2789 COMPARE(hlt(65535), "hlt #0xffff");
2790
2791 CLEANUP();
2792 }
2793
2794
TEST(brk)2795 TEST(brk) {
2796 SETUP();
2797
2798 COMPARE(brk(0), "brk #0x0");
2799 COMPARE(brk(1), "brk #0x1");
2800 COMPARE(brk(65535), "brk #0xffff");
2801
2802 CLEANUP();
2803 }
2804
2805
TEST(svc)2806 TEST(svc) {
2807 SETUP();
2808
2809 COMPARE(svc(0), "svc #0x0");
2810 COMPARE(svc(1), "svc #0x1");
2811 COMPARE(svc(65535), "svc #0xffff");
2812
2813 CLEANUP();
2814 }
2815
2816
TEST(add_sub_negative)2817 TEST(add_sub_negative) {
2818 SETUP();
2819
2820 COMPARE_MACRO(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)");
2821 COMPARE_MACRO(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)");
2822 COMPARE_MACRO(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)");
2823
2824 COMPARE_MACRO(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)");
2825 COMPARE_MACRO(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)");
2826 COMPARE_MACRO(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)");
2827
2828 COMPARE_MACRO(Add(w19, w3, -0x344), "sub w19, w3, #0x344 (836)");
2829 COMPARE_MACRO(Add(w20, w4, -2000), "sub w20, w4, #0x7d0 (2000)");
2830
2831 COMPARE_MACRO(Add(w0, w1, 5, LeaveFlags), "add w0, w1, #0x5 (5)");
2832 COMPARE_MACRO(Add(w1, w2, 15, SetFlags), "adds w1, w2, #0xf (15)");
2833
2834 COMPARE_MACRO(Sub(w0, w1, 5, LeaveFlags), "sub w0, w1, #0x5 (5)");
2835 COMPARE_MACRO(Sub(w1, w2, 15, SetFlags), "subs w1, w2, #0xf (15)");
2836
2837 COMPARE_MACRO(Sub(w21, w3, -0xbc), "add w21, w3, #0xbc (188)");
2838 COMPARE_MACRO(Sub(w22, w4, -2000), "add w22, w4, #0x7d0 (2000)");
2839
2840 COMPARE_MACRO(Cmp(w0, -1), "cmn w0, #0x1 (1)");
2841 COMPARE_MACRO(Cmp(x1, -1), "cmn x1, #0x1 (1)");
2842 COMPARE_MACRO(Cmp(w2, -4095), "cmn w2, #0xfff (4095)");
2843 COMPARE_MACRO(Cmp(x3, -4095), "cmn x3, #0xfff (4095)");
2844
2845 COMPARE_MACRO(Cmn(w0, -1), "cmp w0, #0x1 (1)");
2846 COMPARE_MACRO(Cmn(x1, -1), "cmp x1, #0x1 (1)");
2847 COMPARE_MACRO(Cmn(w2, -4095), "cmp w2, #0xfff (4095)");
2848 COMPARE_MACRO(Cmn(x3, -4095), "cmp x3, #0xfff (4095)");
2849
2850 CLEANUP();
2851 }
2852
TEST(add_sub_macro)2853 TEST(add_sub_macro) {
2854 SETUP();
2855
2856 // Add and Sub use their destination register as a scratch if they can.
2857 COMPARE_MACRO(Add(x0, x1, 0x4242),
2858 "mov x0, #0x4242\n"
2859 "add x0, x1, x0");
2860 COMPARE_MACRO(Add(x0, x0, 0x4242),
2861 "mov x16, #0x4242\n"
2862 "add x0, x0, x16");
2863 COMPARE_MACRO(Adds(x0, xzr, Operand(w1, SXTW)),
2864 "sxtw x0, w1\n"
2865 "adds x0, xzr, x0");
2866 COMPARE_MACRO(Sub(x0, x1, 0x4242),
2867 "mov x0, #0x4242\n"
2868 "sub x0, x1, x0");
2869 COMPARE_MACRO(Sub(x0, x0, 0x4242),
2870 "mov x16, #0x4242\n"
2871 "sub x0, x0, x16");
2872 COMPARE_MACRO(Subs(x0, xzr, Operand(w1, SXTW)),
2873 "sxtw x0, w1\n"
2874 "negs x0, x0");
2875 }
2876
TEST(adc_sbc_macro)2877 TEST(adc_sbc_macro) {
2878 SETUP();
2879
2880 // Adc and Sbc use their destination register as a scratch if they can.
2881 COMPARE_MACRO(Adc(x0, x1, 0x4242),
2882 "mov x0, #0x4242\n"
2883 "adc x0, x1, x0");
2884 COMPARE_MACRO(Adc(x0, x0, 0x4242),
2885 "mov x16, #0x4242\n"
2886 "adc x0, x0, x16");
2887 COMPARE_MACRO(Adcs(x0, xzr, Operand(w1, SXTW)),
2888 "sxtw x0, w1\n"
2889 "adcs x0, xzr, x0");
2890 COMPARE_MACRO(Sbc(x0, x1, 0x4242),
2891 "mov x0, #0x4242\n"
2892 "sbc x0, x1, x0");
2893 COMPARE_MACRO(Sbc(x0, x0, 0x4242),
2894 "mov x16, #0x4242\n"
2895 "sbc x0, x0, x16");
2896 COMPARE_MACRO(Sbcs(x0, xzr, Operand(w1, SXTW)),
2897 "sxtw x0, w1\n"
2898 "ngcs x0, x0");
2899 }
2900
TEST(logical_immediate_move)2901 TEST(logical_immediate_move) {
2902 SETUP();
2903
2904 COMPARE_MACRO(And(w0, w1, 0), "mov w0, #0x0");
2905 COMPARE_MACRO(And(x0, x1, 0), "mov x0, #0x0");
2906 COMPARE_MACRO(Orr(w2, w3, 0), "mov w2, w3");
2907 COMPARE_MACRO(Orr(x2, x3, 0), "mov x2, x3");
2908 COMPARE_MACRO(Eor(w4, w5, 0), "mov w4, w5");
2909 COMPARE_MACRO(Eor(x4, x5, 0), "mov x4, x5");
2910 COMPARE_MACRO(Bic(w6, w7, 0), "mov w6, w7");
2911 COMPARE_MACRO(Bic(x6, x7, 0), "mov x6, x7");
2912 COMPARE_MACRO(Orn(w8, w9, 0), "mov w8, #0xffffffff");
2913 COMPARE_MACRO(Orn(x8, x9, 0), "mov x8, #0xffffffffffffffff");
2914 COMPARE_MACRO(Eon(w10, w11, 0), "mvn w10, w11");
2915 COMPARE_MACRO(Eon(x10, x11, 0), "mvn x10, x11");
2916
2917 COMPARE_MACRO(And(w12, w13, 0xffffffff), "mov w12, w13");
2918 COMPARE_MACRO(And(x12, x13, 0xffffffff), "and x12, x13, #0xffffffff");
2919 COMPARE_MACRO(And(x12, x13, 0xffffffffffffffff), "mov x12, x13");
2920 COMPARE_MACRO(Orr(w14, w15, 0xffffffff), "mov w14, #0xffffffff");
2921 COMPARE_MACRO(Orr(x14, x15, 0xffffffff), "orr x14, x15, #0xffffffff");
2922 COMPARE_MACRO(Orr(x14, x15, 0xffffffffffffffff),
2923 "mov x14, #0xffffffffffffffff");
2924 COMPARE_MACRO(Eor(w16, w17, 0xffffffff), "mvn w16, w17");
2925 COMPARE_MACRO(Eor(x16, x17, 0xffffffff), "eor x16, x17, #0xffffffff");
2926 COMPARE_MACRO(Eor(x16, x17, 0xffffffffffffffff), "mvn x16, x17");
2927 COMPARE_MACRO(Bic(w18, w19, 0xffffffff), "mov w18, #0x0");
2928 COMPARE_MACRO(Bic(x18, x19, 0xffffffff), "and x18, x19, #0xffffffff00000000");
2929 COMPARE_MACRO(Bic(x18, x19, 0xffffffffffffffff), "mov x18, #0x0");
2930 COMPARE_MACRO(Orn(w20, w21, 0xffffffff), "mov w20, w21");
2931 COMPARE_MACRO(Orn(x20, x21, 0xffffffff), "orr x20, x21, #0xffffffff00000000");
2932 COMPARE_MACRO(Orn(x20, x21, 0xffffffffffffffff), "mov x20, x21");
2933 COMPARE_MACRO(Eon(w22, w23, 0xffffffff), "mov w22, w23");
2934 COMPARE_MACRO(Eon(x22, x23, 0xffffffff), "eor x22, x23, #0xffffffff00000000");
2935 COMPARE_MACRO(Eon(x22, x23, 0xffffffffffffffff), "mov x22, x23");
2936
2937 // Test stack pointer with non encodable immediate.
2938 COMPARE_MACRO(Orr(wsp, w5, 0x1234),
2939 "mov w16, #0x1234\n"
2940 "orr w16, w5, w16\n"
2941 "mov wsp, w16");
2942 COMPARE_MACRO(Orr(sp, x15, 0x123),
2943 "mov x16, #0x123\n"
2944 "orr x16, x15, x16\n"
2945 "mov sp, x16");
2946
2947 CLEANUP();
2948 }
2949
TEST(logical_macro)2950 TEST(logical_macro) {
2951 SETUP();
2952
2953 // LogicalMacro uses the destination register as a scratch if it can.
2954 COMPARE_MACRO(And(x0, x1, 0x4242),
2955 "mov x0, #0x4242\n"
2956 "and x0, x1, x0");
2957 COMPARE_MACRO(Bic(x0, x0, 0x4242),
2958 "mov x16, #0xffffffffffffbdbd\n"
2959 "and x0, x0, x16");
2960 COMPARE_MACRO(Orn(x0, xzr, Operand(w1, SXTW)),
2961 "sxtw x0, w1\n"
2962 "mvn x0, x0");
2963 COMPARE_MACRO(Orr(x0, x1, 0x4242),
2964 "mov x0, #0x4242\n"
2965 "orr x0, x1, x0");
2966 COMPARE_MACRO(Ands(x0, x0, 0x4242),
2967 "mov x16, #0x4242\n"
2968 "ands x0, x0, x16");
2969 COMPARE_MACRO(Tst(xzr, Operand(w1, SXTW)),
2970 "sxtw x16, w1\n"
2971 "tst xzr, x16");
2972 }
2973
TEST(barriers)2974 TEST(barriers) {
2975 SETUP();
2976
2977 // DMB
2978 COMPARE_MACRO(Dmb(FullSystem, BarrierAll), "dmb sy");
2979 COMPARE_MACRO(Dmb(FullSystem, BarrierReads), "dmb ld");
2980 COMPARE_MACRO(Dmb(FullSystem, BarrierWrites), "dmb st");
2981
2982 COMPARE_MACRO(Dmb(InnerShareable, BarrierAll), "dmb ish");
2983 COMPARE_MACRO(Dmb(InnerShareable, BarrierReads), "dmb ishld");
2984 COMPARE_MACRO(Dmb(InnerShareable, BarrierWrites), "dmb ishst");
2985
2986 COMPARE_MACRO(Dmb(NonShareable, BarrierAll), "dmb nsh");
2987 COMPARE_MACRO(Dmb(NonShareable, BarrierReads), "dmb nshld");
2988 COMPARE_MACRO(Dmb(NonShareable, BarrierWrites), "dmb nshst");
2989
2990 COMPARE_MACRO(Dmb(OuterShareable, BarrierAll), "dmb osh");
2991 COMPARE_MACRO(Dmb(OuterShareable, BarrierReads), "dmb oshld");
2992 COMPARE_MACRO(Dmb(OuterShareable, BarrierWrites), "dmb oshst");
2993
2994 COMPARE_MACRO(Dmb(FullSystem, BarrierOther), "dmb sy (0b1100)");
2995 COMPARE_MACRO(Dmb(InnerShareable, BarrierOther), "dmb sy (0b1000)");
2996 COMPARE_MACRO(Dmb(NonShareable, BarrierOther), "dmb sy (0b0100)");
2997 COMPARE_MACRO(Dmb(OuterShareable, BarrierOther), "dmb sy (0b0000)");
2998
2999 // DSB
3000 COMPARE_MACRO(Dsb(FullSystem, BarrierAll), "dsb sy");
3001 COMPARE_MACRO(Dsb(FullSystem, BarrierReads), "dsb ld");
3002 COMPARE_MACRO(Dsb(FullSystem, BarrierWrites), "dsb st");
3003
3004 COMPARE_MACRO(Dsb(InnerShareable, BarrierAll), "dsb ish");
3005 COMPARE_MACRO(Dsb(InnerShareable, BarrierReads), "dsb ishld");
3006 COMPARE_MACRO(Dsb(InnerShareable, BarrierWrites), "dsb ishst");
3007
3008 COMPARE_MACRO(Dsb(NonShareable, BarrierAll), "dsb nsh");
3009 COMPARE_MACRO(Dsb(NonShareable, BarrierReads), "dsb nshld");
3010 COMPARE_MACRO(Dsb(NonShareable, BarrierWrites), "dsb nshst");
3011
3012 COMPARE_MACRO(Dsb(OuterShareable, BarrierAll), "dsb osh");
3013 COMPARE_MACRO(Dsb(OuterShareable, BarrierReads), "dsb oshld");
3014 COMPARE_MACRO(Dsb(OuterShareable, BarrierWrites), "dsb oshst");
3015
3016 COMPARE_MACRO(Dsb(FullSystem, BarrierOther), "dsb sy (0b1100)");
3017 COMPARE_MACRO(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)");
3018 COMPARE_MACRO(Dsb(NonShareable, BarrierOther), "pssbb");
3019 COMPARE_MACRO(Dsb(OuterShareable, BarrierOther), "ssbb");
3020
3021 // ISB
3022 COMPARE_MACRO(Isb(), "isb");
3023
3024 // ESB
3025 COMPARE_MACRO(Esb(), "esb");
3026
3027 // CSDB
3028 COMPARE_MACRO(Csdb(), "csdb");
3029
3030 CLEANUP();
3031 }
3032
TEST(address_map)3033 TEST(address_map) {
3034 // Check that we can disassemble from a fake base address.
3035 SETUP();
3036
3037 disasm.MapCodeAddress(0, masm.GetBuffer()->GetStartAddress<Instruction*>());
3038 COMPARE(ldr(x0, INT64_C(0)), "ldr x0, pc+0 (addr 0x0)");
3039 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr -0x4)");
3040 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x4)");
3041 COMPARE(prfm(PLIL1KEEP, INT64_C(0)), "prfm plil1keep, pc+0 (addr 0x0)");
3042 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr -0x4)");
3043 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x4)");
3044 COMPARE(adr(x0, INT64_C(0)), "adr x0, #+0x0 (addr 0x0)");
3045 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr -0x1)");
3046 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x1)");
3047 COMPARE(adrp(x0, INT64_C(0)), "adrp x0, #+0x0 (addr 0x0)");
3048 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr -0x1000)");
3049 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x1000)");
3050 COMPARE(b(INT64_C(0)), "b #+0x0 (addr 0x0)");
3051 COMPARE(b(-1), "b #-0x4 (addr -0x4)");
3052 COMPARE(b(1), "b #+0x4 (addr 0x4)");
3053
3054 disasm.MapCodeAddress(0x1234,
3055 masm.GetBuffer()->GetStartAddress<Instruction*>());
3056 COMPARE(ldr(x0, INT64_C(0)), "ldr x0, pc+0 (addr 0x1234)");
3057 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr 0x1230)");
3058 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x1238)");
3059 COMPARE(prfm(PLIL1KEEP, INT64_C(0)), "prfm plil1keep, pc+0 (addr 0x1234)");
3060 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr 0x1230)");
3061 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x1238)");
3062 COMPARE(adr(x0, INT64_C(0)), "adr x0, #+0x0 (addr 0x1234)");
3063 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr 0x1233)");
3064 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x1235)");
3065 COMPARE(adrp(x0, INT64_C(0)), "adrp x0, #+0x0 (addr 0x1000)");
3066 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr 0x0)");
3067 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x2000)");
3068 COMPARE(b(INT64_C(0)), "b #+0x0 (addr 0x1234)");
3069 COMPARE(b(-1), "b #-0x4 (addr 0x1230)");
3070 COMPARE(b(1), "b #+0x4 (addr 0x1238)");
3071
3072 // Check that 64-bit addresses work.
3073 disasm.MapCodeAddress(UINT64_C(0x100000000),
3074 masm.GetBuffer()->GetStartAddress<Instruction*>());
3075 COMPARE(ldr(x0, INT64_C(0)), "ldr x0, pc+0 (addr 0x100000000)");
3076 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr 0xfffffffc)");
3077 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x100000004)");
3078 COMPARE(prfm(PLIL1KEEP, INT64_C(0)),
3079 "prfm plil1keep, pc+0 (addr 0x100000000)");
3080 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr 0xfffffffc)");
3081 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x100000004)");
3082 COMPARE(adr(x0, INT64_C(0)), "adr x0, #+0x0 (addr 0x100000000)");
3083 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr 0xffffffff)");
3084 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x100000001)");
3085 COMPARE(adrp(x0, INT64_C(0)), "adrp x0, #+0x0 (addr 0x100000000)");
3086 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr 0xfffff000)");
3087 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x100001000)");
3088 COMPARE(b(INT64_C(0)), "b #+0x0 (addr 0x100000000)");
3089 COMPARE(b(-1), "b #-0x4 (addr 0xfffffffc)");
3090 COMPARE(b(1), "b #+0x4 (addr 0x100000004)");
3091
3092 disasm.MapCodeAddress(0xfffffffc,
3093 masm.GetBuffer()->GetStartAddress<Instruction*>());
3094 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x100000000)");
3095 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x100000000)");
3096 COMPARE(b(1), "b #+0x4 (addr 0x100000000)");
3097 COMPARE(adr(x0, 4), "adr x0, #+0x4 (addr 0x100000000)");
3098 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x100000000)");
3099
3100 // Check that very large offsets are handled properly. This detects misuse of
3101 // the host's ptrdiff_t type when run on a 32-bit host. Only adrp is capable
3102 // of encoding such offsets.
3103 disasm.MapCodeAddress(0, masm.GetBuffer()->GetStartAddress<Instruction*>());
3104 COMPARE(adrp(x0, 0x000fffff), "adrp x0, #+0xfffff000 (addr 0xfffff000)");
3105 COMPARE(adrp(x0, -0x00100000), "adrp x0, #-0x100000000 (addr -0x100000000)");
3106
3107 CLEANUP();
3108 }
3109
TEST(hint)3110 TEST(hint) {
3111 SETUP();
3112
3113 // Test that we properly disassemble named and unnamed hints.
3114 COMPARE(hint(NOP), "nop");
3115 COMPARE(hint(YIELD), "yield");
3116 COMPARE(hint(WFE), "wfe");
3117 COMPARE(hint(WFI), "wfi");
3118 COMPARE(hint(SEV), "sev");
3119 COMPARE(hint(SEVL), "sevl");
3120 COMPARE(hint(6), "dgh");
3121 COMPARE(hint(ESB), "esb");
3122 COMPARE(hint(CSDB), "csdb");
3123 COMPARE(hint(42), "hint #42");
3124 COMPARE(hint(127), "hint #127");
3125
3126 // The MacroAssembler should simply pass through to the Assembler.
3127 COMPARE_MACRO(Hint(NOP), "nop");
3128 COMPARE_MACRO(Hint(CSDB), "csdb");
3129 COMPARE_MACRO(Hint(42), "hint #42");
3130 COMPARE_MACRO(Hint(127), "hint #127");
3131
3132 CLEANUP();
3133 }
3134
TEST(bti)3135 TEST(bti) {
3136 SETUP();
3137
3138 COMPARE(bti(EmitBTI), "bti");
3139 COMPARE(bti(EmitBTI_c), "bti c");
3140 COMPARE(bti(EmitBTI_j), "bti j");
3141 COMPARE(bti(EmitBTI_jc), "bti jc");
3142 COMPARE(hint(BTI), "bti");
3143 COMPARE(hint(BTI_c), "bti c");
3144 COMPARE(hint(BTI_j), "bti j");
3145 COMPARE(hint(BTI_jc), "bti jc");
3146
3147 Label placeholder1, placeholder2, placeholder3, placeholder4;
3148 COMPARE_MACRO(Bind(&placeholder1, EmitBTI), "bti");
3149 COMPARE_MACRO(Bind(&placeholder2, EmitBTI_c), "bti c");
3150 COMPARE_MACRO(Bind(&placeholder3, EmitBTI_j), "bti j");
3151 COMPARE_MACRO(Bind(&placeholder4, EmitBTI_jc), "bti jc");
3152
3153 CLEANUP();
3154 }
3155
TEST(udf)3156 TEST(udf) {
3157 SETUP();
3158
3159 COMPARE(udf(0), "udf #0x0");
3160 COMPARE(udf(0x1234), "udf #0x1234");
3161 COMPARE(udf(0xffff), "udf #0xffff");
3162
3163 // UDF gives the useful property that zero-initialised memory is guaranteed to
3164 // generate undefined instruction exceptions.
3165 COMPARE(dc(0), "udf #0x0");
3166
3167 // Check related unallocated bit patterns from the reserved block.
3168 COMPARE(dc(0x00010000), "unallocated (Unallocated)");
3169 COMPARE(dc(0x01000000), "unallocated (Unallocated)");
3170 COMPARE(dc(0x20000000), "unallocated (Unallocated)");
3171 COMPARE(dc(0x80000000), "unallocated (Unallocated)");
3172
3173 CLEANUP();
3174 }
3175
TEST(mte)3176 TEST(mte) {
3177 SETUP();
3178
3179 #if 0
3180 COMPARE(ldg(x2, x2, int imm9), "ldg <Xt>, [<Xn|SP>{, #<simm>}]");
3181 COMPARE(st2g(x3, int imm9), "st2g <Xt|SP>, [<Xn|SP>{, #<simm>}]");
3182 COMPARE(st2g(x31, int imm9), "st2g <Xt|SP>, [<Xn|SP>], #<simm>");
3183 COMPARE(st2g(x30, int imm9), "st2g <Xt|SP>, [<Xn|SP>, #<simm>]!");
3184 COMPARE(stgp(x301, x302, x30, int imm7), "stgp <Xt1>, <Xt2>, [<Xn|SP>{, #<imm>}]");
3185 COMPARE(stgp(x201, x202, x20, int imm7), "stgp <Xt1>, <Xt2>, [<Xn|SP>], #<imm>");
3186 COMPARE(stgp(x161, x162, x16, int imm7), "stgp <Xt1>, <Xt2>, [<Xn|SP>, #<imm>]!");
3187 COMPARE(stg(x9, int imm9), "stg <Xt|SP>, [<Xn|SP>{, #<simm>}]");
3188 COMPARE(stg(x20, int imm9), "stg <Xt|SP>, [<Xn|SP>], #<simm>");
3189 COMPARE(stg(x29, int imm9), "stg <Xt|SP>, [<Xn|SP>, #<simm>]!");
3190 COMPARE(stz2g(x9, int imm9), "stz2g <Xt|SP>, [<Xn|SP>{, #<simm>}]");
3191 COMPARE(stz2g(x28, int imm9), "stz2g <Xt|SP>, [<Xn|SP>], #<simm>");
3192 COMPARE(stz2g(x7, int imm9), "stz2g <Xt|SP>, [<Xn|SP>, #<simm>]!");
3193 COMPARE(stzg(x20, int imm9), "stzg <Xt|SP>, [<Xn|SP>{, #<simm>}]");
3194 COMPARE(stzg(x6, int imm9), "stzg <Xt|SP>, [<Xn|SP>], #<simm>");
3195 COMPARE(stzg(x28, int imm9), "stzg <Xt|SP>, [<Xn|SP>, #<simm>]!");
3196 #endif
3197
3198 CLEANUP();
3199 }
3200
TEST(mte_dp)3201 TEST(mte_dp) {
3202 SETUP();
3203
3204 COMPARE(addg(x26, x27, 0, 0), "addg x26, x27, #0, #0");
3205 COMPARE(addg(x26, x27, 512, 2), "addg x26, x27, #512, #2");
3206 COMPARE(addg(x26, x27, 1008, 15), "addg x26, x27, #1008, #15");
3207 COMPARE(addg(sp, x27, 1008, 15), "addg sp, x27, #1008, #15");
3208 COMPARE(addg(x26, sp, 1008, 15), "addg x26, sp, #1008, #15");
3209 COMPARE(addg(sp, sp, 1008, 15), "addg sp, sp, #1008, #15");
3210 COMPARE(subg(x6, x7, 0, 0), "subg x6, x7, #0, #0");
3211 COMPARE(subg(x6, x7, 640, 9), "subg x6, x7, #640, #9");
3212 COMPARE(subg(x6, x7, 1008, 15), "subg x6, x7, #1008, #15");
3213 COMPARE(subg(sp, x7, 1008, 15), "subg sp, x7, #1008, #15");
3214 COMPARE(subg(x6, sp, 1008, 15), "subg x6, sp, #1008, #15");
3215 COMPARE(subg(sp, sp, 1008, 15), "subg sp, sp, #1008, #15");
3216 COMPARE(gmi(x3, x5, x4), "gmi x3, x5, x4");
3217 COMPARE(gmi(x3, sp, x4), "gmi x3, sp, x4");
3218 COMPARE(gmi(xzr, sp, xzr), "gmi xzr, sp, xzr");
3219 COMPARE(irg(x24, x23, x22), "irg x24, x23, x22");
3220 COMPARE(irg(sp, x23, x22), "irg sp, x23, x22");
3221 COMPARE(irg(x24, sp, x22), "irg x24, sp, x22");
3222 COMPARE(irg(sp, sp, x22), "irg sp, sp, x22");
3223 COMPARE(irg(x24, x23, xzr), "irg x24, x23");
3224 COMPARE(irg(x24, x23), "irg x24, x23");
3225 COMPARE(subp(x28, x29, x30), "subp x28, x29, x30");
3226 COMPARE(subp(x28, sp, x30), "subp x28, sp, x30");
3227 COMPARE(subp(x28, x29, sp), "subp x28, x29, sp");
3228 COMPARE(subp(x28, sp, sp), "subp x28, sp, sp");
3229 COMPARE(subp(xzr, sp, sp), "subp xzr, sp, sp");
3230 COMPARE(subps(x2, x10, x0), "subps x2, x10, x0");
3231 COMPARE(subps(x2, sp, x0), "subps x2, sp, x0");
3232 COMPARE(subps(x2, x10, sp), "subps x2, x10, sp");
3233 COMPARE(subps(x2, sp, sp), "subps x2, sp, sp");
3234 COMPARE(subps(xzr, sp, sp), "cmpp sp, sp");
3235 COMPARE(subps(xzr, x2, sp), "cmpp x2, sp");
3236 COMPARE(cmpp(x6, x30), "cmpp x6, x30");
3237
3238 CLEANUP();
3239 }
3240
TEST(mops)3241 TEST(mops) {
3242 SETUP();
3243
3244 COMPARE_MACRO(Cpyen(x4, x5, x6), "cpyen [x4]!, [x5]!, x6!");
3245 COMPARE_MACRO(Cpyern(x7, x6, x1), "cpyern [x7]!, [x6]!, x1!");
3246 COMPARE_MACRO(Cpyewn(x26, x27, x28), "cpyewn [x26]!, [x27]!, x28!");
3247 COMPARE_MACRO(Cpye(x14, x15, x19), "cpye [x14]!, [x15]!, x19!");
3248 COMPARE_MACRO(Cpyfen(x13, x1, x9), "cpyfen [x13]!, [x1]!, x9!");
3249 COMPARE_MACRO(Cpyfern(x24, x2, x10), "cpyfern [x24]!, [x2]!, x10!");
3250 COMPARE_MACRO(Cpyfewn(x12, x2, x11), "cpyfewn [x12]!, [x2]!, x11!");
3251 COMPARE_MACRO(Cpyfe(x3, x9, x12), "cpyfe [x3]!, [x9]!, x12!");
3252 COMPARE_MACRO(Cpyfmn(x7, x27, x13), "cpyfmn [x7]!, [x27]!, x13!");
3253 COMPARE_MACRO(Cpyfmrn(x19, x9, x14), "cpyfmrn [x19]!, [x9]!, x14!");
3254 COMPARE_MACRO(Cpyfmwn(x1, x11, x15), "cpyfmwn [x1]!, [x11]!, x15!");
3255 COMPARE_MACRO(Cpyfm(x1, x13, x16), "cpyfm [x1]!, [x13]!, x16!");
3256 COMPARE_MACRO(Cpyfpn(x3, x13, x17), "cpyfpn [x3]!, [x13]!, x17!");
3257 COMPARE_MACRO(Cpyfprn(x18, x8, x17), "cpyfprn [x18]!, [x8]!, x17!");
3258 COMPARE_MACRO(Cpyfpwn(x9, x29, x18), "cpyfpwn [x9]!, [x29]!, x18!");
3259 COMPARE_MACRO(Cpyfp(x4, x3, x19), "cpyfp [x4]!, [x3]!, x19!");
3260 COMPARE_MACRO(Cpymn(x5, x15, x20), "cpymn [x5]!, [x15]!, x20!");
3261 COMPARE_MACRO(Cpymrn(x12, x22, x21), "cpymrn [x12]!, [x22]!, x21!");
3262 COMPARE_MACRO(Cpymwn(x12, x1, x22), "cpymwn [x12]!, [x1]!, x22!");
3263 COMPARE_MACRO(Cpym(x1, x10, x23), "cpym [x1]!, [x10]!, x23!");
3264 COMPARE_MACRO(Cpypn(x3, x26, x25), "cpypn [x3]!, [x26]!, x25!");
3265 COMPARE_MACRO(Cpyprn(x4, x14, x24), "cpyprn [x4]!, [x14]!, x24!");
3266 COMPARE_MACRO(Cpypwn(x9, x29, x26), "cpypwn [x9]!, [x29]!, x26!");
3267 COMPARE_MACRO(Cpyp(x0, x30, x28), "cpyp [x0]!, [x30]!, x28!");
3268
3269 COMPARE_MACRO(Seten(x6, x26, x27), "seten [x6]!, x26!, x27");
3270 COMPARE_MACRO(Sete(x3, x23, x1), "sete [x3]!, x23!, x1");
3271 COMPARE_MACRO(Setgen(x6, x16, x2), "setgen [x6]!, x16!, x2");
3272 COMPARE_MACRO(Setge(x4, x24, x3), "setge [x4]!, x24!, x3");
3273 COMPARE_MACRO(Setgmn(x9, x29, x4), "setgmn [x9]!, x29!, x4");
3274 COMPARE_MACRO(Setgm(x30, x3, x5), "setgm [x30]!, x3!, x5");
3275 COMPARE_MACRO(Setgpn(x11, x1, x6), "setgpn [x11]!, x1!, x6");
3276 COMPARE_MACRO(Setgp(x1, x16, x7), "setgp [x1]!, x16!, x7");
3277 COMPARE_MACRO(Setmn(x4, x14, x8), "setmn [x4]!, x14!, x8");
3278 COMPARE_MACRO(Setm(x8, x7, x9), "setm [x8]!, x7!, x9");
3279 COMPARE_MACRO(Setpn(x2, x22, x10), "setpn [x2]!, x22!, x10");
3280 COMPARE_MACRO(Setp(x7, x17, x11), "setp [x7]!, x17!, x11");
3281
3282 // Check unallocated bit patterns.
3283 COMPARE_PREFIX(dci(0x1d000422), "cpyp [x2]!, [x0]!, x1!");
3284 COMPARE_PREFIX(dci(0xdd000422), "unallocated"); // sz != 0
3285 COMPARE_PREFIX(dci(0x1d000442), "unallocated"); // Xd == Xn
3286 COMPARE_PREFIX(dci(0x1d020422), "unallocated"); // Xd == Xs
3287 COMPARE_PREFIX(dci(0x1d000402), "unallocated"); // Xn == Xs
3288 COMPARE_PREFIX(dci(0x1d00043f), "unallocated"); // Xd == 31
3289 COMPARE_PREFIX(dci(0x1d0007e2), "unallocated"); // Xn == 31
3290 COMPARE_PREFIX(dci(0x1d1f0422), "unallocated"); // Xs == 31
3291
3292 COMPARE_PREFIX(dci(0x19c02424), "setpn [x4]!, x1!, x0");
3293 COMPARE_PREFIX(dci(0xd9c02424), "unallocated"); // sz != 0
3294 COMPARE_PREFIX(dci(0x19c0e424), "unallocated"); // op2 == 0xe
3295 COMPARE_PREFIX(dci(0x19c02400), "unallocated"); // Xd == Xn
3296 COMPARE_PREFIX(dci(0x19c02420), "unallocated"); // Xd == Xs
3297 COMPARE_PREFIX(dci(0x19c02404), "unallocated"); // Xn == Xs
3298 COMPARE_PREFIX(dci(0x19c0243f), "unallocated"); // Xd == 31
3299 COMPARE_PREFIX(dci(0x19c027e4), "unallocated"); // Xn == 31
3300
3301 CLEANUP();
3302 }
3303
TEST(cssc)3304 TEST(cssc) {
3305 SETUP();
3306
3307 COMPARE_MACRO(Abs(w0, w22), "abs w0, w22");
3308 COMPARE_MACRO(Abs(x0, x23), "abs x0, x23");
3309 COMPARE_MACRO(Abs(wzr, wzr), "abs wzr, wzr");
3310 COMPARE_MACRO(Cnt(w21, w30), "cnt w21, w30");
3311 COMPARE_MACRO(Cnt(x19, x9), "cnt x19, x9");
3312 COMPARE_MACRO(Cnt(xzr, x30), "cnt xzr, x30");
3313 COMPARE_MACRO(Ctz(w3, w5), "ctz w3, w5");
3314 COMPARE_MACRO(Ctz(x3, x28), "ctz x3, x28");
3315 COMPARE_MACRO(Ctz(w0, wzr), "ctz w0, wzr");
3316
3317 COMPARE_MACRO(Smax(w5, w9, w10), "smax w5, w9, w10");
3318 COMPARE_MACRO(Smax(x6, x8, x9), "smax x6, x8, x9");
3319 COMPARE_MACRO(Smin(w11, w8, w17), "smin w11, w8, w17");
3320 COMPARE_MACRO(Smin(x12, x10, x20), "smin x12, x10, x20");
3321 COMPARE_MACRO(Umax(w5, w9, w10), "umax w5, w9, w10");
3322 COMPARE_MACRO(Umax(x6, x8, x9), "umax x6, x8, x9");
3323 COMPARE_MACRO(Umin(w11, w8, w17), "umin w11, w8, w17");
3324 COMPARE_MACRO(Umin(x12, x10, x20), "umin x12, x10, x20");
3325
3326 COMPARE_MACRO(Smax(w5, w9, 127), "smax w5, w9, #127");
3327 COMPARE_MACRO(Smax(x6, x8, -128), "smax x6, x8, #-128");
3328 COMPARE_MACRO(Smin(w19, w20, -1), "smin w19, w20, #-1");
3329 COMPARE_MACRO(Smin(x30, xzr, 0), "smin x30, xzr, #0");
3330 COMPARE_MACRO(Umax(w5, w9, 255), "umax w5, w9, #255");
3331 COMPARE_MACRO(Umax(x6, x8, 128), "umax x6, x8, #128");
3332 COMPARE_MACRO(Umin(wzr, w20, 1), "umin wzr, w20, #1");
3333 COMPARE_MACRO(Umin(x30, xzr, 0), "umin x30, xzr, #0");
3334
3335 COMPARE_MACRO(Smax(w5, w6, 128),
3336 "mov w16, #0x80\n"
3337 "smax w5, w6, w16");
3338 COMPARE_MACRO(Smax(x10, x11, -129),
3339 "mov x16, #0xffffffffffffff7f\n"
3340 "smax x10, x11, x16");
3341 COMPARE_MACRO(Smin(w5, w6, 128),
3342 "mov w16, #0x80\n"
3343 "smin w5, w6, w16");
3344 COMPARE_MACRO(Smin(x10, x11, -129),
3345 "mov x16, #0xffffffffffffff7f\n"
3346 "smin x10, x11, x16");
3347 COMPARE_MACRO(Umax(w5, w6, 256),
3348 "mov w16, #0x100\n"
3349 "umax w5, w6, w16");
3350 COMPARE_MACRO(Umax(x10, x11, 0x4242),
3351 "mov x16, #0x4242\n"
3352 "umax x10, x11, x16");
3353 COMPARE_MACRO(Umin(w5, w6, 256),
3354 "mov w16, #0x100\n"
3355 "umin w5, w6, w16");
3356 COMPARE_MACRO(Umin(x10, x11, 0x4242),
3357 "mov x16, #0x4242\n"
3358 "umin x10, x11, x16");
3359 CLEANUP();
3360 }
3361
TEST(architecture_features)3362 TEST(architecture_features) {
3363 SETUP();
3364
3365 // ARMv8.1 - LOR
3366 COMPARE_PREFIX(dci(0x089f7c00), "stllrb"); // STLLRB_SL32_ldstexcl
3367 COMPARE_PREFIX(dci(0x08df7c00), "ldlarb"); // LDLARB_LR32_ldstexcl
3368 COMPARE_PREFIX(dci(0x489f7c00), "stllrh"); // STLLRH_SL32_ldstexcl
3369 COMPARE_PREFIX(dci(0x48df7c00), "ldlarh"); // LDLARH_LR32_ldstexcl
3370 COMPARE_PREFIX(dci(0x889f7c00), "stllr"); // STLLR_SL32_ldstexcl
3371 COMPARE_PREFIX(dci(0x88df7c00), "ldlar"); // LDLAR_LR32_ldstexcl
3372 COMPARE_PREFIX(dci(0xc89f7c00), "stllr"); // STLLR_SL64_ldstexcl
3373 COMPARE_PREFIX(dci(0xc8df7c00), "ldlar"); // LDLAR_LR64_ldstexcl
3374
3375 // ARMv8.1 - LSE
3376 COMPARE_PREFIX(dci(0x08207c00), "casp"); // CASP_CP32_ldstexcl
3377 COMPARE_PREFIX(dci(0x0820fc00), "caspl"); // CASPL_CP32_ldstexcl
3378 COMPARE_PREFIX(dci(0x08607c00), "caspa"); // CASPA_CP32_ldstexcl
3379 COMPARE_PREFIX(dci(0x0860fc00), "caspal"); // CASPAL_CP32_ldstexcl
3380 COMPARE_PREFIX(dci(0x08a07c00), "casb"); // CASB_C32_ldstexcl
3381 COMPARE_PREFIX(dci(0x08a0fc00), "caslb"); // CASLB_C32_ldstexcl
3382 COMPARE_PREFIX(dci(0x08e07c00), "casab"); // CASAB_C32_ldstexcl
3383 COMPARE_PREFIX(dci(0x08e0fc00), "casalb"); // CASALB_C32_ldstexcl
3384 COMPARE_PREFIX(dci(0x38200000), "ldaddb"); // LDADDB_32_memop
3385 COMPARE_PREFIX(dci(0x38201000), "ldclrb"); // LDCLRB_32_memop
3386 COMPARE_PREFIX(dci(0x38202000), "ldeorb"); // LDEORB_32_memop
3387 COMPARE_PREFIX(dci(0x38203000), "ldsetb"); // LDSETB_32_memop
3388 COMPARE_PREFIX(dci(0x38204000), "ldsmaxb"); // LDSMAXB_32_memop
3389 COMPARE_PREFIX(dci(0x38205000), "ldsminb"); // LDSMINB_32_memop
3390 COMPARE_PREFIX(dci(0x38206000), "ldumaxb"); // LDUMAXB_32_memop
3391 COMPARE_PREFIX(dci(0x38207000), "lduminb"); // LDUMINB_32_memop
3392 COMPARE_PREFIX(dci(0x38208000), "swpb"); // SWPB_32_memop
3393 COMPARE_PREFIX(dci(0x38600000), "ldaddlb"); // LDADDLB_32_memop
3394 COMPARE_PREFIX(dci(0x38601000), "ldclrlb"); // LDCLRLB_32_memop
3395 COMPARE_PREFIX(dci(0x38602000), "ldeorlb"); // LDEORLB_32_memop
3396 COMPARE_PREFIX(dci(0x38603000), "ldsetlb"); // LDSETLB_32_memop
3397 COMPARE_PREFIX(dci(0x38604000), "ldsmaxlb"); // LDSMAXLB_32_memop
3398 COMPARE_PREFIX(dci(0x38605000), "ldsminlb"); // LDSMINLB_32_memop
3399 COMPARE_PREFIX(dci(0x38606000), "ldumaxlb"); // LDUMAXLB_32_memop
3400 COMPARE_PREFIX(dci(0x38607000), "lduminlb"); // LDUMINLB_32_memop
3401 COMPARE_PREFIX(dci(0x38608000), "swplb"); // SWPLB_32_memop
3402 COMPARE_PREFIX(dci(0x38a00000), "ldaddab"); // LDADDAB_32_memop
3403 COMPARE_PREFIX(dci(0x38a01000), "ldclrab"); // LDCLRAB_32_memop
3404 COMPARE_PREFIX(dci(0x38a02000), "ldeorab"); // LDEORAB_32_memop
3405 COMPARE_PREFIX(dci(0x38a03000), "ldsetab"); // LDSETAB_32_memop
3406 COMPARE_PREFIX(dci(0x38a04000), "ldsmaxab"); // LDSMAXAB_32_memop
3407 COMPARE_PREFIX(dci(0x38a05000), "ldsminab"); // LDSMINAB_32_memop
3408 COMPARE_PREFIX(dci(0x38a06000), "ldumaxab"); // LDUMAXAB_32_memop
3409 COMPARE_PREFIX(dci(0x38a07000), "lduminab"); // LDUMINAB_32_memop
3410 COMPARE_PREFIX(dci(0x38a08000), "swpab"); // SWPAB_32_memop
3411 COMPARE_PREFIX(dci(0x38e00000), "ldaddalb"); // LDADDALB_32_memop
3412 COMPARE_PREFIX(dci(0x38e01000), "ldclralb"); // LDCLRALB_32_memop
3413 COMPARE_PREFIX(dci(0x38e02000), "ldeoralb"); // LDEORALB_32_memop
3414 COMPARE_PREFIX(dci(0x38e03000), "ldsetalb"); // LDSETALB_32_memop
3415 COMPARE_PREFIX(dci(0x38e04000), "ldsmaxalb"); // LDSMAXALB_32_memop
3416 COMPARE_PREFIX(dci(0x38e05000), "ldsminalb"); // LDSMINALB_32_memop
3417 COMPARE_PREFIX(dci(0x38e06000), "ldumaxalb"); // LDUMAXALB_32_memop
3418 COMPARE_PREFIX(dci(0x38e07000), "lduminalb"); // LDUMINALB_32_memop
3419 COMPARE_PREFIX(dci(0x38e08000), "swpalb"); // SWPALB_32_memop
3420 COMPARE_PREFIX(dci(0x48207c00), "casp"); // CASP_CP64_ldstexcl
3421 COMPARE_PREFIX(dci(0x4820fc00), "caspl"); // CASPL_CP64_ldstexcl
3422 COMPARE_PREFIX(dci(0x48607c00), "caspa"); // CASPA_CP64_ldstexcl
3423 COMPARE_PREFIX(dci(0x4860fc00), "caspal"); // CASPAL_CP64_ldstexcl
3424 COMPARE_PREFIX(dci(0x48a07c00), "cash"); // CASH_C32_ldstexcl
3425 COMPARE_PREFIX(dci(0x48a0fc00), "caslh"); // CASLH_C32_ldstexcl
3426 COMPARE_PREFIX(dci(0x48e07c00), "casah"); // CASAH_C32_ldstexcl
3427 COMPARE_PREFIX(dci(0x48e0fc00), "casalh"); // CASALH_C32_ldstexcl
3428 COMPARE_PREFIX(dci(0x78200000), "ldaddh"); // LDADDH_32_memop
3429 COMPARE_PREFIX(dci(0x78201000), "ldclrh"); // LDCLRH_32_memop
3430 COMPARE_PREFIX(dci(0x78202000), "ldeorh"); // LDEORH_32_memop
3431 COMPARE_PREFIX(dci(0x78203000), "ldseth"); // LDSETH_32_memop
3432 COMPARE_PREFIX(dci(0x78204000), "ldsmaxh"); // LDSMAXH_32_memop
3433 COMPARE_PREFIX(dci(0x78205000), "ldsminh"); // LDSMINH_32_memop
3434 COMPARE_PREFIX(dci(0x78206000), "ldumaxh"); // LDUMAXH_32_memop
3435 COMPARE_PREFIX(dci(0x78207000), "lduminh"); // LDUMINH_32_memop
3436 COMPARE_PREFIX(dci(0x78208000), "swph"); // SWPH_32_memop
3437 COMPARE_PREFIX(dci(0x78600000), "ldaddlh"); // LDADDLH_32_memop
3438 COMPARE_PREFIX(dci(0x78601000), "ldclrlh"); // LDCLRLH_32_memop
3439 COMPARE_PREFIX(dci(0x78602000), "ldeorlh"); // LDEORLH_32_memop
3440 COMPARE_PREFIX(dci(0x78603000), "ldsetlh"); // LDSETLH_32_memop
3441 COMPARE_PREFIX(dci(0x78604000), "ldsmaxlh"); // LDSMAXLH_32_memop
3442 COMPARE_PREFIX(dci(0x78605000), "ldsminlh"); // LDSMINLH_32_memop
3443 COMPARE_PREFIX(dci(0x78606000), "ldumaxlh"); // LDUMAXLH_32_memop
3444 COMPARE_PREFIX(dci(0x78607000), "lduminlh"); // LDUMINLH_32_memop
3445 COMPARE_PREFIX(dci(0x78608000), "swplh"); // SWPLH_32_memop
3446 COMPARE_PREFIX(dci(0x78a00000), "ldaddah"); // LDADDAH_32_memop
3447 COMPARE_PREFIX(dci(0x78a01000), "ldclrah"); // LDCLRAH_32_memop
3448 COMPARE_PREFIX(dci(0x78a02000), "ldeorah"); // LDEORAH_32_memop
3449 COMPARE_PREFIX(dci(0x78a03000), "ldsetah"); // LDSETAH_32_memop
3450 COMPARE_PREFIX(dci(0x78a04000), "ldsmaxah"); // LDSMAXAH_32_memop
3451 COMPARE_PREFIX(dci(0x78a05000), "ldsminah"); // LDSMINAH_32_memop
3452 COMPARE_PREFIX(dci(0x78a06000), "ldumaxah"); // LDUMAXAH_32_memop
3453 COMPARE_PREFIX(dci(0x78a07000), "lduminah"); // LDUMINAH_32_memop
3454 COMPARE_PREFIX(dci(0x78a08000), "swpah"); // SWPAH_32_memop
3455 COMPARE_PREFIX(dci(0x78e00000), "ldaddalh"); // LDADDALH_32_memop
3456 COMPARE_PREFIX(dci(0x78e01000), "ldclralh"); // LDCLRALH_32_memop
3457 COMPARE_PREFIX(dci(0x78e02000), "ldeoralh"); // LDEORALH_32_memop
3458 COMPARE_PREFIX(dci(0x78e03000), "ldsetalh"); // LDSETALH_32_memop
3459 COMPARE_PREFIX(dci(0x78e04000), "ldsmaxalh"); // LDSMAXALH_32_memop
3460 COMPARE_PREFIX(dci(0x78e05000), "ldsminalh"); // LDSMINALH_32_memop
3461 COMPARE_PREFIX(dci(0x78e06000), "ldumaxalh"); // LDUMAXALH_32_memop
3462 COMPARE_PREFIX(dci(0x78e07000), "lduminalh"); // LDUMINALH_32_memop
3463 COMPARE_PREFIX(dci(0x78e08000), "swpalh"); // SWPALH_32_memop
3464 COMPARE_PREFIX(dci(0x88a07c00), "cas"); // CAS_C32_ldstexcl
3465 COMPARE_PREFIX(dci(0x88a0fc00), "casl"); // CASL_C32_ldstexcl
3466 COMPARE_PREFIX(dci(0x88e07c00), "casa"); // CASA_C32_ldstexcl
3467 COMPARE_PREFIX(dci(0x88e0fc00), "casal"); // CASAL_C32_ldstexcl
3468 COMPARE_PREFIX(dci(0xb8200000), "ldadd"); // LDADD_32_memop
3469 COMPARE_PREFIX(dci(0xb8201000), "ldclr"); // LDCLR_32_memop
3470 COMPARE_PREFIX(dci(0xb8202000), "ldeor"); // LDEOR_32_memop
3471 COMPARE_PREFIX(dci(0xb8203000), "ldset"); // LDSET_32_memop
3472 COMPARE_PREFIX(dci(0xb8204000), "ldsmax"); // LDSMAX_32_memop
3473 COMPARE_PREFIX(dci(0xb8205000), "ldsmin"); // LDSMIN_32_memop
3474 COMPARE_PREFIX(dci(0xb8206000), "ldumax"); // LDUMAX_32_memop
3475 COMPARE_PREFIX(dci(0xb8207000), "ldumin"); // LDUMIN_32_memop
3476 COMPARE_PREFIX(dci(0xb8208000), "swp"); // SWP_32_memop
3477 COMPARE_PREFIX(dci(0xb8600000), "ldaddl"); // LDADDL_32_memop
3478 COMPARE_PREFIX(dci(0xb8601000), "ldclrl"); // LDCLRL_32_memop
3479 COMPARE_PREFIX(dci(0xb8602000), "ldeorl"); // LDEORL_32_memop
3480 COMPARE_PREFIX(dci(0xb8603000), "ldsetl"); // LDSETL_32_memop
3481 COMPARE_PREFIX(dci(0xb8604000), "ldsmaxl"); // LDSMAXL_32_memop
3482 COMPARE_PREFIX(dci(0xb8605000), "ldsminl"); // LDSMINL_32_memop
3483 COMPARE_PREFIX(dci(0xb8606000), "ldumaxl"); // LDUMAXL_32_memop
3484 COMPARE_PREFIX(dci(0xb8607000), "lduminl"); // LDUMINL_32_memop
3485 COMPARE_PREFIX(dci(0xb8608000), "swpl"); // SWPL_32_memop
3486 COMPARE_PREFIX(dci(0xb8a00000), "ldadda"); // LDADDA_32_memop
3487 COMPARE_PREFIX(dci(0xb8a01000), "ldclra"); // LDCLRA_32_memop
3488 COMPARE_PREFIX(dci(0xb8a02000), "ldeora"); // LDEORA_32_memop
3489 COMPARE_PREFIX(dci(0xb8a03000), "ldseta"); // LDSETA_32_memop
3490 COMPARE_PREFIX(dci(0xb8a04000), "ldsmaxa"); // LDSMAXA_32_memop
3491 COMPARE_PREFIX(dci(0xb8a05000), "ldsmina"); // LDSMINA_32_memop
3492 COMPARE_PREFIX(dci(0xb8a06000), "ldumaxa"); // LDUMAXA_32_memop
3493 COMPARE_PREFIX(dci(0xb8a07000), "ldumina"); // LDUMINA_32_memop
3494 COMPARE_PREFIX(dci(0xb8a08000), "swpa"); // SWPA_32_memop
3495 COMPARE_PREFIX(dci(0xb8e00000), "ldaddal"); // LDADDAL_32_memop
3496 COMPARE_PREFIX(dci(0xb8e01000), "ldclral"); // LDCLRAL_32_memop
3497 COMPARE_PREFIX(dci(0xb8e02000), "ldeoral"); // LDEORAL_32_memop
3498 COMPARE_PREFIX(dci(0xb8e03000), "ldsetal"); // LDSETAL_32_memop
3499 COMPARE_PREFIX(dci(0xb8e04000), "ldsmaxal"); // LDSMAXAL_32_memop
3500 COMPARE_PREFIX(dci(0xb8e05000), "ldsminal"); // LDSMINAL_32_memop
3501 COMPARE_PREFIX(dci(0xb8e06000), "ldumaxal"); // LDUMAXAL_32_memop
3502 COMPARE_PREFIX(dci(0xb8e07000), "lduminal"); // LDUMINAL_32_memop
3503 COMPARE_PREFIX(dci(0xb8e08000), "swpal"); // SWPAL_32_memop
3504 COMPARE_PREFIX(dci(0xc8a07c00), "cas"); // CAS_C64_ldstexcl
3505 COMPARE_PREFIX(dci(0xc8a0fc00), "casl"); // CASL_C64_ldstexcl
3506 COMPARE_PREFIX(dci(0xc8e07c00), "casa"); // CASA_C64_ldstexcl
3507 COMPARE_PREFIX(dci(0xc8e0fc00), "casal"); // CASAL_C64_ldstexcl
3508 COMPARE_PREFIX(dci(0xf8200000), "ldadd"); // LDADD_64_memop
3509 COMPARE_PREFIX(dci(0xf8201000), "ldclr"); // LDCLR_64_memop
3510 COMPARE_PREFIX(dci(0xf8202000), "ldeor"); // LDEOR_64_memop
3511 COMPARE_PREFIX(dci(0xf8203000), "ldset"); // LDSET_64_memop
3512 COMPARE_PREFIX(dci(0xf8204000), "ldsmax"); // LDSMAX_64_memop
3513 COMPARE_PREFIX(dci(0xf8205000), "ldsmin"); // LDSMIN_64_memop
3514 COMPARE_PREFIX(dci(0xf8206000), "ldumax"); // LDUMAX_64_memop
3515 COMPARE_PREFIX(dci(0xf8207000), "ldumin"); // LDUMIN_64_memop
3516 COMPARE_PREFIX(dci(0xf8208000), "swp"); // SWP_64_memop
3517 COMPARE_PREFIX(dci(0xf8600000), "ldaddl"); // LDADDL_64_memop
3518 COMPARE_PREFIX(dci(0xf8601000), "ldclrl"); // LDCLRL_64_memop
3519 COMPARE_PREFIX(dci(0xf8602000), "ldeorl"); // LDEORL_64_memop
3520 COMPARE_PREFIX(dci(0xf8603000), "ldsetl"); // LDSETL_64_memop
3521 COMPARE_PREFIX(dci(0xf8604000), "ldsmaxl"); // LDSMAXL_64_memop
3522 COMPARE_PREFIX(dci(0xf8605000), "ldsminl"); // LDSMINL_64_memop
3523 COMPARE_PREFIX(dci(0xf8606000), "ldumaxl"); // LDUMAXL_64_memop
3524 COMPARE_PREFIX(dci(0xf8607000), "lduminl"); // LDUMINL_64_memop
3525 COMPARE_PREFIX(dci(0xf8608000), "swpl"); // SWPL_64_memop
3526 COMPARE_PREFIX(dci(0xf8a00000), "ldadda"); // LDADDA_64_memop
3527 COMPARE_PREFIX(dci(0xf8a01000), "ldclra"); // LDCLRA_64_memop
3528 COMPARE_PREFIX(dci(0xf8a02000), "ldeora"); // LDEORA_64_memop
3529 COMPARE_PREFIX(dci(0xf8a03000), "ldseta"); // LDSETA_64_memop
3530 COMPARE_PREFIX(dci(0xf8a04000), "ldsmaxa"); // LDSMAXA_64_memop
3531 COMPARE_PREFIX(dci(0xf8a05000), "ldsmina"); // LDSMINA_64_memop
3532 COMPARE_PREFIX(dci(0xf8a06000), "ldumaxa"); // LDUMAXA_64_memop
3533 COMPARE_PREFIX(dci(0xf8a07000), "ldumina"); // LDUMINA_64_memop
3534 COMPARE_PREFIX(dci(0xf8a08000), "swpa"); // SWPA_64_memop
3535 COMPARE_PREFIX(dci(0xf8e00000), "ldaddal"); // LDADDAL_64_memop
3536 COMPARE_PREFIX(dci(0xf8e01000), "ldclral"); // LDCLRAL_64_memop
3537 COMPARE_PREFIX(dci(0xf8e02000), "ldeoral"); // LDEORAL_64_memop
3538 COMPARE_PREFIX(dci(0xf8e03000), "ldsetal"); // LDSETAL_64_memop
3539 COMPARE_PREFIX(dci(0xf8e04000), "ldsmaxal"); // LDSMAXAL_64_memop
3540 COMPARE_PREFIX(dci(0xf8e05000), "ldsminal"); // LDSMINAL_64_memop
3541 COMPARE_PREFIX(dci(0xf8e06000), "ldumaxal"); // LDUMAXAL_64_memop
3542 COMPARE_PREFIX(dci(0xf8e07000), "lduminal"); // LDUMINAL_64_memop
3543 COMPARE_PREFIX(dci(0xf8e08000), "swpal"); // SWPAL_64_memop
3544
3545 // ARMv8.1 - RDM
3546 COMPARE_PREFIX(dci(0x2e008400), "sqrdmlah"); // SQRDMLAH_asimdsame2_only
3547 COMPARE_PREFIX(dci(0x2e008c00), "sqrdmlsh"); // SQRDMLSH_asimdsame2_only
3548 COMPARE_PREFIX(dci(0x2f40d000), "sqrdmlah"); // SQRDMLAH_asimdelem_R
3549 COMPARE_PREFIX(dci(0x2f40f000), "sqrdmlsh"); // SQRDMLSH_asimdelem_R
3550 COMPARE_PREFIX(dci(0x7e008400), "sqrdmlah"); // SQRDMLAH_asisdsame2_only
3551 COMPARE_PREFIX(dci(0x7e008c00), "sqrdmlsh"); // SQRDMLSH_asisdsame2_only
3552 COMPARE_PREFIX(dci(0x7f40d000), "sqrdmlah"); // SQRDMLAH_asisdelem_R
3553 COMPARE_PREFIX(dci(0x7f40f000), "sqrdmlsh"); // SQRDMLSH_asisdelem_R
3554
3555 // ARMv8.2 - DotProd
3556 COMPARE_PREFIX(dci(0x0e009400), "sdot"); // SDOT_asimdsame2_D
3557 COMPARE_PREFIX(dci(0x0f00e000), "sdot"); // SDOT_asimdelem_D
3558 COMPARE_PREFIX(dci(0x2e009400), "udot"); // UDOT_asimdsame2_D
3559 COMPARE_PREFIX(dci(0x2f00e000), "udot"); // UDOT_asimdelem_D
3560
3561 // ARMv8.2 - FHM
3562 COMPARE_PREFIX(dci(0x0e20ec00), "fmlal"); // FMLAL_asimdsame_F
3563 COMPARE_PREFIX(dci(0x0ea0ec00), "fmlsl"); // FMLSL_asimdsame_F
3564 COMPARE_PREFIX(dci(0x0f800000), "fmlal"); // FMLAL_asimdelem_LH
3565 COMPARE_PREFIX(dci(0x0f804000), "fmlsl"); // FMLSL_asimdelem_LH
3566 COMPARE_PREFIX(dci(0x2e20cc00), "fmlal2"); // FMLAL2_asimdsame_F
3567 COMPARE_PREFIX(dci(0x2ea0cc00), "fmlsl2"); // FMLSL2_asimdsame_F
3568 COMPARE_PREFIX(dci(0x2f808000), "fmlal2"); // FMLAL2_asimdelem_LH
3569 COMPARE_PREFIX(dci(0x2f80c000), "fmlsl2"); // FMLSL2_asimdelem_LH
3570
3571 // ARMv8.2 - FP16
3572 COMPARE_PREFIX(dci(0x0e20c400), "fmaxnm"); // FMAXNM_asimdsame_only
3573 COMPARE_PREFIX(dci(0x0e20cc00), "fmla"); // FMLA_asimdsame_only
3574 COMPARE_PREFIX(dci(0x0e20d400), "fadd"); // FADD_asimdsame_only
3575 COMPARE_PREFIX(dci(0x0e20dc00), "fmulx"); // FMULX_asimdsame_only
3576 COMPARE_PREFIX(dci(0x0e20e400), "fcmeq"); // FCMEQ_asimdsame_only
3577 COMPARE_PREFIX(dci(0x0e20f400), "fmax"); // FMAX_asimdsame_only
3578 COMPARE_PREFIX(dci(0x0e20fc00), "frecps"); // FRECPS_asimdsame_only
3579 COMPARE_PREFIX(dci(0x0e218800), "frintn"); // FRINTN_asimdmisc_R
3580 COMPARE_PREFIX(dci(0x0e219800), "frintm"); // FRINTM_asimdmisc_R
3581 COMPARE_PREFIX(dci(0x0e21a800), "fcvtns"); // FCVTNS_asimdmisc_R
3582 COMPARE_PREFIX(dci(0x0e21b800), "fcvtms"); // FCVTMS_asimdmisc_R
3583 COMPARE_PREFIX(dci(0x0e21c800), "fcvtas"); // FCVTAS_asimdmisc_R
3584 COMPARE_PREFIX(dci(0x0e21d800), "scvtf"); // SCVTF_asimdmisc_R
3585 COMPARE_PREFIX(dci(0x0e30c800), "fmaxnmv"); // FMAXNMV_asimdall_only_H
3586 COMPARE_PREFIX(dci(0x0e30f800), "fmaxv"); // FMAXV_asimdall_only_H
3587 COMPARE_PREFIX(dci(0x0e400400), "fmaxnm"); // FMAXNM_asimdsamefp16_only
3588 COMPARE_PREFIX(dci(0x0e400c00), "fmla"); // FMLA_asimdsamefp16_only
3589 COMPARE_PREFIX(dci(0x0e401400), "fadd"); // FADD_asimdsamefp16_only
3590 COMPARE_PREFIX(dci(0x0e401c00), "fmulx"); // FMULX_asimdsamefp16_only
3591 COMPARE_PREFIX(dci(0x0e402400), "fcmeq"); // FCMEQ_asimdsamefp16_only
3592 COMPARE_PREFIX(dci(0x0e403400), "fmax"); // FMAX_asimdsamefp16_only
3593 COMPARE_PREFIX(dci(0x0e403c00), "frecps"); // FRECPS_asimdsamefp16_only
3594 COMPARE_PREFIX(dci(0x0e798800), "frintn"); // FRINTN_asimdmiscfp16_R
3595 COMPARE_PREFIX(dci(0x0e799800), "frintm"); // FRINTM_asimdmiscfp16_R
3596 COMPARE_PREFIX(dci(0x0e79a800), "fcvtns"); // FCVTNS_asimdmiscfp16_R
3597 COMPARE_PREFIX(dci(0x0e79b800), "fcvtms"); // FCVTMS_asimdmiscfp16_R
3598 COMPARE_PREFIX(dci(0x0e79c800), "fcvtas"); // FCVTAS_asimdmiscfp16_R
3599 COMPARE_PREFIX(dci(0x0e79d800), "scvtf"); // SCVTF_asimdmiscfp16_R
3600 COMPARE_PREFIX(dci(0x0ea0c400), "fminnm"); // FMINNM_asimdsame_only
3601 COMPARE_PREFIX(dci(0x0ea0cc00), "fmls"); // FMLS_asimdsame_only
3602 COMPARE_PREFIX(dci(0x0ea0d400), "fsub"); // FSUB_asimdsame_only
3603 COMPARE_PREFIX(dci(0x0ea0f400), "fmin"); // FMIN_asimdsame_only
3604 COMPARE_PREFIX(dci(0x0ea0fc00), "frsqrts"); // FRSQRTS_asimdsame_only
3605 COMPARE_PREFIX(dci(0x0ea0c800), "fcmgt"); // FCMGT_asimdmisc_FZ
3606 COMPARE_PREFIX(dci(0x0ea0d800), "fcmeq"); // FCMEQ_asimdmisc_FZ
3607 COMPARE_PREFIX(dci(0x0ea0e800), "fcmlt"); // FCMLT_asimdmisc_FZ
3608 COMPARE_PREFIX(dci(0x0ea0f800), "fabs"); // FABS_asimdmisc_R
3609 COMPARE_PREFIX(dci(0x0ea18800), "frintp"); // FRINTP_asimdmisc_R
3610 COMPARE_PREFIX(dci(0x0ea19800), "frintz"); // FRINTZ_asimdmisc_R
3611 COMPARE_PREFIX(dci(0x0ea1a800), "fcvtps"); // FCVTPS_asimdmisc_R
3612 COMPARE_PREFIX(dci(0x0ea1b800), "fcvtzs"); // FCVTZS_asimdmisc_R
3613 COMPARE_PREFIX(dci(0x0ea1d800), "frecpe"); // FRECPE_asimdmisc_R
3614 COMPARE_PREFIX(dci(0x0eb0c800), "fminnmv"); // FMINNMV_asimdall_only_H
3615 COMPARE_PREFIX(dci(0x0eb0f800), "fminv"); // FMINV_asimdall_only_H
3616 COMPARE_PREFIX(dci(0x0ec00400), "fminnm"); // FMINNM_asimdsamefp16_only
3617 COMPARE_PREFIX(dci(0x0ec00c00), "fmls"); // FMLS_asimdsamefp16_only
3618 COMPARE_PREFIX(dci(0x0ec01400), "fsub"); // FSUB_asimdsamefp16_only
3619 COMPARE_PREFIX(dci(0x0ec03400), "fmin"); // FMIN_asimdsamefp16_only
3620 COMPARE_PREFIX(dci(0x0ec03c00), "frsqrts"); // FRSQRTS_asimdsamefp16_only
3621 COMPARE_PREFIX(dci(0x0ef8c800), "fcmgt"); // FCMGT_asimdmiscfp16_FZ
3622 COMPARE_PREFIX(dci(0x0ef8d800), "fcmeq"); // FCMEQ_asimdmiscfp16_FZ
3623 COMPARE_PREFIX(dci(0x0ef8e800), "fcmlt"); // FCMLT_asimdmiscfp16_FZ
3624 COMPARE_PREFIX(dci(0x0ef8f800), "fabs"); // FABS_asimdmiscfp16_R
3625 COMPARE_PREFIX(dci(0x0ef98800), "frintp"); // FRINTP_asimdmiscfp16_R
3626 COMPARE_PREFIX(dci(0x0ef99800), "frintz"); // FRINTZ_asimdmiscfp16_R
3627 COMPARE_PREFIX(dci(0x0ef9a800), "fcvtps"); // FCVTPS_asimdmiscfp16_R
3628 COMPARE_PREFIX(dci(0x0ef9b800), "fcvtzs"); // FCVTZS_asimdmiscfp16_R
3629 COMPARE_PREFIX(dci(0x0ef9d800), "frecpe"); // FRECPE_asimdmiscfp16_R
3630 COMPARE_PREFIX(dci(0x0f001000), "fmla"); // FMLA_asimdelem_RH_H
3631 COMPARE_PREFIX(dci(0x0f005000), "fmls"); // FMLS_asimdelem_RH_H
3632 COMPARE_PREFIX(dci(0x0f009000), "fmul"); // FMUL_asimdelem_RH_H
3633 COMPARE_PREFIX(dci(0x0f00f400), "fmov"); // FMOV_asimdimm_S_s
3634 COMPARE_PREFIX(dci(0x0f00fc00), "fmov"); // FMOV_asimdimm_H_h
3635 COMPARE_PREFIX(dci(0x0f801000), "fmla"); // FMLA_asimdelem_R_SD
3636 COMPARE_PREFIX(dci(0x0f805000), "fmls"); // FMLS_asimdelem_R_SD
3637 COMPARE_PREFIX(dci(0x0f809000), "fmul"); // FMUL_asimdelem_R_SD
3638 COMPARE_PREFIX(dci(0x2e20c400), "fmaxnmp"); // FMAXNMP_asimdsame_only
3639 COMPARE_PREFIX(dci(0x2e20d400), "faddp"); // FADDP_asimdsame_only
3640 COMPARE_PREFIX(dci(0x2e20dc00), "fmul"); // FMUL_asimdsame_only
3641 COMPARE_PREFIX(dci(0x2e20e400), "fcmge"); // FCMGE_asimdsame_only
3642 COMPARE_PREFIX(dci(0x2e20ec00), "facge"); // FACGE_asimdsame_only
3643 COMPARE_PREFIX(dci(0x2e20f400), "fmaxp"); // FMAXP_asimdsame_only
3644 COMPARE_PREFIX(dci(0x2e20fc00), "fdiv"); // FDIV_asimdsame_only
3645 COMPARE_PREFIX(dci(0x2e218800), "frinta"); // FRINTA_asimdmisc_R
3646 COMPARE_PREFIX(dci(0x2e219800), "frintx"); // FRINTX_asimdmisc_R
3647 COMPARE_PREFIX(dci(0x2e21a800), "fcvtnu"); // FCVTNU_asimdmisc_R
3648 COMPARE_PREFIX(dci(0x2e21b800), "fcvtmu"); // FCVTMU_asimdmisc_R
3649 COMPARE_PREFIX(dci(0x2e21c800), "fcvtau"); // FCVTAU_asimdmisc_R
3650 COMPARE_PREFIX(dci(0x2e21d800), "ucvtf"); // UCVTF_asimdmisc_R
3651 COMPARE_PREFIX(dci(0x6e30c800), "fmaxnmv"); // FMAXNMV_asimdall_only_SD
3652 COMPARE_PREFIX(dci(0x6e30f800), "fmaxv"); // FMAXV_asimdall_only_SD
3653 COMPARE_PREFIX(dci(0x2e400400), "fmaxnmp"); // FMAXNMP_asimdsamefp16_only
3654 COMPARE_PREFIX(dci(0x2e401400), "faddp"); // FADDP_asimdsamefp16_only
3655 COMPARE_PREFIX(dci(0x2e401c00), "fmul"); // FMUL_asimdsamefp16_only
3656 COMPARE_PREFIX(dci(0x2e402400), "fcmge"); // FCMGE_asimdsamefp16_only
3657 COMPARE_PREFIX(dci(0x2e402c00), "facge"); // FACGE_asimdsamefp16_only
3658 COMPARE_PREFIX(dci(0x2e403400), "fmaxp"); // FMAXP_asimdsamefp16_only
3659 COMPARE_PREFIX(dci(0x2e403c00), "fdiv"); // FDIV_asimdsamefp16_only
3660 COMPARE_PREFIX(dci(0x2e798800), "frinta"); // FRINTA_asimdmiscfp16_R
3661 COMPARE_PREFIX(dci(0x2e799800), "frintx"); // FRINTX_asimdmiscfp16_R
3662 COMPARE_PREFIX(dci(0x2e79a800), "fcvtnu"); // FCVTNU_asimdmiscfp16_R
3663 COMPARE_PREFIX(dci(0x2e79b800), "fcvtmu"); // FCVTMU_asimdmiscfp16_R
3664 COMPARE_PREFIX(dci(0x2e79c800), "fcvtau"); // FCVTAU_asimdmiscfp16_R
3665 COMPARE_PREFIX(dci(0x2e79d800), "ucvtf"); // UCVTF_asimdmiscfp16_R
3666 COMPARE_PREFIX(dci(0x2ea0c400), "fminnmp"); // FMINNMP_asimdsame_only
3667 COMPARE_PREFIX(dci(0x2ea0d400), "fabd"); // FABD_asimdsame_only
3668 COMPARE_PREFIX(dci(0x2ea0e400), "fcmgt"); // FCMGT_asimdsame_only
3669 COMPARE_PREFIX(dci(0x2ea0ec00), "facgt"); // FACGT_asimdsame_only
3670 COMPARE_PREFIX(dci(0x2ea0f400), "fminp"); // FMINP_asimdsame_only
3671 COMPARE_PREFIX(dci(0x2ea0c800), "fcmge"); // FCMGE_asimdmisc_FZ
3672 COMPARE_PREFIX(dci(0x2ea0d800), "fcmle"); // FCMLE_asimdmisc_FZ
3673 COMPARE_PREFIX(dci(0x2ea0f800), "fneg"); // FNEG_asimdmisc_R
3674 COMPARE_PREFIX(dci(0x2ea19800), "frinti"); // FRINTI_asimdmisc_R
3675 COMPARE_PREFIX(dci(0x2ea1a800), "fcvtpu"); // FCVTPU_asimdmisc_R
3676 COMPARE_PREFIX(dci(0x2ea1b800), "fcvtzu"); // FCVTZU_asimdmisc_R
3677 COMPARE_PREFIX(dci(0x2ea1d800), "frsqrte"); // FRSQRTE_asimdmisc_R
3678 COMPARE_PREFIX(dci(0x2ea1f800), "fsqrt"); // FSQRT_asimdmisc_R
3679 COMPARE_PREFIX(dci(0x6eb0c800), "fminnmv"); // FMINNMV_asimdall_only_SD
3680 COMPARE_PREFIX(dci(0x6eb0f800), "fminv"); // FMINV_asimdall_only_SD
3681 COMPARE_PREFIX(dci(0x2ec00400), "fminnmp"); // FMINNMP_asimdsamefp16_only
3682 COMPARE_PREFIX(dci(0x2ec01400), "fabd"); // FABD_asimdsamefp16_only
3683 COMPARE_PREFIX(dci(0x2ec02400), "fcmgt"); // FCMGT_asimdsamefp16_only
3684 COMPARE_PREFIX(dci(0x2ec02c00), "facgt"); // FACGT_asimdsamefp16_only
3685 COMPARE_PREFIX(dci(0x2ec03400), "fminp"); // FMINP_asimdsamefp16_only
3686 COMPARE_PREFIX(dci(0x2ef8c800), "fcmge"); // FCMGE_asimdmiscfp16_FZ
3687 COMPARE_PREFIX(dci(0x2ef8d800), "fcmle"); // FCMLE_asimdmiscfp16_FZ
3688 COMPARE_PREFIX(dci(0x2ef8f800), "fneg"); // FNEG_asimdmiscfp16_R
3689 COMPARE_PREFIX(dci(0x2ef99800), "frinti"); // FRINTI_asimdmiscfp16_R
3690 COMPARE_PREFIX(dci(0x2ef9a800), "fcvtpu"); // FCVTPU_asimdmiscfp16_R
3691 COMPARE_PREFIX(dci(0x2ef9b800), "fcvtzu"); // FCVTZU_asimdmiscfp16_R
3692 COMPARE_PREFIX(dci(0x2ef9d800), "frsqrte"); // FRSQRTE_asimdmiscfp16_R
3693 COMPARE_PREFIX(dci(0x2ef9f800), "fsqrt"); // FSQRT_asimdmiscfp16_R
3694 COMPARE_PREFIX(dci(0x2f009000), "fmulx"); // FMULX_asimdelem_RH_H
3695 COMPARE_PREFIX(dci(0x2f809000), "fmulx"); // FMULX_asimdelem_R_SD
3696 COMPARE_PREFIX(dci(0x5e20dc00), "fmulx"); // FMULX_asisdsame_only
3697 COMPARE_PREFIX(dci(0x5e20e400), "fcmeq"); // FCMEQ_asisdsame_only
3698 COMPARE_PREFIX(dci(0x5e20fc00), "frecps"); // FRECPS_asisdsame_only
3699 COMPARE_PREFIX(dci(0x5e21a800), "fcvtns"); // FCVTNS_asisdmisc_R
3700 COMPARE_PREFIX(dci(0x5e21b800), "fcvtms"); // FCVTMS_asisdmisc_R
3701 COMPARE_PREFIX(dci(0x5e21c800), "fcvtas"); // FCVTAS_asisdmisc_R
3702 COMPARE_PREFIX(dci(0x5e21d800), "scvtf"); // SCVTF_asisdmisc_R
3703 COMPARE_PREFIX(dci(0x5e30c800), "fmaxnmp"); // FMAXNMP_asisdpair_only_H
3704 COMPARE_PREFIX(dci(0x5e30d800), "faddp"); // FADDP_asisdpair_only_H
3705 COMPARE_PREFIX(dci(0x5e30f800), "fmaxp"); // FMAXP_asisdpair_only_H
3706 COMPARE_PREFIX(dci(0x5e401c00), "fmulx"); // FMULX_asisdsamefp16_only
3707 COMPARE_PREFIX(dci(0x5e402400), "fcmeq"); // FCMEQ_asisdsamefp16_only
3708 COMPARE_PREFIX(dci(0x5e403c00), "frecps"); // FRECPS_asisdsamefp16_only
3709 COMPARE_PREFIX(dci(0x5e79a800), "fcvtns"); // FCVTNS_asisdmiscfp16_R
3710 COMPARE_PREFIX(dci(0x5e79b800), "fcvtms"); // FCVTMS_asisdmiscfp16_R
3711 COMPARE_PREFIX(dci(0x5e79c800), "fcvtas"); // FCVTAS_asisdmiscfp16_R
3712 COMPARE_PREFIX(dci(0x5e79d800), "scvtf"); // SCVTF_asisdmiscfp16_R
3713 COMPARE_PREFIX(dci(0x5ea0fc00), "frsqrts"); // FRSQRTS_asisdsame_only
3714 COMPARE_PREFIX(dci(0x5ea0c800), "fcmgt"); // FCMGT_asisdmisc_FZ
3715 COMPARE_PREFIX(dci(0x5ea0d800), "fcmeq"); // FCMEQ_asisdmisc_FZ
3716 COMPARE_PREFIX(dci(0x5ea0e800), "fcmlt"); // FCMLT_asisdmisc_FZ
3717 COMPARE_PREFIX(dci(0x5ea1a800), "fcvtps"); // FCVTPS_asisdmisc_R
3718 COMPARE_PREFIX(dci(0x5ea1b800), "fcvtzs"); // FCVTZS_asisdmisc_R
3719 COMPARE_PREFIX(dci(0x5ea1d800), "frecpe"); // FRECPE_asisdmisc_R
3720 COMPARE_PREFIX(dci(0x5ea1f800), "frecpx"); // FRECPX_asisdmisc_R
3721 COMPARE_PREFIX(dci(0x5eb0c800), "fminnmp"); // FMINNMP_asisdpair_only_H
3722 COMPARE_PREFIX(dci(0x5eb0f800), "fminp"); // FMINP_asisdpair_only_H
3723 COMPARE_PREFIX(dci(0x5ec03c00), "frsqrts"); // FRSQRTS_asisdsamefp16_only
3724 COMPARE_PREFIX(dci(0x5ef8c800), "fcmgt"); // FCMGT_asisdmiscfp16_FZ
3725 COMPARE_PREFIX(dci(0x5ef8d800), "fcmeq"); // FCMEQ_asisdmiscfp16_FZ
3726 COMPARE_PREFIX(dci(0x5ef8e800), "fcmlt"); // FCMLT_asisdmiscfp16_FZ
3727 COMPARE_PREFIX(dci(0x5ef9a800), "fcvtps"); // FCVTPS_asisdmiscfp16_R
3728 COMPARE_PREFIX(dci(0x5ef9b800), "fcvtzs"); // FCVTZS_asisdmiscfp16_R
3729 COMPARE_PREFIX(dci(0x5ef9d800), "frecpe"); // FRECPE_asisdmiscfp16_R
3730 COMPARE_PREFIX(dci(0x5ef9f800), "frecpx"); // FRECPX_asisdmiscfp16_R
3731 COMPARE_PREFIX(dci(0x5f001000), "fmla"); // FMLA_asisdelem_RH_H
3732 COMPARE_PREFIX(dci(0x5f005000), "fmls"); // FMLS_asisdelem_RH_H
3733 COMPARE_PREFIX(dci(0x5f009000), "fmul"); // FMUL_asisdelem_RH_H
3734 COMPARE_PREFIX(dci(0x5f801000), "fmla"); // FMLA_asisdelem_R_SD
3735 COMPARE_PREFIX(dci(0x5f805000), "fmls"); // FMLS_asisdelem_R_SD
3736 COMPARE_PREFIX(dci(0x5f809000), "fmul"); // FMUL_asisdelem_R_SD
3737 COMPARE_PREFIX(dci(0x6f00f400), "fmov"); // FMOV_asimdimm_D2_d
3738 COMPARE_PREFIX(dci(0x7e20e400), "fcmge"); // FCMGE_asisdsame_only
3739 COMPARE_PREFIX(dci(0x7e20ec00), "facge"); // FACGE_asisdsame_only
3740 COMPARE_PREFIX(dci(0x7e21a800), "fcvtnu"); // FCVTNU_asisdmisc_R
3741 COMPARE_PREFIX(dci(0x7e21b800), "fcvtmu"); // FCVTMU_asisdmisc_R
3742 COMPARE_PREFIX(dci(0x7e21c800), "fcvtau"); // FCVTAU_asisdmisc_R
3743 COMPARE_PREFIX(dci(0x7e21d800), "ucvtf"); // UCVTF_asisdmisc_R
3744 COMPARE_PREFIX(dci(0x7e30c800), "fmaxnmp"); // FMAXNMP_asisdpair_only_SD
3745 COMPARE_PREFIX(dci(0x7e30d800), "faddp"); // FADDP_asisdpair_only_SD
3746 COMPARE_PREFIX(dci(0x7e30f800), "fmaxp"); // FMAXP_asisdpair_only_SD
3747 COMPARE_PREFIX(dci(0x7e402400), "fcmge"); // FCMGE_asisdsamefp16_only
3748 COMPARE_PREFIX(dci(0x7e402c00), "facge"); // FACGE_asisdsamefp16_only
3749 COMPARE_PREFIX(dci(0x7e79a800), "fcvtnu"); // FCVTNU_asisdmiscfp16_R
3750 COMPARE_PREFIX(dci(0x7e79b800), "fcvtmu"); // FCVTMU_asisdmiscfp16_R
3751 COMPARE_PREFIX(dci(0x7e79c800), "fcvtau"); // FCVTAU_asisdmiscfp16_R
3752 COMPARE_PREFIX(dci(0x7e79d800), "ucvtf"); // UCVTF_asisdmiscfp16_R
3753 COMPARE_PREFIX(dci(0x7ea0d400), "fabd"); // FABD_asisdsame_only
3754 COMPARE_PREFIX(dci(0x7ea0e400), "fcmgt"); // FCMGT_asisdsame_only
3755 COMPARE_PREFIX(dci(0x7ea0ec00), "facgt"); // FACGT_asisdsame_only
3756 COMPARE_PREFIX(dci(0x7ea0c800), "fcmge"); // FCMGE_asisdmisc_FZ
3757 COMPARE_PREFIX(dci(0x7ea0d800), "fcmle"); // FCMLE_asisdmisc_FZ
3758 COMPARE_PREFIX(dci(0x7ea1a800), "fcvtpu"); // FCVTPU_asisdmisc_R
3759 COMPARE_PREFIX(dci(0x7ea1b800), "fcvtzu"); // FCVTZU_asisdmisc_R
3760 COMPARE_PREFIX(dci(0x7ea1d800), "frsqrte"); // FRSQRTE_asisdmisc_R
3761 COMPARE_PREFIX(dci(0x7eb0c800), "fminnmp"); // FMINNMP_asisdpair_only_SD
3762 COMPARE_PREFIX(dci(0x7eb0f800), "fminp"); // FMINP_asisdpair_only_SD
3763 COMPARE_PREFIX(dci(0x7ec01400), "fabd"); // FABD_asisdsamefp16_only
3764 COMPARE_PREFIX(dci(0x7ec02400), "fcmgt"); // FCMGT_asisdsamefp16_only
3765 COMPARE_PREFIX(dci(0x7ec02c00), "facgt"); // FACGT_asisdsamefp16_only
3766 COMPARE_PREFIX(dci(0x7ef8c800), "fcmge"); // FCMGE_asisdmiscfp16_FZ
3767 COMPARE_PREFIX(dci(0x7ef8d800), "fcmle"); // FCMLE_asisdmiscfp16_FZ
3768 COMPARE_PREFIX(dci(0x7ef9a800), "fcvtpu"); // FCVTPU_asisdmiscfp16_R
3769 COMPARE_PREFIX(dci(0x7ef9b800), "fcvtzu"); // FCVTZU_asisdmiscfp16_R
3770 COMPARE_PREFIX(dci(0x7ef9d800), "frsqrte"); // FRSQRTE_asisdmiscfp16_R
3771 COMPARE_PREFIX(dci(0x7f009000), "fmulx"); // FMULX_asisdelem_RH_H
3772 COMPARE_PREFIX(dci(0x7f809000), "fmulx"); // FMULX_asisdelem_R_SD
3773
3774 // ARMv8.2 - RAS
3775 COMPARE_PREFIX(dci(0xd503221f), "esb"); // ESB_HI_hints
3776
3777 // ARMv8.2 - SHA3
3778 // COMPARE_PREFIX(dci(0xce000000), "eor3"); // EOR3_VVV16_crypto4
3779 // COMPARE_PREFIX(dci(0xce200000), "bcax"); // BCAX_VVV16_crypto4
3780 // COMPARE_PREFIX(dci(0xce608c00), "rax1"); // RAX1_VVV2_cryptosha512_3
3781 // COMPARE_PREFIX(dci(0xce800000), "xar"); // XAR_VVV2_crypto3_imm6
3782
3783 // ARMv8.2 - SHA512
3784 // COMPARE_PREFIX(dci(0xce608000), "sha512h"); // SHA512H_QQV_cryptosha512_3
3785 // COMPARE_PREFIX(dci(0xce608400), "sha512h2"); //
3786 // SHA512H2_QQV_cryptosha512_3
3787 // COMPARE_PREFIX(dci(0xce608800), "sha512su1"); //
3788 // SHA512SU1_VVV2_cryptosha512_3
3789 // COMPARE_PREFIX(dci(0xcec08000), "sha512su0"); //
3790 // SHA512SU0_VV2_cryptosha512_2
3791
3792 // ARMv8.2 - SM3
3793 // COMPARE_PREFIX(dci(0xce400000), "sm3ss1"); // SM3SS1_VVV4_crypto4
3794 // COMPARE_PREFIX(dci(0xce408000), "sm3tt1a"); // SM3TT1A_VVV4_crypto3_imm2
3795 // COMPARE_PREFIX(dci(0xce408400), "sm3tt1b"); // SM3TT1B_VVV4_crypto3_imm2
3796 // COMPARE_PREFIX(dci(0xce408800), "sm3tt2a"); // SM3TT2A_VVV4_crypto3_imm2
3797 // COMPARE_PREFIX(dci(0xce408c00), "sm3tt2b"); // SM3TT2B_VVV_crypto3_imm2
3798 // COMPARE_PREFIX(dci(0xce60c000), "sm3partw1"); //
3799 // SM3PARTW1_VVV4_cryptosha512_3
3800 // COMPARE_PREFIX(dci(0xce60c400), "sm3partw2"); //
3801 // SM3PARTW2_VVV4_cryptosha512_3
3802
3803 // ARMv8.2 - SM4
3804 // COMPARE_PREFIX(dci(0xce60c800), "sm4ekey"); //
3805 // SM4EKEY_VVV4_cryptosha512_3
3806 // COMPARE_PREFIX(dci(0xcec08400), "sm4e"); // SM4E_VV4_cryptosha512_2
3807
3808 // ARMv8.2 - SPE
3809 // COMPARE_PREFIX(dci(0xd503223f), "psb"); // PSB_HC_hints
3810
3811 // ARMv8.3 - FCMA
3812 COMPARE_PREFIX(dci(0x2e40c400), "fcmla"); // FCMLA_asimdsame2_C
3813 COMPARE_PREFIX(dci(0x2e00e400), "fcadd"); // FCADD_asimdsame2_C
3814 COMPARE_PREFIX(dci(0x2f401000), "fcmla"); // FCMLA_asimdelem_C_H
3815 COMPARE_PREFIX(dci(0x6f801000), "fcmla"); // FCMLA_asimdelem_C_S
3816
3817 // ARMv8.3 - JSCVT
3818 COMPARE_PREFIX(dci(0x1e7e0000), "fjcvtzs"); // FJCVTZS_32D_float2int
3819
3820 // ARMv8.3 - LRCPC
3821 COMPARE_PREFIX(dci(0x38bfc000), "ldaprb"); // LDAPRB_32L_memop
3822 COMPARE_PREFIX(dci(0x78bfc000), "ldaprh"); // LDAPRH_32L_memop
3823 COMPARE_PREFIX(dci(0xb8bfc000), "ldapr"); // LDAPR_32L_memop
3824 COMPARE_PREFIX(dci(0xf8bfc000), "ldapr"); // LDAPR_64L_memop
3825
3826 // ARMv8.3 - PAuth
3827 COMPARE_PREFIX(dci(0x9ac03000), "pacga"); // PACGA_64P_dp_2src
3828 COMPARE_PREFIX(dci(0xd50320ff), "xpaclri"); // XPACLRI_HI_hints
3829 COMPARE_PREFIX(dci(0xd503211f), "pacia1716"); // PACIA1716_HI_hints
3830 COMPARE_PREFIX(dci(0xd503215f), "pacib1716"); // PACIB1716_HI_hints
3831 COMPARE_PREFIX(dci(0xd503219f), "autia1716"); // AUTIA1716_HI_hints
3832 COMPARE_PREFIX(dci(0xd50321df), "autib1716"); // AUTIB1716_HI_hints
3833 COMPARE_PREFIX(dci(0xd503231f), "paciaz"); // PACIAZ_HI_hints
3834 COMPARE_PREFIX(dci(0xd503233f), "paciasp"); // PACIASP_HI_hints
3835 COMPARE_PREFIX(dci(0xd503235f), "pacibz"); // PACIBZ_HI_hints
3836 COMPARE_PREFIX(dci(0xd503237f), "pacibsp"); // PACIBSP_HI_hints
3837 COMPARE_PREFIX(dci(0xd503239f), "autiaz"); // AUTIAZ_HI_hints
3838 COMPARE_PREFIX(dci(0xd50323bf), "autiasp"); // AUTIASP_HI_hints
3839 COMPARE_PREFIX(dci(0xd50323df), "autibz"); // AUTIBZ_HI_hints
3840 COMPARE_PREFIX(dci(0xd50323ff), "autibsp"); // AUTIBSP_HI_hints
3841 COMPARE_PREFIX(dci(0xd61f081f), "braaz"); // BRAAZ_64_branch_reg
3842 COMPARE_PREFIX(dci(0xd61f0c1f), "brabz"); // BRABZ_64_branch_reg
3843 COMPARE_PREFIX(dci(0xd63f081f), "blraaz"); // BLRAAZ_64_branch_reg
3844 COMPARE_PREFIX(dci(0xd63f0c1f), "blrabz"); // BLRABZ_64_branch_reg
3845 COMPARE_PREFIX(dci(0xd65f0bff), "retaa"); // RETAA_64E_branch_reg
3846 COMPARE_PREFIX(dci(0xd65f0fff), "retab"); // RETAB_64E_branch_reg
3847 // COMPARE_PREFIX(dci(0xd69f0bff), "eretaa"); // ERETAA_64E_branch_reg
3848 // COMPARE_PREFIX(dci(0xd69f0fff), "eretab"); // ERETAB_64E_branch_reg
3849 COMPARE_PREFIX(dci(0xd71f0800), "braa"); // BRAA_64P_branch_reg
3850 COMPARE_PREFIX(dci(0xd71f0c00), "brab"); // BRAB_64P_branch_reg
3851 COMPARE_PREFIX(dci(0xd73f0800), "blraa"); // BLRAA_64P_branch_reg
3852 COMPARE_PREFIX(dci(0xd73f0c00), "blrab"); // BLRAB_64P_branch_reg
3853 COMPARE_PREFIX(dci(0xdac10000), "pacia"); // PACIA_64P_dp_1src
3854 COMPARE_PREFIX(dci(0xdac10400), "pacib"); // PACIB_64P_dp_1src
3855 COMPARE_PREFIX(dci(0xdac10800), "pacda"); // PACDA_64P_dp_1src
3856 COMPARE_PREFIX(dci(0xdac10c00), "pacdb"); // PACDB_64P_dp_1src
3857 COMPARE_PREFIX(dci(0xdac11000), "autia"); // AUTIA_64P_dp_1src
3858 COMPARE_PREFIX(dci(0xdac11400), "autib"); // AUTIB_64P_dp_1src
3859 COMPARE_PREFIX(dci(0xdac11800), "autda"); // AUTDA_64P_dp_1src
3860 COMPARE_PREFIX(dci(0xdac11c00), "autdb"); // AUTDB_64P_dp_1src
3861 COMPARE_PREFIX(dci(0xdac123e0), "paciza"); // PACIZA_64Z_dp_1src
3862 COMPARE_PREFIX(dci(0xdac127e0), "pacizb"); // PACIZB_64Z_dp_1src
3863 COMPARE_PREFIX(dci(0xdac12be0), "pacdza"); // PACDZA_64Z_dp_1src
3864 COMPARE_PREFIX(dci(0xdac12fe0), "pacdzb"); // PACDZB_64Z_dp_1src
3865 COMPARE_PREFIX(dci(0xdac133e0), "autiza"); // AUTIZA_64Z_dp_1src
3866 COMPARE_PREFIX(dci(0xdac137e0), "autizb"); // AUTIZB_64Z_dp_1src
3867 COMPARE_PREFIX(dci(0xdac13be0), "autdza"); // AUTDZA_64Z_dp_1src
3868 COMPARE_PREFIX(dci(0xdac13fe0), "autdzb"); // AUTDZB_64Z_dp_1src
3869 COMPARE_PREFIX(dci(0xdac143e0), "xpaci"); // XPACI_64Z_dp_1src
3870 COMPARE_PREFIX(dci(0xdac147e0), "xpacd"); // XPACD_64Z_dp_1src
3871 COMPARE_PREFIX(dci(0xf8200400), "ldraa"); // LDRAA_64_ldst_pac
3872 COMPARE_PREFIX(dci(0xf8200c00), "ldraa"); // LDRAA_64W_ldst_pac
3873 COMPARE_PREFIX(dci(0xf8a00400), "ldrab"); // LDRAB_64_ldst_pac
3874 COMPARE_PREFIX(dci(0xf8a00c00), "ldrab"); // LDRAB_64W_ldst_pac
3875
3876 // ARMv8.4 - FlagM
3877 COMPARE_PREFIX(dci(0x3a00080d), "setf8"); // SETF8_only_setf
3878 COMPARE_PREFIX(dci(0x3a00480d), "setf16"); // SETF16_only_setf
3879 COMPARE_PREFIX(dci(0xba000400), "rmif"); // RMIF_only_rmif
3880 COMPARE_PREFIX(dci(0xd500401f), "cfinv"); // CFINV_M_pstate
3881
3882 // ARMv8.4 - LRCPC2
3883 COMPARE_PREFIX(dci(0x19000000), "stlurb"); // STLURB_32_ldapstl_unscaled
3884 COMPARE_PREFIX(dci(0x19400000), "ldapurb"); // LDAPURB_32_ldapstl_unscaled
3885 COMPARE_PREFIX(dci(0x19800000), "ldapursb"); // LDAPURSB_64_ldapstl_unscaled
3886 COMPARE_PREFIX(dci(0x19c00000), "ldapursb"); // LDAPURSB_32_ldapstl_unscaled
3887 COMPARE_PREFIX(dci(0x59000000), "stlurh"); // STLURH_32_ldapstl_unscaled
3888 COMPARE_PREFIX(dci(0x59400000), "ldapurh"); // LDAPURH_32_ldapstl_unscaled
3889 COMPARE_PREFIX(dci(0x59800000), "ldapursh"); // LDAPURSH_64_ldapstl_unscaled
3890 COMPARE_PREFIX(dci(0x59c00000), "ldapursh"); // LDAPURSH_32_ldapstl_unscaled
3891 COMPARE_PREFIX(dci(0x99000000), "stlur"); // STLUR_32_ldapstl_unscaled
3892 COMPARE_PREFIX(dci(0x99400000), "ldapur"); // LDAPUR_32_ldapstl_unscaled
3893 COMPARE_PREFIX(dci(0x99800000), "ldapursw"); // LDAPURSW_64_ldapstl_unscaled
3894 COMPARE_PREFIX(dci(0xd9000000), "stlur"); // STLUR_64_ldapstl_unscaled
3895 COMPARE_PREFIX(dci(0xd9400000), "ldapur"); // LDAPUR_64_ldapstl_unscaled
3896
3897 // ARMv8.4 - TRF
3898 // COMPARE_PREFIX(dci(0xd503225f), "tsb"); // TSB_HC_hints
3899
3900 // ARMv8.5 - BTI
3901 COMPARE_PREFIX(dci(0xd503241f), "bti"); // BTI_HB_hints
3902
3903 // ARMv8.5 - FRINTTS
3904 COMPARE_PREFIX(dci(0x0e21e800), "frint32z"); // FRINT32Z_asimdmisc_R
3905 COMPARE_PREFIX(dci(0x0e21f800), "frint64z"); // FRINT64Z_asimdmisc_R
3906 COMPARE_PREFIX(dci(0x2e21e800), "frint32x"); // FRINT32X_asimdmisc_R
3907 COMPARE_PREFIX(dci(0x2e21f800), "frint64x"); // FRINT64X_asimdmisc_R
3908 COMPARE_PREFIX(dci(0x1e284000), "frint32z"); // FRINT32Z_S_floatdp1
3909 COMPARE_PREFIX(dci(0x1e28c000), "frint32x"); // FRINT32X_S_floatdp1
3910 COMPARE_PREFIX(dci(0x1e294000), "frint64z"); // FRINT64Z_S_floatdp1
3911 COMPARE_PREFIX(dci(0x1e29c000), "frint64x"); // FRINT64X_S_floatdp1
3912 COMPARE_PREFIX(dci(0x1e684000), "frint32z"); // FRINT32Z_D_floatdp1
3913 COMPARE_PREFIX(dci(0x1e68c000), "frint32x"); // FRINT32X_D_floatdp1
3914 COMPARE_PREFIX(dci(0x1e694000), "frint64z"); // FRINT64Z_D_floatdp1
3915 COMPARE_PREFIX(dci(0x1e69c000), "frint64x"); // FRINT64X_D_floatdp1
3916
3917 // ARMv8.5 - FlagM2
3918 COMPARE_PREFIX(dci(0xd500403f), "xaflag"); // XAFLAG_M_pstate
3919 COMPARE_PREFIX(dci(0xd500405f), "axflag"); // AXFLAG_M_pstate
3920
3921 // ARMv8.5 - MTE
3922 // COMPARE_PREFIX(dci(0x68800000), "stgp"); // STGP_64_ldstpair_post
3923 // COMPARE_PREFIX(dci(0x69000000), "stgp"); // STGP_64_ldstpair_off
3924 // COMPARE_PREFIX(dci(0x69800000), "stgp"); // STGP_64_ldstpair_pre
3925 // COMPARE_PREFIX(dci(0x91800000), "addg"); // ADDG_64_addsub_immtags
3926 // COMPARE_PREFIX(dci(0x9ac00000), "subp"); // SUBP_64S_dp_2src
3927 // COMPARE_PREFIX(dci(0x9ac01000), "irg"); // IRG_64I_dp_2src
3928 // COMPARE_PREFIX(dci(0x9ac01400), "gmi"); // GMI_64G_dp_2src
3929 // COMPARE_PREFIX(dci(0xbac00000), "subps"); // SUBPS_64S_dp_2src
3930 // COMPARE_PREFIX(dci(0xd1800000), "subg"); // SUBG_64_addsub_immtags
3931 // COMPARE_PREFIX(dci(0xd9200400), "stg"); // STG_64Spost_ldsttags
3932 // COMPARE_PREFIX(dci(0xd9200800), "stg"); // STG_64Soffset_ldsttags
3933 // COMPARE_PREFIX(dci(0xd9200c00), "stg"); // STG_64Spre_ldsttags
3934 // COMPARE_PREFIX(dci(0xd9600000), "ldg"); // LDG_64Loffset_ldsttags
3935 // COMPARE_PREFIX(dci(0xd9600400), "stzg"); // STZG_64Spost_ldsttags
3936 // COMPARE_PREFIX(dci(0xd9600800), "stzg"); // STZG_64Soffset_ldsttags
3937 // COMPARE_PREFIX(dci(0xd9600c00), "stzg"); // STZG_64Spre_ldsttags
3938 // COMPARE_PREFIX(dci(0xd9a00400), "st2g"); // ST2G_64Spost_ldsttags
3939 // COMPARE_PREFIX(dci(0xd9a00800), "st2g"); // ST2G_64Soffset_ldsttags
3940 // COMPARE_PREFIX(dci(0xd9a00c00), "st2g"); // ST2G_64Spre_ldsttags
3941 // COMPARE_PREFIX(dci(0xd9e00400), "stz2g"); // STZ2G_64Spost_ldsttags
3942 // COMPARE_PREFIX(dci(0xd9e00800), "stz2g"); // STZ2G_64Soffset_ldsttags
3943 // COMPARE_PREFIX(dci(0xd9e00c00), "stz2g"); // STZ2G_64Spre_ldsttags
3944
3945 // ARMv8.5 - MTE2
3946 // COMPARE_PREFIX(dci(0xd9200000), "stzgm"); // STZGM_64bulk_ldsttags
3947 // COMPARE_PREFIX(dci(0xd9a00000), "stgm"); // STGM_64bulk_ldsttags
3948 // COMPARE_PREFIX(dci(0xd9e00000), "ldgm"); // LDGM_64bulk_ldsttags
3949
3950 // ARMv8.6 - BF16
3951 // COMPARE_PREFIX(dci(0x0ea16800), "bfcvtn"); // BFCVTN_asimdmisc_4S
3952 // COMPARE_PREFIX(dci(0x0f40f000), "bfdot"); // BFDOT_asimdelem_E
3953 // COMPARE_PREFIX(dci(0x0fc0f000), "bfmlal"); // BFMLAL_asimdelem_F
3954 // COMPARE_PREFIX(dci(0x2e40fc00), "bfdot"); // BFDOT_asimdsame2_D
3955 // COMPARE_PREFIX(dci(0x2ec0fc00), "bfmlal"); // BFMLAL_asimdsame2_F_
3956 // COMPARE_PREFIX(dci(0x1e634000), "bfcvt"); // BFCVT_BS_floatdp1
3957 // COMPARE_PREFIX(dci(0x6e40ec00), "bfmmla"); // BFMMLA_asimdsame2_E
3958
3959 // ARMv8.6 - DGH
3960 // COMPARE_PREFIX(dci(0xd50320df), "dgh"); // DGH_HI_hints
3961
3962 // ARMv8.6 - I8MM
3963 COMPARE_PREFIX(dci(0x0e809c00), "usdot"); // USDOT_asimdsame2_D
3964 COMPARE_PREFIX(dci(0x0f00f000), "sudot"); // SUDOT_asimdelem_D
3965 COMPARE_PREFIX(dci(0x0f80f000), "usdot"); // USDOT_asimdelem_D
3966 COMPARE_PREFIX(dci(0x4e80a400), "smmla"); // SMMLA_asimdsame2_G
3967 COMPARE_PREFIX(dci(0x4e80ac00), "usmmla"); // USMMLA_asimdsame2_G
3968 COMPARE_PREFIX(dci(0x6e80a400), "ummla"); // UMMLA_asimdsame2_G
3969
3970 // ARMv8.7 - LS64
3971 // COMPARE_PREFIX(dci(0xf83f9000), "st64b"); // ST64B_64L_memop
3972 // COMPARE_PREFIX(dci(0xf83fd000), "ld64b"); // LD64B_64L_memop
3973
3974 // ARMv8.7 - LS64_V
3975 // COMPARE_PREFIX(dci(0xf820a000), "st64bv0"); // ST64BV0_64_memop
3976 // COMPARE_PREFIX(dci(0xf820b000), "st64bv"); // ST64BV_64_memop
3977
3978 // ARMv8.7 - WFxT
3979 // COMPARE_PREFIX(dci(0xd5031000), "wfet"); // WFET_only_systeminstrswithreg
3980 // COMPARE_PREFIX(dci(0xd5031020), "wfit"); // WFIT_only_systeminstrswithreg
3981
3982 // TME
3983 // COMPARE_PREFIX(dci(0xd4600000), "tcancel"); // TCANCEL_EX_exception
3984 // COMPARE_PREFIX(dci(0xd503307f), "tcommit"); // TCOMMIT_only_barriers
3985 // COMPARE_PREFIX(dci(0xd5233060), "tstart"); // TSTART_BR_systemresult
3986 // COMPARE_PREFIX(dci(0xd5233160), "ttest"); // TTEST_BR_systemresult
3987
3988 CLEANUP();
3989 }
3990
3991 } // namespace aarch64
3992 } // namespace vixl
3993