v8  3.25.30(node0.11.13)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
test-disasm-arm64.cc
Go to the documentation of this file.
1 // Copyright 2013 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #include <stdio.h>
29 #include <cstring>
30 #include "cctest.h"
31 
32 #include "v8.h"
33 
34 #include "macro-assembler.h"
35 #include "arm64/assembler-arm64.h"
36 #include "arm64/macro-assembler-arm64.h"
37 #include "arm64/decoder-arm64-inl.h"
38 #include "arm64/disasm-arm64.h"
39 #include "arm64/utils-arm64.h"
40 
41 using namespace v8::internal;
42 
43 #define TEST_(name) TEST(DISASM_##name)
44 
45 #define EXP_SIZE (256)
46 #define INSTR_SIZE (1024)
47 #define SET_UP_CLASS(ASMCLASS) \
48  InitializeVM(); \
49  Isolate* isolate = Isolate::Current(); \
50  HandleScope scope(isolate); \
51  byte* buf = static_cast<byte*>(malloc(INSTR_SIZE)); \
52  uint32_t encoding = 0; \
53  ASMCLASS* assm = new ASMCLASS(isolate, buf, INSTR_SIZE); \
54  Decoder<DispatchingDecoderVisitor>* decoder = \
55  new Decoder<DispatchingDecoderVisitor>(); \
56  Disassembler* disasm = new Disassembler(); \
57  decoder->AppendVisitor(disasm)
58 
59 #define SET_UP() SET_UP_CLASS(Assembler)
60 
61 #define COMPARE(ASM, EXP) \
62  assm->Reset(); \
63  assm->ASM; \
64  assm->GetCode(NULL); \
65  decoder->Decode(reinterpret_cast<Instruction*>(buf)); \
66  encoding = *reinterpret_cast<uint32_t*>(buf); \
67  if (strcmp(disasm->GetOutput(), EXP) != 0) { \
68  printf("%u : Encoding: %08" PRIx32 "\nExpected: %s\nFound: %s\n", \
69  __LINE__, encoding, EXP, disasm->GetOutput()); \
70  abort(); \
71  }
72 
73 #define COMPARE_PREFIX(ASM, EXP) \
74  assm->Reset(); \
75  assm->ASM; \
76  assm->GetCode(NULL); \
77  decoder->Decode(reinterpret_cast<Instruction*>(buf)); \
78  encoding = *reinterpret_cast<uint32_t*>(buf); \
79  if (strncmp(disasm->GetOutput(), EXP, strlen(EXP)) != 0) { \
80  printf("%u : Encoding: %08" PRIx32 "\nExpected: %s\nFound: %s\n", \
81  __LINE__, encoding, EXP, disasm->GetOutput()); \
82  abort(); \
83  }
84 
85 #define CLEANUP() \
86  delete disasm; \
87  delete decoder; \
88  delete assm
89 
90 
91 static bool vm_initialized = false;
92 
93 
94 static void InitializeVM() {
95  if (!vm_initialized) {
96  CcTest::InitializeVM();
97  vm_initialized = true;
98  }
99 }
100 
101 
102 TEST_(bootstrap) {
103  SET_UP();
104 
105  // Instructions generated by C compiler, disassembled by objdump, and
106  // reformatted to suit our disassembly style.
107  COMPARE(dci(0xa9ba7bfd), "stp fp, lr, [csp, #-96]!");
108  COMPARE(dci(0x910003fd), "mov fp, csp");
109  COMPARE(dci(0x9100e3a0), "add x0, fp, #0x38 (56)");
110  COMPARE(dci(0xb900001f), "str wzr, [x0]");
111  COMPARE(dci(0x528000e1), "movz w1, #0x7");
112  COMPARE(dci(0xb9001c01), "str w1, [x0, #28]");
113  COMPARE(dci(0x390043a0), "strb w0, [fp, #16]");
114  COMPARE(dci(0x790027a0), "strh w0, [fp, #18]");
115  COMPARE(dci(0xb9400400), "ldr w0, [x0, #4]");
116  COMPARE(dci(0x0b000021), "add w1, w1, w0");
117  COMPARE(dci(0x531b6800), "lsl w0, w0, #5");
118  COMPARE(dci(0x521e0400), "eor w0, w0, #0xc");
119  COMPARE(dci(0x72af0f00), "movk w0, #0x7878, lsl #16");
120  COMPARE(dci(0xd360fc00), "lsr x0, x0, #32");
121  COMPARE(dci(0x13037c01), "asr w1, w0, #3");
122  COMPARE(dci(0x4b000021), "sub w1, w1, w0");
123  COMPARE(dci(0x2a0103e0), "mov w0, w1");
124  COMPARE(dci(0x93407c00), "sxtw x0, w0");
125  COMPARE(dci(0x2a000020), "orr w0, w1, w0");
126  COMPARE(dci(0xa8c67bfd), "ldp fp, lr, [csp], #96");
127 
128  CLEANUP();
129 }
130 
131 
132 TEST_(mov_mvn) {
133  SET_UP_CLASS(MacroAssembler);
134 
135  COMPARE(Mov(w0, Operand(0x1234)), "movz w0, #0x1234");
136  COMPARE(Mov(x1, Operand(0x1234)), "movz x1, #0x1234");
137  COMPARE(Mov(w2, Operand(w3)), "mov w2, w3");
138  COMPARE(Mov(x4, Operand(x5)), "mov x4, x5");
139  COMPARE(Mov(w6, Operand(w7, LSL, 5)), "lsl w6, w7, #5");
140  COMPARE(Mov(x8, Operand(x9, ASR, 42)), "asr x8, x9, #42");
141  COMPARE(Mov(w10, Operand(w11, UXTB)), "uxtb w10, w11");
142  COMPARE(Mov(x12, Operand(x13, UXTB, 1)), "ubfiz x12, x13, #1, #8");
143  COMPARE(Mov(w14, Operand(w15, SXTH, 2)), "sbfiz w14, w15, #2, #16");
144  COMPARE(Mov(x16, Operand(x20, SXTW, 3)), "sbfiz x16, x20, #3, #32");
145 
146  COMPARE(Mov(x0, csp), "mov x0, csp");
147  COMPARE(Mov(w0, wcsp), "mov w0, wcsp");
148  COMPARE(Mov(x0, xzr), "mov x0, xzr");
149  COMPARE(Mov(w0, wzr), "mov w0, wzr");
150  COMPARE(mov(x0, csp), "mov x0, csp");
151  COMPARE(mov(w0, wcsp), "mov w0, wcsp");
152  COMPARE(mov(x0, xzr), "mov x0, xzr");
153  COMPARE(mov(w0, wzr), "mov w0, wzr");
154 
155  COMPARE(Mvn(w0, Operand(0x1)), "movn w0, #0x1");
156  COMPARE(Mvn(x1, Operand(0xfff)), "movn x1, #0xfff");
157  COMPARE(Mvn(w2, Operand(w3)), "mvn w2, w3");
158  COMPARE(Mvn(x4, Operand(x5)), "mvn x4, x5");
159  COMPARE(Mvn(w6, Operand(w7, LSL, 12)), "mvn w6, w7, lsl #12");
160  COMPARE(Mvn(x8, Operand(x9, ASR, 63)), "mvn x8, x9, asr #63");
161 
162  CLEANUP();
163 }
164 
165 
166 TEST_(move_immediate) {
167  SET_UP();
168 
169  COMPARE(movz(w0, 0x1234), "movz w0, #0x1234");
170  COMPARE(movz(x1, 0xabcd0000), "movz x1, #0xabcd0000");
171  COMPARE(movz(x2, 0x555500000000), "movz x2, #0x555500000000");
172  COMPARE(movz(x3, 0xaaaa000000000000), "movz x3, #0xaaaa000000000000");
173  COMPARE(movz(x4, 0xabcd, 16), "movz x4, #0xabcd0000");
174  COMPARE(movz(x5, 0x5555, 32), "movz x5, #0x555500000000");
175  COMPARE(movz(x6, 0xaaaa, 48), "movz x6, #0xaaaa000000000000");
176 
177  COMPARE(movk(w7, 0x1234), "movk w7, #0x1234");
178  COMPARE(movk(x8, 0xabcd0000), "movk x8, #0xabcd, lsl #16");
179  COMPARE(movk(x9, 0x555500000000), "movk x9, #0x5555, lsl #32");
180  COMPARE(movk(x10, 0xaaaa000000000000), "movk x10, #0xaaaa, lsl #48");
181  COMPARE(movk(w11, 0xabcd, 16), "movk w11, #0xabcd, lsl #16");
182  COMPARE(movk(x12, 0x5555, 32), "movk x12, #0x5555, lsl #32");
183  COMPARE(movk(x13, 0xaaaa, 48), "movk x13, #0xaaaa, lsl #48");
184 
185  COMPARE(movn(w14, 0x1234), "movn w14, #0x1234");
186  COMPARE(movn(x15, 0xabcd0000), "movn x15, #0xabcd0000");
187  COMPARE(movn(x16, 0x555500000000), "movn x16, #0x555500000000");
188  COMPARE(movn(x17, 0xaaaa000000000000), "movn x17, #0xaaaa000000000000");
189  COMPARE(movn(w18, 0xabcd, 16), "movn w18, #0xabcd0000");
190  COMPARE(movn(x19, 0x5555, 32), "movn x19, #0x555500000000");
191  COMPARE(movn(x20, 0xaaaa, 48), "movn x20, #0xaaaa000000000000");
192 
193  COMPARE(movk(w21, 0), "movk w21, #0x0");
194  COMPARE(movk(x22, 0, 0), "movk x22, #0x0");
195  COMPARE(movk(w23, 0, 16), "movk w23, #0x0, lsl #16");
196  COMPARE(movk(x24, 0, 32), "movk x24, #0x0, lsl #32");
197  COMPARE(movk(x25, 0, 48), "movk x25, #0x0, lsl #48");
198 
199  CLEANUP();
200 }
201 
202 
203 TEST(move_immediate_2) {
204  SET_UP_CLASS(MacroAssembler);
205 
206  // Move instructions expected for certain immediates. This is really a macro
207  // assembler test, to ensure it generates immediates efficiently.
208  COMPARE(Mov(w0, 0), "movz w0, #0x0");
209  COMPARE(Mov(w0, 0x0000ffff), "movz w0, #0xffff");
210  COMPARE(Mov(w0, 0x00010000), "movz w0, #0x10000");
211  COMPARE(Mov(w0, 0xffff0000), "movz w0, #0xffff0000");
212  COMPARE(Mov(w0, 0x0001ffff), "movn w0, #0xfffe0000");
213  COMPARE(Mov(w0, 0xffff8000), "movn w0, #0x7fff");
214  COMPARE(Mov(w0, 0xfffffffe), "movn w0, #0x1");
215  COMPARE(Mov(w0, 0xffffffff), "movn w0, #0x0");
216  COMPARE(Mov(w0, 0x00ffff00), "mov w0, #0xffff00");
217  COMPARE(Mov(w0, 0xfffe7fff), "mov w0, #0xfffe7fff");
218  COMPARE(Mov(w0, 0xfffeffff), "movn w0, #0x10000");
219  COMPARE(Mov(w0, 0xffff7fff), "movn w0, #0x8000");
220 
221  COMPARE(Mov(x0, 0), "movz x0, #0x0");
222  COMPARE(Mov(x0, 0x0000ffff), "movz x0, #0xffff");
223  COMPARE(Mov(x0, 0x00010000), "movz x0, #0x10000");
224  COMPARE(Mov(x0, 0xffff0000), "movz x0, #0xffff0000");
225  COMPARE(Mov(x0, 0x0001ffff), "mov x0, #0x1ffff");
226  COMPARE(Mov(x0, 0xffff8000), "mov x0, #0xffff8000");
227  COMPARE(Mov(x0, 0xfffffffe), "mov x0, #0xfffffffe");
228  COMPARE(Mov(x0, 0xffffffff), "mov x0, #0xffffffff");
229  COMPARE(Mov(x0, 0x00ffff00), "mov x0, #0xffff00");
230  COMPARE(Mov(x0, 0xffff000000000000), "movz x0, #0xffff000000000000");
231  COMPARE(Mov(x0, 0x0000ffff00000000), "movz x0, #0xffff00000000");
232  COMPARE(Mov(x0, 0x00000000ffff0000), "movz x0, #0xffff0000");
233  COMPARE(Mov(x0, 0xffffffffffff0000), "movn x0, #0xffff");
234  COMPARE(Mov(x0, 0xffffffff0000ffff), "movn x0, #0xffff0000");
235  COMPARE(Mov(x0, 0xffff0000ffffffff), "movn x0, #0xffff00000000");
236  COMPARE(Mov(x0, 0x0000ffffffffffff), "movn x0, #0xffff000000000000");
237  COMPARE(Mov(x0, 0xfffe7fffffffffff), "mov x0, #0xfffe7fffffffffff");
238  COMPARE(Mov(x0, 0xfffeffffffffffff), "movn x0, #0x1000000000000");
239  COMPARE(Mov(x0, 0xffff7fffffffffff), "movn x0, #0x800000000000");
240  COMPARE(Mov(x0, 0xfffffffe7fffffff), "mov x0, #0xfffffffe7fffffff");
241  COMPARE(Mov(x0, 0xfffffffeffffffff), "movn x0, #0x100000000");
242  COMPARE(Mov(x0, 0xffffffff7fffffff), "movn x0, #0x80000000");
243  COMPARE(Mov(x0, 0xfffffffffffe7fff), "mov x0, #0xfffffffffffe7fff");
244  COMPARE(Mov(x0, 0xfffffffffffeffff), "movn x0, #0x10000");
245  COMPARE(Mov(x0, 0xffffffffffff7fff), "movn x0, #0x8000");
246  COMPARE(Mov(x0, 0xffffffffffffffff), "movn x0, #0x0");
247 
248  COMPARE(Movk(w0, 0x1234, 0), "movk w0, #0x1234");
249  COMPARE(Movk(x1, 0x2345, 0), "movk x1, #0x2345");
250  COMPARE(Movk(w2, 0x3456, 16), "movk w2, #0x3456, lsl #16");
251  COMPARE(Movk(x3, 0x4567, 16), "movk x3, #0x4567, lsl #16");
252  COMPARE(Movk(x4, 0x5678, 32), "movk x4, #0x5678, lsl #32");
253  COMPARE(Movk(x5, 0x6789, 48), "movk x5, #0x6789, lsl #48");
254 
255  CLEANUP();
256 }
257 
258 
259 TEST_(add_immediate) {
260  SET_UP();
261 
262  COMPARE(add(w0, w1, Operand(0xff)), "add w0, w1, #0xff (255)");
263  COMPARE(add(x2, x3, Operand(0x3ff)), "add x2, x3, #0x3ff (1023)");
264  COMPARE(add(w4, w5, Operand(0xfff)), "add w4, w5, #0xfff (4095)");
265  COMPARE(add(x6, x7, Operand(0x1000)), "add x6, x7, #0x1000 (4096)");
266  COMPARE(add(w8, w9, Operand(0xff000)), "add w8, w9, #0xff000 (1044480)");
267  COMPARE(add(x10, x11, Operand(0x3ff000)),
268  "add x10, x11, #0x3ff000 (4190208)");
269  COMPARE(add(w12, w13, Operand(0xfff000)),
270  "add w12, w13, #0xfff000 (16773120)");
271  COMPARE(adds(w14, w15, Operand(0xff)), "adds w14, w15, #0xff (255)");
272  COMPARE(adds(x16, x17, Operand(0xaa000)),
273  "adds x16, x17, #0xaa000 (696320)");
274  COMPARE(cmn(w18, Operand(0xff)), "cmn w18, #0xff (255)");
275  COMPARE(cmn(x19, Operand(0xff000)), "cmn x19, #0xff000 (1044480)");
276  COMPARE(add(w0, wcsp, Operand(0)), "mov w0, wcsp");
277  COMPARE(add(csp, x0, Operand(0)), "mov csp, x0");
278 
279  COMPARE(add(w1, wcsp, Operand(8)), "add w1, wcsp, #0x8 (8)");
280  COMPARE(add(x2, csp, Operand(16)), "add x2, csp, #0x10 (16)");
281  COMPARE(add(wcsp, wcsp, Operand(42)), "add wcsp, wcsp, #0x2a (42)");
282  COMPARE(cmn(csp, Operand(24)), "cmn csp, #0x18 (24)");
283  COMPARE(adds(wzr, wcsp, Operand(9)), "cmn wcsp, #0x9 (9)");
284 
285  CLEANUP();
286 }
287 
288 
289 TEST_(sub_immediate) {
290  SET_UP();
291 
292  COMPARE(sub(w0, w1, Operand(0xff)), "sub w0, w1, #0xff (255)");
293  COMPARE(sub(x2, x3, Operand(0x3ff)), "sub x2, x3, #0x3ff (1023)");
294  COMPARE(sub(w4, w5, Operand(0xfff)), "sub w4, w5, #0xfff (4095)");
295  COMPARE(sub(x6, x7, Operand(0x1000)), "sub x6, x7, #0x1000 (4096)");
296  COMPARE(sub(w8, w9, Operand(0xff000)), "sub w8, w9, #0xff000 (1044480)");
297  COMPARE(sub(x10, x11, Operand(0x3ff000)),
298  "sub x10, x11, #0x3ff000 (4190208)");
299  COMPARE(sub(w12, w13, Operand(0xfff000)),
300  "sub w12, w13, #0xfff000 (16773120)");
301  COMPARE(subs(w14, w15, Operand(0xff)), "subs w14, w15, #0xff (255)");
302  COMPARE(subs(x16, x17, Operand(0xaa000)),
303  "subs x16, x17, #0xaa000 (696320)");
304  COMPARE(cmp(w18, Operand(0xff)), "cmp w18, #0xff (255)");
305  COMPARE(cmp(x19, Operand(0xff000)), "cmp x19, #0xff000 (1044480)");
306 
307  COMPARE(add(w1, wcsp, Operand(8)), "add w1, wcsp, #0x8 (8)");
308  COMPARE(add(x2, csp, Operand(16)), "add x2, csp, #0x10 (16)");
309  COMPARE(add(wcsp, wcsp, Operand(42)), "add wcsp, wcsp, #0x2a (42)");
310  COMPARE(cmn(csp, Operand(24)), "cmn csp, #0x18 (24)");
311  COMPARE(adds(wzr, wcsp, Operand(9)), "cmn wcsp, #0x9 (9)");
312 
313  CLEANUP();
314 }
315 
316 
317 TEST_(add_shifted) {
318  SET_UP();
319 
320  COMPARE(add(w0, w1, Operand(w2)), "add w0, w1, w2");
321  COMPARE(add(x3, x4, Operand(x5)), "add x3, x4, x5");
322  COMPARE(add(w6, w7, Operand(w8, LSL, 1)), "add w6, w7, w8, lsl #1");
323  COMPARE(add(x9, x10, Operand(x11, LSL, 2)), "add x9, x10, x11, lsl #2");
324  COMPARE(add(w12, w13, Operand(w14, LSR, 3)), "add w12, w13, w14, lsr #3");
325  COMPARE(add(x15, x16, Operand(x17, LSR, 4)), "add x15, x16, x17, lsr #4");
326  COMPARE(add(w18, w19, Operand(w20, ASR, 5)), "add w18, w19, w20, asr #5");
327  COMPARE(add(x21, x22, Operand(x23, ASR, 6)), "add x21, x22, x23, asr #6");
328  COMPARE(cmn(w24, Operand(w25)), "cmn w24, w25");
329  COMPARE(cmn(x26, Operand(cp, LSL, 63)), "cmn x26, cp, lsl #63");
330 
331  COMPARE(add(x0, csp, Operand(x1)), "add x0, csp, x1");
332  COMPARE(add(w2, wcsp, Operand(w3)), "add w2, wcsp, w3");
333  COMPARE(add(x4, csp, Operand(x5, LSL, 1)), "add x4, csp, x5, lsl #1");
334  COMPARE(add(x4, xzr, Operand(x5, LSL, 1)), "add x4, xzr, x5, lsl #1");
335  COMPARE(add(w6, wcsp, Operand(w7, LSL, 3)), "add w6, wcsp, w7, lsl #3");
336  COMPARE(adds(xzr, csp, Operand(x8, LSL, 4)), "cmn csp, x8, lsl #4");
337  COMPARE(adds(xzr, xzr, Operand(x8, LSL, 5)), "cmn xzr, x8, lsl #5");
338 
339  CLEANUP();
340 }
341 
342 
343 TEST_(sub_shifted) {
344  SET_UP();
345 
346  COMPARE(sub(w0, w1, Operand(w2)), "sub w0, w1, w2");
347  COMPARE(sub(x3, x4, Operand(x5)), "sub x3, x4, x5");
348  COMPARE(sub(w6, w7, Operand(w8, LSL, 1)), "sub w6, w7, w8, lsl #1");
349  COMPARE(sub(x9, x10, Operand(x11, LSL, 2)), "sub x9, x10, x11, lsl #2");
350  COMPARE(sub(w12, w13, Operand(w14, LSR, 3)), "sub w12, w13, w14, lsr #3");
351  COMPARE(sub(x15, x16, Operand(x17, LSR, 4)), "sub x15, x16, x17, lsr #4");
352  COMPARE(sub(w18, w19, Operand(w20, ASR, 5)), "sub w18, w19, w20, asr #5");
353  COMPARE(sub(x21, x22, Operand(x23, ASR, 6)), "sub x21, x22, x23, asr #6");
354  COMPARE(cmp(w24, Operand(w25)), "cmp w24, w25");
355  COMPARE(cmp(x26, Operand(cp, LSL, 63)), "cmp x26, cp, lsl #63");
356  COMPARE(neg(w28, Operand(w29)), "neg w28, w29");
357  COMPARE(neg(lr, Operand(x0, LSR, 62)), "neg lr, x0, lsr #62");
358  COMPARE(negs(w1, Operand(w2)), "negs w1, w2");
359  COMPARE(negs(x3, Operand(x4, ASR, 61)), "negs x3, x4, asr #61");
360 
361  COMPARE(sub(x0, csp, Operand(x1)), "sub x0, csp, x1");
362  COMPARE(sub(w2, wcsp, Operand(w3)), "sub w2, wcsp, w3");
363  COMPARE(sub(x4, csp, Operand(x5, LSL, 1)), "sub x4, csp, x5, lsl #1");
364  COMPARE(sub(x4, xzr, Operand(x5, LSL, 1)), "neg x4, x5, lsl #1");
365  COMPARE(sub(w6, wcsp, Operand(w7, LSL, 3)), "sub w6, wcsp, w7, lsl #3");
366  COMPARE(subs(xzr, csp, Operand(x8, LSL, 4)), "cmp csp, x8, lsl #4");
367  COMPARE(subs(xzr, xzr, Operand(x8, LSL, 5)), "cmp xzr, x8, lsl #5");
368 
369  CLEANUP();
370 }
371 
372 
373 TEST_(add_extended) {
374  SET_UP();
375 
376  COMPARE(add(w0, w1, Operand(w2, UXTB)), "add w0, w1, w2, uxtb");
377  COMPARE(adds(x3, x4, Operand(w5, UXTB, 1)), "adds x3, x4, w5, uxtb #1");
378  COMPARE(add(w6, w7, Operand(w8, UXTH, 2)), "add w6, w7, w8, uxth #2");
379  COMPARE(adds(x9, x10, Operand(x11, UXTW, 3)), "adds x9, x10, w11, uxtw #3");
380  COMPARE(add(x12, x13, Operand(x14, UXTX, 4)), "add x12, x13, x14, uxtx #4");
381  COMPARE(adds(w15, w16, Operand(w17, SXTB, 4)), "adds w15, w16, w17, sxtb #4");
382  COMPARE(add(x18, x19, Operand(x20, SXTB, 3)), "add x18, x19, w20, sxtb #3");
383  COMPARE(adds(w21, w22, Operand(w23, SXTH, 2)), "adds w21, w22, w23, sxth #2");
384  COMPARE(add(x24, x25, Operand(x26, SXTW, 1)), "add x24, x25, w26, sxtw #1");
385  COMPARE(adds(cp, jssp, Operand(fp, SXTX)), "adds cp, jssp, fp, sxtx");
386  COMPARE(cmn(w0, Operand(w1, UXTB, 2)), "cmn w0, w1, uxtb #2");
387  COMPARE(cmn(x2, Operand(x3, SXTH, 4)), "cmn x2, w3, sxth #4");
388 
389  COMPARE(add(w0, wcsp, Operand(w1, UXTB)), "add w0, wcsp, w1, uxtb");
390  COMPARE(add(x2, csp, Operand(x3, UXTH, 1)), "add x2, csp, w3, uxth #1");
391  COMPARE(add(wcsp, wcsp, Operand(w4, UXTW, 2)), "add wcsp, wcsp, w4, lsl #2");
392  COMPARE(cmn(csp, Operand(xzr, UXTX, 3)), "cmn csp, xzr, lsl #3");
393  COMPARE(cmn(csp, Operand(xzr, LSL, 4)), "cmn csp, xzr, lsl #4");
394 
395  CLEANUP();
396 }
397 
398 
399 TEST_(sub_extended) {
400  SET_UP();
401 
402  COMPARE(sub(w0, w1, Operand(w2, UXTB)), "sub w0, w1, w2, uxtb");
403  COMPARE(subs(x3, x4, Operand(w5, UXTB, 1)), "subs x3, x4, w5, uxtb #1");
404  COMPARE(sub(w6, w7, Operand(w8, UXTH, 2)), "sub w6, w7, w8, uxth #2");
405  COMPARE(subs(x9, x10, Operand(x11, UXTW, 3)), "subs x9, x10, w11, uxtw #3");
406  COMPARE(sub(x12, x13, Operand(x14, UXTX, 4)), "sub x12, x13, x14, uxtx #4");
407  COMPARE(subs(w15, w16, Operand(w17, SXTB, 4)), "subs w15, w16, w17, sxtb #4");
408  COMPARE(sub(x18, x19, Operand(x20, SXTB, 3)), "sub x18, x19, w20, sxtb #3");
409  COMPARE(subs(w21, w22, Operand(w23, SXTH, 2)), "subs w21, w22, w23, sxth #2");
410  COMPARE(sub(x24, x25, Operand(x26, SXTW, 1)), "sub x24, x25, w26, sxtw #1");
411  COMPARE(subs(cp, jssp, Operand(fp, SXTX)), "subs cp, jssp, fp, sxtx");
412  COMPARE(cmp(w0, Operand(w1, SXTB, 1)), "cmp w0, w1, sxtb #1");
413  COMPARE(cmp(x2, Operand(x3, UXTH, 3)), "cmp x2, w3, uxth #3");
414 
415  COMPARE(sub(w0, wcsp, Operand(w1, UXTB)), "sub w0, wcsp, w1, uxtb");
416  COMPARE(sub(x2, csp, Operand(x3, UXTH, 1)), "sub x2, csp, w3, uxth #1");
417  COMPARE(sub(wcsp, wcsp, Operand(w4, UXTW, 2)), "sub wcsp, wcsp, w4, lsl #2");
418  COMPARE(cmp(csp, Operand(xzr, UXTX, 3)), "cmp csp, xzr, lsl #3");
419  COMPARE(cmp(csp, Operand(xzr, LSL, 4)), "cmp csp, xzr, lsl #4");
420 
421  CLEANUP();
422 }
423 
424 
425 TEST_(adc_subc_ngc) {
426  SET_UP();
427 
428  COMPARE(adc(w0, w1, Operand(w2)), "adc w0, w1, w2");
429  COMPARE(adc(x3, x4, Operand(x5)), "adc x3, x4, x5");
430  COMPARE(adcs(w6, w7, Operand(w8)), "adcs w6, w7, w8");
431  COMPARE(adcs(x9, x10, Operand(x11)), "adcs x9, x10, x11");
432  COMPARE(sbc(w12, w13, Operand(w14)), "sbc w12, w13, w14");
433  COMPARE(sbc(x15, x16, Operand(x17)), "sbc x15, x16, x17");
434  COMPARE(sbcs(w18, w19, Operand(w20)), "sbcs w18, w19, w20");
435  COMPARE(sbcs(x21, x22, Operand(x23)), "sbcs x21, x22, x23");
436  COMPARE(ngc(w24, Operand(w25)), "ngc w24, w25");
437  COMPARE(ngc(x26, Operand(cp)), "ngc x26, cp");
438  COMPARE(ngcs(w28, Operand(w29)), "ngcs w28, w29");
439  COMPARE(ngcs(lr, Operand(x0)), "ngcs lr, x0");
440 
441  CLEANUP();
442 }
443 
444 
445 TEST_(mul_and_div) {
446  SET_UP();
447 
448  COMPARE(mul(w0, w1, w2), "mul w0, w1, w2");
449  COMPARE(mul(x3, x4, x5), "mul x3, x4, x5");
450  COMPARE(mul(w30, w0, w1), "mul w30, w0, w1");
451  COMPARE(mul(lr, x0, x1), "mul lr, x0, x1");
452  COMPARE(mneg(w0, w1, w2), "mneg w0, w1, w2");
453  COMPARE(mneg(x3, x4, x5), "mneg x3, x4, x5");
454  COMPARE(mneg(w30, w0, w1), "mneg w30, w0, w1");
455  COMPARE(mneg(lr, x0, x1), "mneg lr, x0, x1");
456  COMPARE(smull(x0, w0, w1), "smull x0, w0, w1");
457  COMPARE(smull(lr, w30, w0), "smull lr, w30, w0");
458  COMPARE(smulh(x0, x1, x2), "smulh x0, x1, x2");
459 
460  COMPARE(madd(w0, w1, w2, w3), "madd w0, w1, w2, w3");
461  COMPARE(madd(x4, x5, x6, x7), "madd x4, x5, x6, x7");
462  COMPARE(madd(w8, w9, w10, wzr), "mul w8, w9, w10");
463  COMPARE(madd(x11, x12, x13, xzr), "mul x11, x12, x13");
464  COMPARE(msub(w14, w15, w16, w17), "msub w14, w15, w16, w17");
465  COMPARE(msub(x18, x19, x20, x21), "msub x18, x19, x20, x21");
466  COMPARE(msub(w22, w23, w24, wzr), "mneg w22, w23, w24");
467  COMPARE(msub(x25, x26, x0, xzr), "mneg x25, x26, x0");
468 
469  COMPARE(sdiv(w0, w1, w2), "sdiv w0, w1, w2");
470  COMPARE(sdiv(x3, x4, x5), "sdiv x3, x4, x5");
471  COMPARE(udiv(w6, w7, w8), "udiv w6, w7, w8");
472  COMPARE(udiv(x9, x10, x11), "udiv x9, x10, x11");
473 
474  CLEANUP();
475 }
476 
477 
478 TEST(maddl_msubl) {
479  SET_UP();
480 
481  COMPARE(smaddl(x0, w1, w2, x3), "smaddl x0, w1, w2, x3");
482  COMPARE(smaddl(x25, w21, w22, x16), "smaddl x25, w21, w22, x16");
483  COMPARE(umaddl(x0, w1, w2, x3), "umaddl x0, w1, w2, x3");
484  COMPARE(umaddl(x25, w21, w22, x16), "umaddl x25, w21, w22, x16");
485 
486  COMPARE(smsubl(x0, w1, w2, x3), "smsubl x0, w1, w2, x3");
487  COMPARE(smsubl(x25, w21, w22, x16), "smsubl x25, w21, w22, x16");
488  COMPARE(umsubl(x0, w1, w2, x3), "umsubl x0, w1, w2, x3");
489  COMPARE(umsubl(x25, w21, w22, x16), "umsubl x25, w21, w22, x16");
490 
491  CLEANUP();
492 }
493 
494 
495 TEST_(dp_1_source) {
496  SET_UP();
497 
498  COMPARE(rbit(w0, w1), "rbit w0, w1");
499  COMPARE(rbit(x2, x3), "rbit x2, x3");
500  COMPARE(rev16(w4, w5), "rev16 w4, w5");
501  COMPARE(rev16(x6, x7), "rev16 x6, x7");
502  COMPARE(rev32(x8, x9), "rev32 x8, x9");
503  COMPARE(rev(w10, w11), "rev w10, w11");
504  COMPARE(rev(x12, x13), "rev x12, x13");
505  COMPARE(clz(w14, w15), "clz w14, w15");
506  COMPARE(clz(x16, x17), "clz x16, x17");
507  COMPARE(cls(w18, w19), "cls w18, w19");
508  COMPARE(cls(x20, x21), "cls x20, x21");
509 
510  CLEANUP();
511 }
512 
513 
514 TEST_(bitfield) {
515  SET_UP();
516 
517  COMPARE(sxtb(w0, w1), "sxtb w0, w1");
518  COMPARE(sxtb(x2, x3), "sxtb x2, w3");
519  COMPARE(sxth(w4, w5), "sxth w4, w5");
520  COMPARE(sxth(x6, x7), "sxth x6, w7");
521  COMPARE(sxtw(x8, x9), "sxtw x8, w9");
522  COMPARE(sxtb(x0, w1), "sxtb x0, w1");
523  COMPARE(sxth(x2, w3), "sxth x2, w3");
524  COMPARE(sxtw(x4, w5), "sxtw x4, w5");
525 
526  COMPARE(uxtb(w10, w11), "uxtb w10, w11");
527  COMPARE(uxtb(x12, x13), "uxtb x12, w13");
528  COMPARE(uxth(w14, w15), "uxth w14, w15");
529  COMPARE(uxth(x16, x17), "uxth x16, w17");
530  COMPARE(uxtw(x18, x19), "ubfx x18, x19, #0, #32");
531 
532  COMPARE(asr(w20, w21, 10), "asr w20, w21, #10");
533  COMPARE(asr(x22, x23, 20), "asr x22, x23, #20");
534  COMPARE(lsr(w24, w25, 10), "lsr w24, w25, #10");
535  COMPARE(lsr(x26, cp, 20), "lsr x26, cp, #20");
536  COMPARE(lsl(w28, w29, 10), "lsl w28, w29, #10");
537  COMPARE(lsl(lr, x0, 20), "lsl lr, x0, #20");
538 
539  COMPARE(sbfiz(w1, w2, 1, 20), "sbfiz w1, w2, #1, #20");
540  COMPARE(sbfiz(x3, x4, 2, 19), "sbfiz x3, x4, #2, #19");
541  COMPARE(sbfx(w5, w6, 3, 18), "sbfx w5, w6, #3, #18");
542  COMPARE(sbfx(x7, x8, 4, 17), "sbfx x7, x8, #4, #17");
543  COMPARE(bfi(w9, w10, 5, 16), "bfi w9, w10, #5, #16");
544  COMPARE(bfi(x11, x12, 6, 15), "bfi x11, x12, #6, #15");
545  COMPARE(bfxil(w13, w14, 7, 14), "bfxil w13, w14, #7, #14");
546  COMPARE(bfxil(x15, x16, 8, 13), "bfxil x15, x16, #8, #13");
547  COMPARE(ubfiz(w17, w18, 9, 12), "ubfiz w17, w18, #9, #12");
548  COMPARE(ubfiz(x19, x20, 10, 11), "ubfiz x19, x20, #10, #11");
549  COMPARE(ubfx(w21, w22, 11, 10), "ubfx w21, w22, #11, #10");
550  COMPARE(ubfx(x23, x24, 12, 9), "ubfx x23, x24, #12, #9");
551 
552  CLEANUP();
553 }
554 
555 
556 TEST_(extract) {
557  SET_UP();
558 
559  COMPARE(extr(w0, w1, w2, 0), "extr w0, w1, w2, #0");
560  COMPARE(extr(x3, x4, x5, 1), "extr x3, x4, x5, #1");
561  COMPARE(extr(w6, w7, w8, 31), "extr w6, w7, w8, #31");
562  COMPARE(extr(x9, x10, x11, 63), "extr x9, x10, x11, #63");
563  COMPARE(extr(w12, w13, w13, 10), "ror w12, w13, #10");
564  COMPARE(extr(x14, x15, x15, 42), "ror x14, x15, #42");
565 
566  CLEANUP();
567 }
568 
569 
570 TEST_(logical_immediate) {
571  SET_UP();
572  #define RESULT_SIZE (256)
573 
574  char result[RESULT_SIZE];
575 
576  // Test immediate encoding - 64-bit destination.
577  // 64-bit patterns.
578  uint64_t value = 0x7fffffff;
579  for (int i = 0; i < 64; i++) {
580  snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
581  COMPARE(and_(x0, x0, Operand(value)), result);
582  value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
583  }
584 
585  // 32-bit patterns.
586  value = 0x00003fff00003fffL;
587  for (int i = 0; i < 32; i++) {
588  snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
589  COMPARE(and_(x0, x0, Operand(value)), result);
590  value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
591  }
592 
593  // 16-bit patterns.
594  value = 0x001f001f001f001fL;
595  for (int i = 0; i < 16; i++) {
596  snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
597  COMPARE(and_(x0, x0, Operand(value)), result);
598  value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
599  }
600 
601  // 8-bit patterns.
602  value = 0x0e0e0e0e0e0e0e0eL;
603  for (int i = 0; i < 8; i++) {
604  snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
605  COMPARE(and_(x0, x0, Operand(value)), result);
606  value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
607  }
608 
609  // 4-bit patterns.
610  value = 0x6666666666666666L;
611  for (int i = 0; i < 4; i++) {
612  snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value);
613  COMPARE(and_(x0, x0, Operand(value)), result);
614  value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit.
615  }
616 
617  // 2-bit patterns.
618  COMPARE(and_(x0, x0, Operand(0x5555555555555555L)),
619  "and x0, x0, #0x5555555555555555");
620  COMPARE(and_(x0, x0, Operand(0xaaaaaaaaaaaaaaaaL)),
621  "and x0, x0, #0xaaaaaaaaaaaaaaaa");
622 
623  // Test immediate encoding - 32-bit destination.
624  COMPARE(and_(w0, w0, Operand(0xff8007ff)),
625  "and w0, w0, #0xff8007ff"); // 32-bit pattern.
626  COMPARE(and_(w0, w0, Operand(0xf87ff87f)),
627  "and w0, w0, #0xf87ff87f"); // 16-bit pattern.
628  COMPARE(and_(w0, w0, Operand(0x87878787)),
629  "and w0, w0, #0x87878787"); // 8-bit pattern.
630  COMPARE(and_(w0, w0, Operand(0x66666666)),
631  "and w0, w0, #0x66666666"); // 4-bit pattern.
632  COMPARE(and_(w0, w0, Operand(0x55555555)),
633  "and w0, w0, #0x55555555"); // 2-bit pattern.
634 
635  // Test other instructions.
636  COMPARE(tst(w1, Operand(0x11111111)),
637  "tst w1, #0x11111111");
638  COMPARE(tst(x2, Operand(0x8888888888888888L)),
639  "tst x2, #0x8888888888888888");
640  COMPARE(orr(w7, w8, Operand(0xaaaaaaaa)),
641  "orr w7, w8, #0xaaaaaaaa");
642  COMPARE(orr(x9, x10, Operand(0x5555555555555555L)),
643  "orr x9, x10, #0x5555555555555555");
644  COMPARE(eor(w15, w16, Operand(0x00000001)),
645  "eor w15, w16, #0x1");
646  COMPARE(eor(x17, x18, Operand(0x0000000000000003L)),
647  "eor x17, x18, #0x3");
648  COMPARE(ands(w23, w24, Operand(0x0000000f)), "ands w23, w24, #0xf");
649  COMPARE(ands(x25, x26, Operand(0x800000000000000fL)),
650  "ands x25, x26, #0x800000000000000f");
651 
652  // Test inverse.
653  COMPARE(bic(w3, w4, Operand(0x20202020)),
654  "and w3, w4, #0xdfdfdfdf");
655  COMPARE(bic(x5, x6, Operand(0x4040404040404040L)),
656  "and x5, x6, #0xbfbfbfbfbfbfbfbf");
657  COMPARE(orn(w11, w12, Operand(0x40004000)),
658  "orr w11, w12, #0xbfffbfff");
659  COMPARE(orn(x13, x14, Operand(0x8181818181818181L)),
660  "orr x13, x14, #0x7e7e7e7e7e7e7e7e");
661  COMPARE(eon(w19, w20, Operand(0x80000001)),
662  "eor w19, w20, #0x7ffffffe");
663  COMPARE(eon(x21, x22, Operand(0xc000000000000003L)),
664  "eor x21, x22, #0x3ffffffffffffffc");
665  COMPARE(bics(w27, w28, Operand(0xfffffff7)), "ands w27, w28, #0x8");
666  COMPARE(bics(fp, x0, Operand(0xfffffffeffffffffL)),
667  "ands fp, x0, #0x100000000");
668 
669  // Test stack pointer.
670  COMPARE(and_(wcsp, wzr, Operand(7)), "and wcsp, wzr, #0x7");
671  COMPARE(ands(xzr, xzr, Operand(7)), "tst xzr, #0x7");
672  COMPARE(orr(csp, xzr, Operand(15)), "orr csp, xzr, #0xf");
673  COMPARE(eor(wcsp, w0, Operand(31)), "eor wcsp, w0, #0x1f");
674 
675  // Test move aliases.
676  COMPARE(orr(w0, wzr, Operand(0x00000780)), "orr w0, wzr, #0x780");
677  COMPARE(orr(w1, wzr, Operand(0x00007800)), "orr w1, wzr, #0x7800");
678  COMPARE(orr(w2, wzr, Operand(0x00078000)), "mov w2, #0x78000");
679  COMPARE(orr(w3, wzr, Operand(0x00780000)), "orr w3, wzr, #0x780000");
680  COMPARE(orr(w4, wzr, Operand(0x07800000)), "orr w4, wzr, #0x7800000");
681  COMPARE(orr(x5, xzr, Operand(0xffffffffffffc001UL)),
682  "orr x5, xzr, #0xffffffffffffc001");
683  COMPARE(orr(x6, xzr, Operand(0xfffffffffffc001fUL)),
684  "mov x6, #0xfffffffffffc001f");
685  COMPARE(orr(x7, xzr, Operand(0xffffffffffc001ffUL)),
686  "mov x7, #0xffffffffffc001ff");
687  COMPARE(orr(x8, xzr, Operand(0xfffffffffc001fffUL)),
688  "mov x8, #0xfffffffffc001fff");
689  COMPARE(orr(x9, xzr, Operand(0xffffffffc001ffffUL)),
690  "orr x9, xzr, #0xffffffffc001ffff");
691 
692  CLEANUP();
693 }
694 
695 
696 TEST_(logical_shifted) {
697  SET_UP();
698 
699  COMPARE(and_(w0, w1, Operand(w2)), "and w0, w1, w2");
700  COMPARE(and_(x3, x4, Operand(x5, LSL, 1)), "and x3, x4, x5, lsl #1");
701  COMPARE(and_(w6, w7, Operand(w8, LSR, 2)), "and w6, w7, w8, lsr #2");
702  COMPARE(and_(x9, x10, Operand(x11, ASR, 3)), "and x9, x10, x11, asr #3");
703  COMPARE(and_(w12, w13, Operand(w14, ROR, 4)), "and w12, w13, w14, ror #4");
704 
705  COMPARE(bic(w15, w16, Operand(w17)), "bic w15, w16, w17");
706  COMPARE(bic(x18, x19, Operand(x20, LSL, 5)), "bic x18, x19, x20, lsl #5");
707  COMPARE(bic(w21, w22, Operand(w23, LSR, 6)), "bic w21, w22, w23, lsr #6");
708  COMPARE(bic(x24, x25, Operand(x26, ASR, 7)), "bic x24, x25, x26, asr #7");
709  COMPARE(bic(w27, w28, Operand(w29, ROR, 8)), "bic w27, w28, w29, ror #8");
710 
711  COMPARE(orr(w0, w1, Operand(w2)), "orr w0, w1, w2");
712  COMPARE(orr(x3, x4, Operand(x5, LSL, 9)), "orr x3, x4, x5, lsl #9");
713  COMPARE(orr(w6, w7, Operand(w8, LSR, 10)), "orr w6, w7, w8, lsr #10");
714  COMPARE(orr(x9, x10, Operand(x11, ASR, 11)), "orr x9, x10, x11, asr #11");
715  COMPARE(orr(w12, w13, Operand(w14, ROR, 12)), "orr w12, w13, w14, ror #12");
716 
717  COMPARE(orn(w15, w16, Operand(w17)), "orn w15, w16, w17");
718  COMPARE(orn(x18, x19, Operand(x20, LSL, 13)), "orn x18, x19, x20, lsl #13");
719  COMPARE(orn(w21, w22, Operand(w23, LSR, 14)), "orn w21, w22, w23, lsr #14");
720  COMPARE(orn(x24, x25, Operand(x26, ASR, 15)), "orn x24, x25, x26, asr #15");
721  COMPARE(orn(w27, w28, Operand(w29, ROR, 16)), "orn w27, w28, w29, ror #16");
722 
723  COMPARE(eor(w0, w1, Operand(w2)), "eor w0, w1, w2");
724  COMPARE(eor(x3, x4, Operand(x5, LSL, 17)), "eor x3, x4, x5, lsl #17");
725  COMPARE(eor(w6, w7, Operand(w8, LSR, 18)), "eor w6, w7, w8, lsr #18");
726  COMPARE(eor(x9, x10, Operand(x11, ASR, 19)), "eor x9, x10, x11, asr #19");
727  COMPARE(eor(w12, w13, Operand(w14, ROR, 20)), "eor w12, w13, w14, ror #20");
728 
729  COMPARE(eon(w15, w16, Operand(w17)), "eon w15, w16, w17");
730  COMPARE(eon(x18, x19, Operand(x20, LSL, 21)), "eon x18, x19, x20, lsl #21");
731  COMPARE(eon(w21, w22, Operand(w23, LSR, 22)), "eon w21, w22, w23, lsr #22");
732  COMPARE(eon(x24, x25, Operand(x26, ASR, 23)), "eon x24, x25, x26, asr #23");
733  COMPARE(eon(w27, w28, Operand(w29, ROR, 24)), "eon w27, w28, w29, ror #24");
734 
735  COMPARE(ands(w0, w1, Operand(w2)), "ands w0, w1, w2");
736  COMPARE(ands(x3, x4, Operand(x5, LSL, 1)), "ands x3, x4, x5, lsl #1");
737  COMPARE(ands(w6, w7, Operand(w8, LSR, 2)), "ands w6, w7, w8, lsr #2");
738  COMPARE(ands(x9, x10, Operand(x11, ASR, 3)), "ands x9, x10, x11, asr #3");
739  COMPARE(ands(w12, w13, Operand(w14, ROR, 4)), "ands w12, w13, w14, ror #4");
740 
741  COMPARE(bics(w15, w16, Operand(w17)), "bics w15, w16, w17");
742  COMPARE(bics(x18, x19, Operand(x20, LSL, 5)), "bics x18, x19, x20, lsl #5");
743  COMPARE(bics(w21, w22, Operand(w23, LSR, 6)), "bics w21, w22, w23, lsr #6");
744  COMPARE(bics(x24, x25, Operand(x26, ASR, 7)), "bics x24, x25, x26, asr #7");
745  COMPARE(bics(w27, w28, Operand(w29, ROR, 8)), "bics w27, w28, w29, ror #8");
746 
747  COMPARE(tst(w0, Operand(w1)), "tst w0, w1");
748  COMPARE(tst(w2, Operand(w3, ROR, 10)), "tst w2, w3, ror #10");
749  COMPARE(tst(x0, Operand(x1)), "tst x0, x1");
750  COMPARE(tst(x2, Operand(x3, ROR, 42)), "tst x2, x3, ror #42");
751 
752  COMPARE(orn(w0, wzr, Operand(w1)), "mvn w0, w1");
753  COMPARE(orn(w2, wzr, Operand(w3, ASR, 5)), "mvn w2, w3, asr #5");
754  COMPARE(orn(x0, xzr, Operand(x1)), "mvn x0, x1");
755  COMPARE(orn(x2, xzr, Operand(x3, ASR, 42)), "mvn x2, x3, asr #42");
756 
757  COMPARE(orr(w0, wzr, Operand(w1)), "mov w0, w1");
758  COMPARE(orr(x0, xzr, Operand(x1)), "mov x0, x1");
759  COMPARE(orr(w16, wzr, Operand(w17, LSL, 1)), "orr w16, wzr, w17, lsl #1");
760  COMPARE(orr(x16, xzr, Operand(x17, ASR, 2)), "orr x16, xzr, x17, asr #2");
761 
762  CLEANUP();
763 }
764 
765 
766 TEST_(dp_2_source) {
767  SET_UP();
768 
769  COMPARE(lslv(w0, w1, w2), "lsl w0, w1, w2");
770  COMPARE(lslv(x3, x4, x5), "lsl x3, x4, x5");
771  COMPARE(lsrv(w6, w7, w8), "lsr w6, w7, w8");
772  COMPARE(lsrv(x9, x10, x11), "lsr x9, x10, x11");
773  COMPARE(asrv(w12, w13, w14), "asr w12, w13, w14");
774  COMPARE(asrv(x15, x16, x17), "asr x15, x16, x17");
775  COMPARE(rorv(w18, w19, w20), "ror w18, w19, w20");
776  COMPARE(rorv(x21, x22, x23), "ror x21, x22, x23");
777 
778  CLEANUP();
779 }
780 
781 
782 TEST_(adr) {
783  SET_UP();
784 
785  COMPARE_PREFIX(adr(x0, 0), "adr x0, #+0x0");
786  COMPARE_PREFIX(adr(x1, 1), "adr x1, #+0x1");
787  COMPARE_PREFIX(adr(x2, -1), "adr x2, #-0x1");
788  COMPARE_PREFIX(adr(x3, 4), "adr x3, #+0x4");
789  COMPARE_PREFIX(adr(x4, -4), "adr x4, #-0x4");
790  COMPARE_PREFIX(adr(x5, 0x000fffff), "adr x5, #+0xfffff");
791  COMPARE_PREFIX(adr(x6, -0x00100000), "adr x6, #-0x100000");
792  COMPARE_PREFIX(adr(xzr, 0), "adr xzr, #+0x0");
793 
794  CLEANUP();
795 }
796 
797 
798 TEST_(branch) {
799  SET_UP();
800 
801  #define INST_OFF(x) ((x) >> kInstructionSizeLog2)
802  COMPARE_PREFIX(b(INST_OFF(0x4)), "b #+0x4");
803  COMPARE_PREFIX(b(INST_OFF(-0x4)), "b #-0x4");
804  COMPARE_PREFIX(b(INST_OFF(0x7fffffc)), "b #+0x7fffffc");
805  COMPARE_PREFIX(b(INST_OFF(-0x8000000)), "b #-0x8000000");
806  COMPARE_PREFIX(b(INST_OFF(0xffffc), eq), "b.eq #+0xffffc");
807  COMPARE_PREFIX(b(INST_OFF(-0x100000), mi), "b.mi #-0x100000");
808  COMPARE_PREFIX(bl(INST_OFF(0x4)), "bl #+0x4");
809  COMPARE_PREFIX(bl(INST_OFF(-0x4)), "bl #-0x4");
810  COMPARE_PREFIX(bl(INST_OFF(0xffffc)), "bl #+0xffffc");
811  COMPARE_PREFIX(bl(INST_OFF(-0x100000)), "bl #-0x100000");
812  COMPARE_PREFIX(cbz(w0, INST_OFF(0xffffc)), "cbz w0, #+0xffffc");
813  COMPARE_PREFIX(cbz(x1, INST_OFF(-0x100000)), "cbz x1, #-0x100000");
814  COMPARE_PREFIX(cbnz(w2, INST_OFF(0xffffc)), "cbnz w2, #+0xffffc");
815  COMPARE_PREFIX(cbnz(x3, INST_OFF(-0x100000)), "cbnz x3, #-0x100000");
816  COMPARE_PREFIX(tbz(w4, 0, INST_OFF(0x7ffc)), "tbz w4, #0, #+0x7ffc");
817  COMPARE_PREFIX(tbz(x5, 63, INST_OFF(-0x8000)), "tbz x5, #63, #-0x8000");
818  COMPARE_PREFIX(tbz(w6, 31, INST_OFF(0)), "tbz w6, #31, #+0x0");
819  COMPARE_PREFIX(tbz(x7, 31, INST_OFF(0x4)), "tbz w7, #31, #+0x4");
820  COMPARE_PREFIX(tbz(x8, 32, INST_OFF(0x8)), "tbz x8, #32, #+0x8");
821  COMPARE_PREFIX(tbnz(w8, 0, INST_OFF(0x7ffc)), "tbnz w8, #0, #+0x7ffc");
822  COMPARE_PREFIX(tbnz(x9, 63, INST_OFF(-0x8000)), "tbnz x9, #63, #-0x8000");
823  COMPARE_PREFIX(tbnz(w10, 31, INST_OFF(0)), "tbnz w10, #31, #+0x0");
824  COMPARE_PREFIX(tbnz(x11, 31, INST_OFF(0x4)), "tbnz w11, #31, #+0x4");
825  COMPARE_PREFIX(tbnz(x12, 32, INST_OFF(0x8)), "tbnz x12, #32, #+0x8");
826  COMPARE(br(x0), "br x0");
827  COMPARE(blr(x1), "blr x1");
828  COMPARE(ret(x2), "ret x2");
829  COMPARE(ret(lr), "ret")
830 
831  CLEANUP();
832 }
833 
834 
835 TEST_(load_store) {
836  SET_UP();
837 
838  COMPARE(ldr(w0, MemOperand(x1)), "ldr w0, [x1]");
839  COMPARE(ldr(w2, MemOperand(x3, 4)), "ldr w2, [x3, #4]");
840  COMPARE(ldr(w4, MemOperand(x5, 16380)), "ldr w4, [x5, #16380]");
841  COMPARE(ldr(x6, MemOperand(x7)), "ldr x6, [x7]");
842  COMPARE(ldr(x8, MemOperand(x9, 8)), "ldr x8, [x9, #8]");
843  COMPARE(ldr(x10, MemOperand(x11, 32760)), "ldr x10, [x11, #32760]");
844  COMPARE(str(w12, MemOperand(x13)), "str w12, [x13]");
845  COMPARE(str(w14, MemOperand(x15, 4)), "str w14, [x15, #4]");
846  COMPARE(str(w16, MemOperand(x17, 16380)), "str w16, [x17, #16380]");
847  COMPARE(str(x18, MemOperand(x19)), "str x18, [x19]");
848  COMPARE(str(x20, MemOperand(x21, 8)), "str x20, [x21, #8]");
849  COMPARE(str(x22, MemOperand(x23, 32760)), "str x22, [x23, #32760]");
850 
851  COMPARE(ldr(w0, MemOperand(x1, 4, PreIndex)), "ldr w0, [x1, #4]!");
852  COMPARE(ldr(w2, MemOperand(x3, 255, PreIndex)), "ldr w2, [x3, #255]!");
853  COMPARE(ldr(w4, MemOperand(x5, -256, PreIndex)), "ldr w4, [x5, #-256]!");
854  COMPARE(ldr(x6, MemOperand(x7, 8, PreIndex)), "ldr x6, [x7, #8]!");
855  COMPARE(ldr(x8, MemOperand(x9, 255, PreIndex)), "ldr x8, [x9, #255]!");
856  COMPARE(ldr(x10, MemOperand(x11, -256, PreIndex)), "ldr x10, [x11, #-256]!");
857  COMPARE(str(w12, MemOperand(x13, 4, PreIndex)), "str w12, [x13, #4]!");
858  COMPARE(str(w14, MemOperand(x15, 255, PreIndex)), "str w14, [x15, #255]!");
859  COMPARE(str(w16, MemOperand(x17, -256, PreIndex)), "str w16, [x17, #-256]!");
860  COMPARE(str(x18, MemOperand(x19, 8, PreIndex)), "str x18, [x19, #8]!");
861  COMPARE(str(x20, MemOperand(x21, 255, PreIndex)), "str x20, [x21, #255]!");
862  COMPARE(str(x22, MemOperand(x23, -256, PreIndex)), "str x22, [x23, #-256]!");
863 
864  COMPARE(ldr(w0, MemOperand(x1, 4, PostIndex)), "ldr w0, [x1], #4");
865  COMPARE(ldr(w2, MemOperand(x3, 255, PostIndex)), "ldr w2, [x3], #255");
866  COMPARE(ldr(w4, MemOperand(x5, -256, PostIndex)), "ldr w4, [x5], #-256");
867  COMPARE(ldr(x6, MemOperand(x7, 8, PostIndex)), "ldr x6, [x7], #8");
868  COMPARE(ldr(x8, MemOperand(x9, 255, PostIndex)), "ldr x8, [x9], #255");
869  COMPARE(ldr(x10, MemOperand(x11, -256, PostIndex)), "ldr x10, [x11], #-256");
870  COMPARE(str(w12, MemOperand(x13, 4, PostIndex)), "str w12, [x13], #4");
871  COMPARE(str(w14, MemOperand(x15, 255, PostIndex)), "str w14, [x15], #255");
872  COMPARE(str(w16, MemOperand(x17, -256, PostIndex)), "str w16, [x17], #-256");
873  COMPARE(str(x18, MemOperand(x19, 8, PostIndex)), "str x18, [x19], #8");
874  COMPARE(str(x20, MemOperand(x21, 255, PostIndex)), "str x20, [x21], #255");
875  COMPARE(str(x22, MemOperand(x23, -256, PostIndex)), "str x22, [x23], #-256");
876 
877  // TODO(all): Fix this for jssp.
878  COMPARE(ldr(w24, MemOperand(jssp)), "ldr w24, [jssp]");
879  COMPARE(ldr(x25, MemOperand(jssp, 8)), "ldr x25, [jssp, #8]");
880  COMPARE(str(w26, MemOperand(jssp, 4, PreIndex)), "str w26, [jssp, #4]!");
881  COMPARE(str(cp, MemOperand(jssp, -8, PostIndex)), "str cp, [jssp], #-8");
882 
883  COMPARE(ldrsw(x0, MemOperand(x1)), "ldrsw x0, [x1]");
884  COMPARE(ldrsw(x2, MemOperand(x3, 8)), "ldrsw x2, [x3, #8]");
885  COMPARE(ldrsw(x4, MemOperand(x5, 42, PreIndex)), "ldrsw x4, [x5, #42]!");
886  COMPARE(ldrsw(x6, MemOperand(x7, -11, PostIndex)), "ldrsw x6, [x7], #-11");
887 
888  CLEANUP();
889 }
890 
891 
892 TEST_(load_store_regoffset) {
893  SET_UP();
894 
895  COMPARE(ldr(w0, MemOperand(x1, w2, UXTW)), "ldr w0, [x1, w2, uxtw]");
896  COMPARE(ldr(w3, MemOperand(x4, w5, UXTW, 2)), "ldr w3, [x4, w5, uxtw #2]");
897  COMPARE(ldr(w6, MemOperand(x7, x8)), "ldr w6, [x7, x8]");
898  COMPARE(ldr(w9, MemOperand(x10, x11, LSL, 2)), "ldr w9, [x10, x11, lsl #2]");
899  COMPARE(ldr(w12, MemOperand(x13, w14, SXTW)), "ldr w12, [x13, w14, sxtw]");
900  COMPARE(ldr(w15, MemOperand(x16, w17, SXTW, 2)),
901  "ldr w15, [x16, w17, sxtw #2]");
902  COMPARE(ldr(w18, MemOperand(x19, x20, SXTX)), "ldr w18, [x19, x20, sxtx]");
903  COMPARE(ldr(w21, MemOperand(x22, x23, SXTX, 2)),
904  "ldr w21, [x22, x23, sxtx #2]");
905  COMPARE(ldr(x0, MemOperand(x1, w2, UXTW)), "ldr x0, [x1, w2, uxtw]");
906  COMPARE(ldr(x3, MemOperand(x4, w5, UXTW, 3)), "ldr x3, [x4, w5, uxtw #3]");
907  COMPARE(ldr(x6, MemOperand(x7, x8)), "ldr x6, [x7, x8]");
908  COMPARE(ldr(x9, MemOperand(x10, x11, LSL, 3)), "ldr x9, [x10, x11, lsl #3]");
909  COMPARE(ldr(x12, MemOperand(x13, w14, SXTW)), "ldr x12, [x13, w14, sxtw]");
910  COMPARE(ldr(x15, MemOperand(x16, w17, SXTW, 3)),
911  "ldr x15, [x16, w17, sxtw #3]");
912  COMPARE(ldr(x18, MemOperand(x19, x20, SXTX)), "ldr x18, [x19, x20, sxtx]");
913  COMPARE(ldr(x21, MemOperand(x22, x23, SXTX, 3)),
914  "ldr x21, [x22, x23, sxtx #3]");
915 
916  COMPARE(str(w0, MemOperand(x1, w2, UXTW)), "str w0, [x1, w2, uxtw]");
917  COMPARE(str(w3, MemOperand(x4, w5, UXTW, 2)), "str w3, [x4, w5, uxtw #2]");
918  COMPARE(str(w6, MemOperand(x7, x8)), "str w6, [x7, x8]");
919  COMPARE(str(w9, MemOperand(x10, x11, LSL, 2)), "str w9, [x10, x11, lsl #2]");
920  COMPARE(str(w12, MemOperand(x13, w14, SXTW)), "str w12, [x13, w14, sxtw]");
921  COMPARE(str(w15, MemOperand(x16, w17, SXTW, 2)),
922  "str w15, [x16, w17, sxtw #2]");
923  COMPARE(str(w18, MemOperand(x19, x20, SXTX)), "str w18, [x19, x20, sxtx]");
924  COMPARE(str(w21, MemOperand(x22, x23, SXTX, 2)),
925  "str w21, [x22, x23, sxtx #2]");
926  COMPARE(str(x0, MemOperand(x1, w2, UXTW)), "str x0, [x1, w2, uxtw]");
927  COMPARE(str(x3, MemOperand(x4, w5, UXTW, 3)), "str x3, [x4, w5, uxtw #3]");
928  COMPARE(str(x6, MemOperand(x7, x8)), "str x6, [x7, x8]");
929  COMPARE(str(x9, MemOperand(x10, x11, LSL, 3)), "str x9, [x10, x11, lsl #3]");
930  COMPARE(str(x12, MemOperand(x13, w14, SXTW)), "str x12, [x13, w14, sxtw]");
931  COMPARE(str(x15, MemOperand(x16, w17, SXTW, 3)),
932  "str x15, [x16, w17, sxtw #3]");
933  COMPARE(str(x18, MemOperand(x19, x20, SXTX)), "str x18, [x19, x20, sxtx]");
934  COMPARE(str(x21, MemOperand(x22, x23, SXTX, 3)),
935  "str x21, [x22, x23, sxtx #3]");
936 
937  COMPARE(ldrb(w0, MemOperand(x1, w2, UXTW)), "ldrb w0, [x1, w2, uxtw]");
938  COMPARE(ldrb(w6, MemOperand(x7, x8)), "ldrb w6, [x7, x8]");
939  COMPARE(ldrb(w12, MemOperand(x13, w14, SXTW)), "ldrb w12, [x13, w14, sxtw]");
940  COMPARE(ldrb(w18, MemOperand(x19, x20, SXTX)), "ldrb w18, [x19, x20, sxtx]");
941  COMPARE(strb(w0, MemOperand(x1, w2, UXTW)), "strb w0, [x1, w2, uxtw]");
942  COMPARE(strb(w6, MemOperand(x7, x8)), "strb w6, [x7, x8]");
943  COMPARE(strb(w12, MemOperand(x13, w14, SXTW)), "strb w12, [x13, w14, sxtw]");
944  COMPARE(strb(w18, MemOperand(x19, x20, SXTX)), "strb w18, [x19, x20, sxtx]");
945 
946  COMPARE(ldrh(w0, MemOperand(x1, w2, UXTW)), "ldrh w0, [x1, w2, uxtw]");
947  COMPARE(ldrh(w3, MemOperand(x4, w5, UXTW, 1)), "ldrh w3, [x4, w5, uxtw #1]");
948  COMPARE(ldrh(w6, MemOperand(x7, x8)), "ldrh w6, [x7, x8]");
949  COMPARE(ldrh(w9, MemOperand(x10, x11, LSL, 1)),
950  "ldrh w9, [x10, x11, lsl #1]");
951  COMPARE(ldrh(w12, MemOperand(x13, w14, SXTW)), "ldrh w12, [x13, w14, sxtw]");
952  COMPARE(ldrh(w15, MemOperand(x16, w17, SXTW, 1)),
953  "ldrh w15, [x16, w17, sxtw #1]");
954  COMPARE(ldrh(w18, MemOperand(x19, x20, SXTX)), "ldrh w18, [x19, x20, sxtx]");
955  COMPARE(ldrh(w21, MemOperand(x22, x23, SXTX, 1)),
956  "ldrh w21, [x22, x23, sxtx #1]");
957  COMPARE(strh(w0, MemOperand(x1, w2, UXTW)), "strh w0, [x1, w2, uxtw]");
958  COMPARE(strh(w3, MemOperand(x4, w5, UXTW, 1)), "strh w3, [x4, w5, uxtw #1]");
959  COMPARE(strh(w6, MemOperand(x7, x8)), "strh w6, [x7, x8]");
960  COMPARE(strh(w9, MemOperand(x10, x11, LSL, 1)),
961  "strh w9, [x10, x11, lsl #1]");
962  COMPARE(strh(w12, MemOperand(x13, w14, SXTW)), "strh w12, [x13, w14, sxtw]");
963  COMPARE(strh(w15, MemOperand(x16, w17, SXTW, 1)),
964  "strh w15, [x16, w17, sxtw #1]");
965  COMPARE(strh(w18, MemOperand(x19, x20, SXTX)), "strh w18, [x19, x20, sxtx]");
966  COMPARE(strh(w21, MemOperand(x22, x23, SXTX, 1)),
967  "strh w21, [x22, x23, sxtx #1]");
968 
969  // TODO(all): Fix this for jssp.
970  COMPARE(ldr(x0, MemOperand(jssp, wzr, SXTW)), "ldr x0, [jssp, wzr, sxtw]");
971  COMPARE(str(x1, MemOperand(jssp, xzr)), "str x1, [jssp, xzr]");
972 
973  CLEANUP();
974 }
975 
976 
977 TEST_(load_store_byte) {
978  SET_UP();
979 
980  COMPARE(ldrb(w0, MemOperand(x1)), "ldrb w0, [x1]");
981  COMPARE(ldrb(x2, MemOperand(x3)), "ldrb w2, [x3]");
982  COMPARE(ldrb(w4, MemOperand(x5, 4095)), "ldrb w4, [x5, #4095]");
983  COMPARE(ldrb(w6, MemOperand(x7, 255, PreIndex)), "ldrb w6, [x7, #255]!");
984  COMPARE(ldrb(w8, MemOperand(x9, -256, PreIndex)), "ldrb w8, [x9, #-256]!");
985  COMPARE(ldrb(w10, MemOperand(x11, 255, PostIndex)), "ldrb w10, [x11], #255");
986  COMPARE(ldrb(w12, MemOperand(x13, -256, PostIndex)),
987  "ldrb w12, [x13], #-256");
988  COMPARE(strb(w14, MemOperand(x15)), "strb w14, [x15]");
989  COMPARE(strb(x16, MemOperand(x17)), "strb w16, [x17]");
990  COMPARE(strb(w18, MemOperand(x19, 4095)), "strb w18, [x19, #4095]");
991  COMPARE(strb(w20, MemOperand(x21, 255, PreIndex)), "strb w20, [x21, #255]!");
992  COMPARE(strb(w22, MemOperand(x23, -256, PreIndex)),
993  "strb w22, [x23, #-256]!");
994  COMPARE(strb(w24, MemOperand(x25, 255, PostIndex)), "strb w24, [x25], #255");
995  COMPARE(strb(w26, MemOperand(cp, -256, PostIndex)),
996  "strb w26, [cp], #-256");
997  // TODO(all): Fix this for jssp.
998  COMPARE(ldrb(w28, MemOperand(jssp, 3, PostIndex)), "ldrb w28, [jssp], #3");
999  COMPARE(strb(fp, MemOperand(jssp, -42, PreIndex)), "strb w29, [jssp, #-42]!");
1000  COMPARE(ldrsb(w0, MemOperand(x1)), "ldrsb w0, [x1]");
1001  COMPARE(ldrsb(x2, MemOperand(x3, 8)), "ldrsb x2, [x3, #8]");
1002  COMPARE(ldrsb(w4, MemOperand(x5, 42, PreIndex)), "ldrsb w4, [x5, #42]!");
1003  COMPARE(ldrsb(x6, MemOperand(x7, -11, PostIndex)), "ldrsb x6, [x7], #-11");
1004 
1005  CLEANUP();
1006 }
1007 
1008 
1009 TEST_(load_store_half) {
1010  SET_UP();
1011 
1012  COMPARE(ldrh(w0, MemOperand(x1)), "ldrh w0, [x1]");
1013  COMPARE(ldrh(x2, MemOperand(x3)), "ldrh w2, [x3]");
1014  COMPARE(ldrh(w4, MemOperand(x5, 8190)), "ldrh w4, [x5, #8190]");
1015  COMPARE(ldrh(w6, MemOperand(x7, 255, PreIndex)), "ldrh w6, [x7, #255]!");
1016  COMPARE(ldrh(w8, MemOperand(x9, -256, PreIndex)), "ldrh w8, [x9, #-256]!");
1017  COMPARE(ldrh(w10, MemOperand(x11, 255, PostIndex)), "ldrh w10, [x11], #255");
1018  COMPARE(ldrh(w12, MemOperand(x13, -256, PostIndex)),
1019  "ldrh w12, [x13], #-256");
1020  COMPARE(strh(w14, MemOperand(x15)), "strh w14, [x15]");
1021  COMPARE(strh(x16, MemOperand(x17)), "strh w16, [x17]");
1022  COMPARE(strh(w18, MemOperand(x19, 8190)), "strh w18, [x19, #8190]");
1023  COMPARE(strh(w20, MemOperand(x21, 255, PreIndex)), "strh w20, [x21, #255]!");
1024  COMPARE(strh(w22, MemOperand(x23, -256, PreIndex)),
1025  "strh w22, [x23, #-256]!");
1026  COMPARE(strh(w24, MemOperand(x25, 255, PostIndex)), "strh w24, [x25], #255");
1027  COMPARE(strh(w26, MemOperand(cp, -256, PostIndex)),
1028  "strh w26, [cp], #-256");
1029  // TODO(all): Fix this for jssp.
1030  COMPARE(ldrh(w28, MemOperand(jssp, 3, PostIndex)), "ldrh w28, [jssp], #3");
1031  COMPARE(strh(fp, MemOperand(jssp, -42, PreIndex)), "strh w29, [jssp, #-42]!");
1032  COMPARE(ldrh(w30, MemOperand(x0, 255)), "ldurh w30, [x0, #255]");
1033  COMPARE(ldrh(x1, MemOperand(x2, -256)), "ldurh w1, [x2, #-256]");
1034  COMPARE(strh(w3, MemOperand(x4, 255)), "sturh w3, [x4, #255]");
1035  COMPARE(strh(x5, MemOperand(x6, -256)), "sturh w5, [x6, #-256]");
1036  COMPARE(ldrsh(w0, MemOperand(x1)), "ldrsh w0, [x1]");
1037  COMPARE(ldrsh(w2, MemOperand(x3, 8)), "ldrsh w2, [x3, #8]");
1038  COMPARE(ldrsh(w4, MemOperand(x5, 42, PreIndex)), "ldrsh w4, [x5, #42]!");
1039  COMPARE(ldrsh(x6, MemOperand(x7, -11, PostIndex)), "ldrsh x6, [x7], #-11");
1040 
1041  CLEANUP();
1042 }
1043 
1044 
1045 TEST_(load_store_fp) {
1046  SET_UP();
1047 
1048  COMPARE(ldr(s0, MemOperand(x1)), "ldr s0, [x1]");
1049  COMPARE(ldr(s2, MemOperand(x3, 4)), "ldr s2, [x3, #4]");
1050  COMPARE(ldr(s4, MemOperand(x5, 16380)), "ldr s4, [x5, #16380]");
1051  COMPARE(ldr(d6, MemOperand(x7)), "ldr d6, [x7]");
1052  COMPARE(ldr(d8, MemOperand(x9, 8)), "ldr d8, [x9, #8]");
1053  COMPARE(ldr(d10, MemOperand(x11, 32760)), "ldr d10, [x11, #32760]");
1054  COMPARE(str(s12, MemOperand(x13)), "str s12, [x13]");
1055  COMPARE(str(s14, MemOperand(x15, 4)), "str s14, [x15, #4]");
1056  COMPARE(str(s16, MemOperand(x17, 16380)), "str s16, [x17, #16380]");
1057  COMPARE(str(d18, MemOperand(x19)), "str d18, [x19]");
1058  COMPARE(str(d20, MemOperand(x21, 8)), "str d20, [x21, #8]");
1059  COMPARE(str(d22, MemOperand(x23, 32760)), "str d22, [x23, #32760]");
1060 
1061  COMPARE(ldr(s0, MemOperand(x1, 4, PreIndex)), "ldr s0, [x1, #4]!");
1062  COMPARE(ldr(s2, MemOperand(x3, 255, PreIndex)), "ldr s2, [x3, #255]!");
1063  COMPARE(ldr(s4, MemOperand(x5, -256, PreIndex)), "ldr s4, [x5, #-256]!");
1064  COMPARE(ldr(d6, MemOperand(x7, 8, PreIndex)), "ldr d6, [x7, #8]!");
1065  COMPARE(ldr(d8, MemOperand(x9, 255, PreIndex)), "ldr d8, [x9, #255]!");
1066  COMPARE(ldr(d10, MemOperand(x11, -256, PreIndex)), "ldr d10, [x11, #-256]!");
1067  COMPARE(str(s12, MemOperand(x13, 4, PreIndex)), "str s12, [x13, #4]!");
1068  COMPARE(str(s14, MemOperand(x15, 255, PreIndex)), "str s14, [x15, #255]!");
1069  COMPARE(str(s16, MemOperand(x17, -256, PreIndex)), "str s16, [x17, #-256]!");
1070  COMPARE(str(d18, MemOperand(x19, 8, PreIndex)), "str d18, [x19, #8]!");
1071  COMPARE(str(d20, MemOperand(x21, 255, PreIndex)), "str d20, [x21, #255]!");
1072  COMPARE(str(d22, MemOperand(x23, -256, PreIndex)), "str d22, [x23, #-256]!");
1073 
1074  COMPARE(ldr(s0, MemOperand(x1, 4, PostIndex)), "ldr s0, [x1], #4");
1075  COMPARE(ldr(s2, MemOperand(x3, 255, PostIndex)), "ldr s2, [x3], #255");
1076  COMPARE(ldr(s4, MemOperand(x5, -256, PostIndex)), "ldr s4, [x5], #-256");
1077  COMPARE(ldr(d6, MemOperand(x7, 8, PostIndex)), "ldr d6, [x7], #8");
1078  COMPARE(ldr(d8, MemOperand(x9, 255, PostIndex)), "ldr d8, [x9], #255");
1079  COMPARE(ldr(d10, MemOperand(x11, -256, PostIndex)), "ldr d10, [x11], #-256");
1080  COMPARE(str(s12, MemOperand(x13, 4, PostIndex)), "str s12, [x13], #4");
1081  COMPARE(str(s14, MemOperand(x15, 255, PostIndex)), "str s14, [x15], #255");
1082  COMPARE(str(s16, MemOperand(x17, -256, PostIndex)), "str s16, [x17], #-256");
1083  COMPARE(str(d18, MemOperand(x19, 8, PostIndex)), "str d18, [x19], #8");
1084  COMPARE(str(d20, MemOperand(x21, 255, PostIndex)), "str d20, [x21], #255");
1085  COMPARE(str(d22, MemOperand(x23, -256, PostIndex)), "str d22, [x23], #-256");
1086 
1087  // TODO(all): Fix this for jssp.
1088  COMPARE(ldr(s24, MemOperand(jssp)), "ldr s24, [jssp]");
1089  COMPARE(ldr(d25, MemOperand(jssp, 8)), "ldr d25, [jssp, #8]");
1090  COMPARE(str(s26, MemOperand(jssp, 4, PreIndex)), "str s26, [jssp, #4]!");
1091  COMPARE(str(d27, MemOperand(jssp, -8, PostIndex)), "str d27, [jssp], #-8");
1092 
1093  CLEANUP();
1094 }
1095 
1096 
1097 TEST_(load_store_unscaled) {
1098  SET_UP();
1099 
1100  COMPARE(ldr(w0, MemOperand(x1, 1)), "ldur w0, [x1, #1]");
1101  COMPARE(ldr(w2, MemOperand(x3, -1)), "ldur w2, [x3, #-1]");
1102  COMPARE(ldr(w4, MemOperand(x5, 255)), "ldur w4, [x5, #255]");
1103  COMPARE(ldr(w6, MemOperand(x7, -256)), "ldur w6, [x7, #-256]");
1104  COMPARE(ldr(x8, MemOperand(x9, 1)), "ldur x8, [x9, #1]");
1105  COMPARE(ldr(x10, MemOperand(x11, -1)), "ldur x10, [x11, #-1]");
1106  COMPARE(ldr(x12, MemOperand(x13, 255)), "ldur x12, [x13, #255]");
1107  COMPARE(ldr(x14, MemOperand(x15, -256)), "ldur x14, [x15, #-256]");
1108  COMPARE(str(w16, MemOperand(x17, 1)), "stur w16, [x17, #1]");
1109  COMPARE(str(w18, MemOperand(x19, -1)), "stur w18, [x19, #-1]");
1110  COMPARE(str(w20, MemOperand(x21, 255)), "stur w20, [x21, #255]");
1111  COMPARE(str(w22, MemOperand(x23, -256)), "stur w22, [x23, #-256]");
1112  COMPARE(str(x24, MemOperand(x25, 1)), "stur x24, [x25, #1]");
1113  COMPARE(str(x26, MemOperand(cp, -1)), "stur x26, [cp, #-1]");
1114  COMPARE(str(jssp, MemOperand(fp, 255)), "stur jssp, [fp, #255]");
1115  COMPARE(str(lr, MemOperand(x0, -256)), "stur lr, [x0, #-256]");
1116  COMPARE(ldr(w0, MemOperand(csp, 1)), "ldur w0, [csp, #1]");
1117  COMPARE(str(x1, MemOperand(csp, -1)), "stur x1, [csp, #-1]");
1118  COMPARE(ldrb(w2, MemOperand(x3, -2)), "ldurb w2, [x3, #-2]");
1119  COMPARE(ldrsb(w4, MemOperand(x5, -3)), "ldursb w4, [x5, #-3]");
1120  COMPARE(ldrsb(x6, MemOperand(x7, -4)), "ldursb x6, [x7, #-4]");
1121  COMPARE(ldrh(w8, MemOperand(x9, -5)), "ldurh w8, [x9, #-5]");
1122  COMPARE(ldrsh(w10, MemOperand(x11, -6)), "ldursh w10, [x11, #-6]");
1123  COMPARE(ldrsh(x12, MemOperand(x13, -7)), "ldursh x12, [x13, #-7]");
1124  COMPARE(ldrsw(x14, MemOperand(x15, -8)), "ldursw x14, [x15, #-8]");
1125 
1126  CLEANUP();
1127 }
1128 
1129 
1130 TEST_(load_store_pair) {
1131  SET_UP();
1132 
1133  COMPARE(ldp(w0, w1, MemOperand(x2)), "ldp w0, w1, [x2]");
1134  COMPARE(ldp(x3, x4, MemOperand(x5)), "ldp x3, x4, [x5]");
1135  COMPARE(ldp(w6, w7, MemOperand(x8, 4)), "ldp w6, w7, [x8, #4]");
1136  COMPARE(ldp(x9, x10, MemOperand(x11, 8)), "ldp x9, x10, [x11, #8]");
1137  COMPARE(ldp(w12, w13, MemOperand(x14, 252)), "ldp w12, w13, [x14, #252]");
1138  COMPARE(ldp(x15, x16, MemOperand(x17, 504)), "ldp x15, x16, [x17, #504]");
1139  COMPARE(ldp(w18, w19, MemOperand(x20, -256)), "ldp w18, w19, [x20, #-256]");
1140  COMPARE(ldp(x21, x22, MemOperand(x23, -512)), "ldp x21, x22, [x23, #-512]");
1141  COMPARE(ldp(w24, w25, MemOperand(x26, 252, PreIndex)),
1142  "ldp w24, w25, [x26, #252]!");
1143  COMPARE(ldp(cp, jssp, MemOperand(fp, 504, PreIndex)),
1144  "ldp cp, jssp, [fp, #504]!");
1145  COMPARE(ldp(w30, w0, MemOperand(x1, -256, PreIndex)),
1146  "ldp w30, w0, [x1, #-256]!");
1147  COMPARE(ldp(x2, x3, MemOperand(x4, -512, PreIndex)),
1148  "ldp x2, x3, [x4, #-512]!");
1149  COMPARE(ldp(w5, w6, MemOperand(x7, 252, PostIndex)),
1150  "ldp w5, w6, [x7], #252");
1151  COMPARE(ldp(x8, x9, MemOperand(x10, 504, PostIndex)),
1152  "ldp x8, x9, [x10], #504");
1153  COMPARE(ldp(w11, w12, MemOperand(x13, -256, PostIndex)),
1154  "ldp w11, w12, [x13], #-256");
1155  COMPARE(ldp(x14, x15, MemOperand(x16, -512, PostIndex)),
1156  "ldp x14, x15, [x16], #-512");
1157 
1158  COMPARE(ldp(s17, s18, MemOperand(x19)), "ldp s17, s18, [x19]");
1159  COMPARE(ldp(s20, s21, MemOperand(x22, 252)), "ldp s20, s21, [x22, #252]");
1160  COMPARE(ldp(s23, s24, MemOperand(x25, -256)), "ldp s23, s24, [x25, #-256]");
1161  COMPARE(ldp(s26, s27, MemOperand(jssp, 252, PreIndex)),
1162  "ldp s26, s27, [jssp, #252]!");
1163  COMPARE(ldp(s29, s30, MemOperand(fp, -256, PreIndex)),
1164  "ldp s29, s30, [fp, #-256]!");
1165  COMPARE(ldp(s31, s0, MemOperand(x1, 252, PostIndex)),
1166  "ldp s31, s0, [x1], #252");
1167  COMPARE(ldp(s2, s3, MemOperand(x4, -256, PostIndex)),
1168  "ldp s2, s3, [x4], #-256");
1169  COMPARE(ldp(d17, d18, MemOperand(x19)), "ldp d17, d18, [x19]");
1170  COMPARE(ldp(d20, d21, MemOperand(x22, 504)), "ldp d20, d21, [x22, #504]");
1171  COMPARE(ldp(d23, d24, MemOperand(x25, -512)), "ldp d23, d24, [x25, #-512]");
1172  COMPARE(ldp(d26, d27, MemOperand(jssp, 504, PreIndex)),
1173  "ldp d26, d27, [jssp, #504]!");
1174  COMPARE(ldp(d29, d30, MemOperand(fp, -512, PreIndex)),
1175  "ldp d29, d30, [fp, #-512]!");
1176  COMPARE(ldp(d31, d0, MemOperand(x1, 504, PostIndex)),
1177  "ldp d31, d0, [x1], #504");
1178  COMPARE(ldp(d2, d3, MemOperand(x4, -512, PostIndex)),
1179  "ldp d2, d3, [x4], #-512");
1180 
1181  COMPARE(stp(w0, w1, MemOperand(x2)), "stp w0, w1, [x2]");
1182  COMPARE(stp(x3, x4, MemOperand(x5)), "stp x3, x4, [x5]");
1183  COMPARE(stp(w6, w7, MemOperand(x8, 4)), "stp w6, w7, [x8, #4]");
1184  COMPARE(stp(x9, x10, MemOperand(x11, 8)), "stp x9, x10, [x11, #8]");
1185  COMPARE(stp(w12, w13, MemOperand(x14, 252)), "stp w12, w13, [x14, #252]");
1186  COMPARE(stp(x15, x16, MemOperand(x17, 504)), "stp x15, x16, [x17, #504]");
1187  COMPARE(stp(w18, w19, MemOperand(x20, -256)), "stp w18, w19, [x20, #-256]");
1188  COMPARE(stp(x21, x22, MemOperand(x23, -512)), "stp x21, x22, [x23, #-512]");
1189  COMPARE(stp(w24, w25, MemOperand(x26, 252, PreIndex)),
1190  "stp w24, w25, [x26, #252]!");
1191  COMPARE(stp(cp, jssp, MemOperand(fp, 504, PreIndex)),
1192  "stp cp, jssp, [fp, #504]!");
1193  COMPARE(stp(w30, w0, MemOperand(x1, -256, PreIndex)),
1194  "stp w30, w0, [x1, #-256]!");
1195  COMPARE(stp(x2, x3, MemOperand(x4, -512, PreIndex)),
1196  "stp x2, x3, [x4, #-512]!");
1197  COMPARE(stp(w5, w6, MemOperand(x7, 252, PostIndex)),
1198  "stp w5, w6, [x7], #252");
1199  COMPARE(stp(x8, x9, MemOperand(x10, 504, PostIndex)),
1200  "stp x8, x9, [x10], #504");
1201  COMPARE(stp(w11, w12, MemOperand(x13, -256, PostIndex)),
1202  "stp w11, w12, [x13], #-256");
1203  COMPARE(stp(x14, x15, MemOperand(x16, -512, PostIndex)),
1204  "stp x14, x15, [x16], #-512");
1205 
1206  COMPARE(stp(s17, s18, MemOperand(x19)), "stp s17, s18, [x19]");
1207  COMPARE(stp(s20, s21, MemOperand(x22, 252)), "stp s20, s21, [x22, #252]");
1208  COMPARE(stp(s23, s24, MemOperand(x25, -256)), "stp s23, s24, [x25, #-256]");
1209  COMPARE(stp(s26, s27, MemOperand(jssp, 252, PreIndex)),
1210  "stp s26, s27, [jssp, #252]!");
1211  COMPARE(stp(s29, s30, MemOperand(fp, -256, PreIndex)),
1212  "stp s29, s30, [fp, #-256]!");
1213  COMPARE(stp(s31, s0, MemOperand(x1, 252, PostIndex)),
1214  "stp s31, s0, [x1], #252");
1215  COMPARE(stp(s2, s3, MemOperand(x4, -256, PostIndex)),
1216  "stp s2, s3, [x4], #-256");
1217  COMPARE(stp(d17, d18, MemOperand(x19)), "stp d17, d18, [x19]");
1218  COMPARE(stp(d20, d21, MemOperand(x22, 504)), "stp d20, d21, [x22, #504]");
1219  COMPARE(stp(d23, d24, MemOperand(x25, -512)), "stp d23, d24, [x25, #-512]");
1220  COMPARE(stp(d26, d27, MemOperand(jssp, 504, PreIndex)),
1221  "stp d26, d27, [jssp, #504]!");
1222  COMPARE(stp(d29, d30, MemOperand(fp, -512, PreIndex)),
1223  "stp d29, d30, [fp, #-512]!");
1224  COMPARE(stp(d31, d0, MemOperand(x1, 504, PostIndex)),
1225  "stp d31, d0, [x1], #504");
1226  COMPARE(stp(d2, d3, MemOperand(x4, -512, PostIndex)),
1227  "stp d2, d3, [x4], #-512");
1228 
1229  // TODO(all): Update / Restore this test.
1230  COMPARE(ldp(w16, w17, MemOperand(jssp, 4, PostIndex)),
1231  "ldp w16, w17, [jssp], #4");
1232  COMPARE(stp(x18, x19, MemOperand(jssp, -8, PreIndex)),
1233  "stp x18, x19, [jssp, #-8]!");
1234  COMPARE(ldp(s30, s31, MemOperand(jssp, 12, PostIndex)),
1235  "ldp s30, s31, [jssp], #12");
1236  COMPARE(stp(d30, d31, MemOperand(jssp, -16)),
1237  "stp d30, d31, [jssp, #-16]");
1238 
1239  COMPARE(ldpsw(x0, x1, MemOperand(x2)), "ldpsw x0, x1, [x2]");
1240  COMPARE(ldpsw(x3, x4, MemOperand(x5, 16)), "ldpsw x3, x4, [x5, #16]");
1241  COMPARE(ldpsw(x6, x7, MemOperand(x8, -32, PreIndex)),
1242  "ldpsw x6, x7, [x8, #-32]!");
1243  COMPARE(ldpsw(x9, x10, MemOperand(x11, 128, PostIndex)),
1244  "ldpsw x9, x10, [x11], #128");
1245 
1246  CLEANUP();
1247 }
1248 
1249 
1250 TEST_(load_store_pair_nontemp) {
1251  SET_UP();
1252 
1253  COMPARE(ldnp(w0, w1, MemOperand(x2)), "ldnp w0, w1, [x2]");
1254  COMPARE(stnp(w3, w4, MemOperand(x5, 252)), "stnp w3, w4, [x5, #252]");
1255  COMPARE(ldnp(w6, w7, MemOperand(x8, -256)), "ldnp w6, w7, [x8, #-256]");
1256  COMPARE(stnp(x9, x10, MemOperand(x11)), "stnp x9, x10, [x11]");
1257  COMPARE(ldnp(x12, x13, MemOperand(x14, 504)), "ldnp x12, x13, [x14, #504]");
1258  COMPARE(stnp(x15, x16, MemOperand(x17, -512)), "stnp x15, x16, [x17, #-512]");
1259  COMPARE(ldnp(s18, s19, MemOperand(x20)), "ldnp s18, s19, [x20]");
1260  COMPARE(stnp(s21, s22, MemOperand(x23, 252)), "stnp s21, s22, [x23, #252]");
1261  COMPARE(ldnp(s24, s25, MemOperand(x26, -256)), "ldnp s24, s25, [x26, #-256]");
1262  COMPARE(stnp(d27, d28, MemOperand(fp)), "stnp d27, d28, [fp]");
1263  COMPARE(ldnp(d30, d31, MemOperand(x0, 504)), "ldnp d30, d31, [x0, #504]");
1264  COMPARE(stnp(d1, d2, MemOperand(x3, -512)), "stnp d1, d2, [x3, #-512]");
1265 
1266  CLEANUP();
1267 }
1268 
1269 #if 0 // TODO(all): enable.
1270 TEST_(load_literal) {
1271  SET_UP();
1272 
1273  COMPARE_PREFIX(ldr(x10, 0x1234567890abcdefUL), "ldr x10, pc+8");
1274  COMPARE_PREFIX(ldr(w20, 0xfedcba09), "ldr w20, pc+8");
1275  COMPARE_PREFIX(ldr(d11, 1.234), "ldr d11, pc+8");
1276  COMPARE_PREFIX(ldr(s22, 2.5f), "ldr s22, pc+8");
1277 
1278  CLEANUP();
1279 }
1280 #endif
1281 
1282 TEST_(cond_select) {
1283  SET_UP();
1284 
1285  COMPARE(csel(w0, w1, w2, eq), "csel w0, w1, w2, eq");
1286  COMPARE(csel(x3, x4, x5, ne), "csel x3, x4, x5, ne");
1287  COMPARE(csinc(w6, w7, w8, hs), "csinc w6, w7, w8, hs");
1288  COMPARE(csinc(x9, x10, x11, lo), "csinc x9, x10, x11, lo");
1289  COMPARE(csinv(w12, w13, w14, mi), "csinv w12, w13, w14, mi");
1290  COMPARE(csinv(x15, x16, x17, pl), "csinv x15, x16, x17, pl");
1291  COMPARE(csneg(w18, w19, w20, vs), "csneg w18, w19, w20, vs");
1292  COMPARE(csneg(x21, x22, x23, vc), "csneg x21, x22, x23, vc");
1293  COMPARE(cset(w24, hi), "cset w24, hi");
1294  COMPARE(cset(x25, ls), "cset x25, ls");
1295  COMPARE(csetm(w26, ge), "csetm w26, ge");
1296  COMPARE(csetm(cp, lt), "csetm cp, lt");
1297  COMPARE(cinc(w28, w29, gt), "cinc w28, w29, gt");
1298  COMPARE(cinc(lr, x0, le), "cinc lr, x0, le");
1299  COMPARE(cinv(w1, w2, eq), "cinv w1, w2, eq");
1300  COMPARE(cinv(x3, x4, ne), "cinv x3, x4, ne");
1301  COMPARE(cneg(w5, w6, hs), "cneg w5, w6, hs");
1302  COMPARE(cneg(x7, x8, lo), "cneg x7, x8, lo");
1303 
1304  COMPARE(csel(x0, x1, x2, al), "csel x0, x1, x2, al");
1305  COMPARE(csel(x1, x2, x3, nv), "csel x1, x2, x3, nv");
1306  COMPARE(csinc(x2, x3, x4, al), "csinc x2, x3, x4, al");
1307  COMPARE(csinc(x3, x4, x5, nv), "csinc x3, x4, x5, nv");
1308  COMPARE(csinv(x4, x5, x6, al), "csinv x4, x5, x6, al");
1309  COMPARE(csinv(x5, x6, x7, nv), "csinv x5, x6, x7, nv");
1310  COMPARE(csneg(x6, x7, x8, al), "csneg x6, x7, x8, al");
1311  COMPARE(csneg(x7, x8, x9, nv), "csneg x7, x8, x9, nv");
1312 
1313  CLEANUP();
1314 }
1315 
1316 
1317 TEST(cond_select_macro) {
1318  SET_UP_CLASS(MacroAssembler);
1319 
1320  COMPARE(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq");
1321  COMPARE(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne");
1322  COMPARE(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs");
1323  COMPARE(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo");
1324  COMPARE(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi");
1325  COMPARE(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl");
1326 
1327  CLEANUP();
1328 }
1329 
1330 
1331 TEST_(cond_cmp) {
1332  SET_UP();
1333 
1334  COMPARE(ccmn(w0, w1, NZCVFlag, eq), "ccmn w0, w1, #NZCV, eq");
1335  COMPARE(ccmn(x2, x3, NZCFlag, ne), "ccmn x2, x3, #NZCv, ne");
1336  COMPARE(ccmp(w4, w5, NZVFlag, hs), "ccmp w4, w5, #NZcV, hs");
1337  COMPARE(ccmp(x6, x7, NZFlag, lo), "ccmp x6, x7, #NZcv, lo");
1338  COMPARE(ccmn(w8, 31, NFlag, mi), "ccmn w8, #31, #Nzcv, mi");
1339  COMPARE(ccmn(x9, 30, NCFlag, pl), "ccmn x9, #30, #NzCv, pl");
1340  COMPARE(ccmp(w10, 29, NVFlag, vs), "ccmp w10, #29, #NzcV, vs");
1341  COMPARE(ccmp(x11, 28, NFlag, vc), "ccmp x11, #28, #Nzcv, vc");
1342  COMPARE(ccmn(w12, w13, NoFlag, al), "ccmn w12, w13, #nzcv, al");
1343  COMPARE(ccmp(x14, 27, ZVFlag, nv), "ccmp x14, #27, #nZcV, nv");
1344 
1345  CLEANUP();
1346 }
1347 
1348 
1349 TEST_(cond_cmp_macro) {
1350  SET_UP_CLASS(MacroAssembler);
1351 
1352  COMPARE(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi");
1353  COMPARE(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge");
1354  COMPARE(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt");
1355  COMPARE(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls");
1356 
1357  CLEANUP();
1358 }
1359 
1360 
1361 TEST_(fmov_imm) {
1362  SET_UP();
1363 
1364  COMPARE(fmov(s0, 1.0f), "fmov s0, #0x70 (1.0000)");
1365  COMPARE(fmov(s31, -13.0f), "fmov s31, #0xaa (-13.0000)");
1366  COMPARE(fmov(d1, 1.0), "fmov d1, #0x70 (1.0000)");
1367  COMPARE(fmov(d29, -13.0), "fmov d29, #0xaa (-13.0000)");
1368 
1369  CLEANUP();
1370 }
1371 
1372 
1373 TEST_(fmov_reg) {
1374  SET_UP();
1375 
1376  COMPARE(fmov(w3, s13), "fmov w3, s13");
1377  COMPARE(fmov(x6, d26), "fmov x6, d26");
1378  COMPARE(fmov(s11, w30), "fmov s11, w30");
1379  COMPARE(fmov(d31, x2), "fmov d31, x2");
1380  COMPARE(fmov(s12, s13), "fmov s12, s13");
1381  COMPARE(fmov(d22, d23), "fmov d22, d23");
1382 
1383  CLEANUP();
1384 }
1385 
1386 
1387 TEST_(fp_dp1) {
1388  SET_UP();
1389 
1390  COMPARE(fabs(s0, s1), "fabs s0, s1");
1391  COMPARE(fabs(s31, s30), "fabs s31, s30");
1392  COMPARE(fabs(d2, d3), "fabs d2, d3");
1393  COMPARE(fabs(d31, d30), "fabs d31, d30");
1394  COMPARE(fneg(s4, s5), "fneg s4, s5");
1395  COMPARE(fneg(s31, s30), "fneg s31, s30");
1396  COMPARE(fneg(d6, d7), "fneg d6, d7");
1397  COMPARE(fneg(d31, d30), "fneg d31, d30");
1398  COMPARE(fsqrt(s8, s9), "fsqrt s8, s9");
1399  COMPARE(fsqrt(s31, s30), "fsqrt s31, s30");
1400  COMPARE(fsqrt(d10, d11), "fsqrt d10, d11");
1401  COMPARE(fsqrt(d31, d30), "fsqrt d31, d30");
1402  COMPARE(frinta(s10, s11), "frinta s10, s11");
1403  COMPARE(frinta(s31, s30), "frinta s31, s30");
1404  COMPARE(frinta(d12, d13), "frinta d12, d13");
1405  COMPARE(frinta(d31, d30), "frinta d31, d30");
1406  COMPARE(frintn(s10, s11), "frintn s10, s11");
1407  COMPARE(frintn(s31, s30), "frintn s31, s30");
1408  COMPARE(frintn(d12, d13), "frintn d12, d13");
1409  COMPARE(frintn(d31, d30), "frintn d31, d30");
1410  COMPARE(frintz(s10, s11), "frintz s10, s11");
1411  COMPARE(frintz(s31, s30), "frintz s31, s30");
1412  COMPARE(frintz(d12, d13), "frintz d12, d13");
1413  COMPARE(frintz(d31, d30), "frintz d31, d30");
1414  COMPARE(fcvt(d14, s15), "fcvt d14, s15");
1415  COMPARE(fcvt(d31, s31), "fcvt d31, s31");
1416 
1417  CLEANUP();
1418 }
1419 
1420 
1421 TEST_(fp_dp2) {
1422  SET_UP();
1423 
1424  COMPARE(fadd(s0, s1, s2), "fadd s0, s1, s2");
1425  COMPARE(fadd(d3, d4, d5), "fadd d3, d4, d5");
1426  COMPARE(fsub(s31, s30, s29), "fsub s31, s30, s29");
1427  COMPARE(fsub(d31, d30, d29), "fsub d31, d30, d29");
1428  COMPARE(fmul(s7, s8, s9), "fmul s7, s8, s9");
1429  COMPARE(fmul(d10, d11, d12), "fmul d10, d11, d12");
1430  COMPARE(fdiv(s13, s14, s15), "fdiv s13, s14, s15");
1431  COMPARE(fdiv(d16, d17, d18), "fdiv d16, d17, d18");
1432  COMPARE(fmax(s19, s20, s21), "fmax s19, s20, s21");
1433  COMPARE(fmax(d22, d23, d24), "fmax d22, d23, d24");
1434  COMPARE(fmin(s25, s26, s27), "fmin s25, s26, s27");
1435  COMPARE(fmin(d28, d29, d30), "fmin d28, d29, d30");
1436  COMPARE(fmaxnm(s31, s0, s1), "fmaxnm s31, s0, s1");
1437  COMPARE(fmaxnm(d2, d3, d4), "fmaxnm d2, d3, d4");
1438  COMPARE(fminnm(s5, s6, s7), "fminnm s5, s6, s7");
1439  COMPARE(fminnm(d8, d9, d10), "fminnm d8, d9, d10");
1440 
1441  CLEANUP();
1442 }
1443 
1444 
1445 TEST(fp_dp3) {
1446  SET_UP();
1447 
1448  COMPARE(fmadd(s7, s8, s9, s10), "fmadd s7, s8, s9, s10");
1449  COMPARE(fmadd(d10, d11, d12, d10), "fmadd d10, d11, d12, d10");
1450  COMPARE(fmsub(s7, s8, s9, s10), "fmsub s7, s8, s9, s10");
1451  COMPARE(fmsub(d10, d11, d12, d10), "fmsub d10, d11, d12, d10");
1452 
1453  COMPARE(fnmadd(s7, s8, s9, s10), "fnmadd s7, s8, s9, s10");
1454  COMPARE(fnmadd(d10, d11, d12, d10), "fnmadd d10, d11, d12, d10");
1455  COMPARE(fnmsub(s7, s8, s9, s10), "fnmsub s7, s8, s9, s10");
1456  COMPARE(fnmsub(d10, d11, d12, d10), "fnmsub d10, d11, d12, d10");
1457 
1458  CLEANUP();
1459 }
1460 
1461 
1462 TEST_(fp_compare) {
1463  SET_UP();
1464 
1465  COMPARE(fcmp(s0, s1), "fcmp s0, s1");
1466  COMPARE(fcmp(s31, s30), "fcmp s31, s30");
1467  COMPARE(fcmp(d0, d1), "fcmp d0, d1");
1468  COMPARE(fcmp(d31, d30), "fcmp d31, d30");
1469  COMPARE(fcmp(s12, 0), "fcmp s12, #0.0");
1470  COMPARE(fcmp(d12, 0), "fcmp d12, #0.0");
1471 
1472  CLEANUP();
1473 }
1474 
1475 
1476 TEST_(fp_cond_compare) {
1477  SET_UP();
1478 
1479  COMPARE(fccmp(s0, s1, NoFlag, eq), "fccmp s0, s1, #nzcv, eq");
1480  COMPARE(fccmp(s2, s3, ZVFlag, ne), "fccmp s2, s3, #nZcV, ne");
1481  COMPARE(fccmp(s30, s16, NCFlag, pl), "fccmp s30, s16, #NzCv, pl");
1482  COMPARE(fccmp(s31, s31, NZCVFlag, le), "fccmp s31, s31, #NZCV, le");
1483  COMPARE(fccmp(d4, d5, VFlag, gt), "fccmp d4, d5, #nzcV, gt");
1484  COMPARE(fccmp(d6, d7, NFlag, vs), "fccmp d6, d7, #Nzcv, vs");
1485  COMPARE(fccmp(d30, d0, NZFlag, vc), "fccmp d30, d0, #NZcv, vc");
1486  COMPARE(fccmp(d31, d31, ZFlag, hs), "fccmp d31, d31, #nZcv, hs");
1487  COMPARE(fccmp(s14, s15, CVFlag, al), "fccmp s14, s15, #nzCV, al");
1488  COMPARE(fccmp(d16, d17, CFlag, nv), "fccmp d16, d17, #nzCv, nv");
1489 
1490  CLEANUP();
1491 }
1492 
1493 
1494 TEST_(fp_select) {
1495  SET_UP();
1496 
1497  COMPARE(fcsel(s0, s1, s2, eq), "fcsel s0, s1, s2, eq")
1498  COMPARE(fcsel(s31, s31, s30, ne), "fcsel s31, s31, s30, ne");
1499  COMPARE(fcsel(d0, d1, d2, mi), "fcsel d0, d1, d2, mi");
1500  COMPARE(fcsel(d31, d30, d31, pl), "fcsel d31, d30, d31, pl");
1501  COMPARE(fcsel(s14, s15, s16, al), "fcsel s14, s15, s16, al");
1502  COMPARE(fcsel(d17, d18, d19, nv), "fcsel d17, d18, d19, nv");
1503 
1504  CLEANUP();
1505 }
1506 
1507 
1508 TEST_(fcvt_scvtf_ucvtf) {
1509  SET_UP();
1510 
1511  COMPARE(fcvtas(w0, s1), "fcvtas w0, s1");
1512  COMPARE(fcvtas(x2, s3), "fcvtas x2, s3");
1513  COMPARE(fcvtas(w4, d5), "fcvtas w4, d5");
1514  COMPARE(fcvtas(x6, d7), "fcvtas x6, d7");
1515  COMPARE(fcvtau(w8, s9), "fcvtau w8, s9");
1516  COMPARE(fcvtau(x10, s11), "fcvtau x10, s11");
1517  COMPARE(fcvtau(w12, d13), "fcvtau w12, d13");
1518  COMPARE(fcvtau(x14, d15), "fcvtau x14, d15");
1519  COMPARE(fcvtns(w0, s1), "fcvtns w0, s1");
1520  COMPARE(fcvtns(x2, s3), "fcvtns x2, s3");
1521  COMPARE(fcvtns(w4, d5), "fcvtns w4, d5");
1522  COMPARE(fcvtns(x6, d7), "fcvtns x6, d7");
1523  COMPARE(fcvtnu(w8, s9), "fcvtnu w8, s9");
1524  COMPARE(fcvtnu(x10, s11), "fcvtnu x10, s11");
1525  COMPARE(fcvtnu(w12, d13), "fcvtnu w12, d13");
1526  COMPARE(fcvtnu(x14, d15), "fcvtnu x14, d15");
1527  COMPARE(fcvtzu(x16, d17), "fcvtzu x16, d17");
1528  COMPARE(fcvtzu(w18, d19), "fcvtzu w18, d19");
1529  COMPARE(fcvtzs(x20, d21), "fcvtzs x20, d21");
1530  COMPARE(fcvtzs(w22, d23), "fcvtzs w22, d23");
1531  COMPARE(fcvtzu(x16, s17), "fcvtzu x16, s17");
1532  COMPARE(fcvtzu(w18, s19), "fcvtzu w18, s19");
1533  COMPARE(fcvtzs(x20, s21), "fcvtzs x20, s21");
1534  COMPARE(fcvtzs(w22, s23), "fcvtzs w22, s23");
1535  COMPARE(scvtf(d24, w25), "scvtf d24, w25");
1536  COMPARE(scvtf(s24, w25), "scvtf s24, w25");
1537  COMPARE(scvtf(d26, x0), "scvtf d26, x0");
1538  COMPARE(scvtf(s26, x0), "scvtf s26, x0");
1539  COMPARE(ucvtf(d28, w29), "ucvtf d28, w29");
1540  COMPARE(ucvtf(s28, w29), "ucvtf s28, w29");
1541  COMPARE(ucvtf(d0, x1), "ucvtf d0, x1");
1542  COMPARE(ucvtf(s0, x1), "ucvtf s0, x1");
1543  COMPARE(ucvtf(d0, x1, 0), "ucvtf d0, x1");
1544  COMPARE(ucvtf(s0, x1, 0), "ucvtf s0, x1");
1545  COMPARE(scvtf(d1, x2, 1), "scvtf d1, x2, #1");
1546  COMPARE(scvtf(s1, x2, 1), "scvtf s1, x2, #1");
1547  COMPARE(scvtf(d3, x4, 15), "scvtf d3, x4, #15");
1548  COMPARE(scvtf(s3, x4, 15), "scvtf s3, x4, #15");
1549  COMPARE(scvtf(d5, x6, 32), "scvtf d5, x6, #32");
1550  COMPARE(scvtf(s5, x6, 32), "scvtf s5, x6, #32");
1551  COMPARE(ucvtf(d7, x8, 2), "ucvtf d7, x8, #2");
1552  COMPARE(ucvtf(s7, x8, 2), "ucvtf s7, x8, #2");
1553  COMPARE(ucvtf(d9, x10, 16), "ucvtf d9, x10, #16");
1554  COMPARE(ucvtf(s9, x10, 16), "ucvtf s9, x10, #16");
1555  COMPARE(ucvtf(d11, x12, 33), "ucvtf d11, x12, #33");
1556  COMPARE(ucvtf(s11, x12, 33), "ucvtf s11, x12, #33");
1557  COMPARE(fcvtms(w0, s1), "fcvtms w0, s1");
1558  COMPARE(fcvtms(x2, s3), "fcvtms x2, s3");
1559  COMPARE(fcvtms(w4, d5), "fcvtms w4, d5");
1560  COMPARE(fcvtms(x6, d7), "fcvtms x6, d7");
1561  COMPARE(fcvtmu(w8, s9), "fcvtmu w8, s9");
1562  COMPARE(fcvtmu(x10, s11), "fcvtmu x10, s11");
1563  COMPARE(fcvtmu(w12, d13), "fcvtmu w12, d13");
1564  COMPARE(fcvtmu(x14, d15), "fcvtmu x14, d15");
1565 
1566  CLEANUP();
1567 }
1568 
1569 
1570 TEST_(system_mrs) {
1571  SET_UP();
1572 
1573  COMPARE(mrs(x0, NZCV), "mrs x0, nzcv");
1574  COMPARE(mrs(lr, NZCV), "mrs lr, nzcv");
1575  COMPARE(mrs(x15, FPCR), "mrs x15, fpcr");
1576 
1577  CLEANUP();
1578 }
1579 
1580 
1581 TEST_(system_msr) {
1582  SET_UP();
1583 
1584  COMPARE(msr(NZCV, x0), "msr nzcv, x0");
1585  COMPARE(msr(NZCV, x30), "msr nzcv, lr");
1586  COMPARE(msr(FPCR, x15), "msr fpcr, x15");
1587 
1588  CLEANUP();
1589 }
1590 
1591 
1592 TEST_(system_nop) {
1593  SET_UP();
1594 
1595  COMPARE(nop(), "nop");
1596 
1597  CLEANUP();
1598 }
1599 
1600 
1601 TEST_(debug) {
1602  SET_UP();
1603 
1604  ASSERT(kImmExceptionIsDebug == 0xdeb0);
1605 
1606  // All debug codes should produce the same instruction, and the debug code
1607  // can be any uint32_t.
1608  COMPARE(debug("message", 0, NO_PARAM), "hlt #0xdeb0");
1609  COMPARE(debug("message", 1, NO_PARAM), "hlt #0xdeb0");
1610  COMPARE(debug("message", 0xffff, NO_PARAM), "hlt #0xdeb0");
1611  COMPARE(debug("message", 0x10000, NO_PARAM), "hlt #0xdeb0");
1612  COMPARE(debug("message", 0x7fffffff, NO_PARAM), "hlt #0xdeb0");
1613  COMPARE(debug("message", 0x80000000u, NO_PARAM), "hlt #0xdeb0");
1614  COMPARE(debug("message", 0xffffffffu, NO_PARAM), "hlt #0xdeb0");
1615 
1616  CLEANUP();
1617 }
1618 
1619 
1620 TEST_(hlt) {
1621  SET_UP();
1622 
1623  COMPARE(hlt(0), "hlt #0x0");
1624  COMPARE(hlt(1), "hlt #0x1");
1625  COMPARE(hlt(65535), "hlt #0xffff");
1626 
1627  CLEANUP();
1628 }
1629 
1630 
1631 TEST_(brk) {
1632  SET_UP();
1633 
1634  COMPARE(brk(0), "brk #0x0");
1635  COMPARE(brk(1), "brk #0x1");
1636  COMPARE(brk(65535), "brk #0xffff");
1637 
1638  CLEANUP();
1639 }
1640 
1641 
1642 TEST_(add_sub_negative) {
1643  SET_UP_CLASS(MacroAssembler);
1644 
1645  COMPARE(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)");
1646  COMPARE(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)");
1647  COMPARE(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)");
1648 
1649  COMPARE(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)");
1650  COMPARE(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)");
1651  COMPARE(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)");
1652 
1653  COMPARE(Add(w19, w3, -0x344), "sub w19, w3, #0x344 (836)");
1654  COMPARE(Add(w20, w4, -2000), "sub w20, w4, #0x7d0 (2000)");
1655 
1656  COMPARE(Sub(w21, w3, -0xbc), "add w21, w3, #0xbc (188)");
1657  COMPARE(Sub(w22, w4, -2000), "add w22, w4, #0x7d0 (2000)");
1658 
1659  COMPARE(Cmp(w0, -1), "cmn w0, #0x1 (1)");
1660  COMPARE(Cmp(x1, -1), "cmn x1, #0x1 (1)");
1661  COMPARE(Cmp(w2, -4095), "cmn w2, #0xfff (4095)");
1662  COMPARE(Cmp(x3, -4095), "cmn x3, #0xfff (4095)");
1663 
1664  COMPARE(Cmn(w0, -1), "cmp w0, #0x1 (1)");
1665  COMPARE(Cmn(x1, -1), "cmp x1, #0x1 (1)");
1666  COMPARE(Cmn(w2, -4095), "cmp w2, #0xfff (4095)");
1667  COMPARE(Cmn(x3, -4095), "cmp x3, #0xfff (4095)");
1668 
1669  CLEANUP();
1670 }
1671 
1672 
1673 TEST_(logical_immediate_move) {
1674  SET_UP_CLASS(MacroAssembler);
1675 
1676  COMPARE(And(w0, w1, 0), "movz w0, #0x0");
1677  COMPARE(And(x0, x1, 0), "movz x0, #0x0");
1678  COMPARE(Orr(w2, w3, 0), "mov w2, w3");
1679  COMPARE(Orr(x2, x3, 0), "mov x2, x3");
1680  COMPARE(Eor(w4, w5, 0), "mov w4, w5");
1681  COMPARE(Eor(x4, x5, 0), "mov x4, x5");
1682  COMPARE(Bic(w6, w7, 0), "mov w6, w7");
1683  COMPARE(Bic(x6, x7, 0), "mov x6, x7");
1684  COMPARE(Orn(w8, w9, 0), "movn w8, #0x0");
1685  COMPARE(Orn(x8, x9, 0), "movn x8, #0x0");
1686  COMPARE(Eon(w10, w11, 0), "mvn w10, w11");
1687  COMPARE(Eon(x10, x11, 0), "mvn x10, x11");
1688 
1689  COMPARE(And(w12, w13, 0xffffffff), "mov w12, w13");
1690  COMPARE(And(x12, x13, 0xffffffff), "and x12, x13, #0xffffffff");
1691  COMPARE(And(x12, x13, 0xffffffffffffffff), "mov x12, x13");
1692  COMPARE(Orr(w14, w15, 0xffffffff), "movn w14, #0x0");
1693  COMPARE(Orr(x14, x15, 0xffffffff), "orr x14, x15, #0xffffffff");
1694  COMPARE(Orr(x14, x15, 0xffffffffffffffff), "movn x14, #0x0");
1695  COMPARE(Eor(w16, w17, 0xffffffff), "mvn w16, w17");
1696  COMPARE(Eor(x16, x17, 0xffffffff), "eor x16, x17, #0xffffffff");
1697  COMPARE(Eor(x16, x17, 0xffffffffffffffff), "mvn x16, x17");
1698  COMPARE(Bic(w18, w19, 0xffffffff), "movz w18, #0x0");
1699  COMPARE(Bic(x18, x19, 0xffffffff), "and x18, x19, #0xffffffff00000000");
1700  COMPARE(Bic(x18, x19, 0xffffffffffffffff), "movz x18, #0x0");
1701  COMPARE(Orn(w20, w21, 0xffffffff), "mov w20, w21");
1702  COMPARE(Orn(x20, x21, 0xffffffff), "orr x20, x21, #0xffffffff00000000");
1703  COMPARE(Orn(x20, x21, 0xffffffffffffffff), "mov x20, x21");
1704  COMPARE(Eon(w22, w23, 0xffffffff), "mov w22, w23");
1705  COMPARE(Eon(x22, x23, 0xffffffff), "eor x22, x23, #0xffffffff00000000");
1706  COMPARE(Eon(x22, x23, 0xffffffffffffffff), "mov x22, x23");
1707 
1708  CLEANUP();
1709 }
1710 
1711 
1712 TEST_(barriers) {
1713  SET_UP_CLASS(MacroAssembler);
1714 
1715  // DMB
1716  COMPARE(Dmb(FullSystem, BarrierAll), "dmb sy");
1717  COMPARE(Dmb(FullSystem, BarrierReads), "dmb ld");
1718  COMPARE(Dmb(FullSystem, BarrierWrites), "dmb st");
1719 
1720  COMPARE(Dmb(InnerShareable, BarrierAll), "dmb ish");
1721  COMPARE(Dmb(InnerShareable, BarrierReads), "dmb ishld");
1722  COMPARE(Dmb(InnerShareable, BarrierWrites), "dmb ishst");
1723 
1724  COMPARE(Dmb(NonShareable, BarrierAll), "dmb nsh");
1725  COMPARE(Dmb(NonShareable, BarrierReads), "dmb nshld");
1726  COMPARE(Dmb(NonShareable, BarrierWrites), "dmb nshst");
1727 
1728  COMPARE(Dmb(OuterShareable, BarrierAll), "dmb osh");
1729  COMPARE(Dmb(OuterShareable, BarrierReads), "dmb oshld");
1730  COMPARE(Dmb(OuterShareable, BarrierWrites), "dmb oshst");
1731 
1732  COMPARE(Dmb(FullSystem, BarrierOther), "dmb sy (0b1100)");
1733  COMPARE(Dmb(InnerShareable, BarrierOther), "dmb sy (0b1000)");
1734  COMPARE(Dmb(NonShareable, BarrierOther), "dmb sy (0b0100)");
1735  COMPARE(Dmb(OuterShareable, BarrierOther), "dmb sy (0b0000)");
1736 
1737  // DSB
1738  COMPARE(Dsb(FullSystem, BarrierAll), "dsb sy");
1739  COMPARE(Dsb(FullSystem, BarrierReads), "dsb ld");
1740  COMPARE(Dsb(FullSystem, BarrierWrites), "dsb st");
1741 
1742  COMPARE(Dsb(InnerShareable, BarrierAll), "dsb ish");
1743  COMPARE(Dsb(InnerShareable, BarrierReads), "dsb ishld");
1744  COMPARE(Dsb(InnerShareable, BarrierWrites), "dsb ishst");
1745 
1746  COMPARE(Dsb(NonShareable, BarrierAll), "dsb nsh");
1747  COMPARE(Dsb(NonShareable, BarrierReads), "dsb nshld");
1748  COMPARE(Dsb(NonShareable, BarrierWrites), "dsb nshst");
1749 
1750  COMPARE(Dsb(OuterShareable, BarrierAll), "dsb osh");
1751  COMPARE(Dsb(OuterShareable, BarrierReads), "dsb oshld");
1752  COMPARE(Dsb(OuterShareable, BarrierWrites), "dsb oshst");
1753 
1754  COMPARE(Dsb(FullSystem, BarrierOther), "dsb sy (0b1100)");
1755  COMPARE(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)");
1756  COMPARE(Dsb(NonShareable, BarrierOther), "dsb sy (0b0100)");
1757  COMPARE(Dsb(OuterShareable, BarrierOther), "dsb sy (0b0000)");
1758 
1759  // ISB
1760  COMPARE(Isb(), "isb");
1761 
1762  CLEANUP();
1763 }
v8::internal::d19
const DwVfpRegister d19
Definition: assembler-arm.h:449
v8::internal::s2
const SwVfpRegister s2
Definition: assembler-arm.h:398
v8::internal::s28
const SwVfpRegister s28
Definition: assembler-arm.h:424
v8::internal::s12
const SwVfpRegister s12
Definition: assembler-arm.h:408
v8::internal::s29
const SwVfpRegister s29
Definition: assembler-arm.h:425
v8::internal::s25
const SwVfpRegister s25
Definition: assembler-arm.h:421
v8::internal::s26
const SwVfpRegister s26
Definition: assembler-arm.h:422
v8::internal::s17
const SwVfpRegister s17
Definition: assembler-arm.h:413
v8::internal::d11
const LowDwVfpRegister d11
Definition: assembler-arm.h:441
v8::internal::cp
const Register cp
Definition: macro-assembler-arm.h:48
v8::internal::s7
const SwVfpRegister s7
Definition: assembler-arm.h:403
v8::internal::d0
const LowDwVfpRegister d0
Definition: assembler-arm.h:430
v8::internal::d23
const DwVfpRegister d23
Definition: assembler-arm.h:453
v8::internal::s8
const SwVfpRegister s8
Definition: assembler-arm.h:404
v8::internal::s10
const SwVfpRegister s10
Definition: assembler-arm.h:406
v8::internal::d31
const DwVfpRegister d31
Definition: assembler-arm.h:461
v8::internal::d24
const DwVfpRegister d24
Definition: assembler-arm.h:454
v8::internal::s16
const SwVfpRegister s16
Definition: assembler-arm.h:412
v8::internal::s14
const SwVfpRegister s14
Definition: assembler-arm.h:410
v8::internal::s21
const SwVfpRegister s21
Definition: assembler-arm.h:417
v8::internal::d15
const LowDwVfpRegister d15
Definition: assembler-arm.h:445
ASSERT
#define ASSERT(condition)
Definition: checks.h:329
v8::internal::d22
const DwVfpRegister d22
Definition: assembler-arm.h:452
v8::internal::d3
const LowDwVfpRegister d3
Definition: assembler-arm.h:433
COMPARE
#define COMPARE(ASM, EXP)
Definition: test-disasm-arm64.cc:61
TEST_
#define TEST_(name)
Definition: test-disasm-arm64.cc:43
v8::internal::s23
const SwVfpRegister s23
Definition: assembler-arm.h:419
v8::internal::d25
const DwVfpRegister d25
Definition: assembler-arm.h:455
v8::internal::d10
const LowDwVfpRegister d10
Definition: assembler-arm.h:440
RESULT_SIZE
#define RESULT_SIZE
v8::internal::s22
const SwVfpRegister s22
Definition: assembler-arm.h:418
v8::internal::s6
const SwVfpRegister s6
Definition: assembler-arm.h:402
v8::internal::d28
const DwVfpRegister d28
Definition: assembler-arm.h:458
SET_UP_CLASS
#define SET_UP_CLASS(ASMCLASS)
Definition: test-disasm-arm64.cc:47
v8::internal::s31
const SwVfpRegister s31
Definition: assembler-arm.h:427
v8::internal::s18
const SwVfpRegister s18
Definition: assembler-arm.h:414
v8::internal::d16
const DwVfpRegister d16
Definition: assembler-arm.h:446
v8::internal::s3
const SwVfpRegister s3
Definition: assembler-arm.h:399
v8::internal::d18
const DwVfpRegister d18
Definition: assembler-arm.h:448
v8::internal::d14
const LowDwVfpRegister d14
Definition: assembler-arm.h:444
v8::internal::d17
const DwVfpRegister d17
Definition: assembler-arm.h:447
v8::internal::d7
const LowDwVfpRegister d7
Definition: assembler-arm.h:437
v8::internal::d4
const LowDwVfpRegister d4
Definition: assembler-arm.h:434
v8::internal::d13
const LowDwVfpRegister d13
Definition: assembler-arm.h:443
v8::internal::s13
const SwVfpRegister s13
Definition: assembler-arm.h:409
v8::internal::d6
const LowDwVfpRegister d6
Definition: assembler-arm.h:436
v8::internal::s27
const SwVfpRegister s27
Definition: assembler-arm.h:423
v8::internal::d27
const DwVfpRegister d27
Definition: assembler-arm.h:457
v8::internal::d5
const LowDwVfpRegister d5
Definition: assembler-arm.h:435
COMPARE_PREFIX
#define COMPARE_PREFIX(ASM, EXP)
Definition: test-disasm-arm64.cc:73
INST_OFF
#define INST_OFF(x)
v8::internal::s0
const SwVfpRegister s0
Definition: assembler-arm.h:396
v8::internal::s19
const SwVfpRegister s19
Definition: assembler-arm.h:415
v8::internal::d26
const DwVfpRegister d26
Definition: assembler-arm.h:456
v8::internal::s5
const SwVfpRegister s5
Definition: assembler-arm.h:401
v8::internal::d9
const LowDwVfpRegister d9
Definition: assembler-arm.h:439
v8::internal::s1
const SwVfpRegister s1
Definition: assembler-arm.h:397
v8::internal::lr
const Register lr
Definition: assembler-arm.h:243
v8::internal::d2
const LowDwVfpRegister d2
Definition: assembler-arm.h:432
CcTest::InitializeVM
static void InitializeVM()
Definition: cctest.h:116
v8::internal::d29
const DwVfpRegister d29
Definition: assembler-arm.h:459
v8::internal::s30
const SwVfpRegister s30
Definition: assembler-arm.h:426
SET_UP
#define SET_UP()
Definition: test-disasm-arm64.cc:59
v8::internal::s4
const SwVfpRegister s4
Definition: assembler-arm.h:400
v8::internal::d30
const DwVfpRegister d30
Definition: assembler-arm.h:460
v8::internal::s20
const SwVfpRegister s20
Definition: assembler-arm.h:416
v8::internal::d20
const DwVfpRegister d20
Definition: assembler-arm.h:450
v8::internal::s9
const SwVfpRegister s9
Definition: assembler-arm.h:405
v8::internal::d12
const LowDwVfpRegister d12
Definition: assembler-arm.h:442
v8::internal::d1
const LowDwVfpRegister d1
Definition: assembler-arm.h:431
v8::internal::fp
const Register fp
Definition: assembler-arm.h:240
CLEANUP
#define CLEANUP()
Definition: test-disasm-arm64.cc:85
v8::internal::d8
const LowDwVfpRegister d8
Definition: assembler-arm.h:438
v8::internal::s11
const SwVfpRegister s11
Definition: assembler-arm.h:407
v8::internal::s15
const SwVfpRegister s15
Definition: assembler-arm.h:411
v8::internal::kImmExceptionIsDebug
const Instr kImmExceptionIsDebug
Definition: instructions-arm64.h:445
v8::internal::d21
const DwVfpRegister d21
Definition: assembler-arm.h:451
v8::internal::s24
const SwVfpRegister s24
Definition: assembler-arm.h:420