1// Copyright 2015, ARM Limited 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#include <stdio.h> 28#include <cstring> 29#include "test-runner.h" 30 31#include "vixl/a64/macro-assembler-a64.h" 32#include "vixl/a64/disasm-a64.h" 33 34#define TEST(name) TEST_(DISASM_##name) 35 36#define EXP_SIZE (256) 37#define INSTR_SIZE (1024) 38#define SETUP_CLASS(ASMCLASS) \ 39 byte* buf = new byte[INSTR_SIZE]; \ 40 uint32_t encoding = 0; \ 41 ASMCLASS* masm = new ASMCLASS(buf, INSTR_SIZE); \ 42 Decoder* decoder = new Decoder(); \ 43 Disassembler* disasm = new Disassembler(); \ 44 decoder->AppendVisitor(disasm) 45 46#define SETUP() SETUP_CLASS(Assembler) 47 48#define SETUP_MACRO() SETUP_CLASS(MacroAssembler) 49 50#define COMPARE(ASM, EXP) \ 51 masm->Reset(); \ 52 { \ 53 CodeBufferCheckScope blind(masm); \ 54 masm->ASM; \ 55 } \ 56 masm->FinalizeCode(); \ 57 decoder->Decode(reinterpret_cast<Instruction*>(buf)); \ 58 encoding = *reinterpret_cast<uint32_t*>(buf); \ 59 if (strcmp(disasm->GetOutput(), EXP) != 0) { \ 60 printf("\nEncoding: %08" PRIx32 "\nExpected: %s\nFound: %s\n", \ 61 encoding, EXP, disasm->GetOutput()); \ 62 abort(); \ 63 } \ 64 if (Test::trace_sim()) { \ 65 printf("%08" PRIx32 "\t%s\n", encoding, disasm->GetOutput()); \ 66 } 67 68#define COMPARE_PREFIX(ASM, EXP) \ 69 masm->Reset(); \ 70 { \ 71 CodeBufferCheckScope blind(masm); \ 72 masm->ASM; \ 73 } \ 74 masm->FinalizeCode(); \ 75 decoder->Decode(reinterpret_cast<Instruction*>(buf)); \ 76 encoding = *reinterpret_cast<uint32_t*>(buf); \ 77 if (strncmp(disasm->GetOutput(), EXP, strlen(EXP)) != 0) { \ 78 printf("\nEncoding: %08" PRIx32 "\nExpected: %s\nFound: %s\n", \ 79 encoding, EXP, disasm->GetOutput()); \ 80 abort(); \ 81 } \ 82 if (Test::trace_sim()) { \ 83 printf("%08" PRIx32 "\t%s\n", encoding, disasm->GetOutput()); \ 84 } 85 86#define COMPARE_MACRO(ASM, EXP) \ 87 masm->Reset(); \ 88 masm->ASM; \ 89 masm->FinalizeCode(); \ 90 decoder->Decode(reinterpret_cast<Instruction*>(buf)); \ 91 encoding = *reinterpret_cast<uint32_t*>(buf); \ 92 if (strncmp(disasm->GetOutput(), EXP, strlen(EXP)) != 0) { \ 93 printf("\nEncoding: %08" PRIx32 "\nExpected: %s\nFound: %s\n", \ 94 encoding, EXP, disasm->GetOutput()); \ 95 abort(); \ 96 } \ 97 if (Test::trace_sim()) { \ 98 printf("%08" PRIx32 "\t%s\n", encoding, disasm->GetOutput()); \ 99 } 100 101#define CLEANUP() \ 102 delete disasm; \ 103 delete decoder; \ 104 delete masm; \ 105 delete[] buf 106 107namespace vixl { 108 109TEST(bootstrap) { 110 SETUP(); 111 112 // Instructions generated by C compiler, disassembled by objdump, and 113 // reformatted to suit our disassembly style. 114 COMPARE(dci(0xa9ba7bfd), "stp x29, x30, [sp, #-96]!"); 115 COMPARE(dci(0x910003fd), "mov x29, sp"); 116 COMPARE(dci(0x9100e3a0), "add x0, x29, #0x38 (56)"); 117 COMPARE(dci(0xb900001f), "str wzr, [x0]"); 118 COMPARE(dci(0x528000e1), "mov w1, #0x7"); 119 COMPARE(dci(0xb9001c01), "str w1, [x0, #28]"); 120 COMPARE(dci(0x390043a0), "strb w0, [x29, #16]"); 121 COMPARE(dci(0x790027a0), "strh w0, [x29, #18]"); 122 COMPARE(dci(0xb9400400), "ldr w0, [x0, #4]"); 123 COMPARE(dci(0x0b000021), "add w1, w1, w0"); 124 COMPARE(dci(0x531b6800), "lsl w0, w0, #5"); 125 COMPARE(dci(0x521e0400), "eor w0, w0, #0xc"); 126 COMPARE(dci(0x72af0f00), "movk w0, #0x7878, lsl #16"); 127 COMPARE(dci(0xd360fc00), "lsr x0, x0, #32"); 128 COMPARE(dci(0x13037c01), "asr w1, w0, #3"); 129 COMPARE(dci(0x4b000021), "sub w1, w1, w0"); 130 COMPARE(dci(0x2a0103e0), "mov w0, w1"); 131 COMPARE(dci(0x93407c00), "sxtw x0, w0"); 132 COMPARE(dci(0x2a000020), "orr w0, w1, w0"); 133 COMPARE(dci(0xa8c67bfd), "ldp x29, x30, [sp], #96"); 134 135 CLEANUP(); 136} 137 138 139TEST(mov_mvn) { 140 SETUP_CLASS(MacroAssembler); 141 142 COMPARE(Mov(w0, Operand(0x1234)), "mov w0, #0x1234"); 143 COMPARE(Mov(x1, Operand(0x1234)), "mov x1, #0x1234"); 144 COMPARE(Mov(w2, Operand(w3)), "mov w2, w3"); 145 COMPARE(Mov(x4, Operand(x5)), "mov x4, x5"); 146 COMPARE(Mov(w6, Operand(w7, LSL, 5)), "lsl w6, w7, #5"); 147 COMPARE(Mov(x8, Operand(x9, ASR, 42)), "asr x8, x9, #42"); 148 COMPARE(Mov(w10, Operand(w11, UXTB)), "uxtb w10, w11"); 149 COMPARE(Mov(x12, Operand(x13, UXTB, 1)), "ubfiz x12, x13, #1, #8"); 150 COMPARE(Mov(w14, Operand(w15, SXTH, 2)), "sbfiz w14, w15, #2, #16"); 151 COMPARE(Mov(x16, Operand(x17, SXTW, 3)), "sbfiz x16, x17, #3, #32"); 152 153 COMPARE(Mvn(w0, Operand(0x101)), "mov w0, #0xfffffefe"); 154 COMPARE(Mvn(x1, Operand(0xfff1)), "mov x1, #0xffffffffffff000e"); 155 COMPARE(Mvn(w2, Operand(w3)), "mvn w2, w3"); 156 COMPARE(Mvn(x4, Operand(x5)), "mvn x4, x5"); 157 COMPARE(Mvn(w6, Operand(w7, LSL, 12)), "mvn w6, w7, lsl #12"); 158 COMPARE(Mvn(x8, Operand(x9, ASR, 63)), "mvn x8, x9, asr #63"); 159 160 CLEANUP(); 161} 162 163 164TEST(move_immediate) { 165 SETUP(); 166 167 COMPARE(movz(w0, 0x1234), "mov w0, #0x1234"); 168 COMPARE(movz(x1, 0xabcd0000), "mov x1, #0xabcd0000"); 169 COMPARE(movz(x2, 0x555500000000), "mov x2, #0x555500000000"); 170 COMPARE(movz(x3, 0xaaaa000000000000), "mov x3, #0xaaaa000000000000"); 171 COMPARE(movz(x4, 0xabcd, 16), "mov x4, #0xabcd0000"); 172 COMPARE(movz(x5, 0x5555, 32), "mov x5, #0x555500000000"); 173 COMPARE(movz(x6, 0xaaaa, 48), "mov x6, #0xaaaa000000000000"); 174 175 COMPARE(movk(w7, 0x1234), "movk w7, #0x1234"); 176 COMPARE(movk(x8, 0xabcd0000), "movk x8, #0xabcd, lsl #16"); 177 COMPARE(movk(x9, 0x555500000000), "movk x9, #0x5555, lsl #32"); 178 COMPARE(movk(x10, 0xaaaa000000000000), "movk x10, #0xaaaa, lsl #48"); 179 COMPARE(movk(w11, 0xabcd, 16), "movk w11, #0xabcd, lsl #16"); 180 COMPARE(movk(x12, 0x5555, 32), "movk x12, #0x5555, lsl #32"); 181 COMPARE(movk(x13, 0xaaaa, 48), "movk x13, #0xaaaa, lsl #48"); 182 183 COMPARE(movn(w14, 0x1234), "mov w14, #0xffffedcb"); 184 COMPARE(movn(x15, 0xabcd0000), "mov x15, #0xffffffff5432ffff"); 185 COMPARE(movn(x16, 0x555500000000), "mov x16, #0xffffaaaaffffffff"); 186 COMPARE(movn(x17, 0xaaaa000000000000), "mov x17, #0x5555ffffffffffff"); 187 COMPARE(movn(w18, 0xabcd, 16), "mov w18, #0x5432ffff"); 188 COMPARE(movn(x19, 0x5555, 32), "mov x19, #0xffffaaaaffffffff"); 189 COMPARE(movn(x20, 0xaaaa, 48), "mov x20, #0x5555ffffffffffff"); 190 191 COMPARE(movk(w21, 0), "movk w21, #0x0"); 192 COMPARE(movk(x22, 0, 0), "movk x22, #0x0"); 193 COMPARE(movk(w23, 0, 16), "movk w23, #0x0, lsl #16"); 194 COMPARE(movk(x24, 0, 32), "movk x24, #0x0, lsl #32"); 195 COMPARE(movk(x25, 0, 48), "movk x25, #0x0, lsl #48"); 196 197 COMPARE(movz(x26, 0, 48), "movz x26, #0x0"); 198 COMPARE(movn(x27, 0, 48), "movn x27, #0x0"); 199 COMPARE(movn(w28, 0xffff), "movn w28, #0xffff"); 200 201 CLEANUP(); 202} 203 204 205TEST(move_immediate_2) { 206 SETUP_CLASS(MacroAssembler); 207 208 // Move instructions expected for certain immediates. This is really a macro 209 // assembler test, to ensure it generates immediates efficiently. 210 COMPARE(Mov(w0, 0), "mov w0, #0x0"); 211 COMPARE(Mov(w0, 0x0000ffff), "mov w0, #0xffff"); 212 COMPARE(Mov(w0, 0x00010000), "mov w0, #0x10000"); 213 COMPARE(Mov(w0, 0xffff0000), "mov w0, #0xffff0000"); 214 COMPARE(Mov(w0, 0x0001ffff), "mov w0, #0x1ffff"); 215 COMPARE(Mov(w0, 0xffff8000), "mov w0, #0xffff8000"); 216 COMPARE(Mov(w0, 0xfffffffe), "mov w0, #0xfffffffe"); 217 COMPARE(Mov(w0, 0xffffffff), "mov w0, #0xffffffff"); 218 COMPARE(Mov(w0, 0x00ffff00), "mov w0, #0xffff00"); 219 COMPARE(Mov(w0, 0xfffe7fff), "mov w0, #0xfffe7fff"); 220 COMPARE(Mov(w0, 0xfffeffff), "mov w0, #0xfffeffff"); 221 COMPARE(Mov(w0, 0xffff7fff), "mov w0, #0xffff7fff"); 222 223 COMPARE(Mov(x0, 0), "mov x0, #0x0"); 224 COMPARE(Mov(x0, 0x0000ffff), "mov x0, #0xffff"); 225 COMPARE(Mov(x0, 0x00010000), "mov x0, #0x10000"); 226 COMPARE(Mov(x0, 0xffff0000), "mov x0, #0xffff0000"); 227 COMPARE(Mov(x0, 0x0001ffff), "mov x0, #0x1ffff"); 228 COMPARE(Mov(x0, 0xffff8000), "mov x0, #0xffff8000"); 229 COMPARE(Mov(x0, 0xfffffffe), "mov x0, #0xfffffffe"); 230 COMPARE(Mov(x0, 0xffffffff), "mov x0, #0xffffffff"); 231 COMPARE(Mov(x0, 0x00ffff00), "mov x0, #0xffff00"); 232 COMPARE(Mov(x0, 0xffff000000000000), "mov x0, #0xffff000000000000"); 233 COMPARE(Mov(x0, 0x0000ffff00000000), "mov x0, #0xffff00000000"); 234 COMPARE(Mov(x0, 0x00000000ffff0000), "mov x0, #0xffff0000"); 235 COMPARE(Mov(x0, 0xffffffffffff0000), "mov x0, #0xffffffffffff0000"); 236 COMPARE(Mov(x0, 0xffffffff0000ffff), "mov x0, #0xffffffff0000ffff"); 237 COMPARE(Mov(x0, 0xffff0000ffffffff), "mov x0, #0xffff0000ffffffff"); 238 COMPARE(Mov(x0, 0x0000ffffffffffff), "mov x0, #0xffffffffffff"); 239 COMPARE(Mov(x0, 0xfffe7fffffffffff), "mov x0, #0xfffe7fffffffffff"); 240 COMPARE(Mov(x0, 0xfffeffffffffffff), "mov x0, #0xfffeffffffffffff"); 241 COMPARE(Mov(x0, 0xffff7fffffffffff), "mov x0, #0xffff7fffffffffff"); 242 COMPARE(Mov(x0, 0xfffffffe7fffffff), "mov x0, #0xfffffffe7fffffff"); 243 COMPARE(Mov(x0, 0xfffffffeffffffff), "mov x0, #0xfffffffeffffffff"); 244 COMPARE(Mov(x0, 0xffffffff7fffffff), "mov x0, #0xffffffff7fffffff"); 245 COMPARE(Mov(x0, 0xfffffffffffe7fff), "mov x0, #0xfffffffffffe7fff"); 246 COMPARE(Mov(x0, 0xfffffffffffeffff), "mov x0, #0xfffffffffffeffff"); 247 COMPARE(Mov(x0, 0xffffffffffff7fff), "mov x0, #0xffffffffffff7fff"); 248 COMPARE(Mov(x0, 0xffffffffffffffff), "mov x0, #0xffffffffffffffff"); 249 250 COMPARE(Movk(w0, 0x1234, 0), "movk w0, #0x1234"); 251 COMPARE(Movk(x1, 0x2345, 0), "movk x1, #0x2345"); 252 COMPARE(Movk(w2, 0x3456, 16), "movk w2, #0x3456, lsl #16"); 253 COMPARE(Movk(x3, 0x4567, 16), "movk x3, #0x4567, lsl #16"); 254 COMPARE(Movk(x4, 0x5678, 32), "movk x4, #0x5678, lsl #32"); 255 COMPARE(Movk(x5, 0x6789, 48), "movk x5, #0x6789, lsl #48"); 256 257 CLEANUP(); 258} 259 260 261TEST(add_immediate) { 262 SETUP(); 263 264 COMPARE(add(w0, w1, Operand(0xff)), "add w0, w1, #0xff (255)"); 265 COMPARE(add(x2, x3, Operand(0x3ff)), "add x2, x3, #0x3ff (1023)"); 266 COMPARE(add(w4, w5, Operand(0xfff)), "add w4, w5, #0xfff (4095)"); 267 COMPARE(add(x6, x7, Operand(0x1000)), "add x6, x7, #0x1000 (4096)"); 268 COMPARE(add(w8, w9, Operand(0xff000)), "add w8, w9, #0xff000 (1044480)"); 269 COMPARE(add(x10, x11, Operand(0x3ff000)), 270 "add x10, x11, #0x3ff000 (4190208)"); 271 COMPARE(add(w12, w13, Operand(0xfff000)), 272 "add w12, w13, #0xfff000 (16773120)"); 273 COMPARE(adds(w14, w15, Operand(0xff)), "adds w14, w15, #0xff (255)"); 274 COMPARE(adds(x16, x17, Operand(0xaa000)), "adds x16, x17, #0xaa000 (696320)"); 275 276 COMPARE(cmn(w18, Operand(0xff)), "cmn w18, #0xff (255)"); 277 COMPARE(cmn(x19, Operand(0xff000)), "cmn x19, #0xff000 (1044480)"); 278 COMPARE(add(w0, wsp, Operand(0)), "mov w0, wsp"); 279 COMPARE(add(sp, x0, Operand(0)), "mov sp, x0"); 280 281 COMPARE(add(w1, wsp, Operand(8)), "add w1, wsp, #0x8 (8)"); 282 COMPARE(add(x2, sp, Operand(16)), "add x2, sp, #0x10 (16)"); 283 COMPARE(add(wsp, wsp, Operand(42)), "add wsp, wsp, #0x2a (42)"); 284 COMPARE(cmn(sp, Operand(24)), "cmn sp, #0x18 (24)"); 285 COMPARE(adds(wzr, wsp, Operand(9)), "cmn wsp, #0x9 (9)"); 286 287 CLEANUP(); 288} 289 290 291TEST(sub_immediate) { 292 SETUP(); 293 294 COMPARE(sub(w0, w1, Operand(0xff)), "sub w0, w1, #0xff (255)"); 295 COMPARE(sub(x2, x3, Operand(0x3ff)), "sub x2, x3, #0x3ff (1023)"); 296 COMPARE(sub(w4, w5, Operand(0xfff)), "sub w4, w5, #0xfff (4095)"); 297 COMPARE(sub(x6, x7, Operand(0x1000)), "sub x6, x7, #0x1000 (4096)"); 298 COMPARE(sub(w8, w9, Operand(0xff000)), "sub w8, w9, #0xff000 (1044480)"); 299 COMPARE(sub(x10, x11, Operand(0x3ff000)), 300 "sub x10, x11, #0x3ff000 (4190208)"); 301 COMPARE(sub(w12, w13, Operand(0xfff000)), 302 "sub w12, w13, #0xfff000 (16773120)"); 303 COMPARE(subs(w14, w15, Operand(0xff)), "subs w14, w15, #0xff (255)"); 304 COMPARE(subs(x16, x17, Operand(0xaa000)), "subs x16, x17, #0xaa000 (696320)"); 305 COMPARE(cmp(w18, Operand(0xff)), "cmp w18, #0xff (255)"); 306 COMPARE(cmp(x19, Operand(0xff000)), "cmp x19, #0xff000 (1044480)"); 307 308 COMPARE(sub(w1, wsp, Operand(8)), "sub w1, wsp, #0x8 (8)"); 309 COMPARE(sub(x2, sp, Operand(16)), "sub x2, sp, #0x10 (16)"); 310 COMPARE(sub(wsp, wsp, Operand(42)), "sub wsp, wsp, #0x2a (42)"); 311 COMPARE(cmp(sp, Operand(24)), "cmp sp, #0x18 (24)"); 312 COMPARE(subs(wzr, wsp, Operand(9)), "cmp wsp, #0x9 (9)"); 313 314 CLEANUP(); 315} 316 317 318TEST(add_shifted) { 319 SETUP(); 320 321 COMPARE(add(w0, w1, Operand(w2)), "add w0, w1, w2"); 322 COMPARE(add(x3, x4, Operand(x5)), "add x3, x4, x5"); 323 COMPARE(add(w6, w7, Operand(w8, LSL, 1)), "add w6, w7, w8, lsl #1"); 324 COMPARE(add(x9, x10, Operand(x11, LSL, 2)), "add x9, x10, x11, lsl #2"); 325 COMPARE(add(w12, w13, Operand(w14, LSR, 3)), "add w12, w13, w14, lsr #3"); 326 COMPARE(add(x15, x16, Operand(x17, LSR, 4)), "add x15, x16, x17, lsr #4"); 327 COMPARE(add(w18, w19, Operand(w20, ASR, 5)), "add w18, w19, w20, asr #5"); 328 COMPARE(add(x21, x22, Operand(x23, ASR, 6)), "add x21, x22, x23, asr #6"); 329 COMPARE(cmn(w24, Operand(w25)), "cmn w24, w25"); 330 COMPARE(cmn(x26, Operand(x27, LSL, 63)), "cmn x26, x27, lsl #63"); 331 332 COMPARE(add(x0, sp, Operand(x1)), "add x0, sp, x1"); 333 COMPARE(add(w2, wsp, Operand(w3)), "add w2, wsp, w3"); 334 COMPARE(add(x4, sp, Operand(x5, LSL, 1)), "add x4, sp, x5, lsl #1"); 335 COMPARE(add(x4, xzr, Operand(x5, LSL, 1)), "add x4, xzr, x5, lsl #1"); 336 COMPARE(add(w6, wsp, Operand(w7, LSL, 3)), "add w6, wsp, w7, lsl #3"); 337 COMPARE(adds(xzr, sp, Operand(x8, LSL, 4)), "cmn sp, x8, lsl #4"); 338 COMPARE(adds(xzr, xzr, Operand(x8, LSL, 5)), "cmn xzr, x8, lsl #5"); 339 340 CLEANUP(); 341} 342 343 344TEST(sub_shifted) { 345 SETUP(); 346 347 COMPARE(sub(w0, w1, Operand(w2)), "sub w0, w1, w2"); 348 COMPARE(sub(x3, x4, Operand(x5)), "sub x3, x4, x5"); 349 COMPARE(sub(w6, w7, Operand(w8, LSL, 1)), "sub w6, w7, w8, lsl #1"); 350 COMPARE(sub(x9, x10, Operand(x11, LSL, 2)), "sub x9, x10, x11, lsl #2"); 351 COMPARE(sub(w12, w13, Operand(w14, LSR, 3)), "sub w12, w13, w14, lsr #3"); 352 COMPARE(sub(x15, x16, Operand(x17, LSR, 4)), "sub x15, x16, x17, lsr #4"); 353 COMPARE(sub(w18, w19, Operand(w20, ASR, 5)), "sub w18, w19, w20, asr #5"); 354 COMPARE(sub(x21, x22, Operand(x23, ASR, 6)), "sub x21, x22, x23, asr #6"); 355 COMPARE(cmp(w24, Operand(w25)), "cmp w24, w25"); 356 COMPARE(cmp(x26, Operand(x27, LSL, 63)), "cmp x26, x27, lsl #63"); 357 COMPARE(neg(w28, Operand(w29)), "neg w28, w29"); 358 COMPARE(neg(x30, Operand(x0, LSR, 62)), "neg x30, x0, lsr #62"); 359 COMPARE(negs(w1, Operand(w2)), "negs w1, w2"); 360 COMPARE(negs(x3, Operand(x4, ASR, 61)), "negs x3, x4, asr #61"); 361 362 COMPARE(sub(x0, sp, Operand(x1)), "sub x0, sp, x1"); 363 COMPARE(sub(w2, wsp, Operand(w3)), "sub w2, wsp, w3"); 364 COMPARE(sub(x4, sp, Operand(x5, LSL, 1)), "sub x4, sp, x5, lsl #1"); 365 COMPARE(sub(x4, xzr, Operand(x5, LSL, 1)), "neg x4, x5, lsl #1"); 366 COMPARE(sub(w6, wsp, Operand(w7, LSL, 3)), "sub w6, wsp, w7, lsl #3"); 367 COMPARE(subs(xzr, sp, Operand(x8, LSL, 4)), "cmp sp, x8, lsl #4"); 368 COMPARE(subs(xzr, xzr, Operand(x8, LSL, 5)), "cmp xzr, x8, lsl #5"); 369 370 CLEANUP(); 371} 372 373 374TEST(add_extended) { 375 SETUP(); 376 377 COMPARE(add(w0, w1, Operand(w2, UXTB)), "add w0, w1, w2, uxtb"); 378 COMPARE(adds(x3, x4, Operand(w5, UXTB, 1)), "adds x3, x4, w5, uxtb #1"); 379 COMPARE(add(w6, w7, Operand(w8, UXTH, 2)), "add w6, w7, w8, uxth #2"); 380 COMPARE(adds(x9, x10, Operand(x11, UXTW, 3)), "adds x9, x10, w11, uxtw #3"); 381 COMPARE(add(x12, x13, Operand(x14, UXTX, 4)), "add x12, x13, x14, uxtx #4"); 382 COMPARE(adds(w15, w16, Operand(w17, SXTB, 4)), "adds w15, w16, w17, sxtb #4"); 383 COMPARE(add(x18, x19, Operand(x20, SXTB, 3)), "add x18, x19, w20, sxtb #3"); 384 COMPARE(adds(w21, w22, Operand(w23, SXTH, 2)), "adds w21, w22, w23, sxth #2"); 385 COMPARE(add(x24, x25, Operand(x26, SXTW, 1)), "add x24, x25, w26, sxtw #1"); 386 COMPARE(adds(x27, x28, Operand(x29, SXTX)), "adds x27, x28, x29, sxtx"); 387 COMPARE(cmn(w0, Operand(w1, UXTB, 2)), "cmn w0, w1, uxtb #2"); 388 COMPARE(cmn(x2, Operand(x3, SXTH, 4)), "cmn x2, w3, sxth #4"); 389 390 COMPARE(add(w0, wsp, Operand(w1, UXTB)), "add w0, wsp, w1, uxtb"); 391 COMPARE(add(x2, sp, Operand(x3, UXTH, 1)), "add x2, sp, w3, uxth #1"); 392 COMPARE(add(wsp, wsp, Operand(w4, UXTW, 2)), "add wsp, wsp, w4, lsl #2"); 393 COMPARE(cmn(sp, Operand(xzr, UXTX, 3)), "cmn sp, xzr, lsl #3"); 394 COMPARE(cmn(sp, Operand(xzr, LSL, 4)), "cmn sp, xzr, lsl #4"); 395 396 CLEANUP(); 397} 398 399 400TEST(sub_extended) { 401 SETUP(); 402 403 COMPARE(sub(w0, w1, Operand(w2, UXTB)), "sub w0, w1, w2, uxtb"); 404 COMPARE(subs(x3, x4, Operand(w5, UXTB, 1)), "subs x3, x4, w5, uxtb #1"); 405 COMPARE(sub(w6, w7, Operand(w8, UXTH, 2)), "sub w6, w7, w8, uxth #2"); 406 COMPARE(subs(x9, x10, Operand(x11, UXTW, 3)), "subs x9, x10, w11, uxtw #3"); 407 COMPARE(sub(x12, x13, Operand(x14, UXTX, 4)), "sub x12, x13, x14, uxtx #4"); 408 COMPARE(subs(w15, w16, Operand(w17, SXTB, 4)), "subs w15, w16, w17, sxtb #4"); 409 COMPARE(sub(x18, x19, Operand(x20, SXTB, 3)), "sub x18, x19, w20, sxtb #3"); 410 COMPARE(subs(w21, w22, Operand(w23, SXTH, 2)), "subs w21, w22, w23, sxth #2"); 411 COMPARE(sub(x24, x25, Operand(x26, SXTW, 1)), "sub x24, x25, w26, sxtw #1"); 412 COMPARE(subs(x27, x28, Operand(x29, SXTX)), "subs x27, x28, x29, sxtx"); 413 COMPARE(cmp(w0, Operand(w1, SXTB, 1)), "cmp w0, w1, sxtb #1"); 414 COMPARE(cmp(x2, Operand(x3, UXTH, 3)), "cmp x2, w3, uxth #3"); 415 416 COMPARE(sub(w0, wsp, Operand(w1, UXTB)), "sub w0, wsp, w1, uxtb"); 417 COMPARE(sub(x2, sp, Operand(x3, UXTH, 1)), "sub x2, sp, w3, uxth #1"); 418 COMPARE(sub(wsp, wsp, Operand(w4, UXTW, 2)), "sub wsp, wsp, w4, lsl #2"); 419 COMPARE(cmp(sp, Operand(xzr, UXTX, 3)), "cmp sp, xzr, lsl #3"); 420 COMPARE(cmp(sp, Operand(xzr, LSL, 4)), "cmp sp, xzr, lsl #4"); 421 422 CLEANUP(); 423} 424 425 426TEST(adc_subc_ngc) { 427 SETUP(); 428 429 COMPARE(adc(w0, w1, Operand(w2)), "adc w0, w1, w2"); 430 COMPARE(adc(x3, x4, Operand(x5)), "adc x3, x4, x5"); 431 COMPARE(adcs(w6, w7, Operand(w8)), "adcs w6, w7, w8"); 432 COMPARE(adcs(x9, x10, Operand(x11)), "adcs x9, x10, x11"); 433 COMPARE(sbc(w12, w13, Operand(w14)), "sbc w12, w13, w14"); 434 COMPARE(sbc(x15, x16, Operand(x17)), "sbc x15, x16, x17"); 435 COMPARE(sbcs(w18, w19, Operand(w20)), "sbcs w18, w19, w20"); 436 COMPARE(sbcs(x21, x22, Operand(x23)), "sbcs x21, x22, x23"); 437 COMPARE(ngc(w24, Operand(w25)), "ngc w24, w25"); 438 COMPARE(ngc(x26, Operand(x27)), "ngc x26, x27"); 439 COMPARE(ngcs(w28, Operand(w29)), "ngcs w28, w29"); 440 COMPARE(ngcs(x30, Operand(x0)), "ngcs x30, x0"); 441 442 CLEANUP(); 443} 444 445 446TEST(mul_and_div) { 447 SETUP(); 448 449 COMPARE(mul(w0, w1, w2), "mul w0, w1, w2"); 450 COMPARE(mul(x3, x4, x5), "mul x3, x4, x5"); 451 COMPARE(mul(w30, w0, w1), "mul w30, w0, w1"); 452 COMPARE(mul(x30, x0, x1), "mul x30, x0, x1"); 453 COMPARE(mneg(w0, w1, w2), "mneg w0, w1, w2"); 454 COMPARE(mneg(x3, x4, x5), "mneg x3, x4, x5"); 455 COMPARE(mneg(w30, w0, w1), "mneg w30, w0, w1"); 456 COMPARE(mneg(x30, x0, x1), "mneg x30, x0, x1"); 457 COMPARE(smull(x0, w0, w1), "smull x0, w0, w1"); 458 COMPARE(smull(x30, w30, w0), "smull x30, w30, w0"); 459 COMPARE(smulh(x0, x1, x2), "smulh x0, x1, x2"); 460 COMPARE(umulh(x0, x2, x1), "umulh x0, x2, x1"); 461 462 COMPARE(sdiv(w0, w1, w2), "sdiv w0, w1, w2"); 463 COMPARE(sdiv(x3, x4, x5), "sdiv x3, x4, x5"); 464 COMPARE(udiv(w6, w7, w8), "udiv w6, w7, w8"); 465 COMPARE(udiv(x9, x10, x11), "udiv x9, x10, x11"); 466 467 CLEANUP(); 468} 469 470 471TEST(madd) { 472 SETUP(); 473 474 COMPARE(madd(w0, w1, w2, w3), "madd w0, w1, w2, w3"); 475 COMPARE(madd(w30, w21, w22, w16), "madd w30, w21, w22, w16"); 476 COMPARE(madd(x0, x1, x2, x3), "madd x0, x1, x2, x3"); 477 COMPARE(madd(x30, x21, x22, x16), "madd x30, x21, x22, x16"); 478 479 COMPARE(smaddl(x0, w1, w2, x3), "smaddl x0, w1, w2, x3"); 480 COMPARE(smaddl(x30, w21, w22, x16), "smaddl x30, w21, w22, x16"); 481 COMPARE(umaddl(x0, w1, w2, x3), "umaddl x0, w1, w2, x3"); 482 COMPARE(umaddl(x30, w21, w22, x16), "umaddl x30, w21, w22, x16"); 483 COMPARE(umull(x0, w1, w2), "umull x0, w1, w2"); 484 COMPARE(umull(x30, w21, w22), "umull x30, w21, w22"); 485 486 CLEANUP(); 487} 488 489 490TEST(msub) { 491 SETUP(); 492 493 COMPARE(msub(w0, w1, w2, w3), "msub w0, w1, w2, w3"); 494 COMPARE(msub(w30, w21, w22, w16), "msub w30, w21, w22, w16"); 495 COMPARE(msub(x0, x1, x2, x3), "msub x0, x1, x2, x3"); 496 COMPARE(msub(x30, x21, x22, x16), "msub x30, x21, x22, x16"); 497 498 COMPARE(smsubl(x0, w1, w2, x3), "smsubl x0, w1, w2, x3"); 499 COMPARE(smsubl(x30, w21, w22, x16), "smsubl x30, w21, w22, x16"); 500 COMPARE(umsubl(x0, w1, w2, x3), "umsubl x0, w1, w2, x3"); 501 COMPARE(umsubl(x30, w21, w22, x16), "umsubl x30, w21, w22, x16"); 502 503 CLEANUP(); 504} 505 506 507TEST(dp_1_source) { 508 SETUP(); 509 510 COMPARE(rbit(w0, w1), "rbit w0, w1"); 511 COMPARE(rbit(x2, x3), "rbit x2, x3"); 512 COMPARE(rev16(w4, w5), "rev16 w4, w5"); 513 COMPARE(rev16(x6, x7), "rev16 x6, x7"); 514 COMPARE(rev32(x8, x9), "rev32 x8, x9"); 515 COMPARE(rev(w10, w11), "rev w10, w11"); 516 COMPARE(rev(x12, x13), "rev x12, x13"); 517 COMPARE(clz(w14, w15), "clz w14, w15"); 518 COMPARE(clz(x16, x17), "clz x16, x17"); 519 COMPARE(cls(w18, w19), "cls w18, w19"); 520 COMPARE(cls(x20, x21), "cls x20, x21"); 521 522 CLEANUP(); 523} 524 525 526TEST(bitfield) { 527 SETUP(); 528 529 COMPARE(sxtb(w0, w1), "sxtb w0, w1"); 530 COMPARE(sxtb(x2, x3), "sxtb x2, w3"); 531 COMPARE(sxth(w4, w5), "sxth w4, w5"); 532 COMPARE(sxth(x6, x7), "sxth x6, w7"); 533 COMPARE(sxtw(x8, x9), "sxtw x8, w9"); 534 COMPARE(sxtb(x0, w1), "sxtb x0, w1"); 535 COMPARE(sxth(x2, w3), "sxth x2, w3"); 536 COMPARE(sxtw(x4, w5), "sxtw x4, w5"); 537 538 COMPARE(uxtb(w10, w11), "uxtb w10, w11"); 539 COMPARE(uxtb(x12, x13), "uxtb x12, w13"); 540 COMPARE(uxth(w14, w15), "uxth w14, w15"); 541 COMPARE(uxth(x16, x17), "uxth x16, w17"); 542 COMPARE(uxtw(x18, x19), "ubfx x18, x19, #0, #32"); 543 544 COMPARE(asr(w20, w21, 10), "asr w20, w21, #10"); 545 COMPARE(asr(x22, x23, 20), "asr x22, x23, #20"); 546 COMPARE(lsr(w24, w25, 10), "lsr w24, w25, #10"); 547 COMPARE(lsr(x26, x27, 20), "lsr x26, x27, #20"); 548 COMPARE(lsl(w28, w29, 10), "lsl w28, w29, #10"); 549 COMPARE(lsl(x30, x0, 20), "lsl x30, x0, #20"); 550 551 COMPARE(sbfiz(w1, w2, 1, 20), "sbfiz w1, w2, #1, #20"); 552 COMPARE(sbfiz(x3, x4, 2, 19), "sbfiz x3, x4, #2, #19"); 553 COMPARE(sbfx(w5, w6, 3, 18), "sbfx w5, w6, #3, #18"); 554 COMPARE(sbfx(x7, x8, 4, 17), "sbfx x7, x8, #4, #17"); 555 COMPARE(bfi(w9, w10, 5, 16), "bfi w9, w10, #5, #16"); 556 COMPARE(bfi(x11, x12, 6, 15), "bfi x11, x12, #6, #15"); 557 COMPARE(bfxil(w13, w14, 7, 14), "bfxil w13, w14, #7, #14"); 558 COMPARE(bfxil(x15, x16, 8, 13), "bfxil x15, x16, #8, #13"); 559 COMPARE(ubfiz(w17, w18, 9, 12), "ubfiz w17, w18, #9, #12"); 560 COMPARE(ubfiz(x19, x20, 10, 11), "ubfiz x19, x20, #10, #11"); 561 COMPARE(ubfx(w21, w22, 11, 10), "ubfx w21, w22, #11, #10"); 562 COMPARE(ubfx(x23, x24, 12, 9), "ubfx x23, x24, #12, #9"); 563 564 CLEANUP(); 565} 566 567 568TEST(crc32b) { 569 SETUP(); 570 571 COMPARE(crc32b(w0, w1, w2), "crc32b w0, w1, w2"); 572 COMPARE(crc32b(w0, w11, w22), "crc32b w0, w11, w22"); 573 COMPARE(crc32b(w10, w20, w30), "crc32b w10, w20, w30"); 574 575 CLEANUP(); 576} 577 578 579TEST(crc32h) { 580 SETUP(); 581 582 COMPARE(crc32h(w1, w2, w3), "crc32h w1, w2, w3"); 583 COMPARE(crc32h(w2, w13, w23), "crc32h w2, w13, w23"); 584 COMPARE(crc32h(w11, w12, w15), "crc32h w11, w12, w15"); 585 586 CLEANUP(); 587} 588 589 590TEST(crc32w) { 591 SETUP(); 592 593 COMPARE(crc32w(w2, w3, w4), "crc32w w2, w3, w4"); 594 COMPARE(crc32w(w3, w14, w24), "crc32w w3, w14, w24"); 595 COMPARE(crc32w(w13, w13, w16), "crc32w w13, w13, w16"); 596 597 CLEANUP(); 598} 599 600 601TEST(crc32x) { 602 SETUP(); 603 604 COMPARE(crc32x(w3, w4, x5), "crc32x w3, w4, x5"); 605 COMPARE(crc32x(w4, w15, x25), "crc32x w4, w15, x25"); 606 COMPARE(crc32x(w14, w14, x30), "crc32x w14, w14, x30"); 607 608 CLEANUP(); 609} 610 611 612TEST(crc32cb) { 613 SETUP(); 614 615 COMPARE(crc32cb(w4, w5, w6), "crc32cb w4, w5, w6"); 616 COMPARE(crc32cb(w5, w16, w26), "crc32cb w5, w16, w26"); 617 COMPARE(crc32cb(w15, w15, w5), "crc32cb w15, w15, w5"); 618 619 CLEANUP(); 620} 621 622 623TEST(crc32ch) { 624 SETUP(); 625 626 COMPARE(crc32ch(w5, w6, w7), "crc32ch w5, w6, w7"); 627 COMPARE(crc32ch(w6, w17, w27), "crc32ch w6, w17, w27"); 628 COMPARE(crc32ch(w16, w16, w2), "crc32ch w16, w16, w2"); 629 630 CLEANUP(); 631} 632 633 634TEST(crc32cw) { 635 SETUP(); 636 637 COMPARE(crc32cw(w6, w7, w8), "crc32cw w6, w7, w8"); 638 COMPARE(crc32cw(w7, w18, w28), "crc32cw w7, w18, w28"); 639 COMPARE(crc32cw(w17, w17, w3), "crc32cw w17, w17, w3"); 640 641 CLEANUP(); 642} 643 644 645TEST(crc32cx) { 646 SETUP(); 647 648 COMPARE(crc32cx(w7, w8, x9), "crc32cx w7, w8, x9"); 649 COMPARE(crc32cx(w8, w19, x29), "crc32cx w8, w19, x29"); 650 COMPARE(crc32cx(w18, w18, x4), "crc32cx w18, w18, x4"); 651 652 CLEANUP(); 653} 654 655 656TEST(extract) { 657 SETUP(); 658 659 COMPARE(extr(w0, w1, w2, 0), "extr w0, w1, w2, #0"); 660 COMPARE(extr(x3, x4, x5, 1), "extr x3, x4, x5, #1"); 661 COMPARE(extr(w6, w7, w8, 31), "extr w6, w7, w8, #31"); 662 COMPARE(extr(x9, x10, x11, 63), "extr x9, x10, x11, #63"); 663 COMPARE(extr(w12, w13, w13, 10), "ror w12, w13, #10"); 664 COMPARE(extr(x14, x15, x15, 42), "ror x14, x15, #42"); 665 666 CLEANUP(); 667} 668 669 670TEST(logical_immediate) { 671 SETUP(); 672 #define RESULT_SIZE (256) 673 674 char result[RESULT_SIZE]; 675 676 // Test immediate encoding - 64-bit destination. 677 // 64-bit patterns. 678 uint64_t value = 0x7fffffff; 679 for (int i = 0; i < 64; i++) { 680 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 681 COMPARE(and_(x0, x0, Operand(value)), result); 682 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 683 } 684 685 // 32-bit patterns. 686 value = 0x00003fff00003fff; 687 for (int i = 0; i < 32; i++) { 688 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 689 COMPARE(and_(x0, x0, Operand(value)), result); 690 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 691 } 692 693 // 16-bit patterns. 694 value = 0x001f001f001f001f; 695 for (int i = 0; i < 16; i++) { 696 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 697 COMPARE(and_(x0, x0, Operand(value)), result); 698 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 699 } 700 701 // 8-bit patterns. 702 value = 0x0e0e0e0e0e0e0e0e; 703 for (int i = 0; i < 8; i++) { 704 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 705 COMPARE(and_(x0, x0, Operand(value)), result); 706 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 707 } 708 709 // 4-bit patterns. 710 value = 0x6666666666666666; 711 for (int i = 0; i < 4; i++) { 712 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 713 COMPARE(and_(x0, x0, Operand(value)), result); 714 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 715 } 716 717 // 2-bit patterns. 718 COMPARE(and_(x0, x0, Operand(0x5555555555555555)), 719 "and x0, x0, #0x5555555555555555"); 720 COMPARE(and_(x0, x0, Operand(0xaaaaaaaaaaaaaaaa)), 721 "and x0, x0, #0xaaaaaaaaaaaaaaaa"); 722 723 // Test immediate encoding - 32-bit destination. 724 COMPARE(and_(w0, w0, Operand(0xff8007ff)), 725 "and w0, w0, #0xff8007ff"); // 32-bit pattern. 726 COMPARE(and_(w0, w0, Operand(0xf87ff87f)), 727 "and w0, w0, #0xf87ff87f"); // 16-bit pattern. 728 COMPARE(and_(w0, w0, Operand(0x87878787)), 729 "and w0, w0, #0x87878787"); // 8-bit pattern. 730 COMPARE(and_(w0, w0, Operand(0x66666666)), 731 "and w0, w0, #0x66666666"); // 4-bit pattern. 732 COMPARE(and_(w0, w0, Operand(0x55555555)), 733 "and w0, w0, #0x55555555"); // 2-bit pattern. 734 735 // Test other instructions. 736 COMPARE(tst(w1, Operand(0x11111111)), 737 "tst w1, #0x11111111"); 738 COMPARE(tst(x2, Operand(0x8888888888888888)), 739 "tst x2, #0x8888888888888888"); 740 COMPARE(orr(w7, w8, Operand(0xaaaaaaaa)), 741 "orr w7, w8, #0xaaaaaaaa"); 742 COMPARE(orr(x9, x10, Operand(0x5555555555555555)), 743 "orr x9, x10, #0x5555555555555555"); 744 COMPARE(eor(w15, w16, Operand(0x00000001)), 745 "eor w15, w16, #0x1"); 746 COMPARE(eor(x17, x18, Operand(0x0000000000000003)), 747 "eor x17, x18, #0x3"); 748 COMPARE(ands(w23, w24, Operand(0x0000000f)), "ands w23, w24, #0xf"); 749 COMPARE(ands(x25, x26, Operand(0x800000000000000f)), 750 "ands x25, x26, #0x800000000000000f"); 751 752 // Test inverse. 753 COMPARE(bic(w3, w4, Operand(0x20202020)), 754 "and w3, w4, #0xdfdfdfdf"); 755 COMPARE(bic(x5, x6, Operand(0x4040404040404040)), 756 "and x5, x6, #0xbfbfbfbfbfbfbfbf"); 757 COMPARE(orn(w11, w12, Operand(0x40004000)), 758 "orr w11, w12, #0xbfffbfff"); 759 COMPARE(orn(x13, x14, Operand(0x8181818181818181)), 760 "orr x13, x14, #0x7e7e7e7e7e7e7e7e"); 761 COMPARE(eon(w19, w20, Operand(0x80000001)), 762 "eor w19, w20, #0x7ffffffe"); 763 COMPARE(eon(x21, x22, Operand(0xc000000000000003)), 764 "eor x21, x22, #0x3ffffffffffffffc"); 765 COMPARE(bics(w27, w28, Operand(0xfffffff7)), "ands w27, w28, #0x8"); 766 COMPARE(bics(x29, x0, Operand(0xfffffffeffffffff)), 767 "ands x29, x0, #0x100000000"); 768 769 // Test stack pointer. 770 COMPARE(and_(wsp, wzr, Operand(7)), "and wsp, wzr, #0x7"); 771 COMPARE(ands(xzr, xzr, Operand(7)), "tst xzr, #0x7"); 772 COMPARE(orr(sp, xzr, Operand(15)), "orr sp, xzr, #0xf"); 773 COMPARE(eor(wsp, w0, Operand(31)), "eor wsp, w0, #0x1f"); 774 775 // Test move aliases. 776 COMPARE(orr(w0, wzr, Operand(0x00000780)), "orr w0, wzr, #0x780"); 777 COMPARE(orr(w1, wzr, Operand(0x00007800)), "orr w1, wzr, #0x7800"); 778 COMPARE(orr(w2, wzr, Operand(0x00078000)), "mov w2, #0x78000"); 779 COMPARE(orr(w3, wzr, Operand(0x00780000)), "orr w3, wzr, #0x780000"); 780 COMPARE(orr(w4, wzr, Operand(0x07800000)), "orr w4, wzr, #0x7800000"); 781 COMPARE(orr(x5, xzr, Operand(0xffffffffffffc001)), 782 "orr x5, xzr, #0xffffffffffffc001"); 783 COMPARE(orr(x6, xzr, Operand(0xfffffffffffc001f)), 784 "mov x6, #0xfffffffffffc001f"); 785 COMPARE(orr(x7, xzr, Operand(0xffffffffffc001ff)), 786 "mov x7, #0xffffffffffc001ff"); 787 COMPARE(orr(x8, xzr, Operand(0xfffffffffc001fff)), 788 "mov x8, #0xfffffffffc001fff"); 789 COMPARE(orr(x9, xzr, Operand(0xffffffffc001ffff)), 790 "orr x9, xzr, #0xffffffffc001ffff"); 791 792 CLEANUP(); 793} 794 795 796TEST(logical_shifted) { 797 SETUP(); 798 799 COMPARE(and_(w0, w1, Operand(w2)), "and w0, w1, w2"); 800 COMPARE(and_(x3, x4, Operand(x5, LSL, 1)), "and x3, x4, x5, lsl #1"); 801 COMPARE(and_(w6, w7, Operand(w8, LSR, 2)), "and w6, w7, w8, lsr #2"); 802 COMPARE(and_(x9, x10, Operand(x11, ASR, 3)), "and x9, x10, x11, asr #3"); 803 COMPARE(and_(w12, w13, Operand(w14, ROR, 4)), "and w12, w13, w14, ror #4"); 804 805 COMPARE(bic(w15, w16, Operand(w17)), "bic w15, w16, w17"); 806 COMPARE(bic(x18, x19, Operand(x20, LSL, 5)), "bic x18, x19, x20, lsl #5"); 807 COMPARE(bic(w21, w22, Operand(w23, LSR, 6)), "bic w21, w22, w23, lsr #6"); 808 COMPARE(bic(x24, x25, Operand(x26, ASR, 7)), "bic x24, x25, x26, asr #7"); 809 COMPARE(bic(w27, w28, Operand(w29, ROR, 8)), "bic w27, w28, w29, ror #8"); 810 811 COMPARE(orr(w0, w1, Operand(w2)), "orr w0, w1, w2"); 812 COMPARE(orr(x3, x4, Operand(x5, LSL, 9)), "orr x3, x4, x5, lsl #9"); 813 COMPARE(orr(w6, w7, Operand(w8, LSR, 10)), "orr w6, w7, w8, lsr #10"); 814 COMPARE(orr(x9, x10, Operand(x11, ASR, 11)), "orr x9, x10, x11, asr #11"); 815 COMPARE(orr(w12, w13, Operand(w14, ROR, 12)), "orr w12, w13, w14, ror #12"); 816 817 COMPARE(orn(w15, w16, Operand(w17)), "orn w15, w16, w17"); 818 COMPARE(orn(x18, x19, Operand(x20, LSL, 13)), "orn x18, x19, x20, lsl #13"); 819 COMPARE(orn(w21, w22, Operand(w23, LSR, 14)), "orn w21, w22, w23, lsr #14"); 820 COMPARE(orn(x24, x25, Operand(x26, ASR, 15)), "orn x24, x25, x26, asr #15"); 821 COMPARE(orn(w27, w28, Operand(w29, ROR, 16)), "orn w27, w28, w29, ror #16"); 822 823 COMPARE(eor(w0, w1, Operand(w2)), "eor w0, w1, w2"); 824 COMPARE(eor(x3, x4, Operand(x5, LSL, 17)), "eor x3, x4, x5, lsl #17"); 825 COMPARE(eor(w6, w7, Operand(w8, LSR, 18)), "eor w6, w7, w8, lsr #18"); 826 COMPARE(eor(x9, x10, Operand(x11, ASR, 19)), "eor x9, x10, x11, asr #19"); 827 COMPARE(eor(w12, w13, Operand(w14, ROR, 20)), "eor w12, w13, w14, ror #20"); 828 829 COMPARE(eon(w15, w16, Operand(w17)), "eon w15, w16, w17"); 830 COMPARE(eon(x18, x19, Operand(x20, LSL, 21)), "eon x18, x19, x20, lsl #21"); 831 COMPARE(eon(w21, w22, Operand(w23, LSR, 22)), "eon w21, w22, w23, lsr #22"); 832 COMPARE(eon(x24, x25, Operand(x26, ASR, 23)), "eon x24, x25, x26, asr #23"); 833 COMPARE(eon(w27, w28, Operand(w29, ROR, 24)), "eon w27, w28, w29, ror #24"); 834 835 COMPARE(ands(w0, w1, Operand(w2)), "ands w0, w1, w2"); 836 COMPARE(ands(x3, x4, Operand(x5, LSL, 1)), "ands x3, x4, x5, lsl #1"); 837 COMPARE(ands(w6, w7, Operand(w8, LSR, 2)), "ands w6, w7, w8, lsr #2"); 838 COMPARE(ands(x9, x10, Operand(x11, ASR, 3)), "ands x9, x10, x11, asr #3"); 839 COMPARE(ands(w12, w13, Operand(w14, ROR, 4)), "ands w12, w13, w14, ror #4"); 840 841 COMPARE(bics(w15, w16, Operand(w17)), "bics w15, w16, w17"); 842 COMPARE(bics(x18, x19, Operand(x20, LSL, 5)), "bics x18, x19, x20, lsl #5"); 843 COMPARE(bics(w21, w22, Operand(w23, LSR, 6)), "bics w21, w22, w23, lsr #6"); 844 COMPARE(bics(x24, x25, Operand(x26, ASR, 7)), "bics x24, x25, x26, asr #7"); 845 COMPARE(bics(w27, w28, Operand(w29, ROR, 8)), "bics w27, w28, w29, ror #8"); 846 847 COMPARE(tst(w0, Operand(w1)), "tst w0, w1"); 848 COMPARE(tst(w2, Operand(w3, ROR, 10)), "tst w2, w3, ror #10"); 849 COMPARE(tst(x0, Operand(x1)), "tst x0, x1"); 850 COMPARE(tst(x2, Operand(x3, ROR, 42)), "tst x2, x3, ror #42"); 851 852 COMPARE(orn(w0, wzr, Operand(w1)), "mvn w0, w1"); 853 COMPARE(orn(w2, wzr, Operand(w3, ASR, 5)), "mvn w2, w3, asr #5"); 854 COMPARE(orn(x0, xzr, Operand(x1)), "mvn x0, x1"); 855 COMPARE(orn(x2, xzr, Operand(x3, ASR, 42)), "mvn x2, x3, asr #42"); 856 857 COMPARE(orr(w0, wzr, Operand(w1)), "mov w0, w1"); 858 COMPARE(orr(x0, xzr, Operand(x1)), "mov x0, x1"); 859 COMPARE(orr(w16, wzr, Operand(w17, LSL, 1)), "orr w16, wzr, w17, lsl #1"); 860 COMPARE(orr(x16, xzr, Operand(x17, ASR, 2)), "orr x16, xzr, x17, asr #2"); 861 862 CLEANUP(); 863} 864 865 866TEST(dp_2_source) { 867 SETUP(); 868 869 COMPARE(lslv(w0, w1, w2), "lsl w0, w1, w2"); 870 COMPARE(lslv(x3, x4, x5), "lsl x3, x4, x5"); 871 COMPARE(lsrv(w6, w7, w8), "lsr w6, w7, w8"); 872 COMPARE(lsrv(x9, x10, x11), "lsr x9, x10, x11"); 873 COMPARE(asrv(w12, w13, w14), "asr w12, w13, w14"); 874 COMPARE(asrv(x15, x16, x17), "asr x15, x16, x17"); 875 COMPARE(rorv(w18, w19, w20), "ror w18, w19, w20"); 876 COMPARE(rorv(x21, x22, x23), "ror x21, x22, x23"); 877 878 CLEANUP(); 879} 880 881 882TEST(adr) { 883 SETUP(); 884 885 COMPARE_PREFIX(adr(x0, 0), "adr x0, #+0x0"); 886 COMPARE_PREFIX(adr(x1, 1), "adr x1, #+0x1"); 887 COMPARE_PREFIX(adr(x2, -1), "adr x2, #-0x1"); 888 COMPARE_PREFIX(adr(x3, 4), "adr x3, #+0x4"); 889 COMPARE_PREFIX(adr(x4, -4), "adr x4, #-0x4"); 890 COMPARE_PREFIX(adr(x5, 0x000fffff), "adr x5, #+0xfffff"); 891 COMPARE_PREFIX(adr(x6, -0x00100000), "adr x6, #-0x100000"); 892 COMPARE_PREFIX(adr(xzr, 0), "adr xzr, #+0x0"); 893 894 CLEANUP(); 895} 896 897 898TEST(adrp) { 899 SETUP(); 900 901 COMPARE_PREFIX(adrp(x0, 0), "adrp x0, #+0x0"); 902 COMPARE_PREFIX(adrp(x1, 1), "adrp x1, #+0x1000"); 903 COMPARE_PREFIX(adrp(x2, -1), "adrp x2, #-0x1000"); 904 COMPARE_PREFIX(adrp(x3, 4), "adrp x3, #+0x4000"); 905 COMPARE_PREFIX(adrp(x4, -4), "adrp x4, #-0x4000"); 906 COMPARE_PREFIX(adrp(x5, 0x000fffff), "adrp x5, #+0xfffff000"); 907 COMPARE_PREFIX(adrp(x6, -0x00100000), "adrp x6, #-0x100000000"); 908 COMPARE_PREFIX(adrp(xzr, 0), "adrp xzr, #+0x0"); 909 910 CLEANUP(); 911} 912 913 914TEST(branch) { 915 SETUP(); 916 917 #define INST_OFF(x) ((x) >> kInstructionSizeLog2) 918 COMPARE_PREFIX(b(INST_OFF(0x4)), "b #+0x4"); 919 COMPARE_PREFIX(b(INST_OFF(-0x4)), "b #-0x4"); 920 COMPARE_PREFIX(b(INST_OFF(0x7fffffc)), "b #+0x7fffffc"); 921 COMPARE_PREFIX(b(INST_OFF(-0x8000000)), "b #-0x8000000"); 922 COMPARE_PREFIX(b(INST_OFF(0xffffc), eq), "b.eq #+0xffffc"); 923 COMPARE_PREFIX(b(INST_OFF(-0x100000), mi), "b.mi #-0x100000"); 924 COMPARE_PREFIX(b(INST_OFF(0xffffc), al), "b.al #+0xffffc"); 925 COMPARE_PREFIX(b(INST_OFF(-0x100000), nv), "b.nv #-0x100000"); 926 COMPARE_PREFIX(bl(INST_OFF(0x4)), "bl #+0x4"); 927 COMPARE_PREFIX(bl(INST_OFF(-0x4)), "bl #-0x4"); 928 COMPARE_PREFIX(bl(INST_OFF(0xffffc)), "bl #+0xffffc"); 929 COMPARE_PREFIX(bl(INST_OFF(-0x100000)), "bl #-0x100000"); 930 COMPARE_PREFIX(cbz(w0, INST_OFF(0xffffc)), "cbz w0, #+0xffffc"); 931 COMPARE_PREFIX(cbz(x1, INST_OFF(-0x100000)), "cbz x1, #-0x100000"); 932 COMPARE_PREFIX(cbnz(w2, INST_OFF(0xffffc)), "cbnz w2, #+0xffffc"); 933 COMPARE_PREFIX(cbnz(x3, INST_OFF(-0x100000)), "cbnz x3, #-0x100000"); 934 COMPARE_PREFIX(tbz(w4, 0, INST_OFF(0x7ffc)), "tbz w4, #0, #+0x7ffc"); 935 COMPARE_PREFIX(tbz(x5, 63, INST_OFF(-0x8000)), "tbz x5, #63, #-0x8000"); 936 COMPARE_PREFIX(tbz(w6, 31, INST_OFF(0)), "tbz w6, #31, #+0x0"); 937 COMPARE_PREFIX(tbz(x7, 31, INST_OFF(0x4)), "tbz w7, #31, #+0x4"); 938 COMPARE_PREFIX(tbz(x8, 32, INST_OFF(0x8)), "tbz x8, #32, #+0x8"); 939 COMPARE_PREFIX(tbnz(w8, 0, INST_OFF(0x7ffc)), "tbnz w8, #0, #+0x7ffc"); 940 COMPARE_PREFIX(tbnz(x9, 63, INST_OFF(-0x8000)), "tbnz x9, #63, #-0x8000"); 941 COMPARE_PREFIX(tbnz(w10, 31, INST_OFF(0)), "tbnz w10, #31, #+0x0"); 942 COMPARE_PREFIX(tbnz(x11, 31, INST_OFF(0x4)), "tbnz w11, #31, #+0x4"); 943 COMPARE_PREFIX(tbnz(x12, 32, INST_OFF(0x8)), "tbnz x12, #32, #+0x8"); 944 COMPARE(br(x0), "br x0"); 945 COMPARE(blr(x1), "blr x1"); 946 COMPARE(ret(x2), "ret x2"); 947 COMPARE(ret(lr), "ret") 948 949 CLEANUP(); 950} 951 952 953TEST(load_store) { 954 SETUP(); 955 956 COMPARE(ldr(w0, MemOperand(x1)), "ldr w0, [x1]"); 957 COMPARE(ldr(w2, MemOperand(x3, 4)), "ldr w2, [x3, #4]"); 958 COMPARE(ldr(w4, MemOperand(x5, 16380)), "ldr w4, [x5, #16380]"); 959 COMPARE(ldr(x6, MemOperand(x7)), "ldr x6, [x7]"); 960 COMPARE(ldr(x8, MemOperand(x9, 8)), "ldr x8, [x9, #8]"); 961 COMPARE(ldr(x10, MemOperand(x11, 32760)), "ldr x10, [x11, #32760]"); 962 COMPARE(str(w12, MemOperand(x13)), "str w12, [x13]"); 963 COMPARE(str(w14, MemOperand(x15, 4)), "str w14, [x15, #4]"); 964 COMPARE(str(w16, MemOperand(x17, 16380)), "str w16, [x17, #16380]"); 965 COMPARE(str(x18, MemOperand(x19)), "str x18, [x19]"); 966 COMPARE(str(x20, MemOperand(x21, 8)), "str x20, [x21, #8]"); 967 COMPARE(str(x22, MemOperand(x23, 32760)), "str x22, [x23, #32760]"); 968 969 COMPARE(ldr(w0, MemOperand(x1, 4, PreIndex)), "ldr w0, [x1, #4]!"); 970 COMPARE(ldr(w2, MemOperand(x3, 255, PreIndex)), "ldr w2, [x3, #255]!"); 971 COMPARE(ldr(w4, MemOperand(x5, -256, PreIndex)), "ldr w4, [x5, #-256]!"); 972 COMPARE(ldr(x6, MemOperand(x7, 8, PreIndex)), "ldr x6, [x7, #8]!"); 973 COMPARE(ldr(x8, MemOperand(x9, 255, PreIndex)), "ldr x8, [x9, #255]!"); 974 COMPARE(ldr(x10, MemOperand(x11, -256, PreIndex)), "ldr x10, [x11, #-256]!"); 975 COMPARE(str(w12, MemOperand(x13, 4, PreIndex)), "str w12, [x13, #4]!"); 976 COMPARE(str(w14, MemOperand(x15, 255, PreIndex)), "str w14, [x15, #255]!"); 977 COMPARE(str(w16, MemOperand(x17, -256, PreIndex)), "str w16, [x17, #-256]!"); 978 COMPARE(str(x18, MemOperand(x19, 8, PreIndex)), "str x18, [x19, #8]!"); 979 COMPARE(str(x20, MemOperand(x21, 255, PreIndex)), "str x20, [x21, #255]!"); 980 COMPARE(str(x22, MemOperand(x23, -256, PreIndex)), "str x22, [x23, #-256]!"); 981 982 COMPARE(ldr(w0, MemOperand(x1, 4, PostIndex)), "ldr w0, [x1], #4"); 983 COMPARE(ldr(w2, MemOperand(x3, 255, PostIndex)), "ldr w2, [x3], #255"); 984 COMPARE(ldr(w4, MemOperand(x5, -256, PostIndex)), "ldr w4, [x5], #-256"); 985 COMPARE(ldr(x6, MemOperand(x7, 8, PostIndex)), "ldr x6, [x7], #8"); 986 COMPARE(ldr(x8, MemOperand(x9, 255, PostIndex)), "ldr x8, [x9], #255"); 987 COMPARE(ldr(x10, MemOperand(x11, -256, PostIndex)), "ldr x10, [x11], #-256"); 988 COMPARE(str(w12, MemOperand(x13, 4, PostIndex)), "str w12, [x13], #4"); 989 COMPARE(str(w14, MemOperand(x15, 255, PostIndex)), "str w14, [x15], #255"); 990 COMPARE(str(w16, MemOperand(x17, -256, PostIndex)), "str w16, [x17], #-256"); 991 COMPARE(str(x18, MemOperand(x19, 8, PostIndex)), "str x18, [x19], #8"); 992 COMPARE(str(x20, MemOperand(x21, 255, PostIndex)), "str x20, [x21], #255"); 993 COMPARE(str(x22, MemOperand(x23, -256, PostIndex)), "str x22, [x23], #-256"); 994 995 COMPARE(ldr(w24, MemOperand(sp)), "ldr w24, [sp]"); 996 COMPARE(ldr(x25, MemOperand(sp, 8)), "ldr x25, [sp, #8]"); 997 COMPARE(str(w26, MemOperand(sp, 4, PreIndex)), "str w26, [sp, #4]!"); 998 COMPARE(str(x27, MemOperand(sp, -8, PostIndex)), "str x27, [sp], #-8"); 999 1000 COMPARE(ldrsw(x0, MemOperand(x1)), "ldrsw x0, [x1]"); 1001 COMPARE(ldrsw(x2, MemOperand(x3, 8)), "ldrsw x2, [x3, #8]"); 1002 COMPARE(ldrsw(x4, MemOperand(x5, 42, PreIndex)), "ldrsw x4, [x5, #42]!"); 1003 COMPARE(ldrsw(x6, MemOperand(x7, -11, PostIndex)), "ldrsw x6, [x7], #-11"); 1004 1005 CLEANUP(); 1006} 1007 1008 1009TEST(load_store_regoffset) { 1010 SETUP(); 1011 1012 COMPARE(ldr(w0, MemOperand(x1, w2, UXTW)), "ldr w0, [x1, w2, uxtw]"); 1013 COMPARE(ldr(w3, MemOperand(x4, w5, UXTW, 2)), "ldr w3, [x4, w5, uxtw #2]"); 1014 COMPARE(ldr(w6, MemOperand(x7, x8)), "ldr w6, [x7, x8]"); 1015 COMPARE(ldr(w9, MemOperand(x10, x11, LSL, 2)), "ldr w9, [x10, x11, lsl #2]"); 1016 COMPARE(ldr(w12, MemOperand(x13, w14, SXTW)), "ldr w12, [x13, w14, sxtw]"); 1017 COMPARE(ldr(w15, MemOperand(x16, w17, SXTW, 2)), 1018 "ldr w15, [x16, w17, sxtw #2]"); 1019 COMPARE(ldr(w18, MemOperand(x19, x20, SXTX)), "ldr w18, [x19, x20, sxtx]"); 1020 COMPARE(ldr(w21, MemOperand(x22, x23, SXTX, 2)), 1021 "ldr w21, [x22, x23, sxtx #2]"); 1022 COMPARE(ldr(x0, MemOperand(x1, w2, UXTW)), "ldr x0, [x1, w2, uxtw]"); 1023 COMPARE(ldr(x3, MemOperand(x4, w5, UXTW, 3)), "ldr x3, [x4, w5, uxtw #3]"); 1024 COMPARE(ldr(x6, MemOperand(x7, x8)), "ldr x6, [x7, x8]"); 1025 COMPARE(ldr(x9, MemOperand(x10, x11, LSL, 3)), "ldr x9, [x10, x11, lsl #3]"); 1026 COMPARE(ldr(x12, MemOperand(x13, w14, SXTW)), "ldr x12, [x13, w14, sxtw]"); 1027 COMPARE(ldr(x15, MemOperand(x16, w17, SXTW, 3)), 1028 "ldr x15, [x16, w17, sxtw #3]"); 1029 COMPARE(ldr(x18, MemOperand(x19, x20, SXTX)), "ldr x18, [x19, x20, sxtx]"); 1030 COMPARE(ldr(x21, MemOperand(x22, x23, SXTX, 3)), 1031 "ldr x21, [x22, x23, sxtx #3]"); 1032 1033 COMPARE(str(w0, MemOperand(x1, w2, UXTW)), "str w0, [x1, w2, uxtw]"); 1034 COMPARE(str(w3, MemOperand(x4, w5, UXTW, 2)), "str w3, [x4, w5, uxtw #2]"); 1035 COMPARE(str(w6, MemOperand(x7, x8)), "str w6, [x7, x8]"); 1036 COMPARE(str(w9, MemOperand(x10, x11, LSL, 2)), "str w9, [x10, x11, lsl #2]"); 1037 COMPARE(str(w12, MemOperand(x13, w14, SXTW)), "str w12, [x13, w14, sxtw]"); 1038 COMPARE(str(w15, MemOperand(x16, w17, SXTW, 2)), 1039 "str w15, [x16, w17, sxtw #2]"); 1040 COMPARE(str(w18, MemOperand(x19, x20, SXTX)), "str w18, [x19, x20, sxtx]"); 1041 COMPARE(str(w21, MemOperand(x22, x23, SXTX, 2)), 1042 "str w21, [x22, x23, sxtx #2]"); 1043 COMPARE(str(x0, MemOperand(x1, w2, UXTW)), "str x0, [x1, w2, uxtw]"); 1044 COMPARE(str(x3, MemOperand(x4, w5, UXTW, 3)), "str x3, [x4, w5, uxtw #3]"); 1045 COMPARE(str(x6, MemOperand(x7, x8)), "str x6, [x7, x8]"); 1046 COMPARE(str(x9, MemOperand(x10, x11, LSL, 3)), "str x9, [x10, x11, lsl #3]"); 1047 COMPARE(str(x12, MemOperand(x13, w14, SXTW)), "str x12, [x13, w14, sxtw]"); 1048 COMPARE(str(x15, MemOperand(x16, w17, SXTW, 3)), 1049 "str x15, [x16, w17, sxtw #3]"); 1050 COMPARE(str(x18, MemOperand(x19, x20, SXTX)), "str x18, [x19, x20, sxtx]"); 1051 COMPARE(str(x21, MemOperand(x22, x23, SXTX, 3)), 1052 "str x21, [x22, x23, sxtx #3]"); 1053 1054 COMPARE(ldrb(w0, MemOperand(x1, w2, UXTW)), "ldrb w0, [x1, w2, uxtw]"); 1055 COMPARE(ldrb(w6, MemOperand(x7, x8)), "ldrb w6, [x7, x8]"); 1056 COMPARE(ldrb(w12, MemOperand(x13, w14, SXTW)), "ldrb w12, [x13, w14, sxtw]"); 1057 COMPARE(ldrb(w18, MemOperand(x19, x20, SXTX)), "ldrb w18, [x19, x20, sxtx]"); 1058 COMPARE(strb(w0, MemOperand(x1, w2, UXTW)), "strb w0, [x1, w2, uxtw]"); 1059 COMPARE(strb(w6, MemOperand(x7, x8)), "strb w6, [x7, x8]"); 1060 COMPARE(strb(w12, MemOperand(x13, w14, SXTW)), "strb w12, [x13, w14, sxtw]"); 1061 COMPARE(strb(w18, MemOperand(x19, x20, SXTX)), "strb w18, [x19, x20, sxtx]"); 1062 1063 COMPARE(ldrh(w0, MemOperand(x1, w2, UXTW)), "ldrh w0, [x1, w2, uxtw]"); 1064 COMPARE(ldrh(w3, MemOperand(x4, w5, UXTW, 1)), "ldrh w3, [x4, w5, uxtw #1]"); 1065 COMPARE(ldrh(w6, MemOperand(x7, x8)), "ldrh w6, [x7, x8]"); 1066 COMPARE(ldrh(w9, MemOperand(x10, x11, LSL, 1)), 1067 "ldrh w9, [x10, x11, lsl #1]"); 1068 COMPARE(ldrh(w12, MemOperand(x13, w14, SXTW)), "ldrh w12, [x13, w14, sxtw]"); 1069 COMPARE(ldrh(w15, MemOperand(x16, w17, SXTW, 1)), 1070 "ldrh w15, [x16, w17, sxtw #1]"); 1071 COMPARE(ldrh(w18, MemOperand(x19, x20, SXTX)), "ldrh w18, [x19, x20, sxtx]"); 1072 COMPARE(ldrh(w21, MemOperand(x22, x23, SXTX, 1)), 1073 "ldrh w21, [x22, x23, sxtx #1]"); 1074 COMPARE(strh(w0, MemOperand(x1, w2, UXTW)), "strh w0, [x1, w2, uxtw]"); 1075 COMPARE(strh(w3, MemOperand(x4, w5, UXTW, 1)), "strh w3, [x4, w5, uxtw #1]"); 1076 COMPARE(strh(w6, MemOperand(x7, x8)), "strh w6, [x7, x8]"); 1077 COMPARE(strh(w9, MemOperand(x10, x11, LSL, 1)), 1078 "strh w9, [x10, x11, lsl #1]"); 1079 COMPARE(strh(w12, MemOperand(x13, w14, SXTW)), "strh w12, [x13, w14, sxtw]"); 1080 COMPARE(strh(w15, MemOperand(x16, w17, SXTW, 1)), 1081 "strh w15, [x16, w17, sxtw #1]"); 1082 COMPARE(strh(w18, MemOperand(x19, x20, SXTX)), "strh w18, [x19, x20, sxtx]"); 1083 COMPARE(strh(w21, MemOperand(x22, x23, SXTX, 1)), 1084 "strh w21, [x22, x23, sxtx #1]"); 1085 1086 COMPARE(ldr(x0, MemOperand(sp, wzr, SXTW)), "ldr x0, [sp, wzr, sxtw]"); 1087 COMPARE(str(x1, MemOperand(sp, xzr)), "str x1, [sp, xzr]"); 1088 1089 CLEANUP(); 1090} 1091 1092 1093TEST(load_store_byte) { 1094 SETUP(); 1095 1096 COMPARE(ldrb(w0, MemOperand(x1)), "ldrb w0, [x1]"); 1097 COMPARE(ldrb(x2, MemOperand(x3)), "ldrb w2, [x3]"); 1098 COMPARE(ldrb(w4, MemOperand(x5, 4095)), "ldrb w4, [x5, #4095]"); 1099 COMPARE(ldrb(w6, MemOperand(x7, 255, PreIndex)), "ldrb w6, [x7, #255]!"); 1100 COMPARE(ldrb(w8, MemOperand(x9, -256, PreIndex)), "ldrb w8, [x9, #-256]!"); 1101 COMPARE(ldrb(w10, MemOperand(x11, 255, PostIndex)), "ldrb w10, [x11], #255"); 1102 COMPARE(ldrb(w12, MemOperand(x13, -256, PostIndex)), 1103 "ldrb w12, [x13], #-256"); 1104 COMPARE(strb(w14, MemOperand(x15)), "strb w14, [x15]"); 1105 COMPARE(strb(x16, MemOperand(x17)), "strb w16, [x17]"); 1106 COMPARE(strb(w18, MemOperand(x19, 4095)), "strb w18, [x19, #4095]"); 1107 COMPARE(strb(w20, MemOperand(x21, 255, PreIndex)), "strb w20, [x21, #255]!"); 1108 COMPARE(strb(w22, MemOperand(x23, -256, PreIndex)), 1109 "strb w22, [x23, #-256]!"); 1110 COMPARE(strb(w24, MemOperand(x25, 255, PostIndex)), "strb w24, [x25], #255"); 1111 COMPARE(strb(w26, MemOperand(x27, -256, PostIndex)), 1112 "strb w26, [x27], #-256"); 1113 COMPARE(ldrb(w28, MemOperand(sp, 3, PostIndex)), "ldrb w28, [sp], #3"); 1114 COMPARE(strb(x29, MemOperand(sp, -42, PreIndex)), "strb w29, [sp, #-42]!"); 1115 COMPARE(ldrsb(w0, MemOperand(x1)), "ldrsb w0, [x1]"); 1116 COMPARE(ldrsb(x2, MemOperand(x3, 8)), "ldrsb x2, [x3, #8]"); 1117 COMPARE(ldrsb(w4, MemOperand(x5, 42, PreIndex)), "ldrsb w4, [x5, #42]!"); 1118 COMPARE(ldrsb(x6, MemOperand(x7, -11, PostIndex)), "ldrsb x6, [x7], #-11"); 1119 1120 CLEANUP(); 1121} 1122 1123 1124TEST(load_store_half) { 1125 SETUP(); 1126 1127 COMPARE(ldrh(w0, MemOperand(x1)), "ldrh w0, [x1]"); 1128 COMPARE(ldrh(x2, MemOperand(x3)), "ldrh w2, [x3]"); 1129 COMPARE(ldrh(w4, MemOperand(x5, 8190)), "ldrh w4, [x5, #8190]"); 1130 COMPARE(ldrh(w6, MemOperand(x7, 255, PreIndex)), "ldrh w6, [x7, #255]!"); 1131 COMPARE(ldrh(w8, MemOperand(x9, -256, PreIndex)), "ldrh w8, [x9, #-256]!"); 1132 COMPARE(ldrh(w10, MemOperand(x11, 255, PostIndex)), "ldrh w10, [x11], #255"); 1133 COMPARE(ldrh(w12, MemOperand(x13, -256, PostIndex)), 1134 "ldrh w12, [x13], #-256"); 1135 COMPARE(strh(w14, MemOperand(x15)), "strh w14, [x15]"); 1136 COMPARE(strh(x16, MemOperand(x17)), "strh w16, [x17]"); 1137 COMPARE(strh(w18, MemOperand(x19, 8190)), "strh w18, [x19, #8190]"); 1138 COMPARE(strh(w20, MemOperand(x21, 255, PreIndex)), "strh w20, [x21, #255]!"); 1139 COMPARE(strh(w22, MemOperand(x23, -256, PreIndex)), 1140 "strh w22, [x23, #-256]!"); 1141 COMPARE(strh(w24, MemOperand(x25, 255, PostIndex)), "strh w24, [x25], #255"); 1142 COMPARE(strh(w26, MemOperand(x27, -256, PostIndex)), 1143 "strh w26, [x27], #-256"); 1144 COMPARE(ldrh(w28, MemOperand(sp, 3, PostIndex)), "ldrh w28, [sp], #3"); 1145 COMPARE(strh(x29, MemOperand(sp, -42, PreIndex)), "strh w29, [sp, #-42]!"); 1146 COMPARE(ldrh(w30, MemOperand(x0, 255)), "ldurh w30, [x0, #255]"); 1147 COMPARE(ldrh(x1, MemOperand(x2, -256)), "ldurh w1, [x2, #-256]"); 1148 COMPARE(strh(w3, MemOperand(x4, 255)), "sturh w3, [x4, #255]"); 1149 COMPARE(strh(x5, MemOperand(x6, -256)), "sturh w5, [x6, #-256]"); 1150 COMPARE(ldrsh(w0, MemOperand(x1)), "ldrsh w0, [x1]"); 1151 COMPARE(ldrsh(w2, MemOperand(x3, 8)), "ldrsh w2, [x3, #8]"); 1152 COMPARE(ldrsh(w4, MemOperand(x5, 42, PreIndex)), "ldrsh w4, [x5, #42]!"); 1153 COMPARE(ldrsh(x6, MemOperand(x7, -11, PostIndex)), "ldrsh x6, [x7], #-11"); 1154 1155 CLEANUP(); 1156} 1157 1158 1159TEST(load_store_v_offset) { 1160 SETUP(); 1161 1162 COMPARE(ldr(s0, MemOperand(x1)), "ldr s0, [x1]"); 1163 COMPARE(ldr(s2, MemOperand(x3, 4)), "ldr s2, [x3, #4]"); 1164 COMPARE(ldr(s4, MemOperand(x5, 16380)), "ldr s4, [x5, #16380]"); 1165 COMPARE(ldr(d6, MemOperand(x7)), "ldr d6, [x7]"); 1166 COMPARE(ldr(d8, MemOperand(x9, 8)), "ldr d8, [x9, #8]"); 1167 COMPARE(ldr(d10, MemOperand(x11, 32760)), "ldr d10, [x11, #32760]"); 1168 COMPARE(str(s12, MemOperand(x13)), "str s12, [x13]"); 1169 COMPARE(str(s14, MemOperand(x15, 4)), "str s14, [x15, #4]"); 1170 COMPARE(str(s16, MemOperand(x17, 16380)), "str s16, [x17, #16380]"); 1171 COMPARE(str(d18, MemOperand(x19)), "str d18, [x19]"); 1172 COMPARE(str(d20, MemOperand(x21, 8)), "str d20, [x21, #8]"); 1173 COMPARE(str(d22, MemOperand(x23, 32760)), "str d22, [x23, #32760]"); 1174 1175 COMPARE(ldr(b0, MemOperand(x1)), "ldr b0, [x1]"); 1176 COMPARE(ldr(b2, MemOperand(x3, 1)), "ldr b2, [x3, #1]"); 1177 COMPARE(ldr(b4, MemOperand(x5, 4095)), "ldr b4, [x5, #4095]"); 1178 COMPARE(ldr(h6, MemOperand(x7)), "ldr h6, [x7]"); 1179 COMPARE(ldr(h8, MemOperand(x9, 2)), "ldr h8, [x9, #2]"); 1180 COMPARE(ldr(h10, MemOperand(x11, 8190)), "ldr h10, [x11, #8190]"); 1181 COMPARE(ldr(q12, MemOperand(x13)), "ldr q12, [x13]"); 1182 COMPARE(ldr(q14, MemOperand(x15, 16)), "ldr q14, [x15, #16]"); 1183 COMPARE(ldr(q16, MemOperand(x17, 65520)), "ldr q16, [x17, #65520]"); 1184 COMPARE(str(b18, MemOperand(x19)), "str b18, [x19]"); 1185 COMPARE(str(b20, MemOperand(x21, 1)), "str b20, [x21, #1]"); 1186 COMPARE(str(b22, MemOperand(x23, 4095)), "str b22, [x23, #4095]"); 1187 COMPARE(str(h24, MemOperand(x25)), "str h24, [x25]"); 1188 COMPARE(str(h26, MemOperand(x27, 2)), "str h26, [x27, #2]"); 1189 COMPARE(str(h28, MemOperand(x29, 8190)), "str h28, [x29, #8190]"); 1190 COMPARE(str(q30, MemOperand(x30)), "str q30, [x30]"); 1191 COMPARE(str(q31, MemOperand(x1, 16)), "str q31, [x1, #16]"); 1192 COMPARE(str(q0, MemOperand(x3, 65520)), "str q0, [x3, #65520]"); 1193 1194 COMPARE(ldr(s24, MemOperand(sp)), "ldr s24, [sp]"); 1195 COMPARE(ldr(d25, MemOperand(sp, 8)), "ldr d25, [sp, #8]"); 1196 COMPARE(ldr(b26, MemOperand(sp, 1)), "ldr b26, [sp, #1]"); 1197 COMPARE(ldr(h27, MemOperand(sp, 2)), "ldr h27, [sp, #2]"); 1198 COMPARE(ldr(q28, MemOperand(sp, 16)), "ldr q28, [sp, #16]"); 1199 1200 CLEANUP(); 1201} 1202 1203 1204TEST(load_store_v_pre) { 1205 SETUP(); 1206 1207 COMPARE(ldr(s0, MemOperand(x1, 4, PreIndex)), "ldr s0, [x1, #4]!"); 1208 COMPARE(ldr(s2, MemOperand(x3, 255, PreIndex)), "ldr s2, [x3, #255]!"); 1209 COMPARE(ldr(s4, MemOperand(x5, -256, PreIndex)), "ldr s4, [x5, #-256]!"); 1210 COMPARE(ldr(d6, MemOperand(x7, 8, PreIndex)), "ldr d6, [x7, #8]!"); 1211 COMPARE(ldr(d8, MemOperand(x9, 255, PreIndex)), "ldr d8, [x9, #255]!"); 1212 COMPARE(ldr(d10, MemOperand(x11, -256, PreIndex)), "ldr d10, [x11, #-256]!"); 1213 1214 COMPARE(str(s12, MemOperand(x13, 4, PreIndex)), "str s12, [x13, #4]!"); 1215 COMPARE(str(s14, MemOperand(x15, 255, PreIndex)), "str s14, [x15, #255]!"); 1216 COMPARE(str(s16, MemOperand(x17, -256, PreIndex)), "str s16, [x17, #-256]!"); 1217 COMPARE(str(d18, MemOperand(x19, 8, PreIndex)), "str d18, [x19, #8]!"); 1218 COMPARE(str(d20, MemOperand(x21, 255, PreIndex)), "str d20, [x21, #255]!"); 1219 COMPARE(str(d22, MemOperand(x23, -256, PreIndex)), "str d22, [x23, #-256]!"); 1220 1221 COMPARE(ldr(b0, MemOperand(x1, 1, PreIndex)), "ldr b0, [x1, #1]!"); 1222 COMPARE(ldr(b2, MemOperand(x3, 255, PreIndex)), "ldr b2, [x3, #255]!"); 1223 COMPARE(ldr(b4, MemOperand(x5, -256, PreIndex)), "ldr b4, [x5, #-256]!"); 1224 COMPARE(ldr(h6, MemOperand(x7, 2, PreIndex)), "ldr h6, [x7, #2]!"); 1225 COMPARE(ldr(h8, MemOperand(x9, 255, PreIndex)), "ldr h8, [x9, #255]!"); 1226 COMPARE(ldr(h10, MemOperand(x11, -256, PreIndex)), "ldr h10, [x11, #-256]!"); 1227 COMPARE(ldr(q12, MemOperand(x13, 16, PreIndex)), "ldr q12, [x13, #16]!"); 1228 COMPARE(ldr(q14, MemOperand(x15, 255, PreIndex)), "ldr q14, [x15, #255]!"); 1229 COMPARE(ldr(q16, MemOperand(x17, -256, PreIndex)), "ldr q16, [x17, #-256]!"); 1230 1231 COMPARE(str(b18, MemOperand(x19, 1, PreIndex)), "str b18, [x19, #1]!"); 1232 COMPARE(str(b20, MemOperand(x21, 255, PreIndex)), "str b20, [x21, #255]!"); 1233 COMPARE(str(b22, MemOperand(x23, -256, PreIndex)), "str b22, [x23, #-256]!"); 1234 COMPARE(str(h24, MemOperand(x25, 2, PreIndex)), "str h24, [x25, #2]!"); 1235 COMPARE(str(h26, MemOperand(x27, 255, PreIndex)), "str h26, [x27, #255]!"); 1236 COMPARE(str(h28, MemOperand(x29, -256, PreIndex)), "str h28, [x29, #-256]!"); 1237 COMPARE(str(q30, MemOperand(x1, 16, PreIndex)), "str q30, [x1, #16]!"); 1238 COMPARE(str(q31, MemOperand(x3, 255, PreIndex)), "str q31, [x3, #255]!"); 1239 COMPARE(str(q0, MemOperand(x5, -256, PreIndex)), "str q0, [x5, #-256]!"); 1240 1241 COMPARE(str(b24, MemOperand(sp, 1, PreIndex)), "str b24, [sp, #1]!"); 1242 COMPARE(str(h25, MemOperand(sp, -2, PreIndex)), "str h25, [sp, #-2]!"); 1243 COMPARE(str(s26, MemOperand(sp, 4, PreIndex)), "str s26, [sp, #4]!"); 1244 COMPARE(str(d27, MemOperand(sp, -8, PreIndex)), "str d27, [sp, #-8]!"); 1245 COMPARE(str(q28, MemOperand(sp, 16, PreIndex)), "str q28, [sp, #16]!"); 1246 1247 CLEANUP(); 1248} 1249 1250 1251TEST(load_store_v_post) { 1252 SETUP(); 1253 1254 COMPARE(ldr(s0, MemOperand(x1, 4, PostIndex)), "ldr s0, [x1], #4"); 1255 COMPARE(ldr(s2, MemOperand(x3, 255, PostIndex)), "ldr s2, [x3], #255"); 1256 COMPARE(ldr(s4, MemOperand(x5, -256, PostIndex)), "ldr s4, [x5], #-256"); 1257 COMPARE(ldr(d6, MemOperand(x7, 8, PostIndex)), "ldr d6, [x7], #8"); 1258 COMPARE(ldr(d8, MemOperand(x9, 255, PostIndex)), "ldr d8, [x9], #255"); 1259 COMPARE(ldr(d10, MemOperand(x11, -256, PostIndex)), "ldr d10, [x11], #-256"); 1260 1261 COMPARE(str(s12, MemOperand(x13, 4, PostIndex)), "str s12, [x13], #4"); 1262 COMPARE(str(s14, MemOperand(x15, 255, PostIndex)), "str s14, [x15], #255"); 1263 COMPARE(str(s16, MemOperand(x17, -256, PostIndex)), "str s16, [x17], #-256"); 1264 COMPARE(str(d18, MemOperand(x19, 8, PostIndex)), "str d18, [x19], #8"); 1265 COMPARE(str(d20, MemOperand(x21, 255, PostIndex)), "str d20, [x21], #255"); 1266 COMPARE(str(d22, MemOperand(x23, -256, PostIndex)), "str d22, [x23], #-256"); 1267 1268 COMPARE(ldr(b0, MemOperand(x1, 4, PostIndex)), "ldr b0, [x1], #4"); 1269 COMPARE(ldr(b2, MemOperand(x3, 255, PostIndex)), "ldr b2, [x3], #255"); 1270 COMPARE(ldr(b4, MemOperand(x5, -256, PostIndex)), "ldr b4, [x5], #-256"); 1271 COMPARE(ldr(h6, MemOperand(x7, 8, PostIndex)), "ldr h6, [x7], #8"); 1272 COMPARE(ldr(h8, MemOperand(x9, 255, PostIndex)), "ldr h8, [x9], #255"); 1273 COMPARE(ldr(h10, MemOperand(x11, -256, PostIndex)), "ldr h10, [x11], #-256"); 1274 COMPARE(ldr(q12, MemOperand(x13, 8, PostIndex)), "ldr q12, [x13], #8"); 1275 COMPARE(ldr(q14, MemOperand(x15, 255, PostIndex)), "ldr q14, [x15], #255"); 1276 COMPARE(ldr(q16, MemOperand(x17, -256, PostIndex)), "ldr q16, [x17], #-256"); 1277 1278 COMPARE(str(b18, MemOperand(x19, 4, PostIndex)), "str b18, [x19], #4"); 1279 COMPARE(str(b20, MemOperand(x21, 255, PostIndex)), "str b20, [x21], #255"); 1280 COMPARE(str(b22, MemOperand(x23, -256, PostIndex)), "str b22, [x23], #-256"); 1281 COMPARE(str(h24, MemOperand(x25, 8, PostIndex)), "str h24, [x25], #8"); 1282 COMPARE(str(h26, MemOperand(x27, 255, PostIndex)), "str h26, [x27], #255"); 1283 COMPARE(str(h28, MemOperand(x29, -256, PostIndex)), "str h28, [x29], #-256"); 1284 COMPARE(str(q30, MemOperand(x1, 8, PostIndex)), "str q30, [x1], #8"); 1285 COMPARE(str(q31, MemOperand(x3, 255, PostIndex)), "str q31, [x3], #255"); 1286 COMPARE(str(q0, MemOperand(x5, -256, PostIndex)), "str q0, [x5], #-256"); 1287 1288 COMPARE(ldr(b24, MemOperand(sp, -1, PreIndex)), "ldr b24, [sp, #-1]!"); 1289 COMPARE(ldr(h25, MemOperand(sp, 2, PreIndex)), "ldr h25, [sp, #2]!"); 1290 COMPARE(ldr(s26, MemOperand(sp, -4, PreIndex)), "ldr s26, [sp, #-4]!"); 1291 COMPARE(ldr(d27, MemOperand(sp, 8, PreIndex)), "ldr d27, [sp, #8]!"); 1292 COMPARE(ldr(q28, MemOperand(sp, -16, PreIndex)), "ldr q28, [sp, #-16]!"); 1293 1294 CLEANUP(); 1295} 1296 1297 1298TEST(load_store_v_regoffset) { 1299 SETUP(); 1300 1301 COMPARE(ldr(b0, MemOperand(x1, x2)), "ldr b0, [x1, x2]"); 1302 COMPARE(ldr(b1, MemOperand(x2, w3, UXTW)), "ldr b1, [x2, w3, uxtw]"); 1303 COMPARE(ldr(b2, MemOperand(x3, w4, SXTW)), "ldr b2, [x3, w4, sxtw]"); 1304 // We can't assemble this instruction, but we check it disassembles correctly. 1305 COMPARE(dci(0x3c657883), "ldr b3, [x4, x5, lsl #0]"); 1306 COMPARE(ldr(b30, MemOperand(sp, xzr)), "ldr b30, [sp, xzr]"); 1307 COMPARE(ldr(b31, MemOperand(sp, wzr, UXTW)), "ldr b31, [sp, wzr, uxtw]"); 1308 1309 COMPARE(ldr(h0, MemOperand(x1, x2)), "ldr h0, [x1, x2]"); 1310 COMPARE(ldr(h1, MemOperand(x2, w3, UXTW)), "ldr h1, [x2, w3, uxtw]"); 1311 COMPARE(ldr(h2, MemOperand(x3, w4, SXTW)), "ldr h2, [x3, w4, sxtw]"); 1312 COMPARE(ldr(h3, MemOperand(x4, w5, UXTW, 1)), "ldr h3, [x4, w5, uxtw #1]"); 1313 COMPARE(ldr(h4, MemOperand(x5, w5, SXTW, 1)), "ldr h4, [x5, w5, sxtw #1]"); 1314 COMPARE(ldr(h30, MemOperand(sp, xzr)), "ldr h30, [sp, xzr]"); 1315 COMPARE(ldr(h31, MemOperand(sp, wzr, SXTW, 1)), 1316 "ldr h31, [sp, wzr, sxtw #1]"); 1317 1318 COMPARE(ldr(s0, MemOperand(x1, x2)), "ldr s0, [x1, x2]"); 1319 COMPARE(ldr(s1, MemOperand(x2, w3, UXTW)), "ldr s1, [x2, w3, uxtw]"); 1320 COMPARE(ldr(s2, MemOperand(x3, w4, SXTW)), "ldr s2, [x3, w4, sxtw]"); 1321 COMPARE(ldr(s3, MemOperand(x4, w5, UXTW, 2)), "ldr s3, [x4, w5, uxtw #2]"); 1322 COMPARE(ldr(s4, MemOperand(x5, w5, SXTW, 2)), "ldr s4, [x5, w5, sxtw #2]"); 1323 COMPARE(ldr(s30, MemOperand(sp, xzr)), "ldr s30, [sp, xzr]"); 1324 COMPARE(ldr(s31, MemOperand(sp, wzr, SXTW, 2)), 1325 "ldr s31, [sp, wzr, sxtw #2]"); 1326 1327 COMPARE(ldr(d0, MemOperand(x1, x2)), "ldr d0, [x1, x2]"); 1328 COMPARE(ldr(d1, MemOperand(x2, w3, UXTW)), "ldr d1, [x2, w3, uxtw]"); 1329 COMPARE(ldr(d2, MemOperand(x3, w4, SXTW)), "ldr d2, [x3, w4, sxtw]"); 1330 COMPARE(ldr(d3, MemOperand(x4, w5, UXTW, 3)), "ldr d3, [x4, w5, uxtw #3]"); 1331 COMPARE(ldr(d4, MemOperand(x5, w5, SXTW, 3)), "ldr d4, [x5, w5, sxtw #3]"); 1332 COMPARE(ldr(d30, MemOperand(sp, xzr)), "ldr d30, [sp, xzr]"); 1333 COMPARE(ldr(d31, MemOperand(sp, wzr, SXTW, 3)), 1334 "ldr d31, [sp, wzr, sxtw #3]"); 1335 1336 COMPARE(ldr(q0, MemOperand(x1, x2)), "ldr q0, [x1, x2]"); 1337 COMPARE(ldr(q1, MemOperand(x2, w3, UXTW)), "ldr q1, [x2, w3, uxtw]"); 1338 COMPARE(ldr(q2, MemOperand(x3, w4, SXTW)), "ldr q2, [x3, w4, sxtw]"); 1339 COMPARE(ldr(q3, MemOperand(x4, w5, UXTW, 4)), "ldr q3, [x4, w5, uxtw #4]"); 1340 COMPARE(ldr(q4, MemOperand(x5, w5, SXTW, 4)), "ldr q4, [x5, w5, sxtw #4]"); 1341 COMPARE(ldr(q30, MemOperand(sp, xzr)), "ldr q30, [sp, xzr]"); 1342 COMPARE(ldr(q31, MemOperand(sp, wzr, SXTW, 4)), 1343 "ldr q31, [sp, wzr, sxtw #4]"); 1344 1345 COMPARE(str(b0, MemOperand(x1, x2)), "str b0, [x1, x2]"); 1346 COMPARE(str(b1, MemOperand(x2, w3, UXTW)), "str b1, [x2, w3, uxtw]"); 1347 COMPARE(str(b2, MemOperand(x3, w4, SXTW)), "str b2, [x3, w4, sxtw]"); 1348 // We can't assemble this instruction, but we check it disassembles correctly. 1349 COMPARE(dci(0x3c257883), "str b3, [x4, x5, lsl #0]"); 1350 COMPARE(str(b30, MemOperand(sp, xzr)), "str b30, [sp, xzr]"); 1351 COMPARE(str(b31, MemOperand(sp, wzr, UXTW)), "str b31, [sp, wzr, uxtw]"); 1352 1353 COMPARE(str(h0, MemOperand(x1, x2)), "str h0, [x1, x2]"); 1354 COMPARE(str(h1, MemOperand(x2, w3, UXTW)), "str h1, [x2, w3, uxtw]"); 1355 COMPARE(str(h2, MemOperand(x3, w4, SXTW)), "str h2, [x3, w4, sxtw]"); 1356 COMPARE(str(h3, MemOperand(x4, w5, UXTW, 1)), "str h3, [x4, w5, uxtw #1]"); 1357 COMPARE(str(h4, MemOperand(x5, w5, SXTW, 1)), "str h4, [x5, w5, sxtw #1]"); 1358 COMPARE(str(h30, MemOperand(sp, xzr)), "str h30, [sp, xzr]"); 1359 COMPARE(str(h31, MemOperand(sp, wzr, SXTW, 1)), 1360 "str h31, [sp, wzr, sxtw #1]"); 1361 1362 COMPARE(str(s0, MemOperand(x1, x2)), "str s0, [x1, x2]"); 1363 COMPARE(str(s1, MemOperand(x2, w3, UXTW)), "str s1, [x2, w3, uxtw]"); 1364 COMPARE(str(s2, MemOperand(x3, w4, SXTW)), "str s2, [x3, w4, sxtw]"); 1365 COMPARE(str(s3, MemOperand(x4, w5, UXTW, 2)), "str s3, [x4, w5, uxtw #2]"); 1366 COMPARE(str(s4, MemOperand(x5, w5, SXTW, 2)), "str s4, [x5, w5, sxtw #2]"); 1367 COMPARE(str(s30, MemOperand(sp, xzr)), "str s30, [sp, xzr]"); 1368 COMPARE(str(s31, MemOperand(sp, wzr, SXTW, 2)), 1369 "str s31, [sp, wzr, sxtw #2]"); 1370 1371 COMPARE(str(d0, MemOperand(x1, x2)), "str d0, [x1, x2]"); 1372 COMPARE(str(d1, MemOperand(x2, w3, UXTW)), "str d1, [x2, w3, uxtw]"); 1373 COMPARE(str(d2, MemOperand(x3, w4, SXTW)), "str d2, [x3, w4, sxtw]"); 1374 COMPARE(str(d3, MemOperand(x4, w5, UXTW, 3)), "str d3, [x4, w5, uxtw #3]"); 1375 COMPARE(str(d4, MemOperand(x5, w5, SXTW, 3)), "str d4, [x5, w5, sxtw #3]"); 1376 COMPARE(str(d30, MemOperand(sp, xzr)), "str d30, [sp, xzr]"); 1377 COMPARE(str(d31, MemOperand(sp, wzr, SXTW, 3)), 1378 "str d31, [sp, wzr, sxtw #3]"); 1379 1380 COMPARE(str(q0, MemOperand(x1, x2)), "str q0, [x1, x2]"); 1381 COMPARE(str(q1, MemOperand(x2, w3, UXTW)), "str q1, [x2, w3, uxtw]"); 1382 COMPARE(str(q2, MemOperand(x3, w4, SXTW)), "str q2, [x3, w4, sxtw]"); 1383 COMPARE(str(q3, MemOperand(x4, w5, UXTW, 4)), "str q3, [x4, w5, uxtw #4]"); 1384 COMPARE(str(q4, MemOperand(x5, w5, SXTW, 4)), "str q4, [x5, w5, sxtw #4]"); 1385 COMPARE(str(q30, MemOperand(sp, xzr)), "str q30, [sp, xzr]"); 1386 COMPARE(str(q31, MemOperand(sp, wzr, SXTW, 4)), 1387 "str q31, [sp, wzr, sxtw #4]"); 1388 1389 CLEANUP(); 1390} 1391 1392 1393TEST(load_store_unscaled) { 1394 SETUP(); 1395 1396 // If an unscaled-offset instruction is requested, it is used, even if the 1397 // offset could be encoded in a scaled-offset instruction. 1398 COMPARE(ldurb(w0, MemOperand(x1)), "ldurb w0, [x1]"); 1399 COMPARE(ldurb(x2, MemOperand(x3, 1)), "ldurb w2, [x3, #1]"); 1400 COMPARE(ldurb(w4, MemOperand(x5, 255)), "ldurb w4, [x5, #255]"); 1401 COMPARE(sturb(w14, MemOperand(x15)), "sturb w14, [x15]"); 1402 COMPARE(sturb(x16, MemOperand(x17, 1)), "sturb w16, [x17, #1]"); 1403 COMPARE(sturb(w18, MemOperand(x19, 255)), "sturb w18, [x19, #255]"); 1404 COMPARE(ldursb(w0, MemOperand(x1)), "ldursb w0, [x1]"); 1405 COMPARE(ldursb(w2, MemOperand(x3, 1)), "ldursb w2, [x3, #1]"); 1406 COMPARE(ldursb(x2, MemOperand(x3, 255)), "ldursb x2, [x3, #255]"); 1407 1408 COMPARE(ldurh(w0, MemOperand(x1)), "ldurh w0, [x1]"); 1409 COMPARE(ldurh(x2, MemOperand(x3, 2)), "ldurh w2, [x3, #2]"); 1410 COMPARE(ldurh(w4, MemOperand(x5, 254)), "ldurh w4, [x5, #254]"); 1411 COMPARE(sturh(w14, MemOperand(x15)), "sturh w14, [x15]"); 1412 COMPARE(sturh(x16, MemOperand(x17, 2)), "sturh w16, [x17, #2]"); 1413 COMPARE(sturh(w18, MemOperand(x19, 254)), "sturh w18, [x19, #254]"); 1414 COMPARE(ldursh(w0, MemOperand(x1)), "ldursh w0, [x1]"); 1415 COMPARE(ldursh(w2, MemOperand(x3, 2)), "ldursh w2, [x3, #2]"); 1416 COMPARE(ldursh(x4, MemOperand(x5, 254)), "ldursh x4, [x5, #254]"); 1417 1418 COMPARE(ldur(w0, MemOperand(x1)), "ldur w0, [x1]"); 1419 COMPARE(ldur(w2, MemOperand(x3, 4)), "ldur w2, [x3, #4]"); 1420 COMPARE(ldur(w4, MemOperand(x5, 248)), "ldur w4, [x5, #248]"); 1421 COMPARE(stur(w12, MemOperand(x13)), "stur w12, [x13]"); 1422 COMPARE(stur(w14, MemOperand(x15, 4)), "stur w14, [x15, #4]"); 1423 COMPARE(stur(w16, MemOperand(x17, 248)), "stur w16, [x17, #248]"); 1424 COMPARE(ldursw(x0, MemOperand(x1)), "ldursw x0, [x1]"); 1425 COMPARE(ldursw(x2, MemOperand(x3, 4)), "ldursw x2, [x3, #4]"); 1426 COMPARE(ldursw(x4, MemOperand(x5, 248)), "ldursw x4, [x5, #248]"); 1427 1428 COMPARE(ldur(x6, MemOperand(x7)), "ldur x6, [x7]"); 1429 COMPARE(ldur(x8, MemOperand(x9, 8)), "ldur x8, [x9, #8]"); 1430 COMPARE(ldur(x10, MemOperand(x11, 248)), "ldur x10, [x11, #248]"); 1431 COMPARE(stur(x18, MemOperand(x19)), "stur x18, [x19]"); 1432 COMPARE(stur(x20, MemOperand(x21, 8)), "stur x20, [x21, #8]"); 1433 COMPARE(stur(x22, MemOperand(x23, 248)), "stur x22, [x23, #248]"); 1434 1435 COMPARE(ldur(b0, MemOperand(x1)), "ldur b0, [x1]"); 1436 COMPARE(ldur(h2, MemOperand(x3, -1)), "ldur h2, [x3, #-1]"); 1437 COMPARE(ldur(s4, MemOperand(x5, 2)), "ldur s4, [x5, #2]"); 1438 COMPARE(ldur(d6, MemOperand(x7, -3)), "ldur d6, [x7, #-3]"); 1439 COMPARE(ldur(q8, MemOperand(x9, 4)), "ldur q8, [x9, #4]"); 1440 COMPARE(stur(b10, MemOperand(x11)), "stur b10, [x11]"); 1441 COMPARE(stur(h12, MemOperand(x13, -1)), "stur h12, [x13, #-1]"); 1442 COMPARE(stur(s14, MemOperand(x15, 2)), "stur s14, [x15, #2]"); 1443 COMPARE(stur(d16, MemOperand(x17, -3)), "stur d16, [x17, #-3]"); 1444 COMPARE(stur(q18, MemOperand(x19, 4)), "stur q18, [x19, #4]"); 1445 1446 // Normal loads and stores are converted to unscaled loads and stores if the 1447 // offset requires it. 1448 COMPARE(ldr(w0, MemOperand(x1, 1)), "ldur w0, [x1, #1]"); 1449 COMPARE(ldr(w2, MemOperand(x3, -1)), "ldur w2, [x3, #-1]"); 1450 COMPARE(ldr(w4, MemOperand(x5, 255)), "ldur w4, [x5, #255]"); 1451 COMPARE(ldr(w6, MemOperand(x7, -256)), "ldur w6, [x7, #-256]"); 1452 COMPARE(ldr(x8, MemOperand(x9, 1)), "ldur x8, [x9, #1]"); 1453 COMPARE(ldr(x10, MemOperand(x11, -1)), "ldur x10, [x11, #-1]"); 1454 COMPARE(ldr(x12, MemOperand(x13, 255)), "ldur x12, [x13, #255]"); 1455 COMPARE(ldr(x14, MemOperand(x15, -256)), "ldur x14, [x15, #-256]"); 1456 COMPARE(str(w16, MemOperand(x17, 1)), "stur w16, [x17, #1]"); 1457 COMPARE(str(w18, MemOperand(x19, -1)), "stur w18, [x19, #-1]"); 1458 COMPARE(str(w20, MemOperand(x21, 255)), "stur w20, [x21, #255]"); 1459 COMPARE(str(w22, MemOperand(x23, -256)), "stur w22, [x23, #-256]"); 1460 COMPARE(str(x24, MemOperand(x25, 1)), "stur x24, [x25, #1]"); 1461 COMPARE(str(x26, MemOperand(x27, -1)), "stur x26, [x27, #-1]"); 1462 COMPARE(str(x28, MemOperand(x29, 255)), "stur x28, [x29, #255]"); 1463 COMPARE(str(x30, MemOperand(x0, -256)), "stur x30, [x0, #-256]"); 1464 COMPARE(ldr(w0, MemOperand(sp, 1)), "ldur w0, [sp, #1]"); 1465 COMPARE(str(x1, MemOperand(sp, -1)), "stur x1, [sp, #-1]"); 1466 COMPARE(ldrb(w2, MemOperand(x3, -2)), "ldurb w2, [x3, #-2]"); 1467 COMPARE(ldrsb(w4, MemOperand(x5, -3)), "ldursb w4, [x5, #-3]"); 1468 COMPARE(ldrsb(x6, MemOperand(x7, -4)), "ldursb x6, [x7, #-4]"); 1469 COMPARE(ldrh(w8, MemOperand(x9, -5)), "ldurh w8, [x9, #-5]"); 1470 COMPARE(ldrsh(w10, MemOperand(x11, -6)), "ldursh w10, [x11, #-6]"); 1471 COMPARE(ldrsh(x12, MemOperand(x13, -7)), "ldursh x12, [x13, #-7]"); 1472 COMPARE(ldrsw(x14, MemOperand(x15, -8)), "ldursw x14, [x15, #-8]"); 1473 1474 CLEANUP(); 1475} 1476 1477 1478TEST(load_store_unscaled_option) { 1479 SETUP(); 1480 1481 // Just like load_store_unscaled, but specify the scaling option explicitly. 1482 LoadStoreScalingOption options[] = { 1483 PreferUnscaledOffset, 1484 RequireUnscaledOffset 1485 }; 1486 1487 for (size_t i = 0; i < sizeof(options)/sizeof(options[0]); i++) { 1488 LoadStoreScalingOption option = options[i]; 1489 1490 // If an unscaled-offset instruction is requested, it is used, even if the 1491 // offset could be encoded in a scaled-offset instruction. 1492 COMPARE(ldurb(w0, MemOperand(x1), option), "ldurb w0, [x1]"); 1493 COMPARE(ldurb(x2, MemOperand(x3, 1), option), "ldurb w2, [x3, #1]"); 1494 COMPARE(ldurb(w4, MemOperand(x5, 255), option), "ldurb w4, [x5, #255]"); 1495 COMPARE(sturb(w14, MemOperand(x15), option), "sturb w14, [x15]"); 1496 COMPARE(sturb(x16, MemOperand(x17, 1), option), "sturb w16, [x17, #1]"); 1497 COMPARE(sturb(w18, MemOperand(x19, 255), option), "sturb w18, [x19, #255]"); 1498 COMPARE(ldursb(w0, MemOperand(x1), option), "ldursb w0, [x1]"); 1499 COMPARE(ldursb(w2, MemOperand(x3, 1), option), "ldursb w2, [x3, #1]"); 1500 COMPARE(ldursb(x2, MemOperand(x3, 255), option), "ldursb x2, [x3, #255]"); 1501 1502 COMPARE(ldurh(w0, MemOperand(x1), option), "ldurh w0, [x1]"); 1503 COMPARE(ldurh(x2, MemOperand(x3, 2), option), "ldurh w2, [x3, #2]"); 1504 COMPARE(ldurh(w4, MemOperand(x5, 254), option), "ldurh w4, [x5, #254]"); 1505 COMPARE(sturh(w14, MemOperand(x15), option), "sturh w14, [x15]"); 1506 COMPARE(sturh(x16, MemOperand(x17, 2), option), "sturh w16, [x17, #2]"); 1507 COMPARE(sturh(w18, MemOperand(x19, 254), option), "sturh w18, [x19, #254]"); 1508 COMPARE(ldursh(w0, MemOperand(x1), option), "ldursh w0, [x1]"); 1509 COMPARE(ldursh(w2, MemOperand(x3, 2), option), "ldursh w2, [x3, #2]"); 1510 COMPARE(ldursh(x4, MemOperand(x5, 254), option), "ldursh x4, [x5, #254]"); 1511 1512 COMPARE(ldur(w0, MemOperand(x1), option), "ldur w0, [x1]"); 1513 COMPARE(ldur(w2, MemOperand(x3, 4), option), "ldur w2, [x3, #4]"); 1514 COMPARE(ldur(w4, MemOperand(x5, 248), option), "ldur w4, [x5, #248]"); 1515 COMPARE(stur(w12, MemOperand(x13), option), "stur w12, [x13]"); 1516 COMPARE(stur(w14, MemOperand(x15, 4), option), "stur w14, [x15, #4]"); 1517 COMPARE(stur(w16, MemOperand(x17, 248), option), "stur w16, [x17, #248]"); 1518 COMPARE(ldursw(x0, MemOperand(x1), option), "ldursw x0, [x1]"); 1519 COMPARE(ldursw(x2, MemOperand(x3, 4), option), "ldursw x2, [x3, #4]"); 1520 COMPARE(ldursw(x4, MemOperand(x5, 248), option), "ldursw x4, [x5, #248]"); 1521 1522 COMPARE(ldur(x6, MemOperand(x7), option), "ldur x6, [x7]"); 1523 COMPARE(ldur(x8, MemOperand(x9, 8), option), "ldur x8, [x9, #8]"); 1524 COMPARE(ldur(x10, MemOperand(x11, 248), option), "ldur x10, [x11, #248]"); 1525 COMPARE(stur(x18, MemOperand(x19), option), "stur x18, [x19]"); 1526 COMPARE(stur(x20, MemOperand(x21, 8), option), "stur x20, [x21, #8]"); 1527 COMPARE(stur(x22, MemOperand(x23, 248), option), "stur x22, [x23, #248]"); 1528 1529 COMPARE(ldur(b0, MemOperand(x1), option), "ldur b0, [x1]"); 1530 COMPARE(ldur(h2, MemOperand(x3, 2), option), "ldur h2, [x3, #2]"); 1531 COMPARE(ldur(s4, MemOperand(x5, 4), option), "ldur s4, [x5, #4]"); 1532 COMPARE(ldur(d6, MemOperand(x7, 8), option), "ldur d6, [x7, #8]"); 1533 COMPARE(ldur(q8, MemOperand(x9, 16), option), "ldur q8, [x9, #16]"); 1534 COMPARE(stur(b10, MemOperand(x11), option), "stur b10, [x11]"); 1535 COMPARE(stur(h12, MemOperand(x13, 2), option), "stur h12, [x13, #2]"); 1536 COMPARE(stur(s14, MemOperand(x15, 4), option), "stur s14, [x15, #4]"); 1537 COMPARE(stur(d16, MemOperand(x17, 8), option), "stur d16, [x17, #8]"); 1538 COMPARE(stur(q18, MemOperand(x19, 16), option), "stur q18, [x19, #16]"); 1539 } 1540 1541 // Normal loads and stores are converted to unscaled loads and stores if the 1542 // offset requires it. PreferScaledOffset is the default for these cases, so 1543 // the behaviour here is the same when no option is specified. 1544 LoadStoreScalingOption option = PreferScaledOffset; 1545 COMPARE(ldr(w0, MemOperand(x1, 1), option), "ldur w0, [x1, #1]"); 1546 COMPARE(ldr(w2, MemOperand(x3, -1), option), "ldur w2, [x3, #-1]"); 1547 COMPARE(ldr(w4, MemOperand(x5, 255), option), "ldur w4, [x5, #255]"); 1548 COMPARE(ldr(w6, MemOperand(x7, -256), option), "ldur w6, [x7, #-256]"); 1549 COMPARE(ldr(x8, MemOperand(x9, 1), option), "ldur x8, [x9, #1]"); 1550 COMPARE(ldr(x10, MemOperand(x11, -1), option), "ldur x10, [x11, #-1]"); 1551 COMPARE(ldr(x12, MemOperand(x13, 255), option), "ldur x12, [x13, #255]"); 1552 COMPARE(ldr(x14, MemOperand(x15, -256), option), "ldur x14, [x15, #-256]"); 1553 COMPARE(str(w16, MemOperand(x17, 1), option), "stur w16, [x17, #1]"); 1554 COMPARE(str(w18, MemOperand(x19, -1), option), "stur w18, [x19, #-1]"); 1555 COMPARE(str(w20, MemOperand(x21, 255), option), "stur w20, [x21, #255]"); 1556 COMPARE(str(w22, MemOperand(x23, -256), option), "stur w22, [x23, #-256]"); 1557 COMPARE(str(x24, MemOperand(x25, 1), option), "stur x24, [x25, #1]"); 1558 COMPARE(str(x26, MemOperand(x27, -1), option), "stur x26, [x27, #-1]"); 1559 COMPARE(str(x28, MemOperand(x29, 255), option), "stur x28, [x29, #255]"); 1560 COMPARE(str(x30, MemOperand(x0, -256), option), "stur x30, [x0, #-256]"); 1561 COMPARE(ldr(w0, MemOperand(sp, 1), option), "ldur w0, [sp, #1]"); 1562 COMPARE(str(x1, MemOperand(sp, -1), option), "stur x1, [sp, #-1]"); 1563 COMPARE(ldrb(w2, MemOperand(x3, -2), option), "ldurb w2, [x3, #-2]"); 1564 COMPARE(ldrsb(w4, MemOperand(x5, -3), option), "ldursb w4, [x5, #-3]"); 1565 COMPARE(ldrsb(x6, MemOperand(x7, -4), option), "ldursb x6, [x7, #-4]"); 1566 COMPARE(ldrh(w8, MemOperand(x9, -5), option), "ldurh w8, [x9, #-5]"); 1567 COMPARE(ldrsh(w10, MemOperand(x11, -6), option), "ldursh w10, [x11, #-6]"); 1568 COMPARE(ldrsh(x12, MemOperand(x13, -7), option), "ldursh x12, [x13, #-7]"); 1569 COMPARE(ldrsw(x14, MemOperand(x15, -8), option), "ldursw x14, [x15, #-8]"); 1570 COMPARE(ldr(b0, MemOperand(x1, 1), option), "ldr b0, [x1, #1]"); 1571 COMPARE(ldr(h2, MemOperand(x3, 1), option), "ldur h2, [x3, #1]"); 1572 COMPARE(ldr(s4, MemOperand(x5, 3), option), "ldur s4, [x5, #3]"); 1573 COMPARE(ldr(d6, MemOperand(x7, 7), option), "ldur d6, [x7, #7]"); 1574 COMPARE(ldr(q8, MemOperand(x9, 15), option), "ldur q8, [x9, #15]"); 1575 COMPARE(str(b10, MemOperand(x11, 1), option), "str b10, [x11, #1]"); 1576 COMPARE(str(h12, MemOperand(x13, 1), option), "stur h12, [x13, #1]"); 1577 COMPARE(str(s14, MemOperand(x15, 3), option), "stur s14, [x15, #3]"); 1578 COMPARE(str(d16, MemOperand(x17, 7), option), "stur d16, [x17, #7]"); 1579 COMPARE(str(q18, MemOperand(x19, 15), option), "stur q18, [x19, #15]"); 1580 1581 CLEANUP(); 1582} 1583 1584 1585TEST(load_store_pair) { 1586 SETUP(); 1587 1588 COMPARE(ldp(w0, w1, MemOperand(x2)), "ldp w0, w1, [x2]"); 1589 COMPARE(ldp(x3, x4, MemOperand(x5)), "ldp x3, x4, [x5]"); 1590 COMPARE(ldp(w6, w7, MemOperand(x8, 4)), "ldp w6, w7, [x8, #4]"); 1591 COMPARE(ldp(x9, x10, MemOperand(x11, 8)), "ldp x9, x10, [x11, #8]"); 1592 COMPARE(ldp(w12, w13, MemOperand(x14, 252)), "ldp w12, w13, [x14, #252]"); 1593 COMPARE(ldp(x15, x16, MemOperand(x17, 504)), "ldp x15, x16, [x17, #504]"); 1594 COMPARE(ldp(w18, w19, MemOperand(x20, -256)), "ldp w18, w19, [x20, #-256]"); 1595 COMPARE(ldp(x21, x22, MemOperand(x23, -512)), "ldp x21, x22, [x23, #-512]"); 1596 COMPARE(ldp(w24, w25, MemOperand(x26, 252, PreIndex)), 1597 "ldp w24, w25, [x26, #252]!"); 1598 COMPARE(ldp(x27, x28, MemOperand(x29, 504, PreIndex)), 1599 "ldp x27, x28, [x29, #504]!"); 1600 COMPARE(ldp(w30, w0, MemOperand(x1, -256, PreIndex)), 1601 "ldp w30, w0, [x1, #-256]!"); 1602 COMPARE(ldp(x2, x3, MemOperand(x4, -512, PreIndex)), 1603 "ldp x2, x3, [x4, #-512]!"); 1604 COMPARE(ldp(w5, w6, MemOperand(x7, 252, PostIndex)), 1605 "ldp w5, w6, [x7], #252"); 1606 COMPARE(ldp(x8, x9, MemOperand(x10, 504, PostIndex)), 1607 "ldp x8, x9, [x10], #504"); 1608 COMPARE(ldp(w11, w12, MemOperand(x13, -256, PostIndex)), 1609 "ldp w11, w12, [x13], #-256"); 1610 COMPARE(ldp(x14, x15, MemOperand(x16, -512, PostIndex)), 1611 "ldp x14, x15, [x16], #-512"); 1612 1613 COMPARE(ldp(s17, s18, MemOperand(x19)), "ldp s17, s18, [x19]"); 1614 COMPARE(ldp(s20, s21, MemOperand(x22, 252)), "ldp s20, s21, [x22, #252]"); 1615 COMPARE(ldp(s23, s24, MemOperand(x25, -256)), "ldp s23, s24, [x25, #-256]"); 1616 COMPARE(ldp(s26, s27, MemOperand(x28, 252, PreIndex)), 1617 "ldp s26, s27, [x28, #252]!"); 1618 COMPARE(ldp(s29, s30, MemOperand(x29, -256, PreIndex)), 1619 "ldp s29, s30, [x29, #-256]!"); 1620 COMPARE(ldp(s31, s0, MemOperand(x1, 252, PostIndex)), 1621 "ldp s31, s0, [x1], #252"); 1622 COMPARE(ldp(s2, s3, MemOperand(x4, -256, PostIndex)), 1623 "ldp s2, s3, [x4], #-256"); 1624 COMPARE(ldp(d17, d18, MemOperand(x19)), "ldp d17, d18, [x19]"); 1625 COMPARE(ldp(d20, d21, MemOperand(x22, 504)), "ldp d20, d21, [x22, #504]"); 1626 COMPARE(ldp(d23, d24, MemOperand(x25, -512)), "ldp d23, d24, [x25, #-512]"); 1627 COMPARE(ldp(d26, d27, MemOperand(x28, 504, PreIndex)), 1628 "ldp d26, d27, [x28, #504]!"); 1629 COMPARE(ldp(d29, d30, MemOperand(x29, -512, PreIndex)), 1630 "ldp d29, d30, [x29, #-512]!"); 1631 COMPARE(ldp(d31, d0, MemOperand(x1, 504, PostIndex)), 1632 "ldp d31, d0, [x1], #504"); 1633 COMPARE(ldp(d2, d3, MemOperand(x4, -512, PostIndex)), 1634 "ldp d2, d3, [x4], #-512"); 1635 1636 COMPARE(ldp(q5, q6, MemOperand(x7)), "ldp q5, q6, [x7]"); 1637 COMPARE(ldp(q8, q9, MemOperand(x10, 1008)), "ldp q8, q9, [x10, #1008]"); 1638 COMPARE(ldp(q11, q12, MemOperand(x13, -1024)), "ldp q11, q12, [x13, #-1024]"); 1639 COMPARE(ldp(q14, q15, MemOperand(x16, 1008, PreIndex)), 1640 "ldp q14, q15, [x16, #1008]!"); 1641 COMPARE(ldp(q17, q18, MemOperand(x19, -1024, PreIndex)), 1642 "ldp q17, q18, [x19, #-1024]!"); 1643 COMPARE(ldp(q20, q21, MemOperand(x22, 1008, PostIndex)), 1644 "ldp q20, q21, [x22], #1008"); 1645 COMPARE(ldp(q23, q24, MemOperand(x25, -1024, PostIndex)), 1646 "ldp q23, q24, [x25], #-1024"); 1647 1648 COMPARE(stp(w0, w1, MemOperand(x2)), "stp w0, w1, [x2]"); 1649 COMPARE(stp(x3, x4, MemOperand(x5)), "stp x3, x4, [x5]"); 1650 COMPARE(stp(w6, w7, MemOperand(x8, 4)), "stp w6, w7, [x8, #4]"); 1651 COMPARE(stp(x9, x10, MemOperand(x11, 8)), "stp x9, x10, [x11, #8]"); 1652 COMPARE(stp(w12, w13, MemOperand(x14, 252)), "stp w12, w13, [x14, #252]"); 1653 COMPARE(stp(x15, x16, MemOperand(x17, 504)), "stp x15, x16, [x17, #504]"); 1654 COMPARE(stp(w18, w19, MemOperand(x20, -256)), "stp w18, w19, [x20, #-256]"); 1655 COMPARE(stp(x21, x22, MemOperand(x23, -512)), "stp x21, x22, [x23, #-512]"); 1656 COMPARE(stp(w24, w25, MemOperand(x26, 252, PreIndex)), 1657 "stp w24, w25, [x26, #252]!"); 1658 COMPARE(stp(x27, x28, MemOperand(x29, 504, PreIndex)), 1659 "stp x27, x28, [x29, #504]!"); 1660 COMPARE(stp(w30, w0, MemOperand(x1, -256, PreIndex)), 1661 "stp w30, w0, [x1, #-256]!"); 1662 COMPARE(stp(x2, x3, MemOperand(x4, -512, PreIndex)), 1663 "stp x2, x3, [x4, #-512]!"); 1664 COMPARE(stp(w5, w6, MemOperand(x7, 252, PostIndex)), 1665 "stp w5, w6, [x7], #252"); 1666 COMPARE(stp(x8, x9, MemOperand(x10, 504, PostIndex)), 1667 "stp x8, x9, [x10], #504"); 1668 COMPARE(stp(w11, w12, MemOperand(x13, -256, PostIndex)), 1669 "stp w11, w12, [x13], #-256"); 1670 COMPARE(stp(x14, x15, MemOperand(x16, -512, PostIndex)), 1671 "stp x14, x15, [x16], #-512"); 1672 1673 COMPARE(stp(s17, s18, MemOperand(x19)), "stp s17, s18, [x19]"); 1674 COMPARE(stp(s20, s21, MemOperand(x22, 252)), "stp s20, s21, [x22, #252]"); 1675 COMPARE(stp(s23, s24, MemOperand(x25, -256)), "stp s23, s24, [x25, #-256]"); 1676 COMPARE(stp(s26, s27, MemOperand(x28, 252, PreIndex)), 1677 "stp s26, s27, [x28, #252]!"); 1678 COMPARE(stp(s29, s30, MemOperand(x29, -256, PreIndex)), 1679 "stp s29, s30, [x29, #-256]!"); 1680 COMPARE(stp(s31, s0, MemOperand(x1, 252, PostIndex)), 1681 "stp s31, s0, [x1], #252"); 1682 COMPARE(stp(s2, s3, MemOperand(x4, -256, PostIndex)), 1683 "stp s2, s3, [x4], #-256"); 1684 COMPARE(stp(d17, d18, MemOperand(x19)), "stp d17, d18, [x19]"); 1685 COMPARE(stp(d20, d21, MemOperand(x22, 504)), "stp d20, d21, [x22, #504]"); 1686 COMPARE(stp(d23, d24, MemOperand(x25, -512)), "stp d23, d24, [x25, #-512]"); 1687 COMPARE(stp(d26, d27, MemOperand(x28, 504, PreIndex)), 1688 "stp d26, d27, [x28, #504]!"); 1689 COMPARE(stp(d29, d30, MemOperand(x29, -512, PreIndex)), 1690 "stp d29, d30, [x29, #-512]!"); 1691 COMPARE(stp(d31, d0, MemOperand(x1, 504, PostIndex)), 1692 "stp d31, d0, [x1], #504"); 1693 COMPARE(stp(d2, d3, MemOperand(x4, -512, PostIndex)), 1694 "stp d2, d3, [x4], #-512"); 1695 1696 COMPARE(stp(q5, q6, MemOperand(x7)), "stp q5, q6, [x7]"); 1697 COMPARE(stp(q8, q9, MemOperand(x10, 1008)), "stp q8, q9, [x10, #1008]"); 1698 COMPARE(stp(q11, q12, MemOperand(x13, -1024)), "stp q11, q12, [x13, #-1024]"); 1699 COMPARE(stp(q14, q15, MemOperand(x16, 1008, PreIndex)), 1700 "stp q14, q15, [x16, #1008]!"); 1701 COMPARE(stp(q17, q18, MemOperand(x19, -1024, PreIndex)), 1702 "stp q17, q18, [x19, #-1024]!"); 1703 COMPARE(stp(q20, q21, MemOperand(x22, 1008, PostIndex)), 1704 "stp q20, q21, [x22], #1008"); 1705 COMPARE(stp(q23, q24, MemOperand(x25, -1024, PostIndex)), 1706 "stp q23, q24, [x25], #-1024"); 1707 1708 COMPARE(ldp(w16, w17, MemOperand(sp, 4, PostIndex)), 1709 "ldp w16, w17, [sp], #4"); 1710 COMPARE(stp(x18, x19, MemOperand(sp, -8, PreIndex)), 1711 "stp x18, x19, [sp, #-8]!"); 1712 COMPARE(ldp(s30, s31, MemOperand(sp, 12, PostIndex)), 1713 "ldp s30, s31, [sp], #12"); 1714 COMPARE(stp(d30, d31, MemOperand(sp, -16)), 1715 "stp d30, d31, [sp, #-16]"); 1716 COMPARE(ldp(q30, q31, MemOperand(sp, 32, PostIndex)), 1717 "ldp q30, q31, [sp], #32"); 1718 1719 COMPARE(ldpsw(x0, x1, MemOperand(x2)), "ldpsw x0, x1, [x2]"); 1720 COMPARE(ldpsw(x3, x4, MemOperand(x5, 16)), "ldpsw x3, x4, [x5, #16]"); 1721 COMPARE(ldpsw(x6, x7, MemOperand(x8, -32, PreIndex)), 1722 "ldpsw x6, x7, [x8, #-32]!"); 1723 COMPARE(ldpsw(x9, x10, MemOperand(x11, 128, PostIndex)), 1724 "ldpsw x9, x10, [x11], #128"); 1725 1726 CLEANUP(); 1727} 1728 1729 1730TEST(load_store_exclusive) { 1731 SETUP(); 1732 1733 COMPARE(stxrb(w0, w1, MemOperand(x2)), "stxrb w0, w1, [x2]"); 1734 COMPARE(stxrb(x3, w4, MemOperand(sp)), "stxrb w3, w4, [sp]"); 1735 COMPARE(stxrb(w5, x6, MemOperand(x7)), "stxrb w5, w6, [x7]"); 1736 COMPARE(stxrb(x8, x9, MemOperand(sp)), "stxrb w8, w9, [sp]"); 1737 COMPARE(stxrh(w10, w11, MemOperand(x12)), "stxrh w10, w11, [x12]"); 1738 COMPARE(stxrh(x13, w14, MemOperand(sp)), "stxrh w13, w14, [sp]"); 1739 COMPARE(stxrh(w15, x16, MemOperand(x17)), "stxrh w15, w16, [x17]"); 1740 COMPARE(stxrh(x18, x19, MemOperand(sp)), "stxrh w18, w19, [sp]"); 1741 COMPARE(stxr(w20, w21, MemOperand(x22)), "stxr w20, w21, [x22]"); 1742 COMPARE(stxr(x23, w24, MemOperand(sp)), "stxr w23, w24, [sp]"); 1743 COMPARE(stxr(w25, x26, MemOperand(x27)), "stxr w25, x26, [x27]"); 1744 COMPARE(stxr(x28, x29, MemOperand(sp)), "stxr w28, x29, [sp]"); 1745 COMPARE(ldxrb(w30, MemOperand(x0)), "ldxrb w30, [x0]"); 1746 COMPARE(ldxrb(w1, MemOperand(sp)), "ldxrb w1, [sp]"); 1747 COMPARE(ldxrb(x2, MemOperand(x3)), "ldxrb w2, [x3]"); 1748 COMPARE(ldxrb(x4, MemOperand(sp)), "ldxrb w4, [sp]"); 1749 COMPARE(ldxrh(w5, MemOperand(x6)), "ldxrh w5, [x6]"); 1750 COMPARE(ldxrh(w7, MemOperand(sp)), "ldxrh w7, [sp]"); 1751 COMPARE(ldxrh(x8, MemOperand(x9)), "ldxrh w8, [x9]"); 1752 COMPARE(ldxrh(x10, MemOperand(sp)), "ldxrh w10, [sp]"); 1753 COMPARE(ldxr(w11, MemOperand(x12)), "ldxr w11, [x12]"); 1754 COMPARE(ldxr(w13, MemOperand(sp)), "ldxr w13, [sp]"); 1755 COMPARE(ldxr(x14, MemOperand(x15)), "ldxr x14, [x15]"); 1756 COMPARE(ldxr(x16, MemOperand(sp)), "ldxr x16, [sp]"); 1757 COMPARE(stxp(w17, w18, w19, MemOperand(x20)), "stxp w17, w18, w19, [x20]"); 1758 COMPARE(stxp(x21, w22, w23, MemOperand(sp)), "stxp w21, w22, w23, [sp]"); 1759 COMPARE(stxp(w24, x25, x26, MemOperand(x27)), "stxp w24, x25, x26, [x27]"); 1760 COMPARE(stxp(x28, x29, x30, MemOperand(sp)), "stxp w28, x29, x30, [sp]"); 1761 COMPARE(ldxp(w0, w1, MemOperand(x2)), "ldxp w0, w1, [x2]"); 1762 COMPARE(ldxp(w3, w4, MemOperand(sp)), "ldxp w3, w4, [sp]"); 1763 COMPARE(ldxp(x5, x6, MemOperand(x7)), "ldxp x5, x6, [x7]"); 1764 COMPARE(ldxp(x8, x9, MemOperand(sp)), "ldxp x8, x9, [sp]"); 1765 COMPARE(stlxrb(w10, w11, MemOperand(x12)), "stlxrb w10, w11, [x12]"); 1766 COMPARE(stlxrb(x13, w14, MemOperand(sp)), "stlxrb w13, w14, [sp]"); 1767 COMPARE(stlxrb(w15, x16, MemOperand(x17)), "stlxrb w15, w16, [x17]"); 1768 COMPARE(stlxrb(x18, x19, MemOperand(sp)), "stlxrb w18, w19, [sp]"); 1769 COMPARE(stlxrh(w20, w21, MemOperand(x22)), "stlxrh w20, w21, [x22]"); 1770 COMPARE(stlxrh(x23, w24, MemOperand(sp)), "stlxrh w23, w24, [sp]"); 1771 COMPARE(stlxrh(w25, x26, MemOperand(x27)), "stlxrh w25, w26, [x27]"); 1772 COMPARE(stlxrh(x28, x29, MemOperand(sp)), "stlxrh w28, w29, [sp]"); 1773 COMPARE(stlxr(w30, w0, MemOperand(x1)), "stlxr w30, w0, [x1]"); 1774 COMPARE(stlxr(x2, w3, MemOperand(sp)), "stlxr w2, w3, [sp]"); 1775 COMPARE(stlxr(w4, x5, MemOperand(x6)), "stlxr w4, x5, [x6]"); 1776 COMPARE(stlxr(x7, x8, MemOperand(sp)), "stlxr w7, x8, [sp]"); 1777 COMPARE(ldaxrb(w9, MemOperand(x10)), "ldaxrb w9, [x10]"); 1778 COMPARE(ldaxrb(w11, MemOperand(sp)), "ldaxrb w11, [sp]"); 1779 COMPARE(ldaxrb(x12, MemOperand(x13)), "ldaxrb w12, [x13]"); 1780 COMPARE(ldaxrb(x14, MemOperand(sp)), "ldaxrb w14, [sp]"); 1781 COMPARE(ldaxrh(w15, MemOperand(x16)), "ldaxrh w15, [x16]"); 1782 COMPARE(ldaxrh(w17, MemOperand(sp)), "ldaxrh w17, [sp]"); 1783 COMPARE(ldaxrh(x18, MemOperand(x19)), "ldaxrh w18, [x19]"); 1784 COMPARE(ldaxrh(x20, MemOperand(sp)), "ldaxrh w20, [sp]"); 1785 COMPARE(ldaxr(w21, MemOperand(x22)), "ldaxr w21, [x22]"); 1786 COMPARE(ldaxr(w23, MemOperand(sp)), "ldaxr w23, [sp]"); 1787 COMPARE(ldaxr(x24, MemOperand(x25)), "ldaxr x24, [x25]"); 1788 COMPARE(ldaxr(x26, MemOperand(sp)), "ldaxr x26, [sp]"); 1789 COMPARE(stlxp(w27, w28, w29, MemOperand(x30)), "stlxp w27, w28, w29, [x30]"); 1790 COMPARE(stlxp(x0, w1, w2, MemOperand(sp)), "stlxp w0, w1, w2, [sp]"); 1791 COMPARE(stlxp(w3, x4, x5, MemOperand(x6)), "stlxp w3, x4, x5, [x6]"); 1792 COMPARE(stlxp(x7, x8, x9, MemOperand(sp)), "stlxp w7, x8, x9, [sp]"); 1793 COMPARE(ldaxp(w10, w11, MemOperand(x12)), "ldaxp w10, w11, [x12]"); 1794 COMPARE(ldaxp(w13, w14, MemOperand(sp)), "ldaxp w13, w14, [sp]"); 1795 COMPARE(ldaxp(x15, x16, MemOperand(x17)), "ldaxp x15, x16, [x17]"); 1796 COMPARE(ldaxp(x18, x19, MemOperand(sp)), "ldaxp x18, x19, [sp]"); 1797 COMPARE(stlrb(w20, MemOperand(x21)), "stlrb w20, [x21]"); 1798 COMPARE(stlrb(w22, MemOperand(sp)), "stlrb w22, [sp]"); 1799 COMPARE(stlrb(x23, MemOperand(x24)), "stlrb w23, [x24]"); 1800 COMPARE(stlrb(x25, MemOperand(sp)), "stlrb w25, [sp]"); 1801 COMPARE(stlrh(w26, MemOperand(x27)), "stlrh w26, [x27]"); 1802 COMPARE(stlrh(w28, MemOperand(sp)), "stlrh w28, [sp]"); 1803 COMPARE(stlrh(x29, MemOperand(x30)), "stlrh w29, [x30]"); 1804 COMPARE(stlrh(x0, MemOperand(sp)), "stlrh w0, [sp]"); 1805 COMPARE(stlr(w1, MemOperand(x2)), "stlr w1, [x2]"); 1806 COMPARE(stlr(w3, MemOperand(sp)), "stlr w3, [sp]"); 1807 COMPARE(stlr(x4, MemOperand(x5)), "stlr x4, [x5]"); 1808 COMPARE(stlr(x6, MemOperand(sp)), "stlr x6, [sp]"); 1809 COMPARE(ldarb(w7, MemOperand(x8)), "ldarb w7, [x8]"); 1810 COMPARE(ldarb(w9, MemOperand(sp)), "ldarb w9, [sp]"); 1811 COMPARE(ldarb(x10, MemOperand(x11)), "ldarb w10, [x11]"); 1812 COMPARE(ldarb(x12, MemOperand(sp)), "ldarb w12, [sp]"); 1813 COMPARE(ldarh(w13, MemOperand(x14)), "ldarh w13, [x14]"); 1814 COMPARE(ldarh(w15, MemOperand(sp)), "ldarh w15, [sp]"); 1815 COMPARE(ldarh(x16, MemOperand(x17)), "ldarh w16, [x17]"); 1816 COMPARE(ldarh(x18, MemOperand(sp)), "ldarh w18, [sp]"); 1817 COMPARE(ldar(w19, MemOperand(x20)), "ldar w19, [x20]"); 1818 COMPARE(ldar(w21, MemOperand(sp)), "ldar w21, [sp]"); 1819 COMPARE(ldar(x22, MemOperand(x23)), "ldar x22, [x23]"); 1820 COMPARE(ldar(x24, MemOperand(sp)), "ldar x24, [sp]"); 1821 1822 CLEANUP(); 1823} 1824 1825 1826TEST(load_store_pair_nontemp) { 1827 SETUP(); 1828 1829 COMPARE(ldnp(w0, w1, MemOperand(x2)), "ldnp w0, w1, [x2]"); 1830 COMPARE(stnp(w3, w4, MemOperand(x5, 252)), "stnp w3, w4, [x5, #252]"); 1831 COMPARE(ldnp(w6, w7, MemOperand(x8, -256)), "ldnp w6, w7, [x8, #-256]"); 1832 COMPARE(stnp(x9, x10, MemOperand(x11)), "stnp x9, x10, [x11]"); 1833 COMPARE(ldnp(x12, x13, MemOperand(x14, 504)), "ldnp x12, x13, [x14, #504]"); 1834 COMPARE(stnp(x15, x16, MemOperand(x17, -512)), "stnp x15, x16, [x17, #-512]"); 1835 COMPARE(ldnp(s18, s19, MemOperand(x20)), "ldnp s18, s19, [x20]"); 1836 COMPARE(stnp(s21, s22, MemOperand(x23, 252)), "stnp s21, s22, [x23, #252]"); 1837 COMPARE(ldnp(s24, s25, MemOperand(x26, -256)), "ldnp s24, s25, [x26, #-256]"); 1838 COMPARE(stnp(d27, d28, MemOperand(x29)), "stnp d27, d28, [x29]"); 1839 COMPARE(ldnp(d30, d31, MemOperand(x0, 504)), "ldnp d30, d31, [x0, #504]"); 1840 COMPARE(stnp(d1, d2, MemOperand(x3, -512)), "stnp d1, d2, [x3, #-512]"); 1841 COMPARE(ldnp(q4, q5, MemOperand(x6)), "ldnp q4, q5, [x6]"); 1842 COMPARE(stnp(q7, q8, MemOperand(x9, 1008)), "stnp q7, q8, [x9, #1008]"); 1843 COMPARE(ldnp(q10, q11, MemOperand(x12, -1024)), 1844 "ldnp q10, q11, [x12, #-1024]"); 1845 1846 CLEANUP(); 1847} 1848 1849 1850TEST(load_literal_macro) { 1851 SETUP_CLASS(MacroAssembler); 1852 1853 // In each case, the literal will be placed at PC+8: 1854 // ldr x10, pc+8 // Test instruction. 1855 // ldr xzr, pc+12 // Pool marker. 1856 // .word64 #0x1234567890abcdef // Test literal. 1857 1858 COMPARE_PREFIX(Ldr(x10, 0x1234567890abcdef), "ldr x10, pc+8"); 1859 COMPARE_PREFIX(Ldr(w20, 0xfedcba09), "ldr w20, pc+8"); 1860 COMPARE_PREFIX(Ldr(d11, 1.234), "ldr d11, pc+8"); 1861 COMPARE_PREFIX(Ldr(s22, 2.5f), "ldr s22, pc+8"); 1862 COMPARE_PREFIX(Ldrsw(x21, 0x80000000), "ldrsw x21, pc+8"); 1863 1864 CLEANUP(); 1865} 1866 1867 1868TEST(load_literal) { 1869 SETUP(); 1870 1871 COMPARE_PREFIX(ldr(x20, 0), "ldr x20, pc+0"); 1872 COMPARE_PREFIX(ldr(x20, 1), "ldr x20, pc+4"); 1873 COMPARE_PREFIX(ldr(x20, -1), "ldr x20, pc-4"); 1874 COMPARE_PREFIX(ldr(x20, 0x3ffff), "ldr x20, pc+1048572"); 1875 COMPARE_PREFIX(ldr(x20, -0x40000), "ldr x20, pc-1048576"); 1876 COMPARE_PREFIX(ldr(w21, 0), "ldr w21, pc+0"); 1877 COMPARE_PREFIX(ldr(w21, 1), "ldr w21, pc+4"); 1878 COMPARE_PREFIX(ldr(w21, -1), "ldr w21, pc-4"); 1879 COMPARE_PREFIX(ldr(w21, 0x3ffff), "ldr w21, pc+1048572"); 1880 COMPARE_PREFIX(ldr(w21, -0x40000), "ldr w21, pc-1048576"); 1881 COMPARE_PREFIX(ldr(d22, 0), "ldr d22, pc+0"); 1882 COMPARE_PREFIX(ldr(d22, 1), "ldr d22, pc+4"); 1883 COMPARE_PREFIX(ldr(d22, -1), "ldr d22, pc-4"); 1884 COMPARE_PREFIX(ldr(d22, 0x3ffff), "ldr d22, pc+1048572"); 1885 COMPARE_PREFIX(ldr(d22, -0x40000), "ldr d22, pc-1048576"); 1886 COMPARE_PREFIX(ldr(s23, 0), "ldr s23, pc+0"); 1887 COMPARE_PREFIX(ldr(s23, 1), "ldr s23, pc+4"); 1888 COMPARE_PREFIX(ldr(s23, -1), "ldr s23, pc-4"); 1889 COMPARE_PREFIX(ldr(s23, 0x3ffff), "ldr s23, pc+1048572"); 1890 COMPARE_PREFIX(ldr(s23, -0x40000), "ldr s23, pc-1048576"); 1891 COMPARE_PREFIX(ldrsw(x24, 0), "ldrsw x24, pc+0"); 1892 COMPARE_PREFIX(ldrsw(x24, 1), "ldrsw x24, pc+4"); 1893 COMPARE_PREFIX(ldrsw(x24, -1), "ldrsw x24, pc-4"); 1894 COMPARE_PREFIX(ldrsw(x24, 0x3ffff), "ldrsw x24, pc+1048572"); 1895 COMPARE_PREFIX(ldrsw(x24, -0x40000), "ldrsw x24, pc-1048576"); 1896 1897 CLEANUP(); 1898} 1899 1900 1901TEST(prfm_operations) { 1902 SETUP(); 1903 1904 // Test every encodable prefetch operation. 1905 const char* expected[] = { 1906 "prfm pldl1keep, ", 1907 "prfm pldl1strm, ", 1908 "prfm pldl2keep, ", 1909 "prfm pldl2strm, ", 1910 "prfm pldl3keep, ", 1911 "prfm pldl3strm, ", 1912 "prfm #0b00110, ", 1913 "prfm #0b00111, ", 1914 "prfm plil1keep, ", 1915 "prfm plil1strm, ", 1916 "prfm plil2keep, ", 1917 "prfm plil2strm, ", 1918 "prfm plil3keep, ", 1919 "prfm plil3strm, ", 1920 "prfm #0b01110, ", 1921 "prfm #0b01111, ", 1922 "prfm pstl1keep, ", 1923 "prfm pstl1strm, ", 1924 "prfm pstl2keep, ", 1925 "prfm pstl2strm, ", 1926 "prfm pstl3keep, ", 1927 "prfm pstl3strm, ", 1928 "prfm #0b10110, ", 1929 "prfm #0b10111, ", 1930 "prfm #0b11000, ", 1931 "prfm #0b11001, ", 1932 "prfm #0b11010, ", 1933 "prfm #0b11011, ", 1934 "prfm #0b11100, ", 1935 "prfm #0b11101, ", 1936 "prfm #0b11110, ", 1937 "prfm #0b11111, ", 1938 }; 1939 const int expected_count = sizeof(expected) / sizeof(expected[0]); 1940 VIXL_STATIC_ASSERT((1 << ImmPrefetchOperation_width) == expected_count); 1941 1942 for (int i = 0; i < (1 << ImmPrefetchOperation_width); i++) { 1943 PrefetchOperation op = static_cast<PrefetchOperation>(i); 1944 COMPARE_PREFIX(prfm(op, 0), expected[i]); 1945 COMPARE_PREFIX(prfm(op, MemOperand(x0, 0)), expected[i]); 1946 COMPARE_PREFIX(prfm(op, MemOperand(x0, x1)), expected[i]); 1947 } 1948 1949 CLEANUP(); 1950} 1951 1952 1953TEST(prfum_operations) { 1954 SETUP(); 1955 1956 // Test every encodable prefetch operation. 1957 const char* expected[] = { 1958 "prfum pldl1keep, ", 1959 "prfum pldl1strm, ", 1960 "prfum pldl2keep, ", 1961 "prfum pldl2strm, ", 1962 "prfum pldl3keep, ", 1963 "prfum pldl3strm, ", 1964 "prfum #0b00110, ", 1965 "prfum #0b00111, ", 1966 "prfum plil1keep, ", 1967 "prfum plil1strm, ", 1968 "prfum plil2keep, ", 1969 "prfum plil2strm, ", 1970 "prfum plil3keep, ", 1971 "prfum plil3strm, ", 1972 "prfum #0b01110, ", 1973 "prfum #0b01111, ", 1974 "prfum pstl1keep, ", 1975 "prfum pstl1strm, ", 1976 "prfum pstl2keep, ", 1977 "prfum pstl2strm, ", 1978 "prfum pstl3keep, ", 1979 "prfum pstl3strm, ", 1980 "prfum #0b10110, ", 1981 "prfum #0b10111, ", 1982 "prfum #0b11000, ", 1983 "prfum #0b11001, ", 1984 "prfum #0b11010, ", 1985 "prfum #0b11011, ", 1986 "prfum #0b11100, ", 1987 "prfum #0b11101, ", 1988 "prfum #0b11110, ", 1989 "prfum #0b11111, ", 1990 }; 1991 const int expected_count = sizeof(expected) / sizeof(expected[0]); 1992 VIXL_STATIC_ASSERT((1 << ImmPrefetchOperation_width) == expected_count); 1993 1994 for (int i = 0; i < (1 << ImmPrefetchOperation_width); i++) { 1995 PrefetchOperation op = static_cast<PrefetchOperation>(i); 1996 COMPARE_PREFIX(prfum(op, MemOperand(x0, 0)), expected[i]); 1997 } 1998 1999 CLEANUP(); 2000} 2001 2002 2003TEST(prfm_offset) { 2004 SETUP(); 2005 2006 COMPARE(prfm(PLDL1KEEP, MemOperand(x1)), "prfm pldl1keep, [x1]"); 2007 COMPARE(prfm(PLDL1STRM, MemOperand(x3, 8)), "prfm pldl1strm, [x3, #8]"); 2008 COMPARE(prfm(PLDL2KEEP, MemOperand(x5, 32760)), 2009 "prfm pldl2keep, [x5, #32760]"); 2010 2011 COMPARE(prfm(PLDL2STRM, MemOperand(sp)), "prfm pldl2strm, [sp]"); 2012 COMPARE(prfm(PLDL3KEEP, MemOperand(sp, 8)), "prfm pldl3keep, [sp, #8]"); 2013 COMPARE(prfm(PLDL3STRM, MemOperand(sp, 32760)), 2014 "prfm pldl3strm, [sp, #32760]"); 2015 2016 CLEANUP(); 2017} 2018 2019 2020TEST(prfm_regoffset) { 2021 SETUP(); 2022 2023 COMPARE(prfm(PLIL1KEEP, MemOperand(x1, x2)), "prfm plil1keep, [x1, x2]"); 2024 COMPARE(prfm(PLIL1STRM, MemOperand(x3, w4, SXTW)), 2025 "prfm plil1strm, [x3, w4, sxtw]"); 2026 COMPARE(prfm(PLIL2KEEP, MemOperand(x5, x6, LSL, 3)), 2027 "prfm plil2keep, [x5, x6, lsl #3]"); 2028 2029 COMPARE(prfm(PLIL2STRM, MemOperand(sp, xzr)), "prfm plil2strm, [sp, xzr]"); 2030 COMPARE(prfm(PLIL3KEEP, MemOperand(sp, wzr, SXTW)), 2031 "prfm plil3keep, [sp, wzr, sxtw]"); 2032 COMPARE(prfm(PLIL3STRM, MemOperand(sp, xzr, LSL, 3)), 2033 "prfm plil3strm, [sp, xzr, lsl #3]"); 2034 2035 CLEANUP(); 2036} 2037 2038 2039TEST(prfm_literal) { 2040 SETUP(); 2041 2042 COMPARE_PREFIX(prfm(PSTL1KEEP, 0), "prfm pstl1keep, pc+0"); 2043 COMPARE_PREFIX(prfm(PSTL1STRM, 1), "prfm pstl1strm, pc+4"); 2044 COMPARE_PREFIX(prfm(PSTL2KEEP, -1), "prfm pstl2keep, pc-4"); 2045 COMPARE_PREFIX(prfm(PSTL2STRM, 0x3ffff), "prfm pstl2strm, pc+1048572"); 2046 COMPARE_PREFIX(prfm(PSTL3KEEP, -0x3ffff), "prfm pstl3keep, pc-1048572"); 2047 COMPARE_PREFIX(prfm(PSTL3STRM, -0x40000), "prfm pstl3strm, pc-1048576"); 2048 2049 CLEANUP(); 2050} 2051 2052 2053TEST(prfm_unscaled) { 2054 SETUP(); 2055 2056 // If an unscaled-offset instruction is requested, it is used, even if the 2057 // offset could be encoded in a scaled-offset instruction. 2058 COMPARE(prfum(PLDL1KEEP, MemOperand(x1)), "prfum pldl1keep, [x1]"); 2059 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8)), "prfum pldl1strm, [x1, #8]"); 2060 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248)), "prfum pldl2keep, [x1, #248]"); 2061 2062 // Normal offsets are converted to unscaled offsets if necssary. 2063 COMPARE(prfm(PLDL2STRM, MemOperand(x1, 1)), "prfum pldl2strm, [x1, #1]"); 2064 COMPARE(prfm(PLDL3KEEP, MemOperand(x1, -1)), "prfum pldl3keep, [x1, #-1]"); 2065 COMPARE(prfm(PLDL3STRM, MemOperand(x1, 255)), "prfum pldl3strm, [x1, #255]"); 2066 COMPARE(prfm(PLDL3STRM, MemOperand(x1, -256)), 2067 "prfum pldl3strm, [x1, #-256]"); 2068 2069 CLEANUP(); 2070} 2071 2072 2073TEST(prfm_unscaled_option) { 2074 SETUP(); 2075 2076 // Just like prfm_unscaled, but specify the scaling option explicitly. 2077 2078 // Require unscaled-offset forms. 2079 LoadStoreScalingOption option = RequireUnscaledOffset; 2080 2081 COMPARE(prfum(PLDL1KEEP, MemOperand(x1), option), "prfum pldl1keep, [x1]"); 2082 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8), option), 2083 "prfum pldl1strm, [x1, #8]"); 2084 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248), option), 2085 "prfum pldl2keep, [x1, #248]"); 2086 COMPARE(prfum(PLDL2STRM, MemOperand(x1, 1), option), 2087 "prfum pldl2strm, [x1, #1]"); 2088 COMPARE(prfum(PLDL3KEEP, MemOperand(x1, -1), option), 2089 "prfum pldl3keep, [x1, #-1]"); 2090 COMPARE(prfum(PLDL3STRM, MemOperand(x1, 255), option), 2091 "prfum pldl3strm, [x1, #255]"); 2092 COMPARE(prfum(PLIL1KEEP, MemOperand(x1, -256), option), 2093 "prfum plil1keep, [x1, #-256]"); 2094 2095 // Require scaled-offset forms.. 2096 option = RequireScaledOffset; 2097 2098 COMPARE(prfm(PLDL1KEEP, MemOperand(x1), option), "prfm pldl1keep, [x1]"); 2099 COMPARE(prfm(PLDL1STRM, MemOperand(x1, 8), option), 2100 "prfm pldl1strm, [x1, #8]"); 2101 COMPARE(prfm(PLDL2KEEP, MemOperand(x1, 248), option), 2102 "prfm pldl2keep, [x1, #248]"); 2103 COMPARE(prfm(PLIL2STRM, MemOperand(x1, 256), option), 2104 "prfm plil2strm, [x1, #256]"); 2105 COMPARE(prfm(PLIL3KEEP, MemOperand(x1, 32760), option), 2106 "prfm plil3keep, [x1, #32760]"); 2107 2108 // Prefer unscaled-offset forms, but allow scaled-offset forms if necessary. 2109 option = PreferUnscaledOffset; 2110 2111 COMPARE(prfum(PLDL1KEEP, MemOperand(x1), option), "prfum pldl1keep, [x1]"); 2112 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8), option), 2113 "prfum pldl1strm, [x1, #8]"); 2114 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248), option), 2115 "prfum pldl2keep, [x1, #248]"); 2116 COMPARE(prfum(PLDL2STRM, MemOperand(x1, 1), option), 2117 "prfum pldl2strm, [x1, #1]"); 2118 COMPARE(prfum(PLDL3KEEP, MemOperand(x1, -1), option), 2119 "prfum pldl3keep, [x1, #-1]"); 2120 COMPARE(prfum(PLDL3STRM, MemOperand(x1, 255), option), 2121 "prfum pldl3strm, [x1, #255]"); 2122 COMPARE(prfum(PLIL1KEEP, MemOperand(x1, -256), option), 2123 "prfum plil1keep, [x1, #-256]"); 2124 COMPARE(prfum(PLIL1STRM, MemOperand(x1, 256), option), 2125 "prfm plil1strm, [x1, #256]"); 2126 COMPARE(prfum(PLIL2KEEP, MemOperand(x1, 32760), option), 2127 "prfm plil2keep, [x1, #32760]"); 2128 2129 // Prefer scaled-offset forms, but allow unscaled-offset forms if necessary. 2130 option = PreferScaledOffset; 2131 2132 COMPARE(prfm(PLDL1KEEP, MemOperand(x1), option), "prfm pldl1keep, [x1]"); 2133 COMPARE(prfm(PLDL1STRM, MemOperand(x1, 8), option), 2134 "prfm pldl1strm, [x1, #8]"); 2135 COMPARE(prfm(PLDL2KEEP, MemOperand(x1, 248), option), 2136 "prfm pldl2keep, [x1, #248]"); 2137 COMPARE(prfm(PLDL2STRM, MemOperand(x1, 1), option), 2138 "prfum pldl2strm, [x1, #1]"); 2139 COMPARE(prfm(PLDL3KEEP, MemOperand(x1, -1), option), 2140 "prfum pldl3keep, [x1, #-1]"); 2141 COMPARE(prfm(PLDL3STRM, MemOperand(x1, 255), option), 2142 "prfum pldl3strm, [x1, #255]"); 2143 COMPARE(prfm(PLIL1KEEP, MemOperand(x1, -256), option), 2144 "prfum plil1keep, [x1, #-256]"); 2145 COMPARE(prfm(PLIL1STRM, MemOperand(x1, 256), option), 2146 "prfm plil1strm, [x1, #256]"); 2147 COMPARE(prfm(PLIL2KEEP, MemOperand(x1, 32760), option), 2148 "prfm plil2keep, [x1, #32760]"); 2149 2150 CLEANUP(); 2151} 2152 2153 2154TEST(cond_select) { 2155 SETUP(); 2156 2157 COMPARE(csel(w0, w1, w2, eq), "csel w0, w1, w2, eq"); 2158 COMPARE(csel(x3, x4, x5, ne), "csel x3, x4, x5, ne"); 2159 COMPARE(csinc(w6, w7, w8, hs), "csinc w6, w7, w8, hs"); 2160 COMPARE(csinc(x9, x10, x11, lo), "csinc x9, x10, x11, lo"); 2161 COMPARE(csinv(w12, w13, w14, mi), "csinv w12, w13, w14, mi"); 2162 COMPARE(csinv(x15, x16, x17, pl), "csinv x15, x16, x17, pl"); 2163 COMPARE(csneg(w18, w19, w20, vs), "csneg w18, w19, w20, vs"); 2164 COMPARE(csneg(x21, x22, x23, vc), "csneg x21, x22, x23, vc"); 2165 COMPARE(cset(w24, hi), "cset w24, hi"); 2166 COMPARE(cset(x25, ls), "cset x25, ls"); 2167 COMPARE(csetm(w26, ge), "csetm w26, ge"); 2168 COMPARE(csetm(x27, lt), "csetm x27, lt"); 2169 COMPARE(cinc(w28, w29, gt), "cinc w28, w29, gt"); 2170 COMPARE(cinc(x30, x0, le), "cinc x30, x0, le"); 2171 COMPARE(cinv(w1, w2, eq), "cinv w1, w2, eq"); 2172 COMPARE(cinv(x3, x4, ne), "cinv x3, x4, ne"); 2173 COMPARE(cneg(w5, w6, hs), "cneg w5, w6, hs"); 2174 COMPARE(cneg(x7, x8, lo), "cneg x7, x8, lo"); 2175 2176 COMPARE(csel(x0, x1, x2, al), "csel x0, x1, x2, al"); 2177 COMPARE(csel(x1, x2, x3, nv), "csel x1, x2, x3, nv"); 2178 COMPARE(csinc(x2, x3, x4, al), "csinc x2, x3, x4, al"); 2179 COMPARE(csinc(x3, x4, x5, nv), "csinc x3, x4, x5, nv"); 2180 COMPARE(csinv(x4, x5, x6, al), "csinv x4, x5, x6, al"); 2181 COMPARE(csinv(x5, x6, x7, nv), "csinv x5, x6, x7, nv"); 2182 COMPARE(csneg(x6, x7, x8, al), "csneg x6, x7, x8, al"); 2183 COMPARE(csneg(x7, x8, x9, nv), "csneg x7, x8, x9, nv"); 2184 2185 CLEANUP(); 2186} 2187 2188 2189TEST(cond_select_macro) { 2190 SETUP_CLASS(MacroAssembler); 2191 2192 COMPARE(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq"); 2193 COMPARE(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne"); 2194 COMPARE(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs"); 2195 COMPARE(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo"); 2196 COMPARE(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi"); 2197 COMPARE(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl"); 2198 2199 CLEANUP(); 2200} 2201 2202 2203TEST(cond_cmp) { 2204 SETUP(); 2205 2206 COMPARE(ccmn(w0, w1, NZCVFlag, eq), "ccmn w0, w1, #NZCV, eq"); 2207 COMPARE(ccmn(x2, x3, NZCFlag, ne), "ccmn x2, x3, #NZCv, ne"); 2208 COMPARE(ccmp(w4, w5, NZVFlag, hs), "ccmp w4, w5, #NZcV, hs"); 2209 COMPARE(ccmp(x6, x7, NZFlag, lo), "ccmp x6, x7, #NZcv, lo"); 2210 COMPARE(ccmn(w8, 31, NFlag, mi), "ccmn w8, #31, #Nzcv, mi"); 2211 COMPARE(ccmn(x9, 30, NCFlag, pl), "ccmn x9, #30, #NzCv, pl"); 2212 COMPARE(ccmp(w10, 29, NVFlag, vs), "ccmp w10, #29, #NzcV, vs"); 2213 COMPARE(ccmp(x11, 28, NFlag, vc), "ccmp x11, #28, #Nzcv, vc"); 2214 COMPARE(ccmn(w12, w13, NoFlag, al), "ccmn w12, w13, #nzcv, al"); 2215 COMPARE(ccmp(x14, 27, ZVFlag, nv), "ccmp x14, #27, #nZcV, nv"); 2216 2217 CLEANUP(); 2218} 2219 2220 2221TEST(cond_cmp_macro) { 2222 SETUP_CLASS(MacroAssembler); 2223 2224 COMPARE(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi"); 2225 COMPARE(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge"); 2226 COMPARE(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt"); 2227 COMPARE(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls"); 2228 2229 CLEANUP(); 2230} 2231 2232 2233TEST(fmov_imm) { 2234 SETUP(); 2235 2236 COMPARE(fmov(s0, 1.0f), "fmov s0, #0x70 (1.0000)"); 2237 COMPARE(fmov(s31, -13.0f), "fmov s31, #0xaa (-13.0000)"); 2238 COMPARE(fmov(d1, 1.0), "fmov d1, #0x70 (1.0000)"); 2239 COMPARE(fmov(d29, -13.0), "fmov d29, #0xaa (-13.0000)"); 2240 2241 CLEANUP(); 2242} 2243 2244 2245TEST(fmov_reg) { 2246 SETUP(); 2247 2248 COMPARE(fmov(w3, s13), "fmov w3, s13"); 2249 COMPARE(fmov(x6, d26), "fmov x6, d26"); 2250 COMPARE(fmov(s11, w30), "fmov s11, w30"); 2251 COMPARE(fmov(d31, x2), "fmov d31, x2"); 2252 COMPARE(fmov(s12, s13), "fmov s12, s13"); 2253 COMPARE(fmov(d22, d23), "fmov d22, d23"); 2254 COMPARE(fmov(v0.D(), 1, x13), "fmov v0.D[1], x13"); 2255 COMPARE(fmov(x13, v0.D(), 1), "fmov x13, v0.D[1]"); 2256 2257 CLEANUP(); 2258} 2259 2260 2261TEST(fp_dp1) { 2262 SETUP(); 2263 2264 COMPARE(fabs(s0, s1), "fabs s0, s1"); 2265 COMPARE(fabs(s31, s30), "fabs s31, s30"); 2266 COMPARE(fabs(d2, d3), "fabs d2, d3"); 2267 COMPARE(fabs(d31, d30), "fabs d31, d30"); 2268 COMPARE(fneg(s4, s5), "fneg s4, s5"); 2269 COMPARE(fneg(s31, s30), "fneg s31, s30"); 2270 COMPARE(fneg(d6, d7), "fneg d6, d7"); 2271 COMPARE(fneg(d31, d30), "fneg d31, d30"); 2272 COMPARE(fsqrt(s8, s9), "fsqrt s8, s9"); 2273 COMPARE(fsqrt(s31, s30), "fsqrt s31, s30"); 2274 COMPARE(fsqrt(d10, d11), "fsqrt d10, d11"); 2275 COMPARE(fsqrt(d31, d30), "fsqrt d31, d30"); 2276 COMPARE(frinta(s10, s11), "frinta s10, s11"); 2277 COMPARE(frinta(s31, s30), "frinta s31, s30"); 2278 COMPARE(frinta(d12, d13), "frinta d12, d13"); 2279 COMPARE(frinta(d31, d30), "frinta d31, d30"); 2280 COMPARE(frinti(s10, s11), "frinti s10, s11"); 2281 COMPARE(frinti(s31, s30), "frinti s31, s30"); 2282 COMPARE(frinti(d12, d13), "frinti d12, d13"); 2283 COMPARE(frinti(d31, d30), "frinti d31, d30"); 2284 COMPARE(frintm(s10, s11), "frintm s10, s11"); 2285 COMPARE(frintm(s31, s30), "frintm s31, s30"); 2286 COMPARE(frintm(d12, d13), "frintm d12, d13"); 2287 COMPARE(frintm(d31, d30), "frintm d31, d30"); 2288 COMPARE(frintn(s10, s11), "frintn s10, s11"); 2289 COMPARE(frintn(s31, s30), "frintn s31, s30"); 2290 COMPARE(frintn(d12, d13), "frintn d12, d13"); 2291 COMPARE(frintn(d31, d30), "frintn d31, d30"); 2292 COMPARE(frintx(s10, s11), "frintx s10, s11"); 2293 COMPARE(frintx(s31, s30), "frintx s31, s30"); 2294 COMPARE(frintx(d12, d13), "frintx d12, d13"); 2295 COMPARE(frintx(d31, d30), "frintx d31, d30"); 2296 COMPARE(frintz(s10, s11), "frintz s10, s11"); 2297 COMPARE(frintz(s31, s30), "frintz s31, s30"); 2298 COMPARE(frintz(d12, d13), "frintz d12, d13"); 2299 COMPARE(frintz(d31, d30), "frintz d31, d30"); 2300 COMPARE(fcvt(d14, s15), "fcvt d14, s15"); 2301 COMPARE(fcvt(d31, s31), "fcvt d31, s31"); 2302 COMPARE(fcvt(s0, d1), "fcvt s0, d1"); 2303 COMPARE(fcvt(s2, h3), "fcvt s2, h3"); 2304 COMPARE(fcvt(d4, h5), "fcvt d4, h5"); 2305 COMPARE(fcvt(h6, s7), "fcvt h6, s7"); 2306 COMPARE(fcvt(h8, d9), "fcvt h8, d9"); 2307 2308 CLEANUP(); 2309} 2310 2311 2312TEST(fp_dp2) { 2313 SETUP(); 2314 2315 COMPARE(fadd(s0, s1, s2), "fadd s0, s1, s2"); 2316 COMPARE(fadd(d3, d4, d5), "fadd d3, d4, d5"); 2317 COMPARE(fsub(s31, s30, s29), "fsub s31, s30, s29"); 2318 COMPARE(fsub(d31, d30, d29), "fsub d31, d30, d29"); 2319 COMPARE(fmul(s7, s8, s9), "fmul s7, s8, s9"); 2320 COMPARE(fmul(d10, d11, d12), "fmul d10, d11, d12"); 2321 COMPARE(fnmul(s7, s8, s9), "fnmul s7, s8, s9"); 2322 COMPARE(fnmul(d10, d11, d12), "fnmul d10, d11, d12"); 2323 COMPARE(fdiv(s13, s14, s15), "fdiv s13, s14, s15"); 2324 COMPARE(fdiv(d16, d17, d18), "fdiv d16, d17, d18"); 2325 COMPARE(fmax(s19, s20, s21), "fmax s19, s20, s21"); 2326 COMPARE(fmax(d22, d23, d24), "fmax d22, d23, d24"); 2327 COMPARE(fmin(s25, s26, s27), "fmin s25, s26, s27"); 2328 COMPARE(fmin(d28, d29, d30), "fmin d28, d29, d30"); 2329 COMPARE(fmaxnm(s31, s0, s1), "fmaxnm s31, s0, s1"); 2330 COMPARE(fmaxnm(d2, d3, d4), "fmaxnm d2, d3, d4"); 2331 COMPARE(fminnm(s5, s6, s7), "fminnm s5, s6, s7"); 2332 COMPARE(fminnm(d8, d9, d10), "fminnm d8, d9, d10"); 2333 2334 CLEANUP(); 2335} 2336 2337 2338TEST(fp_dp3) { 2339 SETUP(); 2340 2341 COMPARE(fmadd(s7, s8, s9, s10), "fmadd s7, s8, s9, s10"); 2342 COMPARE(fmadd(d10, d11, d12, d10), "fmadd d10, d11, d12, d10"); 2343 COMPARE(fmsub(s7, s8, s9, s10), "fmsub s7, s8, s9, s10"); 2344 COMPARE(fmsub(d10, d11, d12, d10), "fmsub d10, d11, d12, d10"); 2345 2346 COMPARE(fnmadd(s7, s8, s9, s10), "fnmadd s7, s8, s9, s10"); 2347 COMPARE(fnmadd(d10, d11, d12, d10), "fnmadd d10, d11, d12, d10"); 2348 COMPARE(fnmsub(s7, s8, s9, s10), "fnmsub s7, s8, s9, s10"); 2349 COMPARE(fnmsub(d10, d11, d12, d10), "fnmsub d10, d11, d12, d10"); 2350 2351 CLEANUP(); 2352} 2353 2354 2355TEST(fp_compare) { 2356 SETUP(); 2357 2358 COMPARE(fcmp(s0, s1), "fcmp s0, s1"); 2359 COMPARE(fcmp(s31, s30), "fcmp s31, s30"); 2360 COMPARE(fcmp(d0, d1), "fcmp d0, d1"); 2361 COMPARE(fcmp(d31, d30), "fcmp d31, d30"); 2362 COMPARE(fcmp(s12, 0), "fcmp s12, #0.0"); 2363 COMPARE(fcmp(d12, 0), "fcmp d12, #0.0"); 2364 2365 COMPARE(fcmpe(s0, s1), "fcmpe s0, s1"); 2366 COMPARE(fcmpe(s31, s30), "fcmpe s31, s30"); 2367 COMPARE(fcmpe(d0, d1), "fcmpe d0, d1"); 2368 COMPARE(fcmpe(d31, d30), "fcmpe d31, d30"); 2369 COMPARE(fcmpe(s12, 0), "fcmpe s12, #0.0"); 2370 COMPARE(fcmpe(d12, 0), "fcmpe d12, #0.0"); 2371 2372 CLEANUP(); 2373} 2374 2375 2376TEST(fp_cond_compare) { 2377 SETUP(); 2378 2379 COMPARE(fccmp(s0, s1, NoFlag, eq), "fccmp s0, s1, #nzcv, eq"); 2380 COMPARE(fccmp(s2, s3, ZVFlag, ne), "fccmp s2, s3, #nZcV, ne"); 2381 COMPARE(fccmp(s30, s16, NCFlag, pl), "fccmp s30, s16, #NzCv, pl"); 2382 COMPARE(fccmp(s31, s31, NZCVFlag, le), "fccmp s31, s31, #NZCV, le"); 2383 COMPARE(fccmp(d4, d5, VFlag, gt), "fccmp d4, d5, #nzcV, gt"); 2384 COMPARE(fccmp(d6, d7, NFlag, vs), "fccmp d6, d7, #Nzcv, vs"); 2385 COMPARE(fccmp(d30, d0, NZFlag, vc), "fccmp d30, d0, #NZcv, vc"); 2386 COMPARE(fccmp(d31, d31, ZFlag, hs), "fccmp d31, d31, #nZcv, hs"); 2387 COMPARE(fccmp(s14, s15, CVFlag, al), "fccmp s14, s15, #nzCV, al"); 2388 COMPARE(fccmp(d16, d17, CFlag, nv), "fccmp d16, d17, #nzCv, nv"); 2389 2390 COMPARE(fccmpe(s0, s1, NoFlag, eq), "fccmpe s0, s1, #nzcv, eq"); 2391 COMPARE(fccmpe(s2, s3, ZVFlag, ne), "fccmpe s2, s3, #nZcV, ne"); 2392 COMPARE(fccmpe(s30, s16, NCFlag, pl), "fccmpe s30, s16, #NzCv, pl"); 2393 COMPARE(fccmpe(s31, s31, NZCVFlag, le), "fccmpe s31, s31, #NZCV, le"); 2394 COMPARE(fccmpe(d4, d5, VFlag, gt), "fccmpe d4, d5, #nzcV, gt"); 2395 COMPARE(fccmpe(d6, d7, NFlag, vs), "fccmpe d6, d7, #Nzcv, vs"); 2396 COMPARE(fccmpe(d30, d0, NZFlag, vc), "fccmpe d30, d0, #NZcv, vc"); 2397 COMPARE(fccmpe(d31, d31, ZFlag, hs), "fccmpe d31, d31, #nZcv, hs"); 2398 COMPARE(fccmpe(s14, s15, CVFlag, al), "fccmpe s14, s15, #nzCV, al"); 2399 COMPARE(fccmpe(d16, d17, CFlag, nv), "fccmpe d16, d17, #nzCv, nv"); 2400 2401 CLEANUP(); 2402} 2403 2404 2405TEST(fp_select) { 2406 SETUP(); 2407 2408 COMPARE(fcsel(s0, s1, s2, eq), "fcsel s0, s1, s2, eq") 2409 COMPARE(fcsel(s31, s31, s30, ne), "fcsel s31, s31, s30, ne"); 2410 COMPARE(fcsel(d0, d1, d2, mi), "fcsel d0, d1, d2, mi"); 2411 COMPARE(fcsel(d31, d30, d31, pl), "fcsel d31, d30, d31, pl"); 2412 COMPARE(fcsel(s14, s15, s16, al), "fcsel s14, s15, s16, al"); 2413 COMPARE(fcsel(d17, d18, d19, nv), "fcsel d17, d18, d19, nv"); 2414 2415 CLEANUP(); 2416} 2417 2418 2419TEST(fcvt_scvtf_ucvtf) { 2420 SETUP(); 2421 2422 COMPARE(fcvtas(w0, s1), "fcvtas w0, s1"); 2423 COMPARE(fcvtas(x2, s3), "fcvtas x2, s3"); 2424 COMPARE(fcvtas(w4, d5), "fcvtas w4, d5"); 2425 COMPARE(fcvtas(x6, d7), "fcvtas x6, d7"); 2426 COMPARE(fcvtau(w8, s9), "fcvtau w8, s9"); 2427 COMPARE(fcvtau(x10, s11), "fcvtau x10, s11"); 2428 COMPARE(fcvtau(w12, d13), "fcvtau w12, d13"); 2429 COMPARE(fcvtau(x14, d15), "fcvtau x14, d15"); 2430 COMPARE(fcvtns(w0, s1), "fcvtns w0, s1"); 2431 COMPARE(fcvtns(x2, s3), "fcvtns x2, s3"); 2432 COMPARE(fcvtns(w4, d5), "fcvtns w4, d5"); 2433 COMPARE(fcvtns(x6, d7), "fcvtns x6, d7"); 2434 COMPARE(fcvtnu(w8, s9), "fcvtnu w8, s9"); 2435 COMPARE(fcvtnu(x10, s11), "fcvtnu x10, s11"); 2436 COMPARE(fcvtnu(w12, d13), "fcvtnu w12, d13"); 2437 COMPARE(fcvtnu(x14, d15), "fcvtnu x14, d15"); 2438 COMPARE(fcvtzu(x16, d17), "fcvtzu x16, d17"); 2439 COMPARE(fcvtzu(w18, d19), "fcvtzu w18, d19"); 2440 COMPARE(fcvtzs(x20, d21), "fcvtzs x20, d21"); 2441 COMPARE(fcvtzs(w22, d23), "fcvtzs w22, d23"); 2442 COMPARE(fcvtzu(x16, s17), "fcvtzu x16, s17"); 2443 COMPARE(fcvtzu(w18, s19), "fcvtzu w18, s19"); 2444 COMPARE(fcvtzs(x20, s21), "fcvtzs x20, s21"); 2445 COMPARE(fcvtzs(w22, s23), "fcvtzs w22, s23"); 2446 COMPARE(fcvtzs(w2, d1, 1), "fcvtzs w2, d1, #1"); 2447 COMPARE(fcvtzs(w2, s1, 1), "fcvtzs w2, s1, #1"); 2448 COMPARE(fcvtzs(x4, d3, 15), "fcvtzs x4, d3, #15"); 2449 COMPARE(fcvtzs(x4, s3, 15), "fcvtzs x4, s3, #15"); 2450 COMPARE(fcvtzs(w6, d5, 32), "fcvtzs w6, d5, #32"); 2451 COMPARE(fcvtzs(w6, s5, 32), "fcvtzs w6, s5, #32"); 2452 COMPARE(fcvtzu(w2, d1, 1), "fcvtzu w2, d1, #1"); 2453 COMPARE(fcvtzu(w2, s1, 1), "fcvtzu w2, s1, #1"); 2454 COMPARE(fcvtzu(x4, d3, 15), "fcvtzu x4, d3, #15"); 2455 COMPARE(fcvtzu(x4, s3, 15), "fcvtzu x4, s3, #15"); 2456 COMPARE(fcvtzu(w6, d5, 32), "fcvtzu w6, d5, #32"); 2457 COMPARE(fcvtzu(w6, s5, 32), "fcvtzu w6, s5, #32"); 2458 COMPARE(fcvtpu(x24, d25), "fcvtpu x24, d25"); 2459 COMPARE(fcvtpu(w26, d27), "fcvtpu w26, d27"); 2460 COMPARE(fcvtps(x28, d29), "fcvtps x28, d29"); 2461 COMPARE(fcvtps(w30, d31), "fcvtps w30, d31"); 2462 COMPARE(fcvtpu(x0, s1), "fcvtpu x0, s1"); 2463 COMPARE(fcvtpu(w2, s3), "fcvtpu w2, s3"); 2464 COMPARE(fcvtps(x4, s5), "fcvtps x4, s5"); 2465 COMPARE(fcvtps(w6, s7), "fcvtps w6, s7"); 2466 COMPARE(scvtf(d24, w25), "scvtf d24, w25"); 2467 COMPARE(scvtf(s24, w25), "scvtf s24, w25"); 2468 COMPARE(scvtf(d26, x0), "scvtf d26, x0"); 2469 COMPARE(scvtf(s26, x0), "scvtf s26, x0"); 2470 COMPARE(ucvtf(d28, w29), "ucvtf d28, w29"); 2471 COMPARE(ucvtf(s28, w29), "ucvtf s28, w29"); 2472 COMPARE(ucvtf(d0, x1), "ucvtf d0, x1"); 2473 COMPARE(ucvtf(s0, x1), "ucvtf s0, x1"); 2474 COMPARE(ucvtf(d0, x1, 0), "ucvtf d0, x1"); 2475 COMPARE(ucvtf(s0, x1, 0), "ucvtf s0, x1"); 2476 COMPARE(scvtf(d1, x2, 1), "scvtf d1, x2, #1"); 2477 COMPARE(scvtf(s1, x2, 1), "scvtf s1, x2, #1"); 2478 COMPARE(scvtf(d3, x4, 15), "scvtf d3, x4, #15"); 2479 COMPARE(scvtf(s3, x4, 15), "scvtf s3, x4, #15"); 2480 COMPARE(scvtf(d5, x6, 32), "scvtf d5, x6, #32"); 2481 COMPARE(scvtf(s5, x6, 32), "scvtf s5, x6, #32"); 2482 COMPARE(ucvtf(d7, x8, 2), "ucvtf d7, x8, #2"); 2483 COMPARE(ucvtf(s7, x8, 2), "ucvtf s7, x8, #2"); 2484 COMPARE(ucvtf(d9, x10, 16), "ucvtf d9, x10, #16"); 2485 COMPARE(ucvtf(s9, x10, 16), "ucvtf s9, x10, #16"); 2486 COMPARE(ucvtf(d11, x12, 33), "ucvtf d11, x12, #33"); 2487 COMPARE(ucvtf(s11, x12, 33), "ucvtf s11, x12, #33"); 2488 COMPARE(fcvtms(w0, s1), "fcvtms w0, s1"); 2489 COMPARE(fcvtms(x2, s3), "fcvtms x2, s3"); 2490 COMPARE(fcvtms(w4, d5), "fcvtms w4, d5"); 2491 COMPARE(fcvtms(x6, d7), "fcvtms x6, d7"); 2492 COMPARE(fcvtmu(w8, s9), "fcvtmu w8, s9"); 2493 COMPARE(fcvtmu(x10, s11), "fcvtmu x10, s11"); 2494 COMPARE(fcvtmu(w12, d13), "fcvtmu w12, d13"); 2495 COMPARE(fcvtmu(x14, d15), "fcvtmu x14, d15"); 2496 2497 CLEANUP(); 2498} 2499 2500 2501TEST(system_clrex) { 2502 SETUP(); 2503 2504 COMPARE(clrex(0), "clrex #0x0"); 2505 COMPARE(clrex(14), "clrex #0xe"); 2506 COMPARE(clrex(15), "clrex"); 2507 COMPARE(clrex(), "clrex"); 2508 2509 CLEANUP(); 2510} 2511 2512 2513TEST(system_mrs) { 2514 SETUP(); 2515 2516 COMPARE(mrs(x0, NZCV), "mrs x0, nzcv"); 2517 COMPARE(mrs(x30, NZCV), "mrs x30, nzcv"); 2518 COMPARE(mrs(x15, FPCR), "mrs x15, fpcr"); 2519 2520 CLEANUP(); 2521} 2522 2523 2524TEST(system_msr) { 2525 SETUP(); 2526 2527 COMPARE(msr(NZCV, x0), "msr nzcv, x0"); 2528 COMPARE(msr(NZCV, x30), "msr nzcv, x30"); 2529 COMPARE(msr(FPCR, x15), "msr fpcr, x15"); 2530 2531 CLEANUP(); 2532} 2533 2534 2535TEST(system_sys) { 2536 SETUP(); 2537 2538 COMPARE(sys(0x3, 0x7, 0x5, 0x1, x1), "ic ivau, x1"); 2539 COMPARE(sys(0x3, 0x7, 0xa, 0x1, x2), "dc cvac, x2"); 2540 COMPARE(sys(0x3, 0x7, 0xb, 0x1, x3), "dc cvau, x3"); 2541 COMPARE(sys(0x3, 0x7, 0xe, 0x1, x4), "dc civac, x4"); 2542 COMPARE(sys(0x3, 0x7, 0x4, 0x1, x0), "dc zva, x0"); 2543 COMPARE(sys(0x0, 0x0, 0x0, 0x0, x0), "sys #0, C0, C0, #0, x0"); 2544 COMPARE(sys(0x1, 0x2, 0x5, 0x2, x5), "sys #1, C2, C5, #2, x5"); 2545 COMPARE(sys(0x2, 0x8, 0xa, 0x3, x6), "sys #2, C8, C10, #3, x6"); 2546 COMPARE(sys(0x2, 0xf, 0xf, 0x1, xzr), "sys #2, C15, C15, #1"); 2547 COMPARE(sys(0x2, 0xf, 0xf, 0x1), "sys #2, C15, C15, #1"); 2548 2549 CLEANUP(); 2550} 2551 2552 2553TEST(system_ic) { 2554 SETUP(); 2555 2556 COMPARE(ic(IVAU, x0), "ic ivau, x0"); 2557 COMPARE(ic(IVAU, x1), "ic ivau, x1"); 2558 COMPARE(ic(IVAU, xzr), "ic ivau, xzr"); 2559 2560 CLEANUP(); 2561} 2562 2563 2564TEST(system_dc) { 2565 SETUP(); 2566 2567 COMPARE(dc(CVAC, x2), "dc cvac, x2"); 2568 COMPARE(dc(CVAU, x3), "dc cvau, x3"); 2569 COMPARE(dc(CIVAC, x4), "dc civac, x4"); 2570 COMPARE(dc(ZVA, x0), "dc zva, x0"); 2571 COMPARE(dc(ZVA, xzr), "dc zva, xzr"); 2572 2573 CLEANUP(); 2574} 2575 2576 2577TEST(system_nop) { 2578 SETUP(); 2579 2580 COMPARE(nop(), "nop"); 2581 2582 CLEANUP(); 2583} 2584 2585 2586TEST(unreachable) { 2587 SETUP_CLASS(MacroAssembler); 2588 2589#ifdef USE_SIMULATOR 2590 VIXL_ASSERT(kUnreachableOpcode == 0xdeb0); 2591 COMPARE(Unreachable(), "hlt #0xdeb0"); 2592#else 2593 COMPARE(Unreachable(), "blr xzr"); 2594#endif 2595 2596 CLEANUP(); 2597} 2598 2599 2600#ifdef USE_SIMULATOR 2601TEST(trace) { 2602 SETUP_CLASS(MacroAssembler); 2603 2604 VIXL_ASSERT(kTraceOpcode == 0xdeb2); 2605 2606 // All Trace calls should produce the same instruction. 2607 COMPARE_MACRO(Trace(LOG_ALL, TRACE_ENABLE), "hlt #0xdeb2"); 2608 COMPARE_MACRO(Trace(LOG_REGS, TRACE_DISABLE), "hlt #0xdeb2"); 2609 2610 CLEANUP(); 2611} 2612#endif 2613 2614 2615#ifdef USE_SIMULATOR 2616TEST(log) { 2617 SETUP_CLASS(MacroAssembler); 2618 2619 VIXL_ASSERT(kLogOpcode == 0xdeb3); 2620 2621 // All Log calls should produce the same instruction. 2622 COMPARE_MACRO(Log(LOG_ALL), "hlt #0xdeb3"); 2623 COMPARE_MACRO(Log(LOG_SYSREGS), "hlt #0xdeb3"); 2624 2625 CLEANUP(); 2626} 2627#endif 2628 2629 2630TEST(hlt) { 2631 SETUP(); 2632 2633 COMPARE(hlt(0), "hlt #0x0"); 2634 COMPARE(hlt(1), "hlt #0x1"); 2635 COMPARE(hlt(65535), "hlt #0xffff"); 2636 2637 CLEANUP(); 2638} 2639 2640 2641TEST(brk) { 2642 SETUP(); 2643 2644 COMPARE(brk(0), "brk #0x0"); 2645 COMPARE(brk(1), "brk #0x1"); 2646 COMPARE(brk(65535), "brk #0xffff"); 2647 2648 CLEANUP(); 2649} 2650 2651 2652TEST(svc) { 2653 SETUP(); 2654 2655 COMPARE(svc(0), "svc #0x0"); 2656 COMPARE(svc(1), "svc #0x1"); 2657 COMPARE(svc(65535), "svc #0xffff"); 2658 2659 CLEANUP(); 2660} 2661 2662 2663TEST(add_sub_negative) { 2664 SETUP_CLASS(MacroAssembler); 2665 2666 COMPARE(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)"); 2667 COMPARE(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)"); 2668 COMPARE(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)"); 2669 2670 COMPARE(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)"); 2671 COMPARE(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)"); 2672 COMPARE(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)"); 2673 2674 COMPARE(Add(w19, w3, -0x344), "sub w19, w3, #0x344 (836)"); 2675 COMPARE(Add(w20, w4, -2000), "sub w20, w4, #0x7d0 (2000)"); 2676 2677 COMPARE(Add(w0, w1, 5, LeaveFlags), "add w0, w1, #0x5 (5)"); 2678 COMPARE(Add(w1, w2, 15, SetFlags), "adds w1, w2, #0xf (15)"); 2679 2680 COMPARE(Sub(w0, w1, 5, LeaveFlags), "sub w0, w1, #0x5 (5)"); 2681 COMPARE(Sub(w1, w2, 15, SetFlags), "subs w1, w2, #0xf (15)"); 2682 2683 COMPARE(Sub(w21, w3, -0xbc), "add w21, w3, #0xbc (188)"); 2684 COMPARE(Sub(w22, w4, -2000), "add w22, w4, #0x7d0 (2000)"); 2685 2686 COMPARE(Cmp(w0, -1), "cmn w0, #0x1 (1)"); 2687 COMPARE(Cmp(x1, -1), "cmn x1, #0x1 (1)"); 2688 COMPARE(Cmp(w2, -4095), "cmn w2, #0xfff (4095)"); 2689 COMPARE(Cmp(x3, -4095), "cmn x3, #0xfff (4095)"); 2690 2691 COMPARE(Cmn(w0, -1), "cmp w0, #0x1 (1)"); 2692 COMPARE(Cmn(x1, -1), "cmp x1, #0x1 (1)"); 2693 COMPARE(Cmn(w2, -4095), "cmp w2, #0xfff (4095)"); 2694 COMPARE(Cmn(x3, -4095), "cmp x3, #0xfff (4095)"); 2695 2696 CLEANUP(); 2697} 2698 2699 2700TEST(logical_immediate_move) { 2701 SETUP_CLASS(MacroAssembler); 2702 2703 COMPARE(And(w0, w1, 0), "mov w0, #0x0"); 2704 COMPARE(And(x0, x1, 0), "mov x0, #0x0"); 2705 COMPARE(Orr(w2, w3, 0), "mov w2, w3"); 2706 COMPARE(Orr(x2, x3, 0), "mov x2, x3"); 2707 COMPARE(Eor(w4, w5, 0), "mov w4, w5"); 2708 COMPARE(Eor(x4, x5, 0), "mov x4, x5"); 2709 COMPARE(Bic(w6, w7, 0), "mov w6, w7"); 2710 COMPARE(Bic(x6, x7, 0), "mov x6, x7"); 2711 COMPARE(Orn(w8, w9, 0), "mov w8, #0xffffffff"); 2712 COMPARE(Orn(x8, x9, 0), "mov x8, #0xffffffffffffffff"); 2713 COMPARE(Eon(w10, w11, 0), "mvn w10, w11"); 2714 COMPARE(Eon(x10, x11, 0), "mvn x10, x11"); 2715 2716 COMPARE(And(w12, w13, 0xffffffff), "mov w12, w13"); 2717 COMPARE(And(x12, x13, 0xffffffff), "and x12, x13, #0xffffffff"); 2718 COMPARE(And(x12, x13, 0xffffffffffffffff), "mov x12, x13"); 2719 COMPARE(Orr(w14, w15, 0xffffffff), "mov w14, #0xffffffff"); 2720 COMPARE(Orr(x14, x15, 0xffffffff), "orr x14, x15, #0xffffffff"); 2721 COMPARE(Orr(x14, x15, 0xffffffffffffffff), "mov x14, #0xffffffffffffffff"); 2722 COMPARE(Eor(w16, w17, 0xffffffff), "mvn w16, w17"); 2723 COMPARE(Eor(x16, x17, 0xffffffff), "eor x16, x17, #0xffffffff"); 2724 COMPARE(Eor(x16, x17, 0xffffffffffffffff), "mvn x16, x17"); 2725 COMPARE(Bic(w18, w19, 0xffffffff), "mov w18, #0x0"); 2726 COMPARE(Bic(x18, x19, 0xffffffff), "and x18, x19, #0xffffffff00000000"); 2727 COMPARE(Bic(x18, x19, 0xffffffffffffffff), "mov x18, #0x0"); 2728 COMPARE(Orn(w20, w21, 0xffffffff), "mov w20, w21"); 2729 COMPARE(Orn(x20, x21, 0xffffffff), "orr x20, x21, #0xffffffff00000000"); 2730 COMPARE(Orn(x20, x21, 0xffffffffffffffff), "mov x20, x21"); 2731 COMPARE(Eon(w22, w23, 0xffffffff), "mov w22, w23"); 2732 COMPARE(Eon(x22, x23, 0xffffffff), "eor x22, x23, #0xffffffff00000000"); 2733 COMPARE(Eon(x22, x23, 0xffffffffffffffff), "mov x22, x23"); 2734 2735 CLEANUP(); 2736} 2737 2738 2739TEST(barriers) { 2740 SETUP_CLASS(MacroAssembler); 2741 2742 // DMB 2743 COMPARE(Dmb(FullSystem, BarrierAll), "dmb sy"); 2744 COMPARE(Dmb(FullSystem, BarrierReads), "dmb ld"); 2745 COMPARE(Dmb(FullSystem, BarrierWrites), "dmb st"); 2746 2747 COMPARE(Dmb(InnerShareable, BarrierAll), "dmb ish"); 2748 COMPARE(Dmb(InnerShareable, BarrierReads), "dmb ishld"); 2749 COMPARE(Dmb(InnerShareable, BarrierWrites), "dmb ishst"); 2750 2751 COMPARE(Dmb(NonShareable, BarrierAll), "dmb nsh"); 2752 COMPARE(Dmb(NonShareable, BarrierReads), "dmb nshld"); 2753 COMPARE(Dmb(NonShareable, BarrierWrites), "dmb nshst"); 2754 2755 COMPARE(Dmb(OuterShareable, BarrierAll), "dmb osh"); 2756 COMPARE(Dmb(OuterShareable, BarrierReads), "dmb oshld"); 2757 COMPARE(Dmb(OuterShareable, BarrierWrites), "dmb oshst"); 2758 2759 COMPARE(Dmb(FullSystem, BarrierOther), "dmb sy (0b1100)"); 2760 COMPARE(Dmb(InnerShareable, BarrierOther), "dmb sy (0b1000)"); 2761 COMPARE(Dmb(NonShareable, BarrierOther), "dmb sy (0b0100)"); 2762 COMPARE(Dmb(OuterShareable, BarrierOther), "dmb sy (0b0000)"); 2763 2764 // DSB 2765 COMPARE(Dsb(FullSystem, BarrierAll), "dsb sy"); 2766 COMPARE(Dsb(FullSystem, BarrierReads), "dsb ld"); 2767 COMPARE(Dsb(FullSystem, BarrierWrites), "dsb st"); 2768 2769 COMPARE(Dsb(InnerShareable, BarrierAll), "dsb ish"); 2770 COMPARE(Dsb(InnerShareable, BarrierReads), "dsb ishld"); 2771 COMPARE(Dsb(InnerShareable, BarrierWrites), "dsb ishst"); 2772 2773 COMPARE(Dsb(NonShareable, BarrierAll), "dsb nsh"); 2774 COMPARE(Dsb(NonShareable, BarrierReads), "dsb nshld"); 2775 COMPARE(Dsb(NonShareable, BarrierWrites), "dsb nshst"); 2776 2777 COMPARE(Dsb(OuterShareable, BarrierAll), "dsb osh"); 2778 COMPARE(Dsb(OuterShareable, BarrierReads), "dsb oshld"); 2779 COMPARE(Dsb(OuterShareable, BarrierWrites), "dsb oshst"); 2780 2781 COMPARE(Dsb(FullSystem, BarrierOther), "dsb sy (0b1100)"); 2782 COMPARE(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)"); 2783 COMPARE(Dsb(NonShareable, BarrierOther), "dsb sy (0b0100)"); 2784 COMPARE(Dsb(OuterShareable, BarrierOther), "dsb sy (0b0000)"); 2785 2786 // ISB 2787 COMPARE(Isb(), "isb"); 2788 2789 CLEANUP(); 2790} 2791 2792 2793#define VLIST2(v) v, VRegister((v.code()+1)%32, v.size(), v.lanes()) 2794#define VLIST3(v) VLIST2(v), VRegister((v.code()+2)%32, v.size(), v.lanes()) 2795#define VLIST4(v) VLIST3(v), VRegister((v.code()+3)%32, v.size(), v.lanes()) 2796 2797 2798#define NEON_FORMAT_LIST(V) \ 2799 V(V8B(), "8b") \ 2800 V(V16B(), "16b") \ 2801 V(V4H(), "4h") \ 2802 V(V8H(), "8h") \ 2803 V(V2S(), "2s") \ 2804 V(V4S(), "4s") \ 2805 V(V2D(), "2d") 2806 2807#define NEON_FORMAT_LIST_LP(V) \ 2808 V(V4H(), "4h", V8B(), "8b") \ 2809 V(V2S(), "2s", V4H(), "4h") \ 2810 V(V1D(), "1d", V2S(), "2s") \ 2811 V(V8H(), "8h", V16B(), "16b") \ 2812 V(V4S(), "4s", V8H(), "8h") \ 2813 V(V2D(), "2d", V4S(), "4s") 2814 2815#define NEON_FORMAT_LIST_LW(V) \ 2816 V(V8H(), "8h", V8B(), "8b") \ 2817 V(V4S(), "4s", V4H(), "4h") \ 2818 V(V2D(), "2d", V2S(), "2s") 2819 2820#define NEON_FORMAT_LIST_LW2(V) \ 2821 V(V8H(), "8h", V16B(), "16b") \ 2822 V(V4S(), "4s", V8H(), "8h") \ 2823 V(V2D(), "2d", V4S(), "4s") 2824 2825#define NEON_FORMAT_LIST_BHS(V) \ 2826 V(V8B(), "8b") \ 2827 V(V16B(), "16b") \ 2828 V(V4H(), "4h") \ 2829 V(V8H(), "8h") \ 2830 V(V2S(), "2s") \ 2831 V(V4S(), "4s") 2832 2833#define NEON_FORMAT_LIST_HS(V) \ 2834 V(V4H(), "4h") \ 2835 V(V8H(), "8h") \ 2836 V(V2S(), "2s") \ 2837 V(V4S(), "4s") 2838 2839TEST(neon_load_store_vector) { 2840 SETUP_CLASS(MacroAssembler); 2841 2842 #define DISASM_INST(M, S) \ 2843 COMPARE(Ld1(v0.M, MemOperand(x15)), \ 2844 "ld1 {v0." S "}, [x15]"); \ 2845 COMPARE(Ld1(v1.M, v2.M, MemOperand(x16)), \ 2846 "ld1 {v1." S ", v2." S "}, [x16]"); \ 2847 COMPARE(Ld1(v3.M, v4.M, v5.M, MemOperand(x17)), \ 2848 "ld1 {v3." S ", v4." S ", v5." S "}, [x17]"); \ 2849 COMPARE(Ld1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18)), \ 2850 "ld1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18]") \ 2851 COMPARE(Ld1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \ 2852 "ld1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \ 2853 COMPARE(Ld2(v1.M, v2.M, MemOperand(x16)), \ 2854 "ld2 {v1." S ", v2." S "}, [x16]"); \ 2855 COMPARE(Ld3(v3.M, v4.M, v5.M, MemOperand(x17)), \ 2856 "ld3 {v3." S ", v4." S ", v5." S "}, [x17]"); \ 2857 COMPARE(Ld4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18)), \ 2858 "ld4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18]") \ 2859 COMPARE(Ld4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \ 2860 "ld4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \ 2861 NEON_FORMAT_LIST(DISASM_INST); 2862 #undef DISASM_INST 2863 2864 #define DISASM_INST(M, S) \ 2865 COMPARE(Ld1(v0.M, MemOperand(x15, x20, PostIndex)), \ 2866 "ld1 {v0." S "}, [x15], x20"); \ 2867 COMPARE(Ld1(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \ 2868 "ld1 {v1." S ", v2." S "}, [x16], x21"); \ 2869 COMPARE(Ld1(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \ 2870 "ld1 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \ 2871 COMPARE(Ld1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \ 2872 "ld1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \ 2873 COMPARE(Ld1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \ 2874 "ld1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \ 2875 COMPARE(Ld2(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \ 2876 "ld2 {v1." S ", v2." S "}, [x16], x21"); \ 2877 COMPARE(Ld3(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \ 2878 "ld3 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \ 2879 COMPARE(Ld4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \ 2880 "ld4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \ 2881 COMPARE(Ld4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \ 2882 "ld4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \ 2883 NEON_FORMAT_LIST(DISASM_INST); 2884 #undef DISASM_INST 2885 2886 COMPARE(Ld1(v0.V8B(), MemOperand(x15, 8, PostIndex)), 2887 "ld1 {v0.8b}, [x15], #8"); 2888 COMPARE(Ld1(v1.V16B(), MemOperand(x16, 16, PostIndex)), 2889 "ld1 {v1.16b}, [x16], #16"); 2890 COMPARE(Ld1(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)), 2891 "ld1 {v2.4h, v3.4h}, [x17], #16"); 2892 COMPARE(Ld1(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)), 2893 "ld1 {v4.8h, v5.8h}, [x18], #32"); 2894 COMPARE(Ld1(v16.V2S(), v17.V2S(), v18.V2S(), MemOperand(x19, 24, PostIndex)), 2895 "ld1 {v16.2s, v17.2s, v18.2s}, [x19], #24"); 2896 COMPARE(Ld1(v16.V4S(), v17.V4S(), v18.V4S(), MemOperand(x19, 48, PostIndex)), 2897 "ld1 {v16.4s, v17.4s, v18.4s}, [x19], #48"); 2898 COMPARE(Ld1(v19.V2S(), v20.V2S(), v21.V2S(), v22.V2S(), 2899 MemOperand(x20, 32, PostIndex)), 2900 "ld1 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32"); 2901 COMPARE(Ld1(v23.V2D(), v24.V2D(), v25.V2D(), v26.V2D(), 2902 MemOperand(x21, 64, PostIndex)), 2903 "ld1 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64"); 2904 2905 COMPARE(Ld2(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)), 2906 "ld2 {v2.4h, v3.4h}, [x17], #16"); 2907 COMPARE(Ld2(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)), 2908 "ld2 {v4.8h, v5.8h}, [x18], #32"); 2909 COMPARE(Ld3(v16.V2S(), v17.V2S(), v18.V2S(), MemOperand(x19, 24, PostIndex)), 2910 "ld3 {v16.2s, v17.2s, v18.2s}, [x19], #24"); 2911 COMPARE(Ld3(v16.V4S(), v17.V4S(), v18.V4S(), MemOperand(x19, 48, PostIndex)), 2912 "ld3 {v16.4s, v17.4s, v18.4s}, [x19], #48"); 2913 COMPARE(Ld4(v19.V2S(), v20.V2S(), v21.V2S(), v22.V2S(), 2914 MemOperand(x20, 32, PostIndex)), 2915 "ld4 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32"); 2916 COMPARE(Ld4(v23.V2D(), v24.V2D(), v25.V2D(), v26.V2D(), 2917 MemOperand(x21, 64, PostIndex)), 2918 "ld4 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64"); 2919 2920 COMPARE(Ld1(v0.V1D(), MemOperand(x16)), "ld1 {v0.1d}, [x16]"); 2921 COMPARE(Ld1(v1.V1D(), v2.V1D(), MemOperand(x17, 16, PostIndex)), 2922 "ld1 {v1.1d, v2.1d}, [x17], #16"); 2923 COMPARE(Ld1(v3.V1D(), v4.V1D(), v5.V1D(), MemOperand(x18, x19, PostIndex)), 2924 "ld1 {v3.1d, v4.1d, v5.1d}, [x18], x19"); 2925 COMPARE(Ld1(v30.V1D(), v31.V1D(), v0.V1D(), v1.V1D(), 2926 MemOperand(x20, 32, PostIndex)), 2927 "ld1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x20], #32"); 2928 COMPARE(Ld1(d30, d31, d0, d1, MemOperand(x21, x22, PostIndex)), 2929 "ld1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x21], x22"); 2930 2931 #define DISASM_INST(M, S) \ 2932 COMPARE(St1(v20.M, MemOperand(x15)), \ 2933 "st1 {v20." S "}, [x15]"); \ 2934 COMPARE(St1(v21.M, v22.M, MemOperand(x16)), \ 2935 "st1 {v21." S ", v22." S "}, [x16]"); \ 2936 COMPARE(St1(v23.M, v24.M, v25.M, MemOperand(x17)), \ 2937 "st1 {v23." S ", v24." S ", v25." S "}, [x17]"); \ 2938 COMPARE(St1(v26.M, v27.M, v28.M, v29.M, MemOperand(x18)), \ 2939 "st1 {v26." S ", v27." S ", v28." S ", v29." S "}, [x18]") \ 2940 COMPARE(St1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \ 2941 "st1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \ 2942 COMPARE(St2(VLIST2(v21.M), MemOperand(x16)), \ 2943 "st2 {v21." S ", v22." S "}, [x16]"); \ 2944 COMPARE(St3(v23.M, v24.M, v25.M, MemOperand(x17)), \ 2945 "st3 {v23." S ", v24." S ", v25." S "}, [x17]"); \ 2946 COMPARE(St4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \ 2947 "st4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") 2948 NEON_FORMAT_LIST(DISASM_INST); 2949 #undef DISASM_INST 2950 2951 #define DISASM_INST(M, S) \ 2952 COMPARE(St1(v0.M, MemOperand(x15, x20, PostIndex)), \ 2953 "st1 {v0." S "}, [x15], x20"); \ 2954 COMPARE(St1(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \ 2955 "st1 {v1." S ", v2." S "}, [x16], x21"); \ 2956 COMPARE(St1(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \ 2957 "st1 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \ 2958 COMPARE(St1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \ 2959 "st1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \ 2960 COMPARE(St1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \ 2961 "st1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \ 2962 COMPARE(St2(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \ 2963 "st2 {v1." S ", v2." S "}, [x16], x21"); \ 2964 COMPARE(St3(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \ 2965 "st3 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \ 2966 COMPARE(St4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \ 2967 "st4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \ 2968 COMPARE(St4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \ 2969 "st4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") 2970 NEON_FORMAT_LIST(DISASM_INST); 2971 #undef DISASM_INST 2972 2973 COMPARE(St1(v0.V8B(), MemOperand(x15, 8, PostIndex)), 2974 "st1 {v0.8b}, [x15], #8"); 2975 COMPARE(St1(v1.V16B(), MemOperand(x16, 16, PostIndex)), 2976 "st1 {v1.16b}, [x16], #16"); 2977 COMPARE(St1(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)), 2978 "st1 {v2.4h, v3.4h}, [x17], #16"); 2979 COMPARE(St1(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)), 2980 "st1 {v4.8h, v5.8h}, [x18], #32"); 2981 COMPARE(St1(v16.V2S(), v17.V2S(), v18.V2S(), MemOperand(x19, 24, PostIndex)), 2982 "st1 {v16.2s, v17.2s, v18.2s}, [x19], #24"); 2983 COMPARE(St1(v16.V4S(), v17.V4S(), v18.V4S(), MemOperand(x19, 48, PostIndex)), 2984 "st1 {v16.4s, v17.4s, v18.4s}, [x19], #48"); 2985 COMPARE(St1(v19.V2S(), v20.V2S(), v21.V2S(), v22.V2S(), 2986 MemOperand(x20, 32, PostIndex)), 2987 "st1 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32"); 2988 COMPARE(St1(v23.V2D(), v24.V2D(), v25.V2D(), v26.V2D(), 2989 MemOperand(x21, 64, PostIndex)), 2990 "st1 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64"); 2991 COMPARE(St2(v1.V16B(), v2.V16B(), MemOperand(x16, 32, PostIndex)), 2992 "st2 {v1.16b, v2.16b}, [x16], #32"); 2993 COMPARE(St2(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)), 2994 "st2 {v2.4h, v3.4h}, [x17], #16"); 2995 COMPARE(St2(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)), 2996 "st2 {v4.8h, v5.8h}, [x18], #32"); 2997 COMPARE(St3(v16.V2S(), v17.V2S(), v18.V2S(), 2998 MemOperand(x19, 24, PostIndex)), 2999 "st3 {v16.2s, v17.2s, v18.2s}, [x19], #24"); 3000 COMPARE(St3(v16.V4S(), v17.V4S(), v18.V4S(), 3001 MemOperand(x19, 48, PostIndex)), 3002 "st3 {v16.4s, v17.4s, v18.4s}, [x19], #48"); 3003 COMPARE(St4(v19.V2S(), v20.V2S(), v21.V2S(), v22.V2S(), 3004 MemOperand(x20, 32, PostIndex)), 3005 "st4 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32"); 3006 COMPARE(St4(v23.V2D(), v24.V2D(), v25.V2D(), v26.V2D(), 3007 MemOperand(x21, 64, PostIndex)), 3008 "st4 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64"); 3009 3010 COMPARE(St1(v0.V1D(), MemOperand(x16)), "st1 {v0.1d}, [x16]"); 3011 COMPARE(St1(v1.V1D(), v2.V1D(), MemOperand(x17, 16, PostIndex)), 3012 "st1 {v1.1d, v2.1d}, [x17], #16"); 3013 COMPARE(St1(v3.V1D(), v4.V1D(), v5.V1D(), MemOperand(x18, x19, PostIndex)), 3014 "st1 {v3.1d, v4.1d, v5.1d}, [x18], x19"); 3015 COMPARE(St1(v30.V1D(), v31.V1D(), v0.V1D(), v1.V1D(), 3016 MemOperand(x20, 32, PostIndex)), 3017 "st1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x20], #32"); 3018 COMPARE(St1(d30, d31, d0, d1, MemOperand(x21, x22, PostIndex)), 3019 "st1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x21], x22"); 3020 3021 CLEANUP(); 3022} 3023 3024 3025TEST(neon_load_store_lane) { 3026 SETUP_CLASS(MacroAssembler); 3027 3028 COMPARE(Ld1(v0.V8B(), 0, MemOperand(x15)), "ld1 {v0.b}[0], [x15]"); 3029 COMPARE(Ld1(v1.V16B(), 1, MemOperand(x16)), "ld1 {v1.b}[1], [x16]"); 3030 COMPARE(Ld1(v2.V4H(), 2, MemOperand(x17)), "ld1 {v2.h}[2], [x17]"); 3031 COMPARE(Ld1(v3.V8H(), 3, MemOperand(x18)), "ld1 {v3.h}[3], [x18]"); 3032 COMPARE(Ld1(v4.V2S(), 0, MemOperand(x19)), "ld1 {v4.s}[0], [x19]"); 3033 COMPARE(Ld1(v5.V4S(), 1, MemOperand(x20)), "ld1 {v5.s}[1], [x20]"); 3034 COMPARE(Ld1(v6.V2D(), 0, MemOperand(x21)), "ld1 {v6.d}[0], [x21]"); 3035 COMPARE(Ld1(v7.B(), 7, MemOperand(x22)), "ld1 {v7.b}[7], [x22]"); 3036 COMPARE(Ld1(v8.B(), 15, MemOperand(x23)), "ld1 {v8.b}[15], [x23]"); 3037 COMPARE(Ld1(v9.H(), 3, MemOperand(x24)), "ld1 {v9.h}[3], [x24]"); 3038 COMPARE(Ld1(v10.H(), 7, MemOperand(x25)), "ld1 {v10.h}[7], [x25]"); 3039 COMPARE(Ld1(v11.S(), 1, MemOperand(x26)), "ld1 {v11.s}[1], [x26]"); 3040 COMPARE(Ld1(v12.S(), 3, MemOperand(x27)), "ld1 {v12.s}[3], [x27]"); 3041 COMPARE(Ld1(v13.D(), 1, MemOperand(sp)), "ld1 {v13.d}[1], [sp]"); 3042 3043 COMPARE(Ld1(v0.V8B(), 0, MemOperand(x15, x0, PostIndex)), 3044 "ld1 {v0.b}[0], [x15], x0"); 3045 COMPARE(Ld1(v1.V16B(), 1, MemOperand(x16, 1, PostIndex)), 3046 "ld1 {v1.b}[1], [x16], #1"); 3047 COMPARE(Ld1(v2.V4H(), 2, MemOperand(x17, 2, PostIndex)), 3048 "ld1 {v2.h}[2], [x17], #2"); 3049 COMPARE(Ld1(v3.V8H(), 3, MemOperand(x18, x1, PostIndex)), 3050 "ld1 {v3.h}[3], [x18], x1"); 3051 COMPARE(Ld1(v4.V2S(), 0, MemOperand(x19, x2, PostIndex)), 3052 "ld1 {v4.s}[0], [x19], x2"); 3053 COMPARE(Ld1(v5.V4S(), 1, MemOperand(x20, 4, PostIndex)), 3054 "ld1 {v5.s}[1], [x20], #4"); 3055 COMPARE(Ld1(v6.V2D(), 0, MemOperand(x21, 8, PostIndex)), 3056 "ld1 {v6.d}[0], [x21], #8"); 3057 COMPARE(Ld1(v7.B(), 7, MemOperand(x22, 1, PostIndex)), 3058 "ld1 {v7.b}[7], [x22], #1"); 3059 COMPARE(Ld1(v8.B(), 15, MemOperand(x23, x3, PostIndex)), 3060 "ld1 {v8.b}[15], [x23], x3"); 3061 COMPARE(Ld1(v9.H(), 3, MemOperand(x24, x4, PostIndex)), 3062 "ld1 {v9.h}[3], [x24], x4"); 3063 COMPARE(Ld1(v10.H(), 7, MemOperand(x25, 2, PostIndex)), 3064 "ld1 {v10.h}[7], [x25], #2"); 3065 COMPARE(Ld1(v11.S(), 1, MemOperand(x26, 4, PostIndex)), 3066 "ld1 {v11.s}[1], [x26], #4"); 3067 COMPARE(Ld1(v12.S(), 3, MemOperand(x27, x5, PostIndex)), 3068 "ld1 {v12.s}[3], [x27], x5"); 3069 COMPARE(Ld1(v13.D(), 1, MemOperand(sp, x6, PostIndex)), 3070 "ld1 {v13.d}[1], [sp], x6"); 3071 3072 COMPARE(Ld2(v0.V8B(), v1.V8B(), 0, MemOperand(x15)), 3073 "ld2 {v0.b, v1.b}[0], [x15]"); 3074 COMPARE(Ld2(v1.V16B(), v2.V16B(), 1, MemOperand(x16)), 3075 "ld2 {v1.b, v2.b}[1], [x16]"); 3076 COMPARE(Ld2(v2.V4H(), v3.V4H(), 2, MemOperand(x17)), 3077 "ld2 {v2.h, v3.h}[2], [x17]"); 3078 COMPARE(Ld2(v3.V8H(), v4.V8H(), 3, MemOperand(x18)), 3079 "ld2 {v3.h, v4.h}[3], [x18]"); 3080 COMPARE(Ld2(v4.V2S(), v5.V2S(), 0, MemOperand(x19)), 3081 "ld2 {v4.s, v5.s}[0], [x19]"); 3082 COMPARE(Ld2(v5.V4S(), v6.V4S(), 1, MemOperand(x20)), 3083 "ld2 {v5.s, v6.s}[1], [x20]"); 3084 COMPARE(Ld2(v6.V2D(), v7.V2D(), 0, MemOperand(x21)), 3085 "ld2 {v6.d, v7.d}[0], [x21]"); 3086 COMPARE(Ld2(v7.B(), v8.B(), 7, MemOperand(x22)), 3087 "ld2 {v7.b, v8.b}[7], [x22]"); 3088 COMPARE(Ld2(v8.B(), v9.B(), 15, MemOperand(x23)), 3089 "ld2 {v8.b, v9.b}[15], [x23]"); 3090 COMPARE(Ld2(v9.H(), v10.H(), 3, MemOperand(x24)), 3091 "ld2 {v9.h, v10.h}[3], [x24]"); 3092 COMPARE(Ld2(v10.H(), v11.H(), 7, MemOperand(x25)), 3093 "ld2 {v10.h, v11.h}[7], [x25]"); 3094 COMPARE(Ld2(v11.S(), v12.S(), 1, MemOperand(x26)), 3095 "ld2 {v11.s, v12.s}[1], [x26]"); 3096 COMPARE(Ld2(v12.S(), v13.S(), 3, MemOperand(x27)), 3097 "ld2 {v12.s, v13.s}[3], [x27]"); 3098 COMPARE(Ld2(v13.D(), v14.D(), 1, MemOperand(sp)), 3099 "ld2 {v13.d, v14.d}[1], [sp]"); 3100 3101 COMPARE(Ld2(v0.V8B(), v1.V8B(), 0, MemOperand(x15, x0, PostIndex)), 3102 "ld2 {v0.b, v1.b}[0], [x15], x0"); 3103 COMPARE(Ld2(v1.V16B(), v2.V16B(), 1, MemOperand(x16, 2, PostIndex)), 3104 "ld2 {v1.b, v2.b}[1], [x16], #2"); 3105 COMPARE(Ld2(v2.V4H(), v3.V4H(), 2, MemOperand(x17, 4, PostIndex)), 3106 "ld2 {v2.h, v3.h}[2], [x17], #4"); 3107 COMPARE(Ld2(v3.V8H(), v4.V8H(), 3, MemOperand(x18, x1, PostIndex)), 3108 "ld2 {v3.h, v4.h}[3], [x18], x1"); 3109 COMPARE(Ld2(v4.V2S(), v5.V2S(), 0, MemOperand(x19, x2, PostIndex)), 3110 "ld2 {v4.s, v5.s}[0], [x19], x2"); 3111 COMPARE(Ld2(v5.V4S(), v6.V4S(), 1, MemOperand(x20, 8, PostIndex)), 3112 "ld2 {v5.s, v6.s}[1], [x20], #8"); 3113 COMPARE(Ld2(v6.V2D(), v7.V2D(), 0, MemOperand(x21, 16, PostIndex)), 3114 "ld2 {v6.d, v7.d}[0], [x21], #16"); 3115 COMPARE(Ld2(v7.B(), v8.B(), 7, MemOperand(x22, 2, PostIndex)), 3116 "ld2 {v7.b, v8.b}[7], [x22], #2"); 3117 COMPARE(Ld2(v8.B(), v9.B(), 15, MemOperand(x23, x3, PostIndex)), 3118 "ld2 {v8.b, v9.b}[15], [x23], x3"); 3119 COMPARE(Ld2(v9.H(), v10.H(), 3, MemOperand(x24, x4, PostIndex)), 3120 "ld2 {v9.h, v10.h}[3], [x24], x4"); 3121 COMPARE(Ld2(v10.H(), v11.H(), 7, MemOperand(x25, 4, PostIndex)), 3122 "ld2 {v10.h, v11.h}[7], [x25], #4"); 3123 COMPARE(Ld2(v11.S(), v12.S(), 1, MemOperand(x26, 8, PostIndex)), 3124 "ld2 {v11.s, v12.s}[1], [x26], #8"); 3125 COMPARE(Ld2(v12.S(), v13.S(), 3, MemOperand(x27, x5, PostIndex)), 3126 "ld2 {v12.s, v13.s}[3], [x27], x5"); 3127 COMPARE(Ld2(v13.D(), v14.D(), 1, MemOperand(sp, x6, PostIndex)), 3128 "ld2 {v13.d, v14.d}[1], [sp], x6"); 3129 3130 COMPARE(Ld3(v0.V8B(), v1.V8B(), v2.V8B(), 0, MemOperand(x15)), 3131 "ld3 {v0.b, v1.b, v2.b}[0], [x15]"); 3132 COMPARE(Ld3(v1.V16B(), v2.V16B(), v3.V16B(), 1, MemOperand(x16)), 3133 "ld3 {v1.b, v2.b, v3.b}[1], [x16]"); 3134 COMPARE(Ld3(v2.V4H(), v3.V4H(), v4.V4H(), 2, MemOperand(x17)), 3135 "ld3 {v2.h, v3.h, v4.h}[2], [x17]"); 3136 COMPARE(Ld3(v3.V8H(), v4.V8H(), v5.V8H(), 3, MemOperand(x18)), 3137 "ld3 {v3.h, v4.h, v5.h}[3], [x18]"); 3138 COMPARE(Ld3(v4.V2S(), v5.V2S(), v6.V2S(), 0, MemOperand(x19)), 3139 "ld3 {v4.s, v5.s, v6.s}[0], [x19]"); 3140 COMPARE(Ld3(v5.V4S(), v6.V4S(), v7.V4S(), 1, MemOperand(x20)), 3141 "ld3 {v5.s, v6.s, v7.s}[1], [x20]"); 3142 COMPARE(Ld3(v6.V2D(), v7.V2D(), v8.V2D(), 0, MemOperand(x21)), 3143 "ld3 {v6.d, v7.d, v8.d}[0], [x21]"); 3144 COMPARE(Ld3(v7.B(), v8.B(), v9.B(), 7, MemOperand(x22)), 3145 "ld3 {v7.b, v8.b, v9.b}[7], [x22]"); 3146 COMPARE(Ld3(v8.B(), v9.B(), v10.B(), 15, MemOperand(x23)), 3147 "ld3 {v8.b, v9.b, v10.b}[15], [x23]"); 3148 COMPARE(Ld3(v9.H(), v10.H(), v11.H(), 3, MemOperand(x24)), 3149 "ld3 {v9.h, v10.h, v11.h}[3], [x24]"); 3150 COMPARE(Ld3(v10.H(), v11.H(), v12.H(), 7, MemOperand(x25)), 3151 "ld3 {v10.h, v11.h, v12.h}[7], [x25]"); 3152 COMPARE(Ld3(v11.S(), v12.S(), v13.S(), 1, MemOperand(x26)), 3153 "ld3 {v11.s, v12.s, v13.s}[1], [x26]"); 3154 COMPARE(Ld3(v12.S(), v13.S(), v14.S(), 3, MemOperand(x27)), 3155 "ld3 {v12.s, v13.s, v14.s}[3], [x27]"); 3156 COMPARE(Ld3(v13.D(), v14.D(), v15.D(), 1, MemOperand(sp)), 3157 "ld3 {v13.d, v14.d, v15.d}[1], [sp]"); 3158 3159 COMPARE(Ld3(v0.V8B(), v1.V8B(), v2.V8B(), 0, 3160 MemOperand(x15, x0, PostIndex)), 3161 "ld3 {v0.b, v1.b, v2.b}[0], [x15], x0"); 3162 COMPARE(Ld3(v1.V16B(), v2.V16B(), v3.V16B(), 1, 3163 MemOperand(x16, 3, PostIndex)), 3164 "ld3 {v1.b, v2.b, v3.b}[1], [x16], #3"); 3165 COMPARE(Ld3(v2.V4H(), v3.V4H(), v4.V4H(), 2, 3166 MemOperand(x17, 6, PostIndex)), 3167 "ld3 {v2.h, v3.h, v4.h}[2], [x17], #6"); 3168 COMPARE(Ld3(v3.V8H(), v4.V8H(), v5.V8H(), 3, 3169 MemOperand(x18, x1, PostIndex)), 3170 "ld3 {v3.h, v4.h, v5.h}[3], [x18], x1"); 3171 COMPARE(Ld3(v4.V2S(), v5.V2S(), v6.V2S(), 0, 3172 MemOperand(x19, x2, PostIndex)), 3173 "ld3 {v4.s, v5.s, v6.s}[0], [x19], x2"); 3174 COMPARE(Ld3(v5.V4S(), v6.V4S(), v7.V4S(), 1, 3175 MemOperand(x20, 12, PostIndex)), 3176 "ld3 {v5.s, v6.s, v7.s}[1], [x20], #12"); 3177 COMPARE(Ld3(v6.V2D(), v7.V2D(), v8.V2D(), 0, 3178 MemOperand(x21, 24, PostIndex)), 3179 "ld3 {v6.d, v7.d, v8.d}[0], [x21], #24"); 3180 COMPARE(Ld3(v7.B(), v8.B(), v9.B(), 7, 3181 MemOperand(x22, 3, PostIndex)), 3182 "ld3 {v7.b, v8.b, v9.b}[7], [x22], #3"); 3183 COMPARE(Ld3(v8.B(), v9.B(), v10.B(), 15, 3184 MemOperand(x23, x3, PostIndex)), 3185 "ld3 {v8.b, v9.b, v10.b}[15], [x23], x3"); 3186 COMPARE(Ld3(v9.H(), v10.H(), v11.H(), 3, 3187 MemOperand(x24, x4, PostIndex)), 3188 "ld3 {v9.h, v10.h, v11.h}[3], [x24], x4"); 3189 COMPARE(Ld3(v10.H(), v11.H(), v12.H(), 7, 3190 MemOperand(x25, 6, PostIndex)), 3191 "ld3 {v10.h, v11.h, v12.h}[7], [x25], #6"); 3192 COMPARE(Ld3(v11.S(), v12.S(), v13.S(), 1, 3193 MemOperand(x26, 12, PostIndex)), 3194 "ld3 {v11.s, v12.s, v13.s}[1], [x26], #12"); 3195 COMPARE(Ld3(v12.S(), v13.S(), v14.S(), 3, 3196 MemOperand(x27, x5, PostIndex)), 3197 "ld3 {v12.s, v13.s, v14.s}[3], [x27], x5"); 3198 COMPARE(Ld3(v13.D(), v14.D(), v15.D(), 1, 3199 MemOperand(sp, x6, PostIndex)), 3200 "ld3 {v13.d, v14.d, v15.d}[1], [sp], x6"); 3201 3202 COMPARE(Ld4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), 0, 3203 MemOperand(x15)), 3204 "ld4 {v0.b, v1.b, v2.b, v3.b}[0], [x15]"); 3205 COMPARE(Ld4(v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), 1, 3206 MemOperand(x16)), 3207 "ld4 {v1.b, v2.b, v3.b, v4.b}[1], [x16]"); 3208 COMPARE(Ld4(v2.V4H(), v3.V4H(), v4.V4H(), v5.V4H(), 2, 3209 MemOperand(x17)), 3210 "ld4 {v2.h, v3.h, v4.h, v5.h}[2], [x17]"); 3211 COMPARE(Ld4(v3.V8H(), v4.V8H(), v5.V8H(), v6.V8H(), 3, 3212 MemOperand(x18)), 3213 "ld4 {v3.h, v4.h, v5.h, v6.h}[3], [x18]"); 3214 COMPARE(Ld4(v4.V2S(), v5.V2S(), v6.V2S(), v7.V2S(), 0, 3215 MemOperand(x19)), 3216 "ld4 {v4.s, v5.s, v6.s, v7.s}[0], [x19]"); 3217 COMPARE(Ld4(v5.V4S(), v6.V4S(), v7.V4S(), v8.V4S(), 1, 3218 MemOperand(x20)), 3219 "ld4 {v5.s, v6.s, v7.s, v8.s}[1], [x20]"); 3220 COMPARE(Ld4(v6.V2D(), v7.V2D(), v8.V2D(), v9.V2D(), 0, 3221 MemOperand(x21)), 3222 "ld4 {v6.d, v7.d, v8.d, v9.d}[0], [x21]"); 3223 COMPARE(Ld4(v7.B(), v8.B(), v9.B(), v10.B(), 7, 3224 MemOperand(x22)), 3225 "ld4 {v7.b, v8.b, v9.b, v10.b}[7], [x22]"); 3226 COMPARE(Ld4(v8.B(), v9.B(), v10.B(), v11.B(), 15, 3227 MemOperand(x23)), 3228 "ld4 {v8.b, v9.b, v10.b, v11.b}[15], [x23]"); 3229 COMPARE(Ld4(v9.H(), v10.H(), v11.H(), v12.H(), 3, 3230 MemOperand(x24)), 3231 "ld4 {v9.h, v10.h, v11.h, v12.h}[3], [x24]"); 3232 COMPARE(Ld4(v10.H(), v11.H(), v12.H(), v13.H(), 7, 3233 MemOperand(x25)), 3234 "ld4 {v10.h, v11.h, v12.h, v13.h}[7], [x25]"); 3235 COMPARE(Ld4(v11.S(), v12.S(), v13.S(), v14.S(), 1, 3236 MemOperand(x26)), 3237 "ld4 {v11.s, v12.s, v13.s, v14.s}[1], [x26]"); 3238 COMPARE(Ld4(v12.S(), v13.S(), v14.S(), v15.S(), 3, 3239 MemOperand(x27)), 3240 "ld4 {v12.s, v13.s, v14.s, v15.s}[3], [x27]"); 3241 COMPARE(Ld4(v13.D(), v14.D(), v15.D(), v16.D(), 1, 3242 MemOperand(sp)), 3243 "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp]"); 3244 3245 COMPARE(Ld4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), 0, 3246 MemOperand(x15, x0, PostIndex)), 3247 "ld4 {v0.b, v1.b, v2.b, v3.b}[0], [x15], x0"); 3248 COMPARE(Ld4(v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), 1, 3249 MemOperand(x16, 4, PostIndex)), 3250 "ld4 {v1.b, v2.b, v3.b, v4.b}[1], [x16], #4"); 3251 COMPARE(Ld4(v2.V4H(), v3.V4H(), v4.V4H(), v5.V4H(), 2, 3252 MemOperand(x17, 8, PostIndex)), 3253 "ld4 {v2.h, v3.h, v4.h, v5.h}[2], [x17], #8"); 3254 COMPARE(Ld4(v3.V8H(), v4.V8H(), v5.V8H(), v6.V8H(), 3, 3255 MemOperand(x18, x1, PostIndex)), 3256 "ld4 {v3.h, v4.h, v5.h, v6.h}[3], [x18], x1"); 3257 COMPARE(Ld4(v4.V2S(), v5.V2S(), v6.V2S(), v7.V2S(), 0, 3258 MemOperand(x19, x2, PostIndex)), 3259 "ld4 {v4.s, v5.s, v6.s, v7.s}[0], [x19], x2"); 3260 COMPARE(Ld4(v5.V4S(), v6.V4S(), v7.V4S(), v8.V4S(), 1, 3261 MemOperand(x20, 16, PostIndex)), 3262 "ld4 {v5.s, v6.s, v7.s, v8.s}[1], [x20], #16"); 3263 COMPARE(Ld4(v6.V2D(), v7.V2D(), v8.V2D(), v9.V2D(), 0, 3264 MemOperand(x21, 32, PostIndex)), 3265 "ld4 {v6.d, v7.d, v8.d, v9.d}[0], [x21], #32"); 3266 COMPARE(Ld4(v7.B(), v8.B(), v9.B(), v10.B(), 7, 3267 MemOperand(x22, 4, PostIndex)), 3268 "ld4 {v7.b, v8.b, v9.b, v10.b}[7], [x22], #4"); 3269 COMPARE(Ld4(v8.B(), v9.B(), v10.B(), v11.B(), 15, 3270 MemOperand(x23, x3, PostIndex)), 3271 "ld4 {v8.b, v9.b, v10.b, v11.b}[15], [x23], x3"); 3272 COMPARE(Ld4(v9.H(), v10.H(), v11.H(), v12.H(), 3, 3273 MemOperand(x24, x4, PostIndex)), 3274 "ld4 {v9.h, v10.h, v11.h, v12.h}[3], [x24], x4"); 3275 COMPARE(Ld4(v10.H(), v11.H(), v12.H(), v13.H(), 7, 3276 MemOperand(x25, 8, PostIndex)), 3277 "ld4 {v10.h, v11.h, v12.h, v13.h}[7], [x25], #8"); 3278 COMPARE(Ld4(v11.S(), v12.S(), v13.S(), v14.S(), 1, 3279 MemOperand(x26, 16, PostIndex)), 3280 "ld4 {v11.s, v12.s, v13.s, v14.s}[1], [x26], #16"); 3281 COMPARE(Ld4(v12.S(), v13.S(), v14.S(), v15.S(), 3, 3282 MemOperand(x27, x5, PostIndex)), 3283 "ld4 {v12.s, v13.s, v14.s, v15.s}[3], [x27], x5"); 3284 COMPARE(Ld4(v13.D(), v14.D(), v15.D(), v16.D(), 1, 3285 MemOperand(sp, x6, PostIndex)), 3286 "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], x6"); 3287 3288 COMPARE(St1(v0.V8B(), 0, MemOperand(x15)), "st1 {v0.b}[0], [x15]"); 3289 COMPARE(St1(v1.V16B(), 1, MemOperand(x16)), "st1 {v1.b}[1], [x16]"); 3290 COMPARE(St1(v2.V4H(), 2, MemOperand(x17)), "st1 {v2.h}[2], [x17]"); 3291 COMPARE(St1(v3.V8H(), 3, MemOperand(x18)), "st1 {v3.h}[3], [x18]"); 3292 COMPARE(St1(v4.V2S(), 0, MemOperand(x19)), "st1 {v4.s}[0], [x19]"); 3293 COMPARE(St1(v5.V4S(), 1, MemOperand(x20)), "st1 {v5.s}[1], [x20]"); 3294 COMPARE(St1(v6.V2D(), 0, MemOperand(x21)), "st1 {v6.d}[0], [x21]"); 3295 COMPARE(St1(v7.B(), 7, MemOperand(x22)), "st1 {v7.b}[7], [x22]"); 3296 COMPARE(St1(v8.B(), 15, MemOperand(x23)), "st1 {v8.b}[15], [x23]"); 3297 COMPARE(St1(v9.H(), 3, MemOperand(x24)), "st1 {v9.h}[3], [x24]"); 3298 COMPARE(St1(v10.H(), 7, MemOperand(x25)), "st1 {v10.h}[7], [x25]"); 3299 COMPARE(St1(v11.S(), 1, MemOperand(x26)), "st1 {v11.s}[1], [x26]"); 3300 COMPARE(St1(v12.S(), 3, MemOperand(x27)), "st1 {v12.s}[3], [x27]"); 3301 COMPARE(St1(v13.D(), 1, MemOperand(sp)), "st1 {v13.d}[1], [sp]"); 3302 3303 COMPARE(St1(v0.V8B(), 0, MemOperand(x15, x0, PostIndex)), 3304 "st1 {v0.b}[0], [x15], x0"); 3305 COMPARE(St1(v1.V16B(), 1, MemOperand(x16, 1, PostIndex)), 3306 "st1 {v1.b}[1], [x16], #1"); 3307 COMPARE(St1(v2.V4H(), 2, MemOperand(x17, 2, PostIndex)), 3308 "st1 {v2.h}[2], [x17], #2"); 3309 COMPARE(St1(v3.V8H(), 3, MemOperand(x18, x1, PostIndex)), 3310 "st1 {v3.h}[3], [x18], x1"); 3311 COMPARE(St1(v4.V2S(), 0, MemOperand(x19, x2, PostIndex)), 3312 "st1 {v4.s}[0], [x19], x2"); 3313 COMPARE(St1(v5.V4S(), 1, MemOperand(x20, 4, PostIndex)), 3314 "st1 {v5.s}[1], [x20], #4"); 3315 COMPARE(St1(v6.V2D(), 0, MemOperand(x21, 8, PostIndex)), 3316 "st1 {v6.d}[0], [x21], #8"); 3317 COMPARE(St1(v7.B(), 7, MemOperand(x22, 1, PostIndex)), 3318 "st1 {v7.b}[7], [x22], #1"); 3319 COMPARE(St1(v8.B(), 15, MemOperand(x23, x3, PostIndex)), 3320 "st1 {v8.b}[15], [x23], x3"); 3321 COMPARE(St1(v9.H(), 3, MemOperand(x24, x4, PostIndex)), 3322 "st1 {v9.h}[3], [x24], x4"); 3323 COMPARE(St1(v10.H(), 7, MemOperand(x25, 2, PostIndex)), 3324 "st1 {v10.h}[7], [x25], #2"); 3325 COMPARE(St1(v11.S(), 1, MemOperand(x26, 4, PostIndex)), 3326 "st1 {v11.s}[1], [x26], #4"); 3327 COMPARE(St1(v12.S(), 3, MemOperand(x27, x5, PostIndex)), 3328 "st1 {v12.s}[3], [x27], x5"); 3329 COMPARE(St1(v13.D(), 1, MemOperand(sp, x6, PostIndex)), 3330 "st1 {v13.d}[1], [sp], x6"); 3331 COMPARE(St2(v0.V8B(), v1.V8B(), 0, MemOperand(x15, x0, PostIndex)), 3332 "st2 {v0.b, v1.b}[0], [x15], x0"); 3333 COMPARE(St2(v1.V16B(), v2.V16B(), 1, MemOperand(x16, 2, PostIndex)), 3334 "st2 {v1.b, v2.b}[1], [x16], #2"); 3335 COMPARE(St2(v2.V4H(), v3.V4H(), 2, MemOperand(x17, 4, PostIndex)), 3336 "st2 {v2.h, v3.h}[2], [x17], #4"); 3337 COMPARE(St2(v3.V8H(), v4.V8H(), 3, MemOperand(x18, x1, PostIndex)), 3338 "st2 {v3.h, v4.h}[3], [x18], x1"); 3339 COMPARE(St2(v4.V2S(), v5.V2S(), 0, MemOperand(x19, x2, PostIndex)), 3340 "st2 {v4.s, v5.s}[0], [x19], x2"); 3341 COMPARE(St2(v5.V4S(), v6.V4S(), 1, MemOperand(x20, 8, PostIndex)), 3342 "st2 {v5.s, v6.s}[1], [x20], #8"); 3343 COMPARE(St2(v6.V2D(), v7.V2D(), 0, MemOperand(x21, 16, PostIndex)), 3344 "st2 {v6.d, v7.d}[0], [x21], #16"); 3345 COMPARE(St2(v7.B(), v8.B(), 7, MemOperand(x22, 2, PostIndex)), 3346 "st2 {v7.b, v8.b}[7], [x22], #2"); 3347 COMPARE(St2(v8.B(), v9.B(), 15, MemOperand(x23, x3, PostIndex)), 3348 "st2 {v8.b, v9.b}[15], [x23], x3"); 3349 COMPARE(St2(v9.H(), v10.H(), 3, MemOperand(x24, x4, PostIndex)), 3350 "st2 {v9.h, v10.h}[3], [x24], x4"); 3351 COMPARE(St2(v10.H(), v11.H(), 7, MemOperand(x25, 4, PostIndex)), 3352 "st2 {v10.h, v11.h}[7], [x25], #4"); 3353 COMPARE(St2(v11.S(), v12.S(), 1, MemOperand(x26, 8, PostIndex)), 3354 "st2 {v11.s, v12.s}[1], [x26], #8"); 3355 COMPARE(St2(v12.S(), v13.S(), 3, MemOperand(x27, x5, PostIndex)), 3356 "st2 {v12.s, v13.s}[3], [x27], x5"); 3357 COMPARE(St2(v13.D(), v14.D(), 1, MemOperand(sp, x6, PostIndex)), 3358 "st2 {v13.d, v14.d}[1], [sp], x6"); 3359 COMPARE(St3(VLIST3(v0.V8B()), 0, MemOperand(x15, x0, PostIndex)), 3360 "st3 {v0.b, v1.b, v2.b}[0], [x15], x0"); 3361 COMPARE(St3(VLIST3(v1.V16B()), 1, MemOperand(x16, 3, PostIndex)), 3362 "st3 {v1.b, v2.b, v3.b}[1], [x16], #3"); 3363 COMPARE(St3(VLIST3(v2.V4H()), 2, MemOperand(x17, 6, PostIndex)), 3364 "st3 {v2.h, v3.h, v4.h}[2], [x17], #6"); 3365 COMPARE(St3(VLIST3(v3.V8H()), 3, MemOperand(x18, x1, PostIndex)), 3366 "st3 {v3.h, v4.h, v5.h}[3], [x18], x1"); 3367 COMPARE(St3(VLIST3(v4.V2S()), 0, MemOperand(x19, x2, PostIndex)), 3368 "st3 {v4.s, v5.s, v6.s}[0], [x19], x2"); 3369 COMPARE(St3(VLIST3(v5.V4S()), 1, MemOperand(x20, 12, PostIndex)), 3370 "st3 {v5.s, v6.s, v7.s}[1], [x20], #12"); 3371 COMPARE(St3(VLIST3(v6.V2D()), 0, MemOperand(x21, 24, PostIndex)), 3372 "st3 {v6.d, v7.d, v8.d}[0], [x21], #24"); 3373 COMPARE(St3(VLIST3(v7.B()), 7, MemOperand(x22, 3, PostIndex)), 3374 "st3 {v7.b, v8.b, v9.b}[7], [x22], #3"); 3375 COMPARE(St3(VLIST3(v8.B()), 15, MemOperand(x23, x3, PostIndex)), 3376 "st3 {v8.b, v9.b, v10.b}[15], [x23], x3"); 3377 COMPARE(St3(VLIST3(v9.H()), 3, MemOperand(x24, x4, PostIndex)), 3378 "st3 {v9.h, v10.h, v11.h}[3], [x24], x4"); 3379 COMPARE(St3(VLIST3(v10.H()), 7, MemOperand(x25, 6, PostIndex)), 3380 "st3 {v10.h, v11.h, v12.h}[7], [x25], #6"); 3381 COMPARE(St3(VLIST3(v11.S()), 1, MemOperand(x26, 12, PostIndex)), 3382 "st3 {v11.s, v12.s, v13.s}[1], [x26], #12"); 3383 COMPARE(St3(VLIST3(v12.S()), 3, MemOperand(x27, x5, PostIndex)), 3384 "st3 {v12.s, v13.s, v14.s}[3], [x27], x5"); 3385 COMPARE(St3(VLIST3(v13.D()), 1, MemOperand(sp, x6, PostIndex)), 3386 "st3 {v13.d, v14.d, v15.d}[1], [sp], x6"); 3387 3388 COMPARE(St4(VLIST4(v0.V8B()), 0, MemOperand(x15, x0, PostIndex)), 3389 "st4 {v0.b, v1.b, v2.b, v3.b}[0], [x15], x0"); 3390 COMPARE(St4(VLIST4(v1.V16B()), 1, MemOperand(x16, 4, PostIndex)), 3391 "st4 {v1.b, v2.b, v3.b, v4.b}[1], [x16], #4"); 3392 COMPARE(St4(VLIST4(v2.V4H()), 2, MemOperand(x17, 8, PostIndex)), 3393 "st4 {v2.h, v3.h, v4.h, v5.h}[2], [x17], #8"); 3394 COMPARE(St4(VLIST4(v3.V8H()), 3, MemOperand(x18, x1, PostIndex)), 3395 "st4 {v3.h, v4.h, v5.h, v6.h}[3], [x18], x1"); 3396 COMPARE(St4(VLIST4(v4.V2S()), 0, MemOperand(x19, x2, PostIndex)), 3397 "st4 {v4.s, v5.s, v6.s, v7.s}[0], [x19], x2"); 3398 COMPARE(St4(VLIST4(v5.V4S()), 1, MemOperand(x20, 16, PostIndex)), 3399 "st4 {v5.s, v6.s, v7.s, v8.s}[1], [x20], #16"); 3400 COMPARE(St4(VLIST4(v6.V2D()), 0, MemOperand(x21, 32, PostIndex)), 3401 "st4 {v6.d, v7.d, v8.d, v9.d}[0], [x21], #32"); 3402 COMPARE(St4(VLIST4(v7.B()), 7, MemOperand(x22, 4, PostIndex)), 3403 "st4 {v7.b, v8.b, v9.b, v10.b}[7], [x22], #4"); 3404 COMPARE(St4(VLIST4(v8.B()), 15, MemOperand(x23, x3, PostIndex)), 3405 "st4 {v8.b, v9.b, v10.b, v11.b}[15], [x23], x3"); 3406 COMPARE(St4(VLIST4(v9.H()), 3, MemOperand(x24, x4, PostIndex)), 3407 "st4 {v9.h, v10.h, v11.h, v12.h}[3], [x24], x4"); 3408 COMPARE(St4(VLIST4(v10.H()), 7, MemOperand(x25, 8, PostIndex)), 3409 "st4 {v10.h, v11.h, v12.h, v13.h}[7], [x25], #8"); 3410 COMPARE(St4(VLIST4(v11.S()), 1, MemOperand(x26, 16, PostIndex)), 3411 "st4 {v11.s, v12.s, v13.s, v14.s}[1], [x26], #16"); 3412 COMPARE(St4(VLIST4(v12.S()), 3, MemOperand(x27, x5, PostIndex)), 3413 "st4 {v12.s, v13.s, v14.s, v15.s}[3], [x27], x5"); 3414 COMPARE(St4(VLIST4(v13.D()), 1, MemOperand(sp, x6, PostIndex)), 3415 "st4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], x6"); 3416 3417 CLEANUP(); 3418} 3419 3420 3421TEST(neon_load_all_lanes) { 3422 SETUP_CLASS(MacroAssembler); 3423 3424 COMPARE(Ld1r(v14.V8B(), MemOperand(x0)), "ld1r {v14.8b}, [x0]"); 3425 COMPARE(Ld1r(v15.V16B(), MemOperand(x1)), "ld1r {v15.16b}, [x1]"); 3426 COMPARE(Ld1r(v16.V4H(), MemOperand(x2)), "ld1r {v16.4h}, [x2]"); 3427 COMPARE(Ld1r(v17.V8H(), MemOperand(x3)), "ld1r {v17.8h}, [x3]"); 3428 COMPARE(Ld1r(v18.V2S(), MemOperand(x4)), "ld1r {v18.2s}, [x4]"); 3429 COMPARE(Ld1r(v19.V4S(), MemOperand(x5)), "ld1r {v19.4s}, [x5]"); 3430 COMPARE(Ld1r(v20.V2D(), MemOperand(sp)), "ld1r {v20.2d}, [sp]"); 3431 COMPARE(Ld1r(v21.V1D(), MemOperand(x30)), "ld1r {v21.1d}, [x30]"); 3432 3433 COMPARE(Ld1r(v22.V8B(), MemOperand(x6, 1, PostIndex)), 3434 "ld1r {v22.8b}, [x6], #1"); 3435 COMPARE(Ld1r(v23.V16B(), MemOperand(x7, x16, PostIndex)), 3436 "ld1r {v23.16b}, [x7], x16"); 3437 COMPARE(Ld1r(v24.V4H(), MemOperand(x8, x17, PostIndex)), 3438 "ld1r {v24.4h}, [x8], x17"); 3439 COMPARE(Ld1r(v25.V8H(), MemOperand(x9, 2, PostIndex)), 3440 "ld1r {v25.8h}, [x9], #2"); 3441 COMPARE(Ld1r(v26.V2S(), MemOperand(x10, 4, PostIndex)), 3442 "ld1r {v26.2s}, [x10], #4"); 3443 COMPARE(Ld1r(v27.V4S(), MemOperand(x11, x18, PostIndex)), 3444 "ld1r {v27.4s}, [x11], x18"); 3445 COMPARE(Ld1r(v28.V2D(), MemOperand(x12, 8, PostIndex)), 3446 "ld1r {v28.2d}, [x12], #8"); 3447 COMPARE(Ld1r(v29.V1D(), MemOperand(x13, 8, PostIndex)), 3448 "ld1r {v29.1d}, [x13], #8"); 3449 3450 COMPARE(Ld2r(v14.V8B(), v15.V8B(), MemOperand(x0)), 3451 "ld2r {v14.8b, v15.8b}, [x0]"); 3452 COMPARE(Ld2r(v15.V16B(), v16.V16B(), MemOperand(x1)), 3453 "ld2r {v15.16b, v16.16b}, [x1]"); 3454 COMPARE(Ld2r(v16.V4H(), v17.V4H(), MemOperand(x2)), 3455 "ld2r {v16.4h, v17.4h}, [x2]"); 3456 COMPARE(Ld2r(v17.V8H(), v18.V8H(), MemOperand(x3)), 3457 "ld2r {v17.8h, v18.8h}, [x3]"); 3458 COMPARE(Ld2r(v18.V2S(), v19.V2S(), MemOperand(x4)), 3459 "ld2r {v18.2s, v19.2s}, [x4]"); 3460 COMPARE(Ld2r(v19.V4S(), v20.V4S(), MemOperand(x5)), 3461 "ld2r {v19.4s, v20.4s}, [x5]"); 3462 COMPARE(Ld2r(v20.V2D(), v21.V2D(), MemOperand(sp)), 3463 "ld2r {v20.2d, v21.2d}, [sp]"); 3464 COMPARE(Ld2r(v21.V8B(), v22.V8B(), MemOperand(x6, 2, PostIndex)), 3465 "ld2r {v21.8b, v22.8b}, [x6], #2"); 3466 COMPARE(Ld2r(v22.V16B(), v23.V16B(), MemOperand(x7, x16, PostIndex)), 3467 "ld2r {v22.16b, v23.16b}, [x7], x16"); 3468 COMPARE(Ld2r(v23.V4H(), v24.V4H(), MemOperand(x8, x17, PostIndex)), 3469 "ld2r {v23.4h, v24.4h}, [x8], x17"); 3470 COMPARE(Ld2r(v24.V8H(), v25.V8H(), MemOperand(x9, 4, PostIndex)), 3471 "ld2r {v24.8h, v25.8h}, [x9], #4"); 3472 COMPARE(Ld2r(v25.V2S(), v26.V2S(), MemOperand(x10, 8, PostIndex)), 3473 "ld2r {v25.2s, v26.2s}, [x10], #8"); 3474 COMPARE(Ld2r(v26.V4S(), v27.V4S(), MemOperand(x11, x18, PostIndex)), 3475 "ld2r {v26.4s, v27.4s}, [x11], x18"); 3476 COMPARE(Ld2r(v27.V2D(), v28.V2D(), MemOperand(x12, 16, PostIndex)), 3477 "ld2r {v27.2d, v28.2d}, [x12], #16"); 3478 3479 COMPARE(Ld3r(v14.V8B(), v15.V8B(), v16.V8B(), 3480 MemOperand(x0)), 3481 "ld3r {v14.8b, v15.8b, v16.8b}, [x0]"); 3482 COMPARE(Ld3r(v15.V16B(), v16.V16B(), v17.V16B(), 3483 MemOperand(x1)), 3484 "ld3r {v15.16b, v16.16b, v17.16b}, [x1]"); 3485 COMPARE(Ld3r(v16.V4H(), v17.V4H(), v18.V4H(), 3486 MemOperand(x2)), 3487 "ld3r {v16.4h, v17.4h, v18.4h}, [x2]"); 3488 COMPARE(Ld3r(v17.V8H(), v18.V8H(), v19.V8H(), 3489 MemOperand(x3)), 3490 "ld3r {v17.8h, v18.8h, v19.8h}, [x3]"); 3491 COMPARE(Ld3r(v18.V2S(), v19.V2S(), v20.V2S(), 3492 MemOperand(x4)), 3493 "ld3r {v18.2s, v19.2s, v20.2s}, [x4]"); 3494 COMPARE(Ld3r(v19.V4S(), v20.V4S(), v21.V4S(), 3495 MemOperand(x5)), 3496 "ld3r {v19.4s, v20.4s, v21.4s}, [x5]"); 3497 COMPARE(Ld3r(v20.V2D(), v21.V2D(), v22.V2D(), 3498 MemOperand(sp)), 3499 "ld3r {v20.2d, v21.2d, v22.2d}, [sp]"); 3500 COMPARE(Ld3r(v21.V8B(), v22.V8B(), v23.V8B(), 3501 MemOperand(x6, 3, PostIndex)), 3502 "ld3r {v21.8b, v22.8b, v23.8b}, [x6], #3"); 3503 COMPARE(Ld3r(v22.V16B(), v23.V16B(), v24.V16B(), 3504 MemOperand(x7, x16, PostIndex)), 3505 "ld3r {v22.16b, v23.16b, v24.16b}, [x7], x16"); 3506 COMPARE(Ld3r(v23.V4H(), v24.V4H(), v25.V4H(), 3507 MemOperand(x8, x17, PostIndex)), 3508 "ld3r {v23.4h, v24.4h, v25.4h}, [x8], x17"); 3509 COMPARE(Ld3r(v24.V8H(), v25.V8H(), v26.V8H(), 3510 MemOperand(x9, 6, PostIndex)), 3511 "ld3r {v24.8h, v25.8h, v26.8h}, [x9], #6"); 3512 COMPARE(Ld3r(v25.V2S(), v26.V2S(), v27.V2S(), 3513 MemOperand(x10, 12, PostIndex)), 3514 "ld3r {v25.2s, v26.2s, v27.2s}, [x10], #12"); 3515 COMPARE(Ld3r(v26.V4S(), v27.V4S(), v28.V4S(), 3516 MemOperand(x11, x18, PostIndex)), 3517 "ld3r {v26.4s, v27.4s, v28.4s}, [x11], x18"); 3518 COMPARE(Ld3r(v27.V2D(), v28.V2D(), v29.V2D(), 3519 MemOperand(x12, 24, PostIndex)), 3520 "ld3r {v27.2d, v28.2d, v29.2d}, [x12], #24"); 3521 3522 COMPARE(Ld4r(v14.V8B(), v15.V8B(), v16.V8B(), v17.V8B(), 3523 MemOperand(x0)), 3524 "ld4r {v14.8b, v15.8b, v16.8b, v17.8b}, [x0]"); 3525 COMPARE(Ld4r(v15.V16B(), v16.V16B(), v17.V16B(), v18.V16B(), 3526 MemOperand(x1)), 3527 "ld4r {v15.16b, v16.16b, v17.16b, v18.16b}, [x1]"); 3528 COMPARE(Ld4r(v16.V4H(), v17.V4H(), v18.V4H(), v19.V4H(), 3529 MemOperand(x2)), 3530 "ld4r {v16.4h, v17.4h, v18.4h, v19.4h}, [x2]"); 3531 COMPARE(Ld4r(v17.V8H(), v18.V8H(), v19.V8H(), v20.V8H(), 3532 MemOperand(x3)), 3533 "ld4r {v17.8h, v18.8h, v19.8h, v20.8h}, [x3]"); 3534 COMPARE(Ld4r(v18.V2S(), v19.V2S(), v20.V2S(), v21.V2S(), 3535 MemOperand(x4)), 3536 "ld4r {v18.2s, v19.2s, v20.2s, v21.2s}, [x4]"); 3537 COMPARE(Ld4r(v19.V4S(), v20.V4S(), v21.V4S(), v22.V4S(), 3538 MemOperand(x5)), 3539 "ld4r {v19.4s, v20.4s, v21.4s, v22.4s}, [x5]"); 3540 COMPARE(Ld4r(v20.V2D(), v21.V2D(), v22.V2D(), v23.V2D(), 3541 MemOperand(sp)), 3542 "ld4r {v20.2d, v21.2d, v22.2d, v23.2d}, [sp]"); 3543 COMPARE(Ld4r(v21.V8B(), v22.V8B(), v23.V8B(), v24.V8B(), 3544 MemOperand(x6, 4, PostIndex)), 3545 "ld4r {v21.8b, v22.8b, v23.8b, v24.8b}, [x6], #4"); 3546 COMPARE(Ld4r(v22.V16B(), v23.V16B(), v24.V16B(), v25.V16B(), 3547 MemOperand(x7, x16, PostIndex)), 3548 "ld4r {v22.16b, v23.16b, v24.16b, v25.16b}, [x7], x16"); 3549 COMPARE(Ld4r(v23.V4H(), v24.V4H(), v25.V4H(), v26.V4H(), 3550 MemOperand(x8, x17, PostIndex)), 3551 "ld4r {v23.4h, v24.4h, v25.4h, v26.4h}, [x8], x17"); 3552 COMPARE(Ld4r(v24.V8H(), v25.V8H(), v26.V8H(), v27.V8H(), 3553 MemOperand(x9, 8, PostIndex)), 3554 "ld4r {v24.8h, v25.8h, v26.8h, v27.8h}, [x9], #8"); 3555 COMPARE(Ld4r(v25.V2S(), v26.V2S(), v27.V2S(), v28.V2S(), 3556 MemOperand(x10, 16, PostIndex)), 3557 "ld4r {v25.2s, v26.2s, v27.2s, v28.2s}, [x10], #16"); 3558 COMPARE(Ld4r(v26.V4S(), v27.V4S(), v28.V4S(), v29.V4S(), 3559 MemOperand(x11, x18, PostIndex)), 3560 "ld4r {v26.4s, v27.4s, v28.4s, v29.4s}, [x11], x18"); 3561 COMPARE(Ld4r(v27.V2D(), v28.V2D(), v29.V2D(), v30.V2D(), 3562 MemOperand(x12, 32, PostIndex)), 3563 "ld4r {v27.2d, v28.2d, v29.2d, v30.2d}, [x12], #32"); 3564 3565 CLEANUP(); 3566} 3567 3568 3569TEST(neon_3same) { 3570 SETUP_CLASS(MacroAssembler); 3571 3572 #define DISASM_INST(M, S) \ 3573 COMPARE(Cmeq(v0.M, v1.M, v2.M), "cmeq v0." S ", v1." S ", v2." S); 3574 NEON_FORMAT_LIST(DISASM_INST) 3575 #undef DISASM_INST 3576 3577 #define DISASM_INST(M, S) \ 3578 COMPARE(Cmge(v0.M, v1.M, v2.M), "cmge v0." S ", v1." S ", v2." S); 3579 NEON_FORMAT_LIST(DISASM_INST) 3580 #undef DISASM_INST 3581 3582 #define DISASM_INST(M, S) \ 3583 COMPARE(Cmgt(v0.M, v1.M, v2.M), "cmgt v0." S ", v1." S ", v2." S); 3584 NEON_FORMAT_LIST(DISASM_INST) 3585 #undef DISASM_INST 3586 3587 #define DISASM_INST(M, S) \ 3588 COMPARE(Cmhi(v0.M, v1.M, v2.M), "cmhi v0." S ", v1." S ", v2." S); 3589 NEON_FORMAT_LIST(DISASM_INST) 3590 #undef DISASM_INST 3591 3592 #define DISASM_INST(M, S) \ 3593 COMPARE(Cmhs(v0.M, v1.M, v2.M), "cmhs v0." S ", v1." S ", v2." S); 3594 NEON_FORMAT_LIST(DISASM_INST) 3595 #undef DISASM_INST 3596 3597 #define DISASM_INST(M, S) \ 3598 COMPARE(Cmtst(v0.M, v1.M, v2.M), "cmtst v0." S ", v1." S ", v2." S); 3599 NEON_FORMAT_LIST(DISASM_INST) 3600 #undef DISASM_INST 3601 3602 #define DISASM_INST(M, S) \ 3603 COMPARE(Add(v0.M, v1.M, v2.M), "add v0." S ", v1." S ", v2." S); 3604 NEON_FORMAT_LIST(DISASM_INST) 3605 #undef DISASM_INST 3606 3607 #define DISASM_INST(M, S) \ 3608 COMPARE(Sub(v3.M, v4.M, v5.M), "sub v3." S ", v4." S ", v5." S); 3609 NEON_FORMAT_LIST(DISASM_INST) 3610 #undef DISASM_INST 3611 3612 #define DISASM_INST(M, S) \ 3613 COMPARE(Sabd(v3.M, v4.M, v5.M), "sabd v3." S ", v4." S ", v5." S); 3614 NEON_FORMAT_LIST_BHS(DISASM_INST) 3615 #undef DISASM_INST 3616 3617 #define DISASM_INST(M, S) \ 3618 COMPARE(Uabd(v3.M, v4.M, v5.M), "uabd v3." S ", v4." S ", v5." S); 3619 NEON_FORMAT_LIST_BHS(DISASM_INST) 3620 #undef DISASM_INST 3621 3622 #define DISASM_INST(M, S) \ 3623 COMPARE(Saba(v3.M, v4.M, v5.M), "saba v3." S ", v4." S ", v5." S); 3624 NEON_FORMAT_LIST_BHS(DISASM_INST) 3625 #undef DISASM_INST 3626 3627 #define DISASM_INST(M, S) \ 3628 COMPARE(Uaba(v3.M, v4.M, v5.M), "uaba v3." S ", v4." S ", v5." S); 3629 NEON_FORMAT_LIST_BHS(DISASM_INST) 3630 #undef DISASM_INST 3631 3632 #define DISASM_INST(M, S) \ 3633 COMPARE(Smax(v3.M, v4.M, v5.M), "smax v3." S ", v4." S ", v5." S); 3634 NEON_FORMAT_LIST_BHS(DISASM_INST) 3635 #undef DISASM_INST 3636 3637 #define DISASM_INST(M, S) \ 3638 COMPARE(Smin(v3.M, v4.M, v5.M), "smin v3." S ", v4." S ", v5." S); 3639 NEON_FORMAT_LIST_BHS(DISASM_INST) 3640 #undef DISASM_INST 3641 3642 #define DISASM_INST(M, S) \ 3643 COMPARE(Umax(v3.M, v4.M, v5.M), "umax v3." S ", v4." S ", v5." S); 3644 NEON_FORMAT_LIST_BHS(DISASM_INST) 3645 #undef DISASM_INST 3646 3647 #define DISASM_INST(M, S) \ 3648 COMPARE(Umin(v3.M, v4.M, v5.M), "umin v3." S ", v4." S ", v5." S); 3649 NEON_FORMAT_LIST_BHS(DISASM_INST) 3650 #undef DISASM_INST 3651 3652 #define DISASM_INST(M, S) \ 3653 COMPARE(Smaxp(v3.M, v4.M, v5.M), "smaxp v3." S ", v4." S ", v5." S); 3654 NEON_FORMAT_LIST_BHS(DISASM_INST) 3655 #undef DISASM_INST 3656 3657 #define DISASM_INST(M, S) \ 3658 COMPARE(Sminp(v3.M, v4.M, v5.M), "sminp v3." S ", v4." S ", v5." S); 3659 NEON_FORMAT_LIST_BHS(DISASM_INST) 3660 #undef DISASM_INST 3661 3662 #define DISASM_INST(M, S) \ 3663 COMPARE(Umaxp(v3.M, v4.M, v5.M), "umaxp v3." S ", v4." S ", v5." S); 3664 NEON_FORMAT_LIST_BHS(DISASM_INST) 3665 #undef DISASM_INST 3666 3667 #define DISASM_INST(M, S) \ 3668 COMPARE(Uminp(v3.M, v4.M, v5.M), "uminp v3." S ", v4." S ", v5." S); 3669 NEON_FORMAT_LIST_BHS(DISASM_INST) 3670 #undef DISASM_INST 3671 3672 #define DISASM_INST(M, S) \ 3673 COMPARE(Uqadd(v6.M, v7.M, v8.M), "uqadd v6." S ", v7." S ", v8." S); 3674 NEON_FORMAT_LIST(DISASM_INST) 3675 #undef DISASM_INST 3676 3677 #define DISASM_INST(M, S) \ 3678 COMPARE(Sqadd(v9.M, v10.M, v11.M), "sqadd v9." S ", v10." S ", v11." S); 3679 NEON_FORMAT_LIST(DISASM_INST) 3680 #undef DISASM_INST 3681 3682 #define DISASM_INST(M, S) \ 3683 COMPARE(Uqsub(v6.M, v7.M, v8.M), "uqsub v6." S ", v7." S ", v8." S); 3684 NEON_FORMAT_LIST(DISASM_INST) 3685 #undef DISASM_INST 3686 3687 #define DISASM_INST(M, S) \ 3688 COMPARE(Sqsub(v9.M, v10.M, v11.M), "sqsub v9." S ", v10." S ", v11." S); 3689 NEON_FORMAT_LIST(DISASM_INST) 3690 #undef DISASM_INST 3691 3692 #define DISASM_INST(M, S) \ 3693 COMPARE(Sshl(v12.M, v13.M, v14.M), "sshl v12." S ", v13." S ", v14." S); 3694 NEON_FORMAT_LIST(DISASM_INST) 3695 #undef DISASM_INST 3696 3697 #define DISASM_INST(M, S) \ 3698 COMPARE(Ushl(v15.M, v16.M, v17.M), "ushl v15." S ", v16." S ", v17." S); 3699 NEON_FORMAT_LIST(DISASM_INST) 3700 #undef DISASM_INST 3701 3702 #define DISASM_INST(M, S) \ 3703 COMPARE(Sqshl(v18.M, v19.M, v20.M), "sqshl v18." S ", v19." S ", v20." S); 3704 NEON_FORMAT_LIST(DISASM_INST) 3705 #undef DISASM_INST 3706 3707 #define DISASM_INST(M, S) \ 3708 COMPARE(Uqshl(v21.M, v22.M, v23.M), "uqshl v21." S ", v22." S ", v23." S); 3709 NEON_FORMAT_LIST(DISASM_INST) 3710 #undef DISASM_INST 3711 3712 #define DISASM_INST(M, S) \ 3713 COMPARE(Srshl(v24.M, v25.M, v26.M), "srshl v24." S ", v25." S ", v26." S); 3714 NEON_FORMAT_LIST(DISASM_INST) 3715 #undef DISASM_INST 3716 3717 #define DISASM_INST(M, S) \ 3718 COMPARE(Urshl(v27.M, v28.M, v29.M), "urshl v27." S ", v28." S ", v29." S); 3719 NEON_FORMAT_LIST(DISASM_INST) 3720 #undef DISASM_INST 3721 3722 #define DISASM_INST(M, S) \ 3723 COMPARE(Sqrshl(v30.M, v31.M, v0.M), "sqrshl v30." S ", v31." S ", v0." S); 3724 NEON_FORMAT_LIST(DISASM_INST) 3725 #undef DISASM_INST 3726 3727 #define DISASM_INST(M, S) \ 3728 COMPARE(Uqrshl(v1.M, v2.M, v3.M), "uqrshl v1." S ", v2." S ", v3." S); 3729 NEON_FORMAT_LIST(DISASM_INST) 3730 #undef DISASM_INST 3731 3732 #define DISASM_INST(M, S) \ 3733 COMPARE(Shadd(v4.M, v5.M, v6.M), "shadd v4." S ", v5." S ", v6." S); 3734 NEON_FORMAT_LIST_BHS(DISASM_INST) 3735 #undef DISASM_INST 3736 3737 #define DISASM_INST(M, S) \ 3738 COMPARE(Uhadd(v7.M, v8.M, v9.M), "uhadd v7." S ", v8." S ", v9." S); 3739 NEON_FORMAT_LIST_BHS(DISASM_INST) 3740 #undef DISASM_INST 3741 3742 #define DISASM_INST(M, S) \ 3743 COMPARE(Srhadd(v10.M, v11.M, v12.M), "srhadd v10." S ", v11." S ", v12." S); 3744 NEON_FORMAT_LIST_BHS(DISASM_INST) 3745 #undef DISASM_INST 3746 3747 #define DISASM_INST(M, S) \ 3748 COMPARE(Urhadd(v13.M, v14.M, v15.M), "urhadd v13." S ", v14." S ", v15." S); 3749 NEON_FORMAT_LIST_BHS(DISASM_INST) 3750 #undef DISASM_INST 3751 3752 #define DISASM_INST(M, S) \ 3753 COMPARE(Shsub(v16.M, v17.M, v18.M), "shsub v16." S ", v17." S ", v18." S); 3754 NEON_FORMAT_LIST_BHS(DISASM_INST) 3755 #undef DISASM_INST 3756 3757 #define DISASM_INST(M, S) \ 3758 COMPARE(Uhsub(v19.M, v20.M, v21.M), "uhsub v19." S ", v20." S ", v21." S); 3759 NEON_FORMAT_LIST_BHS(DISASM_INST) 3760 #undef DISASM_INST 3761 3762 #define DISASM_INST(M, S) \ 3763 COMPARE(Addp(v19.M, v20.M, v21.M), "addp v19." S ", v20." S ", v21." S); 3764 NEON_FORMAT_LIST(DISASM_INST) 3765 #undef DISASM_INST 3766 3767 #define DISASM_INST(M, S) \ 3768 COMPARE(Mla(v19.M, v20.M, v21.M), "mla v19." S ", v20." S ", v21." S); 3769 NEON_FORMAT_LIST_BHS(DISASM_INST) 3770 #undef DISASM_INST 3771 3772 #define DISASM_INST(M, S) \ 3773 COMPARE(Mls(v19.M, v20.M, v21.M), "mls v19." S ", v20." S ", v21." S); 3774 NEON_FORMAT_LIST_BHS(DISASM_INST) 3775 #undef DISASM_INST 3776 3777 #define DISASM_INST(M, S) \ 3778 COMPARE(Mul(v19.M, v20.M, v21.M), "mul v19." S ", v20." S ", v21." S); 3779 NEON_FORMAT_LIST_BHS(DISASM_INST) 3780 #undef DISASM_INST 3781 3782 #define DISASM_INST(M, S) \ 3783 COMPARE(Sqdmulh(v1.M, v2.M, v3.M), "sqdmulh v1." S ", v2." S ", v3." S); 3784 NEON_FORMAT_LIST_HS(DISASM_INST) 3785 #undef DISASM_INST 3786 3787 #define DISASM_INST(M, S) \ 3788 COMPARE(Sqrdmulh(v1.M, v2.M, v3.M), "sqrdmulh v1." S ", v2." S ", v3." S); 3789 NEON_FORMAT_LIST_HS(DISASM_INST) 3790 #undef DISASM_INST 3791 3792 COMPARE(And(v6.V8B(), v7.V8B(), v8.V8B()), "and v6.8b, v7.8b, v8.8b"); 3793 COMPARE(And(v6.V16B(), v7.V16B(), v8.V16B()), "and v6.16b, v7.16b, v8.16b"); 3794 3795 COMPARE(Bic(v6.V8B(), v7.V8B(), v8.V8B()), "bic v6.8b, v7.8b, v8.8b"); 3796 COMPARE(Bic(v6.V16B(), v7.V16B(), v8.V16B()), "bic v6.16b, v7.16b, v8.16b"); 3797 3798 COMPARE(Orr(v6.V8B(), v7.V8B(), v8.V8B()), "orr v6.8b, v7.8b, v8.8b"); 3799 COMPARE(Orr(v6.V16B(), v7.V16B(), v8.V16B()), "orr v6.16b, v7.16b, v8.16b"); 3800 3801 COMPARE(Orr(v6.V8B(), v7.V8B(), v7.V8B()), "mov v6.8b, v7.8b"); 3802 COMPARE(Orr(v6.V16B(), v7.V16B(), v7.V16B()), "mov v6.16b, v7.16b"); 3803 3804 COMPARE(Mov(v6.V8B(), v8.V8B()), "mov v6.8b, v8.8b"); 3805 COMPARE(Mov(v6.V16B(), v8.V16B()), "mov v6.16b, v8.16b"); 3806 3807 COMPARE(Orn(v6.V8B(), v7.V8B(), v8.V8B()), "orn v6.8b, v7.8b, v8.8b"); 3808 COMPARE(Orn(v6.V16B(), v7.V16B(), v8.V16B()), "orn v6.16b, v7.16b, v8.16b"); 3809 3810 COMPARE(Eor(v6.V8B(), v7.V8B(), v8.V8B()), "eor v6.8b, v7.8b, v8.8b"); 3811 COMPARE(Eor(v6.V16B(), v7.V16B(), v8.V16B()), "eor v6.16b, v7.16b, v8.16b"); 3812 3813 COMPARE(Bif(v6.V8B(), v7.V8B(), v8.V8B()), "bif v6.8b, v7.8b, v8.8b"); 3814 COMPARE(Bif(v6.V16B(), v7.V16B(), v8.V16B()), "bif v6.16b, v7.16b, v8.16b"); 3815 3816 COMPARE(Bit(v6.V8B(), v7.V8B(), v8.V8B()), "bit v6.8b, v7.8b, v8.8b"); 3817 COMPARE(Bit(v6.V16B(), v7.V16B(), v8.V16B()), "bit v6.16b, v7.16b, v8.16b"); 3818 3819 COMPARE(Bsl(v6.V8B(), v7.V8B(), v8.V8B()), "bsl v6.8b, v7.8b, v8.8b"); 3820 COMPARE(Bsl(v6.V16B(), v7.V16B(), v8.V16B()), "bsl v6.16b, v7.16b, v8.16b"); 3821 3822 COMPARE(Pmul(v6.V8B(), v7.V8B(), v8.V8B()), "pmul v6.8b, v7.8b, v8.8b"); 3823 COMPARE(Pmul(v6.V16B(), v7.V16B(), v8.V16B()), "pmul v6.16b, v7.16b, v8.16b"); 3824 3825 CLEANUP(); 3826} 3827 3828 3829#define NEON_FORMAT_LIST_FP(V) \ 3830 V(V2S(), "2s") \ 3831 V(V4S(), "4s") \ 3832 V(V2D(), "2d") 3833 3834TEST(neon_fp_3same) { 3835 SETUP_CLASS(MacroAssembler); 3836 3837 #define DISASM_INST(M, S) \ 3838 COMPARE(Fadd(v0.M, v1.M, v2.M), "fadd v0." S ", v1." S ", v2." S); 3839 NEON_FORMAT_LIST_FP(DISASM_INST) 3840 #undef DISASM_INST 3841 3842 #define DISASM_INST(M, S) \ 3843 COMPARE(Fsub(v3.M, v4.M, v5.M), "fsub v3." S ", v4." S ", v5." S); 3844 NEON_FORMAT_LIST_FP(DISASM_INST) 3845 #undef DISASM_INST 3846 3847 #define DISASM_INST(M, S) \ 3848 COMPARE(Fmul(v6.M, v7.M, v8.M), "fmul v6." S ", v7." S ", v8." S); 3849 NEON_FORMAT_LIST_FP(DISASM_INST) 3850 #undef DISASM_INST 3851 3852 #define DISASM_INST(M, S) \ 3853 COMPARE(Fdiv(v9.M, v10.M, v11.M), "fdiv v9." S ", v10." S ", v11." S); 3854 NEON_FORMAT_LIST_FP(DISASM_INST) 3855 #undef DISASM_INST 3856 3857 #define DISASM_INST(M, S) \ 3858 COMPARE(Fmin(v12.M, v13.M, v14.M), "fmin v12." S ", v13." S ", v14." S); 3859 NEON_FORMAT_LIST_FP(DISASM_INST) 3860 #undef DISASM_INST 3861 3862 #define DISASM_INST(M, S) \ 3863 COMPARE(Fminnm(v15.M, v16.M, v17.M), "fminnm v15." S ", v16." S ", v17." S); 3864 NEON_FORMAT_LIST_FP(DISASM_INST) 3865 #undef DISASM_INST 3866 3867 #define DISASM_INST(M, S) \ 3868 COMPARE(Fmax(v18.M, v19.M, v20.M), "fmax v18." S ", v19." S ", v20." S); 3869 NEON_FORMAT_LIST_FP(DISASM_INST) 3870 #undef DISASM_INST 3871 3872 #define DISASM_INST(M, S) \ 3873 COMPARE(Fmaxnm(v21.M, v22.M, v23.M), "fmaxnm v21." S ", v22." S ", v23." S); 3874 NEON_FORMAT_LIST_FP(DISASM_INST) 3875 #undef DISASM_INST 3876 3877 #define DISASM_INST(M, S) \ 3878 COMPARE(Frecps(v24.M, v25.M, v26.M), "frecps v24." S ", v25." S ", v26." S); 3879 NEON_FORMAT_LIST_FP(DISASM_INST) 3880 #undef DISASM_INST 3881 3882 #define DISASM_INST(M, S) \ 3883 COMPARE(Frsqrts(v27.M, v28.M, v29.M), "frsqrts v27." S ", v28." S ", v29." S); 3884 NEON_FORMAT_LIST_FP(DISASM_INST) 3885 #undef DISASM_INST 3886 3887 #define DISASM_INST(M, S) \ 3888 COMPARE(Fmulx(v30.M, v31.M, v0.M), "fmulx v30." S ", v31." S ", v0." S); 3889 NEON_FORMAT_LIST_FP(DISASM_INST) 3890 #undef DISASM_INST 3891 3892 #define DISASM_INST(M, S) \ 3893 COMPARE(Fmla(v1.M, v2.M, v3.M), "fmla v1." S ", v2." S ", v3." S); 3894 NEON_FORMAT_LIST_FP(DISASM_INST) 3895 #undef DISASM_INST 3896 3897 #define DISASM_INST(M, S) \ 3898 COMPARE(Fmls(v4.M, v5.M, v6.M), "fmls v4." S ", v5." S ", v6." S); 3899 NEON_FORMAT_LIST_FP(DISASM_INST) 3900 #undef DISASM_INST 3901 3902 #define DISASM_INST(M, S) \ 3903 COMPARE(Fabd(v7.M, v8.M, v9.M), "fabd v7." S ", v8." S ", v9." S); 3904 NEON_FORMAT_LIST_FP(DISASM_INST) 3905 #undef DISASM_INST 3906 3907 #define DISASM_INST(M, S) \ 3908 COMPARE(Faddp(v10.M, v11.M, v12.M), "faddp v10." S ", v11." S ", v12." S); 3909 NEON_FORMAT_LIST_FP(DISASM_INST) 3910 #undef DISASM_INST 3911 3912 #define DISASM_INST(M, S) \ 3913 COMPARE(Fmaxp(v13.M, v14.M, v15.M), "fmaxp v13." S ", v14." S ", v15." S); 3914 NEON_FORMAT_LIST_FP(DISASM_INST) 3915 #undef DISASM_INST 3916 3917 #define DISASM_INST(M, S) \ 3918 COMPARE(Fminp(v16.M, v17.M, v18.M), "fminp v16." S ", v17." S ", v18." S); 3919 NEON_FORMAT_LIST_FP(DISASM_INST) 3920 #undef DISASM_INST 3921 3922 #define DISASM_INST(M, S) \ 3923 COMPARE(Fmaxnmp(v19.M, v20.M, v21.M), "fmaxnmp v19." S ", v20." S ", v21." S); 3924 NEON_FORMAT_LIST_FP(DISASM_INST) 3925 #undef DISASM_INST 3926 3927 #define DISASM_INST(M, S) \ 3928 COMPARE(Fminnmp(v22.M, v23.M, v24.M), "fminnmp v22." S ", v23." S ", v24." S); 3929 NEON_FORMAT_LIST_FP(DISASM_INST) 3930 #undef DISASM_INST 3931 3932 #define DISASM_INST(M, S) \ 3933 COMPARE(Fcmeq(v25.M, v26.M, v27.M), "fcmeq v25." S ", v26." S ", v27." S); 3934 NEON_FORMAT_LIST_FP(DISASM_INST) 3935 #undef DISASM_INST 3936 3937 #define DISASM_INST(M, S) \ 3938 COMPARE(Fcmge(v25.M, v26.M, v27.M), "fcmge v25." S ", v26." S ", v27." S); 3939 NEON_FORMAT_LIST_FP(DISASM_INST) 3940 #undef DISASM_INST 3941 3942 #define DISASM_INST(M, S) \ 3943 COMPARE(Fcmgt(v25.M, v26.M, v27.M), "fcmgt v25." S ", v26." S ", v27." S); 3944 NEON_FORMAT_LIST_FP(DISASM_INST) 3945 #undef DISASM_INST 3946 3947 #define DISASM_INST(M, S) \ 3948 COMPARE(Facge(v25.M, v26.M, v27.M), "facge v25." S ", v26." S ", v27." S); 3949 NEON_FORMAT_LIST_FP(DISASM_INST) 3950 #undef DISASM_INST 3951 3952 #define DISASM_INST(M, S) \ 3953 COMPARE(Facgt(v25.M, v26.M, v27.M), "facgt v25." S ", v26." S ", v27." S); 3954 NEON_FORMAT_LIST_FP(DISASM_INST) 3955 #undef DISASM_INST 3956 3957 CLEANUP(); 3958} 3959 3960 3961#define NEON_SCALAR_FORMAT_LIST(V) \ 3962 V(B(), "b") \ 3963 V(H(), "h") \ 3964 V(S(), "s") \ 3965 V(D(), "d") 3966 3967TEST(neon_scalar_3same) { 3968 SETUP_CLASS(MacroAssembler); 3969 3970 // Instructions that only support D-sized scalar operations. 3971 COMPARE(Add(v0.D(), v1.D(), v2.D()), "add d0, d1, d2"); 3972 COMPARE(Sub(v3.D(), v4.D(), v5.D()), "sub d3, d4, d5"); 3973 COMPARE(Cmeq(v0.D(), v1.D(), v2.D()), "cmeq d0, d1, d2"); 3974 COMPARE(Cmge(v3.D(), v4.D(), v5.D()), "cmge d3, d4, d5"); 3975 COMPARE(Cmgt(v6.D(), v7.D(), v8.D()), "cmgt d6, d7, d8"); 3976 COMPARE(Cmhi(v0.D(), v1.D(), v2.D()), "cmhi d0, d1, d2"); 3977 COMPARE(Cmhs(v3.D(), v4.D(), v5.D()), "cmhs d3, d4, d5"); 3978 COMPARE(Cmtst(v6.D(), v7.D(), v8.D()), "cmtst d6, d7, d8"); 3979 COMPARE(Ushl(v6.D(), v7.D(), v8.D()), "ushl d6, d7, d8"); 3980 COMPARE(Sshl(v6.D(), v7.D(), v8.D()), "sshl d6, d7, d8"); 3981 COMPARE(Urshl(v9.D(), v10.D(), v11.D()), "urshl d9, d10, d11"); 3982 COMPARE(Srshl(v9.D(), v10.D(), v11.D()), "srshl d9, d10, d11"); 3983 3984 // Instructions that support S and D-sized scalar operations. 3985 COMPARE(Frecps(v12.S(), v13.S(), v14.S()), "frecps s12, s13, s14"); 3986 COMPARE(Frecps(v15.D(), v16.D(), v17.D()), "frecps d15, d16, d17"); 3987 COMPARE(Frsqrts(v18.S(), v19.S(), v20.S()), "frsqrts s18, s19, s20"); 3988 COMPARE(Frsqrts(v21.D(), v22.D(), v23.D()), "frsqrts d21, d22, d23"); 3989 COMPARE(Fmulx(v12.S(), v13.S(), v14.S()), "fmulx s12, s13, s14"); 3990 COMPARE(Fmulx(v15.D(), v16.D(), v17.D()), "fmulx d15, d16, d17"); 3991 COMPARE(Fcmeq(v12.S(), v13.S(), v14.S()), "fcmeq s12, s13, s14"); 3992 COMPARE(Fcmeq(v15.D(), v16.D(), v17.D()), "fcmeq d15, d16, d17"); 3993 COMPARE(Fcmge(v12.S(), v13.S(), v14.S()), "fcmge s12, s13, s14"); 3994 COMPARE(Fcmge(v15.D(), v16.D(), v17.D()), "fcmge d15, d16, d17"); 3995 COMPARE(Fcmgt(v12.S(), v13.S(), v14.S()), "fcmgt s12, s13, s14"); 3996 COMPARE(Fcmgt(v15.D(), v16.D(), v17.D()), "fcmgt d15, d16, d17"); 3997 COMPARE(Fcmge(v12.S(), v13.S(), v14.S()), "fcmge s12, s13, s14"); 3998 COMPARE(Fcmge(v15.D(), v16.D(), v17.D()), "fcmge d15, d16, d17"); 3999 COMPARE(Facgt(v12.S(), v13.S(), v14.S()), "facgt s12, s13, s14"); 4000 COMPARE(Facgt(v15.D(), v16.D(), v17.D()), "facgt d15, d16, d17"); 4001 4002 // Instructions that support H and S-sized scalar operations. 4003 COMPARE(Sqdmulh(v12.S(), v13.S(), v14.S()), "sqdmulh s12, s13, s14"); 4004 COMPARE(Sqdmulh(v15.H(), v16.H(), v17.H()), "sqdmulh h15, h16, h17"); 4005 COMPARE(Sqrdmulh(v12.S(), v13.S(), v14.S()), "sqrdmulh s12, s13, s14"); 4006 COMPARE(Sqrdmulh(v15.H(), v16.H(), v17.H()), "sqrdmulh h15, h16, h17"); 4007 4008 #define DISASM_INST(M, R) \ 4009 COMPARE(Uqadd(v6.M, v7.M, v8.M), "uqadd " R "6, " R "7, " R "8"); 4010 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4011 #undef DISASM_INST 4012 4013 #define DISASM_INST(M, R) \ 4014 COMPARE(Uqsub(v9.M, v10.M, v11.M), "uqsub " R "9, " R "10, " R "11"); 4015 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4016 #undef DISASM_INST 4017 4018 #define DISASM_INST(M, R) \ 4019 COMPARE(Sqadd(v12.M, v13.M, v14.M), "sqadd " R "12, " R "13, " R "14"); 4020 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4021 #undef DISASM_INST 4022 4023 #define DISASM_INST(M, R) \ 4024 COMPARE(Sqsub(v15.M, v16.M, v17.M), "sqsub " R "15, " R "16, " R "17"); 4025 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4026 #undef DISASM_INST 4027 4028 #define DISASM_INST(M, R) \ 4029 COMPARE(Uqshl(v18.M, v19.M, v20.M), "uqshl " R "18, " R "19, " R "20"); 4030 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4031 #undef DISASM_INST 4032 4033 #define DISASM_INST(M, R) \ 4034 COMPARE(Sqshl(v21.M, v22.M, v23.M), "sqshl " R "21, " R "22, " R "23"); 4035 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4036 #undef DISASM_INST 4037 4038 #define DISASM_INST(M, R) \ 4039 COMPARE(Uqrshl(v30.M, v31.M, v0.M), "uqrshl " R "30, " R "31, " R "0"); 4040 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4041 #undef DISASM_INST 4042 4043 #define DISASM_INST(M, R) \ 4044 COMPARE(Sqrshl(v1.M, v2.M, v3.M), "sqrshl " R "1, " R "2, " R "3"); 4045 NEON_SCALAR_FORMAT_LIST(DISASM_INST) 4046 #undef DISASM_INST 4047 4048 CLEANUP(); 4049} 4050 4051 4052TEST(neon_byelement) { 4053 SETUP_CLASS(MacroAssembler); 4054 4055 COMPARE(Mul(v0.V4H(), v1.V4H(), v2.H(), 0), "mul v0.4h, v1.4h, v2.h[0]"); 4056 COMPARE(Mul(v2.V8H(), v3.V8H(), v15.H(), 7), "mul v2.8h, v3.8h, v15.h[7]"); 4057 COMPARE(Mul(v0.V2S(), v1.V2S(), v2.S(), 0), "mul v0.2s, v1.2s, v2.s[0]"); 4058 COMPARE(Mul(v2.V4S(), v3.V4S(), v15.S(), 3), "mul v2.4s, v3.4s, v15.s[3]"); 4059 4060 COMPARE(Mla(v0.V4H(), v1.V4H(), v2.H(), 0), "mla v0.4h, v1.4h, v2.h[0]"); 4061 COMPARE(Mla(v2.V8H(), v3.V8H(), v15.H(), 7), "mla v2.8h, v3.8h, v15.h[7]"); 4062 COMPARE(Mla(v0.V2S(), v1.V2S(), v2.S(), 0), "mla v0.2s, v1.2s, v2.s[0]"); 4063 COMPARE(Mla(v2.V4S(), v3.V4S(), v15.S(), 3), "mla v2.4s, v3.4s, v15.s[3]"); 4064 4065 COMPARE(Mls(v0.V4H(), v1.V4H(), v2.H(), 0), "mls v0.4h, v1.4h, v2.h[0]"); 4066 COMPARE(Mls(v2.V8H(), v3.V8H(), v15.H(), 7), "mls v2.8h, v3.8h, v15.h[7]"); 4067 COMPARE(Mls(v0.V2S(), v1.V2S(), v2.S(), 0), "mls v0.2s, v1.2s, v2.s[0]"); 4068 COMPARE(Mls(v2.V4S(), v3.V4S(), v15.S(), 3), "mls v2.4s, v3.4s, v15.s[3]"); 4069 4070 COMPARE(Sqdmulh(v0.V4H(), v1.V4H(), v2.H(), 0), 4071 "sqdmulh v0.4h, v1.4h, v2.h[0]"); 4072 COMPARE(Sqdmulh(v2.V8H(), v3.V8H(), v15.H(), 7), 4073 "sqdmulh v2.8h, v3.8h, v15.h[7]"); 4074 COMPARE(Sqdmulh(v0.V2S(), v1.V2S(), v2.S(), 0), 4075 "sqdmulh v0.2s, v1.2s, v2.s[0]"); 4076 COMPARE(Sqdmulh(v2.V4S(), v3.V4S(), v15.S(), 3), 4077 "sqdmulh v2.4s, v3.4s, v15.s[3]"); 4078 COMPARE(Sqdmulh(h0, h1, v2.H(), 0), "sqdmulh h0, h1, v2.h[0]"); 4079 COMPARE(Sqdmulh(s0, s1, v2.S(), 0), "sqdmulh s0, s1, v2.s[0]"); 4080 4081 COMPARE(Sqrdmulh(v0.V4H(), v1.V4H(), v2.H(), 0), 4082 "sqrdmulh v0.4h, v1.4h, v2.h[0]"); 4083 COMPARE(Sqrdmulh(v2.V8H(), v3.V8H(), v15.H(), 7), 4084 "sqrdmulh v2.8h, v3.8h, v15.h[7]"); 4085 COMPARE(Sqrdmulh(v0.V2S(), v1.V2S(), v2.S(), 0), 4086 "sqrdmulh v0.2s, v1.2s, v2.s[0]"); 4087 COMPARE(Sqrdmulh(v2.V4S(), v3.V4S(), v15.S(), 3), 4088 "sqrdmulh v2.4s, v3.4s, v15.s[3]"); 4089 COMPARE(Sqrdmulh(h0, h1, v2.H(), 0), "sqrdmulh h0, h1, v2.h[0]"); 4090 COMPARE(Sqrdmulh(s0, s1, v2.S(), 0), "sqrdmulh s0, s1, v2.s[0]"); 4091 4092 COMPARE(Smull(v0.V4S(), v1.V4H(), v2.H(), 0), "smull v0.4s, v1.4h, v2.h[0]"); 4093 COMPARE(Smull2(v2.V4S(), v3.V8H(), v4.H(), 7), 4094 "smull2 v2.4s, v3.8h, v4.h[7]"); 4095 COMPARE(Smull(v0.V2D(), v1.V2S(), v2.S(), 0), "smull v0.2d, v1.2s, v2.s[0]"); 4096 COMPARE(Smull2(v2.V2D(), v3.V4S(), v4.S(), 3), 4097 "smull2 v2.2d, v3.4s, v4.s[3]"); 4098 4099 COMPARE(Umull(v0.V4S(), v1.V4H(), v2.H(), 0), "umull v0.4s, v1.4h, v2.h[0]"); 4100 COMPARE(Umull2(v2.V4S(), v3.V8H(), v4.H(), 7), 4101 "umull2 v2.4s, v3.8h, v4.h[7]"); 4102 COMPARE(Umull(v0.V2D(), v1.V2S(), v2.S(), 0), "umull v0.2d, v1.2s, v2.s[0]"); 4103 COMPARE(Umull2(v2.V2D(), v3.V4S(), v4.S(), 3), 4104 "umull2 v2.2d, v3.4s, v4.s[3]"); 4105 4106 COMPARE(Smlal(v0.V4S(), v1.V4H(), v2.H(), 0), "smlal v0.4s, v1.4h, v2.h[0]"); 4107 COMPARE(Smlal2(v2.V4S(), v3.V8H(), v4.H(), 7), 4108 "smlal2 v2.4s, v3.8h, v4.h[7]"); 4109 COMPARE(Smlal(v0.V2D(), v1.V2S(), v2.S(), 0), "smlal v0.2d, v1.2s, v2.s[0]"); 4110 COMPARE(Smlal2(v2.V2D(), v3.V4S(), v4.S(), 3), 4111 "smlal2 v2.2d, v3.4s, v4.s[3]"); 4112 4113 COMPARE(Umlal(v0.V4S(), v1.V4H(), v2.H(), 0), "umlal v0.4s, v1.4h, v2.h[0]"); 4114 COMPARE(Umlal2(v2.V4S(), v3.V8H(), v4.H(), 7), 4115 "umlal2 v2.4s, v3.8h, v4.h[7]"); 4116 COMPARE(Umlal(v0.V2D(), v1.V2S(), v2.S(), 0), "umlal v0.2d, v1.2s, v2.s[0]"); 4117 COMPARE(Umlal2(v2.V2D(), v3.V4S(), v4.S(), 3), 4118 "umlal2 v2.2d, v3.4s, v4.s[3]"); 4119 4120 COMPARE(Smlsl(v0.V4S(), v1.V4H(), v2.H(), 0), "smlsl v0.4s, v1.4h, v2.h[0]"); 4121 COMPARE(Smlsl2(v2.V4S(), v3.V8H(), v4.H(), 7), 4122 "smlsl2 v2.4s, v3.8h, v4.h[7]"); 4123 COMPARE(Smlsl(v0.V2D(), v1.V2S(), v2.S(), 0), "smlsl v0.2d, v1.2s, v2.s[0]"); 4124 COMPARE(Smlsl2(v2.V2D(), v3.V4S(), v4.S(), 3), 4125 "smlsl2 v2.2d, v3.4s, v4.s[3]"); 4126 4127 COMPARE(Umlsl(v0.V4S(), v1.V4H(), v2.H(), 0), "umlsl v0.4s, v1.4h, v2.h[0]"); 4128 COMPARE(Umlsl2(v2.V4S(), v3.V8H(), v4.H(), 7), 4129 "umlsl2 v2.4s, v3.8h, v4.h[7]"); 4130 COMPARE(Umlsl(v0.V2D(), v1.V2S(), v2.S(), 0), "umlsl v0.2d, v1.2s, v2.s[0]"); 4131 COMPARE(Umlsl2(v2.V2D(), v3.V4S(), v4.S(), 3), 4132 "umlsl2 v2.2d, v3.4s, v4.s[3]"); 4133 4134 COMPARE(Sqdmull(v0.V4S(), v1.V4H(), v2.H(), 0), 4135 "sqdmull v0.4s, v1.4h, v2.h[0]"); 4136 COMPARE(Sqdmull2(v2.V4S(), v3.V8H(), v4.H(), 7), 4137 "sqdmull2 v2.4s, v3.8h, v4.h[7]"); 4138 COMPARE(Sqdmull(v0.V2D(), v1.V2S(), v2.S(), 0), 4139 "sqdmull v0.2d, v1.2s, v2.s[0]"); 4140 COMPARE(Sqdmull2(v2.V2D(), v3.V4S(), v4.S(), 3), 4141 "sqdmull2 v2.2d, v3.4s, v4.s[3]"); 4142 COMPARE(Sqdmull(s0, h1, v2.H(), 0), "sqdmull s0, h1, v2.h[0]"); 4143 COMPARE(Sqdmull(d0, s1, v2.S(), 0), "sqdmull d0, s1, v2.s[0]"); 4144 4145 COMPARE(Sqdmlal(v0.V4S(), v1.V4H(), v2.H(), 0), 4146 "sqdmlal v0.4s, v1.4h, v2.h[0]"); 4147 COMPARE(Sqdmlal2(v2.V4S(), v3.V8H(), v4.H(), 7), 4148 "sqdmlal2 v2.4s, v3.8h, v4.h[7]"); 4149 COMPARE(Sqdmlal(v0.V2D(), v1.V2S(), v2.S(), 0), 4150 "sqdmlal v0.2d, v1.2s, v2.s[0]"); 4151 COMPARE(Sqdmlal2(v2.V2D(), v3.V4S(), v4.S(), 3), 4152 "sqdmlal2 v2.2d, v3.4s, v4.s[3]"); 4153 COMPARE(Sqdmlal(s0, h1, v2.H(), 0), "sqdmlal s0, h1, v2.h[0]"); 4154 COMPARE(Sqdmlal(d0, s1, v2.S(), 0), "sqdmlal d0, s1, v2.s[0]"); 4155 4156 COMPARE(Sqdmlsl(v0.V4S(), v1.V4H(), v2.H(), 0), 4157 "sqdmlsl v0.4s, v1.4h, v2.h[0]"); 4158 COMPARE(Sqdmlsl2(v2.V4S(), v3.V8H(), v4.H(), 7), 4159 "sqdmlsl2 v2.4s, v3.8h, v4.h[7]"); 4160 COMPARE(Sqdmlsl(v0.V2D(), v1.V2S(), v2.S(), 0), 4161 "sqdmlsl v0.2d, v1.2s, v2.s[0]"); 4162 COMPARE(Sqdmlsl2(v2.V2D(), v3.V4S(), v4.S(), 3), 4163 "sqdmlsl2 v2.2d, v3.4s, v4.s[3]"); 4164 COMPARE(Sqdmlsl(s0, h1, v2.H(), 0), "sqdmlsl s0, h1, v2.h[0]"); 4165 COMPARE(Sqdmlsl(d0, s1, v2.S(), 0), "sqdmlsl d0, s1, v2.s[0]"); 4166 4167 CLEANUP(); 4168} 4169 4170 4171TEST(neon_fp_byelement) { 4172 SETUP_CLASS(MacroAssembler); 4173 4174 COMPARE(Fmul(v0.V2S(), v1.V2S(), v2.S(), 0), "fmul v0.2s, v1.2s, v2.s[0]"); 4175 COMPARE(Fmul(v2.V4S(), v3.V4S(), v15.S(), 3), "fmul v2.4s, v3.4s, v15.s[3]"); 4176 COMPARE(Fmul(v0.V2D(), v1.V2D(), v2.D(), 0), "fmul v0.2d, v1.2d, v2.d[0]"); 4177 COMPARE(Fmul(d0, d1, v2.D(), 0), "fmul d0, d1, v2.d[0]"); 4178 COMPARE(Fmul(s0, s1, v2.S(), 0), "fmul s0, s1, v2.s[0]"); 4179 4180 COMPARE(Fmla(v0.V2S(), v1.V2S(), v2.S(), 0), "fmla v0.2s, v1.2s, v2.s[0]"); 4181 COMPARE(Fmla(v2.V4S(), v3.V4S(), v15.S(), 3), "fmla v2.4s, v3.4s, v15.s[3]"); 4182 COMPARE(Fmla(v0.V2D(), v1.V2D(), v2.D(), 0), "fmla v0.2d, v1.2d, v2.d[0]"); 4183 COMPARE(Fmla(d0, d1, v2.D(), 0), "fmla d0, d1, v2.d[0]"); 4184 COMPARE(Fmla(s0, s1, v2.S(), 0), "fmla s0, s1, v2.s[0]"); 4185 4186 COMPARE(Fmls(v0.V2S(), v1.V2S(), v2.S(), 0), "fmls v0.2s, v1.2s, v2.s[0]"); 4187 COMPARE(Fmls(v2.V4S(), v3.V4S(), v15.S(), 3), "fmls v2.4s, v3.4s, v15.s[3]"); 4188 COMPARE(Fmls(v0.V2D(), v1.V2D(), v2.D(), 0), "fmls v0.2d, v1.2d, v2.d[0]"); 4189 COMPARE(Fmls(d0, d1, v2.D(), 0), "fmls d0, d1, v2.d[0]"); 4190 COMPARE(Fmls(s0, s1, v2.S(), 0), "fmls s0, s1, v2.s[0]"); 4191 4192 COMPARE(Fmulx(v0.V2S(), v1.V2S(), v2.S(), 0), "fmulx v0.2s, v1.2s, v2.s[0]"); 4193 COMPARE(Fmulx(v2.V4S(), v3.V4S(), v8.S(), 3), "fmulx v2.4s, v3.4s, v8.s[3]"); 4194 COMPARE(Fmulx(v0.V2D(), v1.V2D(), v2.D(), 0), "fmulx v0.2d, v1.2d, v2.d[0]"); 4195 COMPARE(Fmulx(d0, d1, v2.D(), 0), "fmulx d0, d1, v2.d[0]"); 4196 COMPARE(Fmulx(s0, s1, v2.S(), 0), "fmulx s0, s1, v2.s[0]"); 4197 4198 CLEANUP(); 4199} 4200 4201 4202TEST(neon_3different) { 4203 SETUP_CLASS(MacroAssembler); 4204 4205 #define DISASM_INST(TA, TAS, TB, TBS) \ 4206 COMPARE(Uaddl(v0.TA, v1.TB, v2.TB), "uaddl v0." TAS ", v1." TBS ", v2." TBS); 4207 NEON_FORMAT_LIST_LW(DISASM_INST) 4208 #undef DISASM_INST 4209 4210 #define DISASM_INST(TA, TAS, TB, TBS) \ 4211 COMPARE(Uaddl2(v0.TA, v1.TB, v2.TB), \ 4212 "uaddl2 v0." TAS ", v1." TBS ", v2." TBS); 4213 NEON_FORMAT_LIST_LW2(DISASM_INST) 4214 #undef DISASM_INST 4215 4216 #define DISASM_INST(TA, TAS, TB, TBS) \ 4217 COMPARE(Uaddw(v0.TA, v1.TA, v2.TB), "uaddw v0." TAS ", v1." TAS ", v2." TBS); 4218 NEON_FORMAT_LIST_LW(DISASM_INST) 4219 #undef DISASM_INST 4220 4221 #define DISASM_INST(TA, TAS, TB, TBS) \ 4222 COMPARE(Uaddw2(v0.TA, v1.TA, v2.TB), \ 4223 "uaddw2 v0." TAS ", v1." TAS ", v2." TBS); 4224 NEON_FORMAT_LIST_LW2(DISASM_INST) 4225 #undef DISASM_INST 4226 4227 #define DISASM_INST(TA, TAS, TB, TBS) \ 4228 COMPARE(Saddl(v0.TA, v1.TB, v2.TB), "saddl v0." TAS ", v1." TBS ", v2." TBS); 4229 NEON_FORMAT_LIST_LW(DISASM_INST) 4230 #undef DISASM_INST 4231 4232 #define DISASM_INST(TA, TAS, TB, TBS) \ 4233 COMPARE(Saddl2(v0.TA, v1.TB, v2.TB), \ 4234 "saddl2 v0." TAS ", v1." TBS ", v2." TBS); 4235 NEON_FORMAT_LIST_LW2(DISASM_INST) 4236 #undef DISASM_INST 4237 4238 #define DISASM_INST(TA, TAS, TB, TBS) \ 4239 COMPARE(Saddw(v0.TA, v1.TA, v2.TB), "saddw v0." TAS ", v1." TAS ", v2." TBS); 4240 NEON_FORMAT_LIST_LW(DISASM_INST) 4241 #undef DISASM_INST 4242 4243 #define DISASM_INST(TA, TAS, TB, TBS) \ 4244 COMPARE(Saddw2(v0.TA, v1.TA, v2.TB), \ 4245 "saddw2 v0." TAS ", v1." TAS ", v2." TBS); 4246 NEON_FORMAT_LIST_LW2(DISASM_INST) 4247 #undef DISASM_INST 4248 4249 #define DISASM_INST(TA, TAS, TB, TBS) \ 4250 COMPARE(Usubl(v0.TA, v1.TB, v2.TB), "usubl v0." TAS ", v1." TBS ", v2." TBS); 4251 NEON_FORMAT_LIST_LW(DISASM_INST) 4252 #undef DISASM_INST 4253 4254 #define DISASM_INST(TA, TAS, TB, TBS) \ 4255 COMPARE(Usubl2(v0.TA, v1.TB, v2.TB), \ 4256 "usubl2 v0." TAS ", v1." TBS ", v2." TBS); 4257 NEON_FORMAT_LIST_LW2(DISASM_INST) 4258 #undef DISASM_INST 4259 4260 #define DISASM_INST(TA, TAS, TB, TBS) \ 4261 COMPARE(Usubw(v0.TA, v1.TA, v2.TB), "usubw v0." TAS ", v1." TAS ", v2." TBS); 4262 NEON_FORMAT_LIST_LW(DISASM_INST) 4263 #undef DISASM_INST 4264 4265 #define DISASM_INST(TA, TAS, TB, TBS) \ 4266 COMPARE(Usubw2(v0.TA, v1.TA, v2.TB), \ 4267 "usubw2 v0." TAS ", v1." TAS ", v2." TBS); 4268 NEON_FORMAT_LIST_LW2(DISASM_INST) 4269 #undef DISASM_INST 4270 4271 #define DISASM_INST(TA, TAS, TB, TBS) \ 4272 COMPARE(Ssubl(v0.TA, v1.TB, v2.TB), "ssubl v0." TAS ", v1." TBS ", v2." TBS); 4273 NEON_FORMAT_LIST_LW(DISASM_INST) 4274 #undef DISASM_INST 4275 4276 #define DISASM_INST(TA, TAS, TB, TBS) \ 4277 COMPARE(Ssubl2(v0.TA, v1.TB, v2.TB), \ 4278 "ssubl2 v0." TAS ", v1." TBS ", v2." TBS); 4279 NEON_FORMAT_LIST_LW2(DISASM_INST) 4280 #undef DISASM_INST 4281 4282 #define DISASM_INST(TA, TAS, TB, TBS) \ 4283 COMPARE(Ssubw(v0.TA, v1.TA, v2.TB), "ssubw v0." TAS ", v1." TAS ", v2." TBS); 4284 NEON_FORMAT_LIST_LW(DISASM_INST) 4285 #undef DISASM_INST 4286 4287 #define DISASM_INST(TA, TAS, TB, TBS) \ 4288 COMPARE(Ssubw2(v0.TA, v1.TA, v2.TB), \ 4289 "ssubw2 v0." TAS ", v1." TAS ", v2." TBS); 4290 NEON_FORMAT_LIST_LW2(DISASM_INST) 4291 #undef DISASM_INST 4292 4293 #define DISASM_INST(TA, TAS, TB, TBS) \ 4294 COMPARE(Sabal(v0.TA, v1.TB, v2.TB), "sabal v0." TAS ", v1." TBS ", v2." TBS); 4295 NEON_FORMAT_LIST_LW(DISASM_INST) 4296 #undef DISASM_INST 4297 4298 #define DISASM_INST(TA, TAS, TB, TBS) \ 4299 COMPARE(Sabal2(v0.TA, v1.TB, v2.TB), \ 4300 "sabal2 v0." TAS ", v1." TBS ", v2." TBS); 4301 NEON_FORMAT_LIST_LW2(DISASM_INST) 4302 #undef DISASM_INST 4303 4304 #define DISASM_INST(TA, TAS, TB, TBS) \ 4305 COMPARE(Uabal(v0.TA, v1.TB, v2.TB), "uabal v0." TAS ", v1." TBS ", v2." TBS); 4306 NEON_FORMAT_LIST_LW(DISASM_INST) 4307 #undef DISASM_INST 4308 4309 #define DISASM_INST(TA, TAS, TB, TBS) \ 4310 COMPARE(Uabal2(v0.TA, v1.TB, v2.TB), \ 4311 "uabal2 v0." TAS ", v1." TBS ", v2." TBS); 4312 NEON_FORMAT_LIST_LW2(DISASM_INST) 4313 #undef DISASM_INST 4314 4315 #define DISASM_INST(TA, TAS, TB, TBS) \ 4316 COMPARE(Sabdl(v0.TA, v1.TB, v2.TB), "sabdl v0." TAS ", v1." TBS ", v2." TBS); 4317 NEON_FORMAT_LIST_LW(DISASM_INST) 4318 #undef DISASM_INST 4319 4320 #define DISASM_INST(TA, TAS, TB, TBS) \ 4321 COMPARE(Sabdl2(v0.TA, v1.TB, v2.TB), \ 4322 "sabdl2 v0." TAS ", v1." TBS ", v2." TBS); 4323 NEON_FORMAT_LIST_LW2(DISASM_INST) 4324 #undef DISASM_INST 4325 4326 #define DISASM_INST(TA, TAS, TB, TBS) \ 4327 COMPARE(Uabdl(v0.TA, v1.TB, v2.TB), "uabdl v0." TAS ", v1." TBS ", v2." TBS); 4328 NEON_FORMAT_LIST_LW(DISASM_INST) 4329 #undef DISASM_INST 4330 4331 #define DISASM_INST(TA, TAS, TB, TBS) \ 4332 COMPARE(Uabdl2(v0.TA, v1.TB, v2.TB), \ 4333 "uabdl2 v0." TAS ", v1." TBS ", v2." TBS); 4334 NEON_FORMAT_LIST_LW2(DISASM_INST) 4335 #undef DISASM_INST 4336 4337 #define DISASM_INST(TA, TAS, TB, TBS) \ 4338 COMPARE(Smlal(v0.TA, v1.TB, v2.TB), "smlal v0." TAS ", v1." TBS ", v2." TBS); 4339 NEON_FORMAT_LIST_LW(DISASM_INST) 4340 #undef DISASM_INST 4341 4342 #define DISASM_INST(TA, TAS, TB, TBS) \ 4343 COMPARE(Smlal2(v0.TA, v1.TB, v2.TB), \ 4344 "smlal2 v0." TAS ", v1." TBS ", v2." TBS); 4345 NEON_FORMAT_LIST_LW2(DISASM_INST) 4346 #undef DISASM_INST 4347 4348 #define DISASM_INST(TA, TAS, TB, TBS) \ 4349 COMPARE(Umlsl(v0.TA, v1.TB, v2.TB), "umlsl v0." TAS ", v1." TBS ", v2." TBS); 4350 NEON_FORMAT_LIST_LW(DISASM_INST) 4351 #undef DISASM_INST 4352 4353 #define DISASM_INST(TA, TAS, TB, TBS) \ 4354 COMPARE(Umlsl2(v0.TA, v1.TB, v2.TB), \ 4355 "umlsl2 v0." TAS ", v1." TBS ", v2." TBS); 4356 NEON_FORMAT_LIST_LW2(DISASM_INST) 4357 #undef DISASM_INST 4358 4359 #define DISASM_INST(TA, TAS, TB, TBS) \ 4360 COMPARE(Smlsl(v0.TA, v1.TB, v2.TB), "smlsl v0." TAS ", v1." TBS ", v2." TBS); 4361 NEON_FORMAT_LIST_LW(DISASM_INST) 4362 #undef DISASM_INST 4363 4364 #define DISASM_INST(TA, TAS, TB, TBS) \ 4365 COMPARE(Smlsl2(v0.TA, v1.TB, v2.TB), \ 4366 "smlsl2 v0." TAS ", v1." TBS ", v2." TBS); 4367 NEON_FORMAT_LIST_LW2(DISASM_INST) 4368 #undef DISASM_INST 4369 4370 #define DISASM_INST(TA, TAS, TB, TBS) \ 4371 COMPARE(Umlsl(v0.TA, v1.TB, v2.TB), "umlsl v0." TAS ", v1." TBS ", v2." TBS); 4372 NEON_FORMAT_LIST_LW(DISASM_INST) 4373 #undef DISASM_INST 4374 4375 #define DISASM_INST(TA, TAS, TB, TBS) \ 4376 COMPARE(Umlsl2(v0.TA, v1.TB, v2.TB), \ 4377 "umlsl2 v0." TAS ", v1." TBS ", v2." TBS); 4378 NEON_FORMAT_LIST_LW2(DISASM_INST) 4379 #undef DISASM_INST 4380 4381 #define DISASM_INST(TA, TAS, TB, TBS) \ 4382 COMPARE(Smull(v0.TA, v1.TB, v2.TB), "smull v0." TAS ", v1." TBS ", v2." TBS); 4383 NEON_FORMAT_LIST_LW(DISASM_INST) 4384 #undef DISASM_INST 4385 4386 #define DISASM_INST(TA, TAS, TB, TBS) \ 4387 COMPARE(Smull2(v0.TA, v1.TB, v2.TB), \ 4388 "smull2 v0." TAS ", v1." TBS ", v2." TBS); 4389 NEON_FORMAT_LIST_LW2(DISASM_INST) 4390 #undef DISASM_INST 4391 4392 #define DISASM_INST(TA, TAS, TB, TBS) \ 4393 COMPARE(Umull(v0.TA, v1.TB, v2.TB), "umull v0." TAS ", v1." TBS ", v2." TBS); 4394 NEON_FORMAT_LIST_LW(DISASM_INST) 4395 #undef DISASM_INST 4396 4397 #define DISASM_INST(TA, TAS, TB, TBS) \ 4398 COMPARE(Umull2(v0.TA, v1.TB, v2.TB), \ 4399 "umull2 v0." TAS ", v1." TBS ", v2." TBS); 4400 NEON_FORMAT_LIST_LW2(DISASM_INST) 4401 #undef DISASM_INST 4402 4403 COMPARE(Sqdmull(v0.V4S(), v1.V4H(), v2.V4H()), "sqdmull v0.4s, v1.4h, v2.4h"); 4404 COMPARE(Sqdmull(v1.V2D(), v2.V2S(), v3.V2S()), "sqdmull v1.2d, v2.2s, v3.2s"); 4405 COMPARE(Sqdmull2(v2.V4S(), v3.V8H(), v4.V8H()), 4406 "sqdmull2 v2.4s, v3.8h, v4.8h"); 4407 COMPARE(Sqdmull2(v3.V2D(), v4.V4S(), v5.V4S()), 4408 "sqdmull2 v3.2d, v4.4s, v5.4s"); 4409 COMPARE(Sqdmull(s0, h1, h2), "sqdmull s0, h1, h2"); 4410 COMPARE(Sqdmull(d1, s2, s3), "sqdmull d1, s2, s3"); 4411 4412 COMPARE(Sqdmlal(v0.V4S(), v1.V4H(), v2.V4H()), "sqdmlal v0.4s, v1.4h, v2.4h"); 4413 COMPARE(Sqdmlal(v1.V2D(), v2.V2S(), v3.V2S()), "sqdmlal v1.2d, v2.2s, v3.2s"); 4414 COMPARE(Sqdmlal2(v2.V4S(), v3.V8H(), v4.V8H()), 4415 "sqdmlal2 v2.4s, v3.8h, v4.8h"); 4416 COMPARE(Sqdmlal2(v3.V2D(), v4.V4S(), v5.V4S()), 4417 "sqdmlal2 v3.2d, v4.4s, v5.4s"); 4418 COMPARE(Sqdmlal(s0, h1, h2), "sqdmlal s0, h1, h2"); 4419 COMPARE(Sqdmlal(d1, s2, s3), "sqdmlal d1, s2, s3"); 4420 4421 COMPARE(Sqdmlsl(v0.V4S(), v1.V4H(), v2.V4H()), "sqdmlsl v0.4s, v1.4h, v2.4h"); 4422 COMPARE(Sqdmlsl(v1.V2D(), v2.V2S(), v3.V2S()), "sqdmlsl v1.2d, v2.2s, v3.2s"); 4423 COMPARE(Sqdmlsl2(v2.V4S(), v3.V8H(), v4.V8H()), 4424 "sqdmlsl2 v2.4s, v3.8h, v4.8h"); 4425 COMPARE(Sqdmlsl2(v3.V2D(), v4.V4S(), v5.V4S()), 4426 "sqdmlsl2 v3.2d, v4.4s, v5.4s"); 4427 COMPARE(Sqdmlsl(s0, h1, h2), "sqdmlsl s0, h1, h2"); 4428 COMPARE(Sqdmlsl(d1, s2, s3), "sqdmlsl d1, s2, s3"); 4429 4430 COMPARE(Addhn(v0.V8B(), v1.V8H(), v2.V8H()), "addhn v0.8b, v1.8h, v2.8h"); 4431 COMPARE(Addhn(v1.V4H(), v2.V4S(), v3.V4S()), "addhn v1.4h, v2.4s, v3.4s"); 4432 COMPARE(Addhn(v2.V2S(), v3.V2D(), v4.V2D()), "addhn v2.2s, v3.2d, v4.2d"); 4433 COMPARE(Addhn2(v0.V16B(), v1.V8H(), v5.V8H()), "addhn2 v0.16b, v1.8h, v5.8h"); 4434 COMPARE(Addhn2(v1.V8H(), v2.V4S(), v6.V4S()), "addhn2 v1.8h, v2.4s, v6.4s"); 4435 COMPARE(Addhn2(v2.V4S(), v3.V2D(), v7.V2D()), "addhn2 v2.4s, v3.2d, v7.2d"); 4436 4437 COMPARE(Raddhn(v0.V8B(), v1.V8H(), v2.V8H()), "raddhn v0.8b, v1.8h, v2.8h"); 4438 COMPARE(Raddhn(v1.V4H(), v2.V4S(), v3.V4S()), "raddhn v1.4h, v2.4s, v3.4s"); 4439 COMPARE(Raddhn(v2.V2S(), v3.V2D(), v4.V2D()), "raddhn v2.2s, v3.2d, v4.2d"); 4440 COMPARE(Raddhn2(v0.V16B(), v1.V8H(), v5.V8H()), 4441 "raddhn2 v0.16b, v1.8h, v5.8h"); 4442 COMPARE(Raddhn2(v1.V8H(), v2.V4S(), v6.V4S()), "raddhn2 v1.8h, v2.4s, v6.4s"); 4443 COMPARE(Raddhn2(v2.V4S(), v3.V2D(), v7.V2D()), "raddhn2 v2.4s, v3.2d, v7.2d"); 4444 4445 COMPARE(Subhn(v1.V4H(), v2.V4S(), v3.V4S()), "subhn v1.4h, v2.4s, v3.4s"); 4446 COMPARE(Subhn(v2.V2S(), v3.V2D(), v4.V2D()), "subhn v2.2s, v3.2d, v4.2d"); 4447 COMPARE(Subhn2(v0.V16B(), v1.V8H(), v5.V8H()), "subhn2 v0.16b, v1.8h, v5.8h"); 4448 COMPARE(Subhn2(v1.V8H(), v2.V4S(), v6.V4S()), "subhn2 v1.8h, v2.4s, v6.4s"); 4449 COMPARE(Subhn2(v2.V4S(), v3.V2D(), v7.V2D()), "subhn2 v2.4s, v3.2d, v7.2d"); 4450 4451 COMPARE(Rsubhn(v0.V8B(), v1.V8H(), v2.V8H()), "rsubhn v0.8b, v1.8h, v2.8h"); 4452 COMPARE(Rsubhn(v1.V4H(), v2.V4S(), v3.V4S()), "rsubhn v1.4h, v2.4s, v3.4s"); 4453 COMPARE(Rsubhn(v2.V2S(), v3.V2D(), v4.V2D()), "rsubhn v2.2s, v3.2d, v4.2d"); 4454 COMPARE(Rsubhn2(v0.V16B(), v1.V8H(), v5.V8H()), 4455 "rsubhn2 v0.16b, v1.8h, v5.8h"); 4456 COMPARE(Rsubhn2(v1.V8H(), v2.V4S(), v6.V4S()), "rsubhn2 v1.8h, v2.4s, v6.4s"); 4457 COMPARE(Rsubhn2(v2.V4S(), v3.V2D(), v7.V2D()), "rsubhn2 v2.4s, v3.2d, v7.2d"); 4458 4459 COMPARE(Pmull(v0.V8H(), v1.V8B(), v2.V8B()), "pmull v0.8h, v1.8b, v2.8b"); 4460 COMPARE(Pmull2(v2.V8H(), v3.V16B(), v4.V16B()), 4461 "pmull2 v2.8h, v3.16b, v4.16b"); 4462 4463 CLEANUP(); 4464} 4465 4466 4467TEST(neon_perm) { 4468 SETUP_CLASS(MacroAssembler); 4469 4470 #define DISASM_INST(M, S) \ 4471 COMPARE(Trn1(v0.M, v1.M, v2.M), "trn1 v0." S ", v1." S ", v2." S); 4472 NEON_FORMAT_LIST(DISASM_INST) 4473 #undef DISASM_INST 4474 4475 #define DISASM_INST(M, S) \ 4476 COMPARE(Trn2(v0.M, v1.M, v2.M), "trn2 v0." S ", v1." S ", v2." S); 4477 NEON_FORMAT_LIST(DISASM_INST) 4478 #undef DISASM_INST 4479 4480 #define DISASM_INST(M, S) \ 4481 COMPARE(Uzp1(v0.M, v1.M, v2.M), "uzp1 v0." S ", v1." S ", v2." S); 4482 NEON_FORMAT_LIST(DISASM_INST) 4483 #undef DISASM_INST 4484 4485 #define DISASM_INST(M, S) \ 4486 COMPARE(Uzp2(v0.M, v1.M, v2.M), "uzp2 v0." S ", v1." S ", v2." S); 4487 NEON_FORMAT_LIST(DISASM_INST) 4488 #undef DISASM_INST 4489 4490 #define DISASM_INST(M, S) \ 4491 COMPARE(Zip1(v0.M, v1.M, v2.M), "zip1 v0." S ", v1." S ", v2." S); 4492 NEON_FORMAT_LIST(DISASM_INST) 4493 #undef DISASM_INST 4494 4495 #define DISASM_INST(M, S) \ 4496 COMPARE(Zip2(v0.M, v1.M, v2.M), "zip2 v0." S ", v1." S ", v2." S); 4497 NEON_FORMAT_LIST(DISASM_INST) 4498 #undef DISASM_INST 4499 4500 CLEANUP(); 4501} 4502 4503 4504TEST(neon_copy) { 4505 SETUP_CLASS(MacroAssembler); 4506 4507 COMPARE(Ins(v1.V16B(), 4, v5.V16B(), 0), "mov v1.b[4], v5.b[0]"); 4508 COMPARE(Ins(v2.V8B(), 5, v6.V8B(), 1), "mov v2.b[5], v6.b[1]"); 4509 COMPARE(Ins(v3.B(), 6, v7.B(), 2), "mov v3.b[6], v7.b[2]"); 4510 COMPARE(Ins(v4.V8H(), 7, v8.V8H(), 3), "mov v4.h[7], v8.h[3]"); 4511 COMPARE(Ins(v5.V4H(), 3, v9.V4H(), 0), "mov v5.h[3], v9.h[0]"); 4512 COMPARE(Ins(v6.H(), 6, v1.H(), 1), "mov v6.h[6], v1.h[1]"); 4513 COMPARE(Ins(v7.V4S(), 2, v2.V4S(), 2), "mov v7.s[2], v2.s[2]"); 4514 COMPARE(Ins(v8.V2S(), 1, v3.V2S(), 0), "mov v8.s[1], v3.s[0]"); 4515 COMPARE(Ins(v9.S(), 0, v4.S(), 1), "mov v9.s[0], v4.s[1]"); 4516 COMPARE(Ins(v1.V2D(), 1, v5.V2D(), 0), "mov v1.d[1], v5.d[0]"); 4517 COMPARE(Ins(v2.D(), 0, v6.D(), 1), "mov v2.d[0], v6.d[1]"); 4518 4519 COMPARE(Mov(v3.V16B(), 4, v7.V16B(), 0), "mov v3.b[4], v7.b[0]"); 4520 COMPARE(Mov(v4.V8B(), 5, v8.V8B(), 1), "mov v4.b[5], v8.b[1]"); 4521 COMPARE(Mov(v5.B(), 6, v9.B(), 2), "mov v5.b[6], v9.b[2]"); 4522 COMPARE(Mov(v6.V8H(), 7, v1.V8H(), 3), "mov v6.h[7], v1.h[3]"); 4523 COMPARE(Mov(v7.V4H(), 0, v2.V4H(), 0), "mov v7.h[0], v2.h[0]"); 4524 COMPARE(Mov(v8.H(), 1, v3.H(), 1), "mov v8.h[1], v3.h[1]"); 4525 COMPARE(Mov(v9.V4S(), 2, v4.V4S(), 2), "mov v9.s[2], v4.s[2]"); 4526 COMPARE(Mov(v1.V2S(), 3, v5.V2S(), 0), "mov v1.s[3], v5.s[0]"); 4527 COMPARE(Mov(v2.S(), 0, v6.S(), 1), "mov v2.s[0], v6.s[1]"); 4528 COMPARE(Mov(v3.V2D(), 1, v7.V2D(), 0), "mov v3.d[1], v7.d[0]"); 4529 COMPARE(Mov(v4.D(), 0, v8.D(), 1), "mov v4.d[0], v8.d[1]"); 4530 4531 COMPARE(Ins(v1.V16B(), 4, w0), "mov v1.b[4], w0"); 4532 COMPARE(Ins(v2.V8B(), 5, w1), "mov v2.b[5], w1"); 4533 COMPARE(Ins(v3.B(), 6, w2), "mov v3.b[6], w2"); 4534 COMPARE(Ins(v4.V8H(), 7, w3), "mov v4.h[7], w3"); 4535 COMPARE(Ins(v5.V4H(), 3, w0), "mov v5.h[3], w0"); 4536 COMPARE(Ins(v6.H(), 6, w1), "mov v6.h[6], w1"); 4537 COMPARE(Ins(v7.V4S(), 2, w2), "mov v7.s[2], w2"); 4538 COMPARE(Ins(v8.V2S(), 1, w0), "mov v8.s[1], w0"); 4539 COMPARE(Ins(v9.S(), 0, w1), "mov v9.s[0], w1"); 4540 COMPARE(Ins(v1.V2D(), 1, x0), "mov v1.d[1], x0"); 4541 COMPARE(Ins(v2.D(), 0, x1), "mov v2.d[0], x1"); 4542 4543 COMPARE(Mov(v1.V16B(), 4, w0), "mov v1.b[4], w0"); 4544 COMPARE(Mov(v2.V8B(), 5, w1), "mov v2.b[5], w1"); 4545 COMPARE(Mov(v3.B(), 6, w2), "mov v3.b[6], w2"); 4546 COMPARE(Mov(v4.V8H(), 7, w3), "mov v4.h[7], w3"); 4547 COMPARE(Mov(v5.V4H(), 3, w0), "mov v5.h[3], w0"); 4548 COMPARE(Mov(v6.H(), 6, w1), "mov v6.h[6], w1"); 4549 COMPARE(Mov(v7.V4S(), 2, w2), "mov v7.s[2], w2"); 4550 COMPARE(Mov(v8.V2S(), 1, w0), "mov v8.s[1], w0"); 4551 COMPARE(Mov(v9.S(), 0, w1), "mov v9.s[0], w1"); 4552 COMPARE(Mov(v1.V2D(), 1, x0), "mov v1.d[1], x0"); 4553 COMPARE(Mov(v2.D(), 0, x1), "mov v2.d[0], x1"); 4554 4555 COMPARE(Dup(v5.V8B(), v9.V8B(), 6), "dup v5.8b, v9.b[6]"); 4556 COMPARE(Dup(v6.V16B(), v1.V16B(), 5), "dup v6.16b, v1.b[5]"); 4557 COMPARE(Dup(v7.V4H(), v2.V4H(), 4), "dup v7.4h, v2.h[4]"); 4558 COMPARE(Dup(v8.V8H(), v3.V8H(), 3), "dup v8.8h, v3.h[3]"); 4559 COMPARE(Dup(v9.V2S(), v4.V2S(), 2), "dup v9.2s, v4.s[2]"); 4560 COMPARE(Dup(v1.V4S(), v5.V4S(), 1), "dup v1.4s, v5.s[1]"); 4561 COMPARE(Dup(v2.V2D(), v6.V2D(), 0), "dup v2.2d, v6.d[0]"); 4562 4563 COMPARE(Dup(v5.B(), v9.B(), 6), "mov b5, v9.b[6]"); 4564 COMPARE(Dup(v7.H(), v2.H(), 4), "mov h7, v2.h[4]"); 4565 COMPARE(Dup(v9.S(), v4.S(), 2), "mov s9, v4.s[2]"); 4566 COMPARE(Dup(v2.D(), v6.D(), 0), "mov d2, v6.d[0]"); 4567 4568 COMPARE(Mov(v5.B(), v9.B(), 6), "mov b5, v9.b[6]"); 4569 COMPARE(Mov(v7.H(), v2.H(), 4), "mov h7, v2.h[4]"); 4570 COMPARE(Mov(v9.S(), v4.S(), 2), "mov s9, v4.s[2]"); 4571 COMPARE(Mov(v2.D(), v6.D(), 0), "mov d2, v6.d[0]"); 4572 4573 COMPARE(Dup(v5.V8B(), w0), "dup v5.8b, w0"); 4574 COMPARE(Dup(v6.V16B(), w1), "dup v6.16b, w1"); 4575 COMPARE(Dup(v7.V4H(), w2), "dup v7.4h, w2"); 4576 COMPARE(Dup(v8.V8H(), w3), "dup v8.8h, w3"); 4577 COMPARE(Dup(v9.V2S(), w4), "dup v9.2s, w4"); 4578 COMPARE(Dup(v1.V4S(), w5), "dup v1.4s, w5"); 4579 COMPARE(Dup(v2.V2D(), x6), "dup v2.2d, x6"); 4580 4581 COMPARE(Smov(w0, v1.V16B(), 4), "smov w0, v1.b[4]"); 4582 COMPARE(Smov(w1, v2.V8B(), 5), "smov w1, v2.b[5]"); 4583 COMPARE(Smov(w2, v3.B(), 6), "smov w2, v3.b[6]"); 4584 COMPARE(Smov(w3, v4.V8H(), 7), "smov w3, v4.h[7]"); 4585 COMPARE(Smov(w0, v5.V4H(), 3), "smov w0, v5.h[3]"); 4586 COMPARE(Smov(w1, v6.H(), 6), "smov w1, v6.h[6]"); 4587 4588 COMPARE(Smov(x0, v1.V16B(), 4), "smov x0, v1.b[4]"); 4589 COMPARE(Smov(x1, v2.V8B(), 5), "smov x1, v2.b[5]"); 4590 COMPARE(Smov(x2, v3.B(), 6), "smov x2, v3.b[6]"); 4591 COMPARE(Smov(x3, v4.V8H(), 7), "smov x3, v4.h[7]"); 4592 COMPARE(Smov(x0, v5.V4H(), 3), "smov x0, v5.h[3]"); 4593 COMPARE(Smov(x1, v6.H(), 6), "smov x1, v6.h[6]"); 4594 COMPARE(Smov(x2, v7.V4S(), 2), "smov x2, v7.s[2]"); 4595 COMPARE(Smov(x0, v8.V2S(), 1), "smov x0, v8.s[1]"); 4596 COMPARE(Smov(x1, v9.S(), 0), "smov x1, v9.s[0]"); 4597 4598 COMPARE(Umov(w0, v1.V16B(), 4), "umov w0, v1.b[4]"); 4599 COMPARE(Umov(w1, v2.V8B(), 5), "umov w1, v2.b[5]"); 4600 COMPARE(Umov(w2, v3.B(), 6), "umov w2, v3.b[6]"); 4601 COMPARE(Umov(w3, v4.V8H(), 7), "umov w3, v4.h[7]"); 4602 COMPARE(Umov(w0, v5.V4H(), 3), "umov w0, v5.h[3]"); 4603 COMPARE(Umov(w1, v6.H(), 6), "umov w1, v6.h[6]"); 4604 COMPARE(Umov(w2, v7.V4S(), 2), "mov w2, v7.s[2]"); 4605 COMPARE(Umov(w0, v8.V2S(), 1), "mov w0, v8.s[1]"); 4606 COMPARE(Umov(w1, v9.S(), 0), "mov w1, v9.s[0]"); 4607 COMPARE(Umov(x0, v1.V2D(), 1), "mov x0, v1.d[1]"); 4608 COMPARE(Umov(x1, v2.D(), 0), "mov x1, v2.d[0]"); 4609 4610 COMPARE(Mov(w2, v7.V4S(), 2), "mov w2, v7.s[2]"); 4611 COMPARE(Mov(w0, v8.V2S(), 1), "mov w0, v8.s[1]"); 4612 COMPARE(Mov(w1, v9.S(), 0), "mov w1, v9.s[0]"); 4613 COMPARE(Mov(x0, v1.V2D(), 1), "mov x0, v1.d[1]"); 4614 COMPARE(Mov(x1, v2.D(), 0), "mov x1, v2.d[0]"); 4615 4616 CLEANUP(); 4617} 4618 4619 4620TEST(neon_extract) { 4621 SETUP_CLASS(MacroAssembler); 4622 4623 COMPARE(Ext(v4.V8B(), v5.V8B(), v6.V8B(), 0), "ext v4.8b, v5.8b, v6.8b, #0"); 4624 COMPARE(Ext(v1.V8B(), v2.V8B(), v3.V8B(), 7), "ext v1.8b, v2.8b, v3.8b, #7"); 4625 COMPARE(Ext(v1.V16B(), v2.V16B(), v3.V16B(), 0), 4626 "ext v1.16b, v2.16b, v3.16b, #0"); 4627 COMPARE(Ext(v1.V16B(), v2.V16B(), v3.V16B(), 15), 4628 "ext v1.16b, v2.16b, v3.16b, #15"); 4629 4630 CLEANUP(); 4631} 4632 4633 4634TEST(neon_modimm) { 4635 SETUP_CLASS(MacroAssembler); 4636 4637 COMPARE(Orr(v4.V4H(), 0xaa, 0), "orr v4.4h, #0xaa, lsl #0"); 4638 COMPARE(Orr(v1.V8H(), 0xcc, 8), "orr v1.8h, #0xcc, lsl #8"); 4639 COMPARE(Orr(v4.V2S(), 0xaa, 0), "orr v4.2s, #0xaa, lsl #0"); 4640 COMPARE(Orr(v1.V2S(), 0xcc, 8), "orr v1.2s, #0xcc, lsl #8"); 4641 COMPARE(Orr(v4.V4S(), 0xaa, 16), "orr v4.4s, #0xaa, lsl #16"); 4642 COMPARE(Orr(v1.V4S(), 0xcc, 24), "orr v1.4s, #0xcc, lsl #24"); 4643 4644 COMPARE(Bic(v4.V4H(), 0xaa, 0), "bic v4.4h, #0xaa, lsl #0"); 4645 COMPARE(Bic(v1.V8H(), 0xcc, 8), "bic v1.8h, #0xcc, lsl #8"); 4646 COMPARE(Bic(v4.V2S(), 0xaa, 0), "bic v4.2s, #0xaa, lsl #0"); 4647 COMPARE(Bic(v1.V2S(), 0xcc, 8), "bic v1.2s, #0xcc, lsl #8"); 4648 COMPARE(Bic(v4.V4S(), 0xaa, 16), "bic v4.4s, #0xaa, lsl #16"); 4649 COMPARE(Bic(v1.V4S(), 0xcc, 24), "bic v1.4s, #0xcc, lsl #24"); 4650 4651 COMPARE(Mvni(v4.V4H(), 0xaa, LSL, 0), "mvni v4.4h, #0xaa, lsl #0"); 4652 COMPARE(Mvni(v1.V8H(), 0xcc, LSL, 8), "mvni v1.8h, #0xcc, lsl #8"); 4653 COMPARE(Mvni(v4.V2S(), 0xaa, LSL, 0), "mvni v4.2s, #0xaa, lsl #0"); 4654 COMPARE(Mvni(v1.V2S(), 0xcc, LSL, 8), "mvni v1.2s, #0xcc, lsl #8"); 4655 COMPARE(Mvni(v4.V4S(), 0xaa, LSL, 16), "mvni v4.4s, #0xaa, lsl #16"); 4656 COMPARE(Mvni(v1.V4S(), 0xcc, LSL, 24), "mvni v1.4s, #0xcc, lsl #24"); 4657 4658 COMPARE(Mvni(v4.V2S(), 0xaa, MSL, 8), "mvni v4.2s, #0xaa, msl #8"); 4659 COMPARE(Mvni(v1.V2S(), 0xcc, MSL, 16), "mvni v1.2s, #0xcc, msl #16"); 4660 COMPARE(Mvni(v4.V4S(), 0xaa, MSL, 8), "mvni v4.4s, #0xaa, msl #8"); 4661 COMPARE(Mvni(v1.V4S(), 0xcc, MSL, 16), "mvni v1.4s, #0xcc, msl #16"); 4662 4663 COMPARE(Movi(v4.V8B(), 0xaa), "movi v4.8b, #0xaa"); 4664 COMPARE(Movi(v1.V16B(), 0xcc), "movi v1.16b, #0xcc"); 4665 4666 COMPARE(Movi(v4.V4H(), 0xaa, LSL, 0), "movi v4.4h, #0xaa, lsl #0"); 4667 COMPARE(Movi(v1.V8H(), 0xcc, LSL, 8), "movi v1.8h, #0xcc, lsl #8"); 4668 4669 COMPARE(Movi(v4.V2S(), 0xaa, LSL, 0), "movi v4.2s, #0xaa, lsl #0"); 4670 COMPARE(Movi(v1.V2S(), 0xcc, LSL, 8), "movi v1.2s, #0xcc, lsl #8"); 4671 COMPARE(Movi(v4.V4S(), 0xaa, LSL, 16), "movi v4.4s, #0xaa, lsl #16"); 4672 COMPARE(Movi(v1.V4S(), 0xcc, LSL, 24), "movi v1.4s, #0xcc, lsl #24"); 4673 4674 COMPARE(Movi(v4.V2S(), 0xaa, MSL, 8), "movi v4.2s, #0xaa, msl #8"); 4675 COMPARE(Movi(v1.V2S(), 0xcc, MSL, 16), "movi v1.2s, #0xcc, msl #16"); 4676 COMPARE(Movi(v4.V4S(), 0xaa, MSL, 8), "movi v4.4s, #0xaa, msl #8"); 4677 COMPARE(Movi(v1.V4S(), 0xcc, MSL, 16), "movi v1.4s, #0xcc, msl #16"); 4678 4679 COMPARE(Movi(d2, 0xffff0000ffffff), "movi d2, #0xffff0000ffffff"); 4680 COMPARE(Movi(v1.V2D(), 0xffff0000ffffff), "movi v1.2d, #0xffff0000ffffff"); 4681 4682 COMPARE(Fmov(v0.V2S(), 1.0f), "fmov v0.2s, #0x70 (1.0000)"); 4683 COMPARE(Fmov(v31.V2S(), -13.0f), "fmov v31.2s, #0xaa (-13.0000)"); 4684 COMPARE(Fmov(v0.V4S(), 1.0f), "fmov v0.4s, #0x70 (1.0000)"); 4685 COMPARE(Fmov(v31.V4S(), -13.0f), "fmov v31.4s, #0xaa (-13.0000)"); 4686 COMPARE(Fmov(v1.V2D(), 1.0), "fmov v1.2d, #0x70 (1.0000)"); 4687 COMPARE(Fmov(v29.V2D(), -13.0), "fmov v29.2d, #0xaa (-13.0000)"); 4688 4689 CLEANUP(); 4690} 4691 4692 4693TEST(neon_2regmisc) { 4694 SETUP_CLASS(MacroAssembler); 4695 4696 COMPARE(Shll(v1.V8H(), v8.V8B(), 8), "shll v1.8h, v8.8b, #8"); 4697 COMPARE(Shll(v3.V4S(), v1.V4H(), 16), "shll v3.4s, v1.4h, #16"); 4698 COMPARE(Shll(v5.V2D(), v3.V2S(), 32), "shll v5.2d, v3.2s, #32"); 4699 COMPARE(Shll2(v2.V8H(), v9.V16B(), 8), "shll2 v2.8h, v9.16b, #8"); 4700 COMPARE(Shll2(v4.V4S(), v2.V8H(), 16), "shll2 v4.4s, v2.8h, #16"); 4701 COMPARE(Shll2(v6.V2D(), v4.V4S(), 32), "shll2 v6.2d, v4.4s, #32"); 4702 4703 #define DISASM_INST(M, S) \ 4704 COMPARE(Cmeq(v0.M, v1.M, 0), "cmeq v0." S ", v1." S ", #0"); 4705 NEON_FORMAT_LIST(DISASM_INST) 4706 #undef DISASM_INST 4707 4708 #define DISASM_INST(M, S) \ 4709 COMPARE(Cmge(v0.M, v1.M, 0), "cmge v0." S ", v1." S ", #0"); 4710 NEON_FORMAT_LIST(DISASM_INST) 4711 #undef DISASM_INST 4712 4713 #define DISASM_INST(M, S) \ 4714 COMPARE(Cmgt(v0.M, v1.M, 0), "cmgt v0." S ", v1." S ", #0"); 4715 NEON_FORMAT_LIST(DISASM_INST) 4716 #undef DISASM_INST 4717 4718 #define DISASM_INST(M, S) \ 4719 COMPARE(Cmle(v0.M, v1.M, 0), "cmle v0." S ", v1." S ", #0"); 4720 NEON_FORMAT_LIST(DISASM_INST) 4721 #undef DISASM_INST 4722 4723 #define DISASM_INST(M, S) \ 4724 COMPARE(Cmlt(v0.M, v1.M, 0), "cmlt v0." S ", v1." S ", #0"); 4725 NEON_FORMAT_LIST(DISASM_INST) 4726 #undef DISASM_INST 4727 4728 COMPARE(Cmeq(v0.D(), v1.D(), 0), "cmeq d0, d1, #0"); 4729 COMPARE(Cmge(v3.D(), v4.D(), 0), "cmge d3, d4, #0"); 4730 COMPARE(Cmgt(v6.D(), v7.D(), 0), "cmgt d6, d7, #0"); 4731 COMPARE(Cmle(v0.D(), v1.D(), 0), "cmle d0, d1, #0"); 4732 COMPARE(Cmlt(v3.D(), v4.D(), 0), "cmlt d3, d4, #0"); 4733 4734 #define DISASM_INST(M, S) \ 4735 COMPARE(Fcmeq(v0.M, v1.M, 0), "fcmeq v0." S ", v1." S ", #0.0"); 4736 NEON_FORMAT_LIST_FP(DISASM_INST) 4737 #undef DISASM_INST 4738 4739 COMPARE(Fcmeq(v0.S(), v1.S(), 0), "fcmeq s0, s1, #0.0"); 4740 COMPARE(Fcmeq(v0.D(), v1.D(), 0), "fcmeq d0, d1, #0.0"); 4741 4742 #define DISASM_INST(M, S) \ 4743 COMPARE(Fcmge(v0.M, v1.M, 0), "fcmge v0." S ", v1." S ", #0.0"); 4744 NEON_FORMAT_LIST_FP(DISASM_INST) 4745 #undef DISASM_INST 4746 4747 COMPARE(Fcmge(v0.S(), v1.S(), 0), "fcmge s0, s1, #0.0"); 4748 COMPARE(Fcmge(v0.D(), v1.D(), 0), "fcmge d0, d1, #0.0"); 4749 4750 #define DISASM_INST(M, S) \ 4751 COMPARE(Fcmgt(v0.M, v1.M, 0), "fcmgt v0." S ", v1." S ", #0.0"); 4752 NEON_FORMAT_LIST_FP(DISASM_INST) 4753 #undef DISASM_INST 4754 4755 COMPARE(Fcmgt(v0.S(), v1.S(), 0), "fcmgt s0, s1, #0.0"); 4756 COMPARE(Fcmgt(v0.D(), v1.D(), 0), "fcmgt d0, d1, #0.0"); 4757 4758 #define DISASM_INST(M, S) \ 4759 COMPARE(Fcmle(v0.M, v1.M, 0), "fcmle v0." S ", v1." S ", #0.0"); 4760 NEON_FORMAT_LIST_FP(DISASM_INST) 4761 #undef DISASM_INST 4762 4763 COMPARE(Fcmle(v0.S(), v1.S(), 0), "fcmle s0, s1, #0.0"); 4764 COMPARE(Fcmle(v0.D(), v1.D(), 0), "fcmle d0, d1, #0.0"); 4765 4766 #define DISASM_INST(M, S) \ 4767 COMPARE(Fcmlt(v0.M, v1.M, 0), "fcmlt v0." S ", v1." S ", #0.0"); 4768 NEON_FORMAT_LIST_FP(DISASM_INST) 4769 #undef DISASM_INST 4770 4771 COMPARE(Fcmlt(v0.S(), v1.S(), 0), "fcmlt s0, s1, #0.0"); 4772 COMPARE(Fcmlt(v0.D(), v1.D(), 0), "fcmlt d0, d1, #0.0"); 4773 4774 #define DISASM_INST(M, S) \ 4775 COMPARE(Neg(v0.M, v1.M), "neg v0." S ", v1." S); 4776 NEON_FORMAT_LIST(DISASM_INST) 4777 #undef DISASM_INST 4778 4779 COMPARE(Neg(v0.D(), v1.D()), "neg d0, d1"); 4780 4781 #define DISASM_INST(M, S) \ 4782 COMPARE(Sqneg(v0.M, v1.M), "sqneg v0." S ", v1." S); 4783 NEON_FORMAT_LIST(DISASM_INST) 4784 #undef DISASM_INST 4785 4786 COMPARE(Sqneg(b0, b1), "sqneg b0, b1"); 4787 COMPARE(Sqneg(h1, h2), "sqneg h1, h2"); 4788 COMPARE(Sqneg(s2, s3), "sqneg s2, s3"); 4789 COMPARE(Sqneg(d3, d4), "sqneg d3, d4"); 4790 4791 #define DISASM_INST(M, S) \ 4792 COMPARE(Abs(v0.M, v1.M), "abs v0." S ", v1." S); 4793 NEON_FORMAT_LIST(DISASM_INST) 4794 #undef DISASM_INST 4795 4796 COMPARE(Abs(v0.D(), v1.D()), "abs d0, d1"); 4797 4798 #define DISASM_INST(M, S) \ 4799 COMPARE(Sqabs(v0.M, v1.M), "sqabs v0." S ", v1." S); 4800 NEON_FORMAT_LIST(DISASM_INST) 4801 #undef DISASM_INST 4802 4803 COMPARE(Sqabs(b0, b1), "sqabs b0, b1"); 4804 COMPARE(Sqabs(h1, h2), "sqabs h1, h2"); 4805 COMPARE(Sqabs(s2, s3), "sqabs s2, s3"); 4806 COMPARE(Sqabs(d3, d4), "sqabs d3, d4"); 4807 4808 #define DISASM_INST(M, S) \ 4809 COMPARE(Suqadd(v0.M, v1.M), "suqadd v0." S ", v1." S); 4810 NEON_FORMAT_LIST(DISASM_INST) 4811 #undef DISASM_INST 4812 4813 COMPARE(Suqadd(b0, b1), "suqadd b0, b1"); 4814 COMPARE(Suqadd(h1, h2), "suqadd h1, h2"); 4815 COMPARE(Suqadd(s2, s3), "suqadd s2, s3"); 4816 COMPARE(Suqadd(d3, d4), "suqadd d3, d4"); 4817 4818 #define DISASM_INST(M, S) \ 4819 COMPARE(Usqadd(v0.M, v1.M), "usqadd v0." S ", v1." S); 4820 NEON_FORMAT_LIST(DISASM_INST) 4821 #undef DISASM_INST 4822 4823 COMPARE(Usqadd(b0, b1), "usqadd b0, b1"); 4824 COMPARE(Usqadd(h1, h2), "usqadd h1, h2"); 4825 COMPARE(Usqadd(s2, s3), "usqadd s2, s3"); 4826 COMPARE(Usqadd(d3, d4), "usqadd d3, d4"); 4827 4828 COMPARE(Xtn(v0.V8B(), v1.V8H()), "xtn v0.8b, v1.8h"); 4829 COMPARE(Xtn(v1.V4H(), v2.V4S()), "xtn v1.4h, v2.4s"); 4830 COMPARE(Xtn(v2.V2S(), v3.V2D()), "xtn v2.2s, v3.2d"); 4831 COMPARE(Xtn2(v0.V16B(), v1.V8H()), "xtn2 v0.16b, v1.8h"); 4832 COMPARE(Xtn2(v1.V8H(), v2.V4S()), "xtn2 v1.8h, v2.4s"); 4833 COMPARE(Xtn2(v2.V4S(), v3.V2D()), "xtn2 v2.4s, v3.2d"); 4834 4835 COMPARE(Sqxtn(v0.V8B(), v1.V8H()), "sqxtn v0.8b, v1.8h"); 4836 COMPARE(Sqxtn(v1.V4H(), v2.V4S()), "sqxtn v1.4h, v2.4s"); 4837 COMPARE(Sqxtn(v2.V2S(), v3.V2D()), "sqxtn v2.2s, v3.2d"); 4838 COMPARE(Sqxtn2(v0.V16B(), v1.V8H()), "sqxtn2 v0.16b, v1.8h"); 4839 COMPARE(Sqxtn2(v1.V8H(), v2.V4S()), "sqxtn2 v1.8h, v2.4s"); 4840 COMPARE(Sqxtn2(v2.V4S(), v3.V2D()), "sqxtn2 v2.4s, v3.2d"); 4841 COMPARE(Sqxtn(b19, h0), "sqxtn b19, h0"); 4842 COMPARE(Sqxtn(h20, s0), "sqxtn h20, s0") ; 4843 COMPARE(Sqxtn(s21, d0), "sqxtn s21, d0"); 4844 4845 COMPARE(Uqxtn(v0.V8B(), v1.V8H()), "uqxtn v0.8b, v1.8h"); 4846 COMPARE(Uqxtn(v1.V4H(), v2.V4S()), "uqxtn v1.4h, v2.4s"); 4847 COMPARE(Uqxtn(v2.V2S(), v3.V2D()), "uqxtn v2.2s, v3.2d"); 4848 COMPARE(Uqxtn2(v0.V16B(), v1.V8H()), "uqxtn2 v0.16b, v1.8h"); 4849 COMPARE(Uqxtn2(v1.V8H(), v2.V4S()), "uqxtn2 v1.8h, v2.4s"); 4850 COMPARE(Uqxtn2(v2.V4S(), v3.V2D()), "uqxtn2 v2.4s, v3.2d"); 4851 COMPARE(Uqxtn(b19, h0), "uqxtn b19, h0"); 4852 COMPARE(Uqxtn(h20, s0), "uqxtn h20, s0") ; 4853 COMPARE(Uqxtn(s21, d0), "uqxtn s21, d0"); 4854 4855 COMPARE(Sqxtun(v0.V8B(), v1.V8H()), "sqxtun v0.8b, v1.8h"); 4856 COMPARE(Sqxtun(v1.V4H(), v2.V4S()), "sqxtun v1.4h, v2.4s"); 4857 COMPARE(Sqxtun(v2.V2S(), v3.V2D()), "sqxtun v2.2s, v3.2d"); 4858 COMPARE(Sqxtun2(v0.V16B(), v1.V8H()), "sqxtun2 v0.16b, v1.8h"); 4859 COMPARE(Sqxtun2(v1.V8H(), v2.V4S()), "sqxtun2 v1.8h, v2.4s"); 4860 COMPARE(Sqxtun2(v2.V4S(), v3.V2D()), "sqxtun2 v2.4s, v3.2d"); 4861 COMPARE(Sqxtun(b19, h0), "sqxtun b19, h0"); 4862 COMPARE(Sqxtun(h20, s0), "sqxtun h20, s0") ; 4863 COMPARE(Sqxtun(s21, d0), "sqxtun s21, d0"); 4864 4865 COMPARE(Cls(v1.V8B(), v8.V8B()), "cls v1.8b, v8.8b"); 4866 COMPARE(Cls(v2.V16B(), v9.V16B()), "cls v2.16b, v9.16b"); 4867 COMPARE(Cls(v3.V4H(), v1.V4H()), "cls v3.4h, v1.4h"); 4868 COMPARE(Cls(v4.V8H(), v2.V8H()), "cls v4.8h, v2.8h"); 4869 COMPARE(Cls(v5.V2S(), v3.V2S()), "cls v5.2s, v3.2s"); 4870 COMPARE(Cls(v6.V4S(), v4.V4S()), "cls v6.4s, v4.4s"); 4871 4872 COMPARE(Clz(v1.V8B(), v8.V8B()), "clz v1.8b, v8.8b"); 4873 COMPARE(Clz(v2.V16B(), v9.V16B()), "clz v2.16b, v9.16b"); 4874 COMPARE(Clz(v3.V4H(), v1.V4H()), "clz v3.4h, v1.4h"); 4875 COMPARE(Clz(v4.V8H(), v2.V8H()), "clz v4.8h, v2.8h"); 4876 COMPARE(Clz(v5.V2S(), v3.V2S()), "clz v5.2s, v3.2s"); 4877 COMPARE(Clz(v6.V4S(), v4.V4S()), "clz v6.4s, v4.4s"); 4878 4879 COMPARE(Cnt(v1.V8B(), v8.V8B()), "cnt v1.8b, v8.8b"); 4880 COMPARE(Cnt(v2.V16B(), v9.V16B()), "cnt v2.16b, v9.16b"); 4881 4882 COMPARE(Mvn(v4.V8B(), v5.V8B()), "mvn v4.8b, v5.8b"); 4883 COMPARE(Mvn(v4.V16B(), v5.V16B()), "mvn v4.16b, v5.16b"); 4884 4885 COMPARE(Not(v4.V8B(), v5.V8B()), "mvn v4.8b, v5.8b"); 4886 COMPARE(Not(v4.V16B(), v5.V16B()), "mvn v4.16b, v5.16b"); 4887 4888 COMPARE(Rev64(v1.V8B(), v8.V8B()), "rev64 v1.8b, v8.8b"); 4889 COMPARE(Rev64(v2.V16B(), v9.V16B()), "rev64 v2.16b, v9.16b"); 4890 COMPARE(Rev64(v3.V4H(), v1.V4H()), "rev64 v3.4h, v1.4h"); 4891 COMPARE(Rev64(v4.V8H(), v2.V8H()), "rev64 v4.8h, v2.8h"); 4892 COMPARE(Rev64(v5.V2S(), v3.V2S()), "rev64 v5.2s, v3.2s"); 4893 COMPARE(Rev64(v6.V4S(), v4.V4S()), "rev64 v6.4s, v4.4s"); 4894 4895 COMPARE(Rev32(v1.V8B(), v8.V8B()), "rev32 v1.8b, v8.8b"); 4896 COMPARE(Rev32(v2.V16B(), v9.V16B()), "rev32 v2.16b, v9.16b"); 4897 COMPARE(Rev32(v3.V4H(), v1.V4H()), "rev32 v3.4h, v1.4h"); 4898 COMPARE(Rev32(v4.V8H(), v2.V8H()), "rev32 v4.8h, v2.8h"); 4899 4900 COMPARE(Rev16(v1.V8B(), v8.V8B()), "rev16 v1.8b, v8.8b"); 4901 COMPARE(Rev16(v2.V16B(), v9.V16B()), "rev16 v2.16b, v9.16b"); 4902 4903 COMPARE(Rbit(v1.V8B(), v8.V8B()), "rbit v1.8b, v8.8b"); 4904 COMPARE(Rbit(v2.V16B(), v9.V16B()), "rbit v2.16b, v9.16b"); 4905 4906 COMPARE(Ursqrte(v2.V2S(), v9.V2S()), "ursqrte v2.2s, v9.2s"); 4907 COMPARE(Ursqrte(v16.V4S(), v23.V4S()), "ursqrte v16.4s, v23.4s"); 4908 4909 COMPARE(Urecpe(v2.V2S(), v9.V2S()), "urecpe v2.2s, v9.2s"); 4910 COMPARE(Urecpe(v16.V4S(), v23.V4S()), "urecpe v16.4s, v23.4s"); 4911 4912 COMPARE(Frsqrte(v2.V2S(), v9.V2S()), "frsqrte v2.2s, v9.2s"); 4913 COMPARE(Frsqrte(v16.V4S(), v23.V4S()), "frsqrte v16.4s, v23.4s"); 4914 COMPARE(Frsqrte(v2.V2D(), v9.V2D()), "frsqrte v2.2d, v9.2d"); 4915 COMPARE(Frsqrte(v0.S(), v1.S()), "frsqrte s0, s1"); 4916 COMPARE(Frsqrte(v0.D(), v1.D()), "frsqrte d0, d1"); 4917 4918 COMPARE(Frecpe(v2.V2S(), v9.V2S()), "frecpe v2.2s, v9.2s"); 4919 COMPARE(Frecpe(v16.V4S(), v23.V4S()), "frecpe v16.4s, v23.4s"); 4920 COMPARE(Frecpe(v2.V2D(), v9.V2D()), "frecpe v2.2d, v9.2d"); 4921 COMPARE(Frecpe(v0.S(), v1.S()), "frecpe s0, s1"); 4922 COMPARE(Frecpe(v0.D(), v1.D()), "frecpe d0, d1"); 4923 4924 COMPARE(Fabs(v2.V2S(), v9.V2S()), "fabs v2.2s, v9.2s"); 4925 COMPARE(Fabs(v16.V4S(), v23.V4S()), "fabs v16.4s, v23.4s"); 4926 COMPARE(Fabs(v31.V2D(), v30.V2D()), "fabs v31.2d, v30.2d"); 4927 4928 COMPARE(Fneg(v2.V2S(), v9.V2S()), "fneg v2.2s, v9.2s"); 4929 COMPARE(Fneg(v16.V4S(), v23.V4S()), "fneg v16.4s, v23.4s"); 4930 COMPARE(Fneg(v31.V2D(), v30.V2D()), "fneg v31.2d, v30.2d"); 4931 4932 COMPARE(Frintn(v2.V2S(), v9.V2S()), "frintn v2.2s, v9.2s"); 4933 COMPARE(Frintn(v16.V4S(), v23.V4S()), "frintn v16.4s, v23.4s"); 4934 COMPARE(Frintn(v31.V2D(), v30.V2D()), "frintn v31.2d, v30.2d"); 4935 4936 COMPARE(Frinta(v2.V2S(), v9.V2S()), "frinta v2.2s, v9.2s"); 4937 COMPARE(Frinta(v16.V4S(), v23.V4S()), "frinta v16.4s, v23.4s"); 4938 COMPARE(Frinta(v31.V2D(), v30.V2D()), "frinta v31.2d, v30.2d"); 4939 4940 COMPARE(Frintp(v2.V2S(), v9.V2S()), "frintp v2.2s, v9.2s"); 4941 COMPARE(Frintp(v16.V4S(), v23.V4S()), "frintp v16.4s, v23.4s"); 4942 COMPARE(Frintp(v31.V2D(), v30.V2D()), "frintp v31.2d, v30.2d"); 4943 4944 COMPARE(Frintm(v2.V2S(), v9.V2S()), "frintm v2.2s, v9.2s"); 4945 COMPARE(Frintm(v16.V4S(), v23.V4S()), "frintm v16.4s, v23.4s"); 4946 COMPARE(Frintm(v31.V2D(), v30.V2D()), "frintm v31.2d, v30.2d"); 4947 4948 COMPARE(Frintx(v2.V2S(), v9.V2S()), "frintx v2.2s, v9.2s"); 4949 COMPARE(Frintx(v16.V4S(), v23.V4S()), "frintx v16.4s, v23.4s"); 4950 COMPARE(Frintx(v31.V2D(), v30.V2D()), "frintx v31.2d, v30.2d"); 4951 4952 COMPARE(Frintz(v2.V2S(), v9.V2S()), "frintz v2.2s, v9.2s"); 4953 COMPARE(Frintz(v16.V4S(), v23.V4S()), "frintz v16.4s, v23.4s"); 4954 COMPARE(Frintz(v31.V2D(), v30.V2D()), "frintz v31.2d, v30.2d"); 4955 4956 COMPARE(Frinti(v2.V2S(), v9.V2S()), "frinti v2.2s, v9.2s"); 4957 COMPARE(Frinti(v16.V4S(), v23.V4S()), "frinti v16.4s, v23.4s"); 4958 COMPARE(Frinti(v31.V2D(), v30.V2D()), "frinti v31.2d, v30.2d"); 4959 4960 COMPARE(Fsqrt(v3.V2S(), v10.V2S()), "fsqrt v3.2s, v10.2s"); 4961 COMPARE(Fsqrt(v22.V4S(), v11.V4S()), "fsqrt v22.4s, v11.4s"); 4962 COMPARE(Fsqrt(v31.V2D(), v0.V2D()), "fsqrt v31.2d, v0.2d"); 4963 4964 COMPARE(Fcvtns(v4.V2S(), v11.V2S()), "fcvtns v4.2s, v11.2s"); 4965 COMPARE(Fcvtns(v23.V4S(), v12.V4S()), "fcvtns v23.4s, v12.4s"); 4966 COMPARE(Fcvtns(v30.V2D(), v1.V2D()), "fcvtns v30.2d, v1.2d"); 4967 COMPARE(Fcvtnu(v4.V2S(), v11.V2S()), "fcvtnu v4.2s, v11.2s"); 4968 COMPARE(Fcvtnu(v23.V4S(), v12.V4S()), "fcvtnu v23.4s, v12.4s"); 4969 COMPARE(Fcvtnu(v30.V2D(), v1.V2D()), "fcvtnu v30.2d, v1.2d"); 4970 4971 COMPARE(Fcvtps(v4.V2S(), v11.V2S()), "fcvtps v4.2s, v11.2s"); 4972 COMPARE(Fcvtps(v23.V4S(), v12.V4S()), "fcvtps v23.4s, v12.4s"); 4973 COMPARE(Fcvtps(v30.V2D(), v1.V2D()), "fcvtps v30.2d, v1.2d"); 4974 COMPARE(Fcvtpu(v4.V2S(), v11.V2S()), "fcvtpu v4.2s, v11.2s"); 4975 COMPARE(Fcvtpu(v23.V4S(), v12.V4S()), "fcvtpu v23.4s, v12.4s"); 4976 COMPARE(Fcvtpu(v30.V2D(), v1.V2D()), "fcvtpu v30.2d, v1.2d"); 4977 4978 COMPARE(Fcvtms(v4.V2S(), v11.V2S()), "fcvtms v4.2s, v11.2s"); 4979 COMPARE(Fcvtms(v23.V4S(), v12.V4S()), "fcvtms v23.4s, v12.4s"); 4980 COMPARE(Fcvtms(v30.V2D(), v1.V2D()), "fcvtms v30.2d, v1.2d"); 4981 COMPARE(Fcvtmu(v4.V2S(), v11.V2S()), "fcvtmu v4.2s, v11.2s"); 4982 COMPARE(Fcvtmu(v23.V4S(), v12.V4S()), "fcvtmu v23.4s, v12.4s"); 4983 COMPARE(Fcvtmu(v30.V2D(), v1.V2D()), "fcvtmu v30.2d, v1.2d"); 4984 4985 COMPARE(Fcvtzs(v4.V2S(), v11.V2S()), "fcvtzs v4.2s, v11.2s"); 4986 COMPARE(Fcvtzs(v23.V4S(), v12.V4S()), "fcvtzs v23.4s, v12.4s"); 4987 COMPARE(Fcvtzs(v30.V2D(), v1.V2D()), "fcvtzs v30.2d, v1.2d"); 4988 COMPARE(Fcvtzu(v4.V2S(), v11.V2S()), "fcvtzu v4.2s, v11.2s"); 4989 COMPARE(Fcvtzu(v23.V4S(), v12.V4S()), "fcvtzu v23.4s, v12.4s"); 4990 COMPARE(Fcvtzu(v30.V2D(), v1.V2D()), "fcvtzu v30.2d, v1.2d"); 4991 4992 COMPARE(Fcvtas(v4.V2S(), v11.V2S()), "fcvtas v4.2s, v11.2s"); 4993 COMPARE(Fcvtas(v23.V4S(), v12.V4S()), "fcvtas v23.4s, v12.4s"); 4994 COMPARE(Fcvtas(v30.V2D(), v1.V2D()), "fcvtas v30.2d, v1.2d"); 4995 COMPARE(Fcvtau(v4.V2S(), v11.V2S()), "fcvtau v4.2s, v11.2s"); 4996 COMPARE(Fcvtau(v23.V4S(), v12.V4S()), "fcvtau v23.4s, v12.4s"); 4997 COMPARE(Fcvtau(v30.V2D(), v1.V2D()), "fcvtau v30.2d, v1.2d"); 4998 4999 COMPARE(Fcvtns(s0, s1), "fcvtns s0, s1"); 5000 COMPARE(Fcvtns(d2, d3), "fcvtns d2, d3"); 5001 COMPARE(Fcvtnu(s4, s5), "fcvtnu s4, s5"); 5002 COMPARE(Fcvtnu(d6, d7), "fcvtnu d6, d7"); 5003 COMPARE(Fcvtps(s8, s9), "fcvtps s8, s9"); 5004 COMPARE(Fcvtps(d10, d11), "fcvtps d10, d11"); 5005 COMPARE(Fcvtpu(s12, s13), "fcvtpu s12, s13"); 5006 COMPARE(Fcvtpu(d14, d15), "fcvtpu d14, d15"); 5007 COMPARE(Fcvtms(s16, s17), "fcvtms s16, s17"); 5008 COMPARE(Fcvtms(d18, d19), "fcvtms d18, d19"); 5009 COMPARE(Fcvtmu(s20, s21), "fcvtmu s20, s21"); 5010 COMPARE(Fcvtmu(d22, d23), "fcvtmu d22, d23"); 5011 COMPARE(Fcvtzs(s24, s25), "fcvtzs s24, s25"); 5012 COMPARE(Fcvtzs(d26, d27), "fcvtzs d26, d27"); 5013 COMPARE(Fcvtzu(s28, s29), "fcvtzu s28, s29"); 5014 COMPARE(Fcvtzu(d30, d31), "fcvtzu d30, d31"); 5015 COMPARE(Fcvtas(s0, s1), "fcvtas s0, s1"); 5016 COMPARE(Fcvtas(d2, d3), "fcvtas d2, d3"); 5017 COMPARE(Fcvtau(s4, s5), "fcvtau s4, s5"); 5018 COMPARE(Fcvtau(d6, d7), "fcvtau d6, d7"); 5019 5020 COMPARE(Fcvtl(v3.V4S(), v5.V4H()), "fcvtl v3.4s, v5.4h"); 5021 COMPARE(Fcvtl(v7.V2D(), v11.V2S()), "fcvtl v7.2d, v11.2s"); 5022 COMPARE(Fcvtl2(v13.V4S(), v17.V8H()), "fcvtl2 v13.4s, v17.8h"); 5023 COMPARE(Fcvtl2(v23.V2D(), v29.V4S()), "fcvtl2 v23.2d, v29.4s"); 5024 5025 COMPARE(Fcvtn(v3.V4H(), v5.V4S()), "fcvtn v3.4h, v5.4s"); 5026 COMPARE(Fcvtn(v7.V2S(), v11.V2D()), "fcvtn v7.2s, v11.2d"); 5027 COMPARE(Fcvtn2(v13.V8H(), v17.V4S()), "fcvtn2 v13.8h, v17.4s"); 5028 COMPARE(Fcvtn2(v23.V4S(), v29.V2D()), "fcvtn2 v23.4s, v29.2d"); 5029 5030 COMPARE(Fcvtxn(v5.V2S(), v7.V2D()), "fcvtxn v5.2s, v7.2d"); 5031 COMPARE(Fcvtxn2(v8.V4S(), v13.V2D()), "fcvtxn2 v8.4s, v13.2d"); 5032 COMPARE(Fcvtxn(s17, d31), "fcvtxn s17, d31"); 5033 5034 COMPARE(Frecpx(s0, s1), "frecpx s0, s1"); 5035 COMPARE(Frecpx(s31, s30), "frecpx s31, s30"); 5036 COMPARE(Frecpx(d2, d3), "frecpx d2, d3"); 5037 COMPARE(Frecpx(d31, d30), "frecpx d31, d30"); 5038 5039 COMPARE(Scvtf(v5.V2S(), v3.V2S()), "scvtf v5.2s, v3.2s"); 5040 COMPARE(Scvtf(v6.V4S(), v4.V4S()), "scvtf v6.4s, v4.4s"); 5041 COMPARE(Scvtf(v7.V2D(), v5.V2D()), "scvtf v7.2d, v5.2d"); 5042 COMPARE(Scvtf(s8, s6), "scvtf s8, s6"); 5043 COMPARE(Scvtf(d8, d6), "scvtf d8, d6"); 5044 5045 COMPARE(Ucvtf(v5.V2S(), v3.V2S()), "ucvtf v5.2s, v3.2s"); 5046 COMPARE(Ucvtf(v6.V4S(), v4.V4S()), "ucvtf v6.4s, v4.4s"); 5047 COMPARE(Ucvtf(v7.V2D(), v5.V2D()), "ucvtf v7.2d, v5.2d"); 5048 COMPARE(Ucvtf(s8, s6), "ucvtf s8, s6"); 5049 COMPARE(Ucvtf(d8, d6), "ucvtf d8, d6"); 5050 5051 #define DISASM_INST(TA, TAS, TB, TBS) \ 5052 COMPARE(Saddlp(v0.TA, v1.TB), "saddlp v0." TAS ", v1." TBS); 5053 NEON_FORMAT_LIST_LP(DISASM_INST) 5054 #undef DISASM_INST 5055 5056 #define DISASM_INST(TA, TAS, TB, TBS) \ 5057 COMPARE(Uaddlp(v0.TA, v1.TB), "uaddlp v0." TAS ", v1." TBS); 5058 NEON_FORMAT_LIST_LP(DISASM_INST) 5059 #undef DISASM_INST 5060 5061 #define DISASM_INST(TA, TAS, TB, TBS) \ 5062 COMPARE(Sadalp(v0.TA, v1.TB), "sadalp v0." TAS ", v1." TBS); 5063 NEON_FORMAT_LIST_LP(DISASM_INST) 5064 #undef DISASM_INST 5065 5066 #define DISASM_INST(TA, TAS, TB, TBS) \ 5067 COMPARE(Uadalp(v0.TA, v1.TB), "uadalp v0." TAS ", v1." TBS); 5068 NEON_FORMAT_LIST_LP(DISASM_INST) 5069 #undef DISASM_INST 5070 5071 CLEANUP(); 5072} 5073 5074TEST(neon_acrosslanes) { 5075 SETUP_CLASS(MacroAssembler); 5076 5077 COMPARE(Smaxv(b4, v5.V8B()), "smaxv b4, v5.8b"); 5078 COMPARE(Smaxv(b4, v5.V16B()), "smaxv b4, v5.16b"); 5079 COMPARE(Smaxv(h4, v5.V4H()), "smaxv h4, v5.4h"); 5080 COMPARE(Smaxv(h4, v5.V8H()), "smaxv h4, v5.8h"); 5081 COMPARE(Smaxv(s4, v5.V4S()), "smaxv s4, v5.4s"); 5082 5083 COMPARE(Sminv(b4, v5.V8B()), "sminv b4, v5.8b"); 5084 COMPARE(Sminv(b4, v5.V16B()), "sminv b4, v5.16b"); 5085 COMPARE(Sminv(h4, v5.V4H()), "sminv h4, v5.4h"); 5086 COMPARE(Sminv(h4, v5.V8H()), "sminv h4, v5.8h"); 5087 COMPARE(Sminv(s4, v5.V4S()), "sminv s4, v5.4s"); 5088 5089 COMPARE(Umaxv(b4, v5.V8B()), "umaxv b4, v5.8b"); 5090 COMPARE(Umaxv(b4, v5.V16B()), "umaxv b4, v5.16b"); 5091 COMPARE(Umaxv(h4, v5.V4H()), "umaxv h4, v5.4h"); 5092 COMPARE(Umaxv(h4, v5.V8H()), "umaxv h4, v5.8h"); 5093 COMPARE(Umaxv(s4, v5.V4S()), "umaxv s4, v5.4s"); 5094 5095 COMPARE(Uminv(b4, v5.V8B()), "uminv b4, v5.8b"); 5096 COMPARE(Uminv(b4, v5.V16B()), "uminv b4, v5.16b"); 5097 COMPARE(Uminv(h4, v5.V4H()), "uminv h4, v5.4h"); 5098 COMPARE(Uminv(h4, v5.V8H()), "uminv h4, v5.8h"); 5099 COMPARE(Uminv(s4, v5.V4S()), "uminv s4, v5.4s"); 5100 5101 COMPARE(Addv(b4, v5.V8B()), "addv b4, v5.8b"); 5102 COMPARE(Addv(b4, v5.V16B()), "addv b4, v5.16b"); 5103 COMPARE(Addv(h4, v5.V4H()), "addv h4, v5.4h"); 5104 COMPARE(Addv(h4, v5.V8H()), "addv h4, v5.8h"); 5105 COMPARE(Addv(s4, v5.V4S()), "addv s4, v5.4s"); 5106 5107 COMPARE(Saddlv(h4, v5.V8B()), "saddlv h4, v5.8b"); 5108 COMPARE(Saddlv(h4, v5.V16B()), "saddlv h4, v5.16b"); 5109 COMPARE(Saddlv(s4, v5.V4H()), "saddlv s4, v5.4h"); 5110 COMPARE(Saddlv(s4, v5.V8H()), "saddlv s4, v5.8h"); 5111 COMPARE(Saddlv(d4, v5.V4S()), "saddlv d4, v5.4s"); 5112 5113 COMPARE(Uaddlv(h4, v5.V8B()), "uaddlv h4, v5.8b"); 5114 COMPARE(Uaddlv(h4, v5.V16B()), "uaddlv h4, v5.16b"); 5115 COMPARE(Uaddlv(s4, v5.V4H()), "uaddlv s4, v5.4h"); 5116 COMPARE(Uaddlv(s4, v5.V8H()), "uaddlv s4, v5.8h"); 5117 COMPARE(Uaddlv(d4, v5.V4S()), "uaddlv d4, v5.4s"); 5118 5119 COMPARE(Fmaxv(s4, v5.V4S()), "fmaxv s4, v5.4s"); 5120 COMPARE(Fminv(s4, v5.V4S()), "fminv s4, v5.4s"); 5121 COMPARE(Fmaxnmv(s4, v5.V4S()), "fmaxnmv s4, v5.4s"); 5122 COMPARE(Fminnmv(s4, v5.V4S()), "fminnmv s4, v5.4s"); 5123 5124 CLEANUP(); 5125} 5126 5127TEST(neon_scalar_pairwise) { 5128 SETUP_CLASS(MacroAssembler); 5129 5130 COMPARE(Addp(d0, v1.V2D()), "addp d0, v1.2d"); 5131 COMPARE(Faddp(s0, v1.V2S()), "faddp s0, v1.2s"); 5132 COMPARE(Faddp(d2, v3.V2D()), "faddp d2, v3.2d"); 5133 COMPARE(Fmaxp(s4, v5.V2S()), "fmaxp s4, v5.2s"); 5134 COMPARE(Fmaxp(d6, v7.V2D()), "fmaxp d6, v7.2d"); 5135 COMPARE(Fmaxnmp(s8, v9.V2S()), "fmaxnmp s8, v9.2s"); 5136 COMPARE(Fmaxnmp(d10, v11.V2D()), "fmaxnmp d10, v11.2d"); 5137 COMPARE(Fminp(s12, v13.V2S()), "fminp s12, v13.2s"); 5138 COMPARE(Fminp(d14, v15.V2D()), "fminp d14, v15.2d"); 5139 COMPARE(Fminnmp(s16, v17.V2S()), "fminnmp s16, v17.2s"); 5140 COMPARE(Fminnmp(d18, v19.V2D()), "fminnmp d18, v19.2d"); 5141 CLEANUP(); 5142} 5143 5144TEST(neon_shift_immediate) { 5145 SETUP_CLASS(MacroAssembler); 5146 5147 COMPARE(Sshr(v0.V8B(), v1.V8B(), 1), "sshr v0.8b, v1.8b, #1"); 5148 COMPARE(Sshr(v2.V8B(), v3.V8B(), 8), "sshr v2.8b, v3.8b, #8"); 5149 COMPARE(Sshr(v4.V16B(), v5.V16B(), 1), "sshr v4.16b, v5.16b, #1"); 5150 COMPARE(Sshr(v6.V16B(), v7.V16B(), 8), "sshr v6.16b, v7.16b, #8"); 5151 COMPARE(Sshr(v8.V4H(), v9.V4H(), 1), "sshr v8.4h, v9.4h, #1"); 5152 COMPARE(Sshr(v10.V4H(), v11.V4H(), 16), "sshr v10.4h, v11.4h, #16"); 5153 COMPARE(Sshr(v12.V8H(), v13.V8H(), 1), "sshr v12.8h, v13.8h, #1"); 5154 COMPARE(Sshr(v14.V8H(), v15.V8H(), 16), "sshr v14.8h, v15.8h, #16"); 5155 COMPARE(Sshr(v16.V2S(), v17.V2S(), 1), "sshr v16.2s, v17.2s, #1"); 5156 COMPARE(Sshr(v18.V2S(), v19.V2S(), 32), "sshr v18.2s, v19.2s, #32"); 5157 COMPARE(Sshr(v20.V4S(), v21.V4S(), 1), "sshr v20.4s, v21.4s, #1"); 5158 COMPARE(Sshr(v22.V4S(), v23.V4S(), 32), "sshr v22.4s, v23.4s, #32"); 5159 COMPARE(Sshr(v28.V2D(), v29.V2D(), 1), "sshr v28.2d, v29.2d, #1"); 5160 COMPARE(Sshr(v30.V2D(), v31.V2D(), 64), "sshr v30.2d, v31.2d, #64"); 5161 COMPARE(Sshr(d0, d1, 7), "sshr d0, d1, #7"); 5162 5163 COMPARE(Ushr(v0.V8B(), v1.V8B(), 1), "ushr v0.8b, v1.8b, #1"); 5164 COMPARE(Ushr(v2.V8B(), v3.V8B(), 8), "ushr v2.8b, v3.8b, #8"); 5165 COMPARE(Ushr(v4.V16B(), v5.V16B(), 1), "ushr v4.16b, v5.16b, #1"); 5166 COMPARE(Ushr(v6.V16B(), v7.V16B(), 8), "ushr v6.16b, v7.16b, #8"); 5167 COMPARE(Ushr(v8.V4H(), v9.V4H(), 1), "ushr v8.4h, v9.4h, #1"); 5168 COMPARE(Ushr(v10.V4H(), v11.V4H(), 16), "ushr v10.4h, v11.4h, #16"); 5169 COMPARE(Ushr(v12.V8H(), v13.V8H(), 1), "ushr v12.8h, v13.8h, #1"); 5170 COMPARE(Ushr(v14.V8H(), v15.V8H(), 16), "ushr v14.8h, v15.8h, #16"); 5171 COMPARE(Ushr(v16.V2S(), v17.V2S(), 1), "ushr v16.2s, v17.2s, #1"); 5172 COMPARE(Ushr(v18.V2S(), v19.V2S(), 32), "ushr v18.2s, v19.2s, #32"); 5173 COMPARE(Ushr(v20.V4S(), v21.V4S(), 1), "ushr v20.4s, v21.4s, #1"); 5174 COMPARE(Ushr(v22.V4S(), v23.V4S(), 32), "ushr v22.4s, v23.4s, #32"); 5175 COMPARE(Ushr(v28.V2D(), v29.V2D(), 1), "ushr v28.2d, v29.2d, #1"); 5176 COMPARE(Ushr(v30.V2D(), v31.V2D(), 64), "ushr v30.2d, v31.2d, #64"); 5177 COMPARE(Ushr(d0, d1, 7), "ushr d0, d1, #7"); 5178 5179 COMPARE(Srshr(v0.V8B(), v1.V8B(), 1), "srshr v0.8b, v1.8b, #1"); 5180 COMPARE(Srshr(v2.V8B(), v3.V8B(), 8), "srshr v2.8b, v3.8b, #8"); 5181 COMPARE(Srshr(v4.V16B(), v5.V16B(), 1), "srshr v4.16b, v5.16b, #1"); 5182 COMPARE(Srshr(v6.V16B(), v7.V16B(), 8), "srshr v6.16b, v7.16b, #8"); 5183 COMPARE(Srshr(v8.V4H(), v9.V4H(), 1), "srshr v8.4h, v9.4h, #1"); 5184 COMPARE(Srshr(v10.V4H(), v11.V4H(), 16), "srshr v10.4h, v11.4h, #16"); 5185 COMPARE(Srshr(v12.V8H(), v13.V8H(), 1), "srshr v12.8h, v13.8h, #1"); 5186 COMPARE(Srshr(v14.V8H(), v15.V8H(), 16), "srshr v14.8h, v15.8h, #16"); 5187 COMPARE(Srshr(v16.V2S(), v17.V2S(), 1), "srshr v16.2s, v17.2s, #1"); 5188 COMPARE(Srshr(v18.V2S(), v19.V2S(), 32), "srshr v18.2s, v19.2s, #32"); 5189 COMPARE(Srshr(v20.V4S(), v21.V4S(), 1), "srshr v20.4s, v21.4s, #1"); 5190 COMPARE(Srshr(v22.V4S(), v23.V4S(), 32), "srshr v22.4s, v23.4s, #32"); 5191 COMPARE(Srshr(v28.V2D(), v29.V2D(), 1), "srshr v28.2d, v29.2d, #1"); 5192 COMPARE(Srshr(v30.V2D(), v31.V2D(), 64), "srshr v30.2d, v31.2d, #64"); 5193 COMPARE(Srshr(d0, d1, 7), "srshr d0, d1, #7"); 5194 5195 COMPARE(Urshr(v0.V8B(), v1.V8B(), 1), "urshr v0.8b, v1.8b, #1"); 5196 COMPARE(Urshr(v2.V8B(), v3.V8B(), 8), "urshr v2.8b, v3.8b, #8"); 5197 COMPARE(Urshr(v4.V16B(), v5.V16B(), 1), "urshr v4.16b, v5.16b, #1"); 5198 COMPARE(Urshr(v6.V16B(), v7.V16B(), 8), "urshr v6.16b, v7.16b, #8"); 5199 COMPARE(Urshr(v8.V4H(), v9.V4H(), 1), "urshr v8.4h, v9.4h, #1"); 5200 COMPARE(Urshr(v10.V4H(), v11.V4H(), 16), "urshr v10.4h, v11.4h, #16"); 5201 COMPARE(Urshr(v12.V8H(), v13.V8H(), 1), "urshr v12.8h, v13.8h, #1"); 5202 COMPARE(Urshr(v14.V8H(), v15.V8H(), 16), "urshr v14.8h, v15.8h, #16"); 5203 COMPARE(Urshr(v16.V2S(), v17.V2S(), 1), "urshr v16.2s, v17.2s, #1"); 5204 COMPARE(Urshr(v18.V2S(), v19.V2S(), 32), "urshr v18.2s, v19.2s, #32"); 5205 COMPARE(Urshr(v20.V4S(), v21.V4S(), 1), "urshr v20.4s, v21.4s, #1"); 5206 COMPARE(Urshr(v22.V4S(), v23.V4S(), 32), "urshr v22.4s, v23.4s, #32"); 5207 COMPARE(Urshr(v28.V2D(), v29.V2D(), 1), "urshr v28.2d, v29.2d, #1"); 5208 COMPARE(Urshr(v30.V2D(), v31.V2D(), 64), "urshr v30.2d, v31.2d, #64"); 5209 COMPARE(Urshr(d0, d1, 7), "urshr d0, d1, #7"); 5210 5211 COMPARE(Srsra(v0.V8B(), v1.V8B(), 1), "srsra v0.8b, v1.8b, #1"); 5212 COMPARE(Srsra(v2.V8B(), v3.V8B(), 8), "srsra v2.8b, v3.8b, #8"); 5213 COMPARE(Srsra(v4.V16B(), v5.V16B(), 1), "srsra v4.16b, v5.16b, #1"); 5214 COMPARE(Srsra(v6.V16B(), v7.V16B(), 8), "srsra v6.16b, v7.16b, #8"); 5215 COMPARE(Srsra(v8.V4H(), v9.V4H(), 1), "srsra v8.4h, v9.4h, #1"); 5216 COMPARE(Srsra(v10.V4H(), v11.V4H(), 16), "srsra v10.4h, v11.4h, #16"); 5217 COMPARE(Srsra(v12.V8H(), v13.V8H(), 1), "srsra v12.8h, v13.8h, #1"); 5218 COMPARE(Srsra(v14.V8H(), v15.V8H(), 16), "srsra v14.8h, v15.8h, #16"); 5219 COMPARE(Srsra(v16.V2S(), v17.V2S(), 1), "srsra v16.2s, v17.2s, #1"); 5220 COMPARE(Srsra(v18.V2S(), v19.V2S(), 32), "srsra v18.2s, v19.2s, #32"); 5221 COMPARE(Srsra(v20.V4S(), v21.V4S(), 1), "srsra v20.4s, v21.4s, #1"); 5222 COMPARE(Srsra(v22.V4S(), v23.V4S(), 32), "srsra v22.4s, v23.4s, #32"); 5223 COMPARE(Srsra(v28.V2D(), v29.V2D(), 1), "srsra v28.2d, v29.2d, #1"); 5224 COMPARE(Srsra(v30.V2D(), v31.V2D(), 64), "srsra v30.2d, v31.2d, #64"); 5225 COMPARE(Srsra(d0, d1, 7), "srsra d0, d1, #7"); 5226 5227 COMPARE(Ssra(v0.V8B(), v1.V8B(), 1), "ssra v0.8b, v1.8b, #1"); 5228 COMPARE(Ssra(v2.V8B(), v3.V8B(), 8), "ssra v2.8b, v3.8b, #8"); 5229 COMPARE(Ssra(v4.V16B(), v5.V16B(), 1), "ssra v4.16b, v5.16b, #1"); 5230 COMPARE(Ssra(v6.V16B(), v7.V16B(), 8), "ssra v6.16b, v7.16b, #8"); 5231 COMPARE(Ssra(v8.V4H(), v9.V4H(), 1), "ssra v8.4h, v9.4h, #1"); 5232 COMPARE(Ssra(v10.V4H(), v11.V4H(), 16), "ssra v10.4h, v11.4h, #16"); 5233 COMPARE(Ssra(v12.V8H(), v13.V8H(), 1), "ssra v12.8h, v13.8h, #1"); 5234 COMPARE(Ssra(v14.V8H(), v15.V8H(), 16), "ssra v14.8h, v15.8h, #16"); 5235 COMPARE(Ssra(v16.V2S(), v17.V2S(), 1), "ssra v16.2s, v17.2s, #1"); 5236 COMPARE(Ssra(v18.V2S(), v19.V2S(), 32), "ssra v18.2s, v19.2s, #32"); 5237 COMPARE(Ssra(v20.V4S(), v21.V4S(), 1), "ssra v20.4s, v21.4s, #1"); 5238 COMPARE(Ssra(v22.V4S(), v23.V4S(), 32), "ssra v22.4s, v23.4s, #32"); 5239 COMPARE(Ssra(v28.V2D(), v29.V2D(), 1), "ssra v28.2d, v29.2d, #1"); 5240 COMPARE(Ssra(v30.V2D(), v31.V2D(), 64), "ssra v30.2d, v31.2d, #64"); 5241 COMPARE(Ssra(d0, d1, 7), "ssra d0, d1, #7"); 5242 5243 COMPARE(Ursra(v0.V8B(), v1.V8B(), 1), "ursra v0.8b, v1.8b, #1"); 5244 COMPARE(Ursra(v2.V8B(), v3.V8B(), 8), "ursra v2.8b, v3.8b, #8"); 5245 COMPARE(Ursra(v4.V16B(), v5.V16B(), 1), "ursra v4.16b, v5.16b, #1"); 5246 COMPARE(Ursra(v6.V16B(), v7.V16B(), 8), "ursra v6.16b, v7.16b, #8"); 5247 COMPARE(Ursra(v8.V4H(), v9.V4H(), 1), "ursra v8.4h, v9.4h, #1"); 5248 COMPARE(Ursra(v10.V4H(), v11.V4H(), 16), "ursra v10.4h, v11.4h, #16"); 5249 COMPARE(Ursra(v12.V8H(), v13.V8H(), 1), "ursra v12.8h, v13.8h, #1"); 5250 COMPARE(Ursra(v14.V8H(), v15.V8H(), 16), "ursra v14.8h, v15.8h, #16"); 5251 COMPARE(Ursra(v16.V2S(), v17.V2S(), 1), "ursra v16.2s, v17.2s, #1"); 5252 COMPARE(Ursra(v18.V2S(), v19.V2S(), 32), "ursra v18.2s, v19.2s, #32"); 5253 COMPARE(Ursra(v20.V4S(), v21.V4S(), 1), "ursra v20.4s, v21.4s, #1"); 5254 COMPARE(Ursra(v22.V4S(), v23.V4S(), 32), "ursra v22.4s, v23.4s, #32"); 5255 COMPARE(Ursra(v28.V2D(), v29.V2D(), 1), "ursra v28.2d, v29.2d, #1"); 5256 COMPARE(Ursra(v30.V2D(), v31.V2D(), 64), "ursra v30.2d, v31.2d, #64"); 5257 COMPARE(Ursra(d0, d1, 7), "ursra d0, d1, #7"); 5258 5259 COMPARE(Usra(v0.V8B(), v1.V8B(), 1), "usra v0.8b, v1.8b, #1"); 5260 COMPARE(Usra(v2.V8B(), v3.V8B(), 8), "usra v2.8b, v3.8b, #8"); 5261 COMPARE(Usra(v4.V16B(), v5.V16B(), 1), "usra v4.16b, v5.16b, #1"); 5262 COMPARE(Usra(v6.V16B(), v7.V16B(), 8), "usra v6.16b, v7.16b, #8"); 5263 COMPARE(Usra(v8.V4H(), v9.V4H(), 1), "usra v8.4h, v9.4h, #1"); 5264 COMPARE(Usra(v10.V4H(), v11.V4H(), 16), "usra v10.4h, v11.4h, #16"); 5265 COMPARE(Usra(v12.V8H(), v13.V8H(), 1), "usra v12.8h, v13.8h, #1"); 5266 COMPARE(Usra(v14.V8H(), v15.V8H(), 16), "usra v14.8h, v15.8h, #16"); 5267 COMPARE(Usra(v16.V2S(), v17.V2S(), 1), "usra v16.2s, v17.2s, #1"); 5268 COMPARE(Usra(v18.V2S(), v19.V2S(), 32), "usra v18.2s, v19.2s, #32"); 5269 COMPARE(Usra(v20.V4S(), v21.V4S(), 1), "usra v20.4s, v21.4s, #1"); 5270 COMPARE(Usra(v22.V4S(), v23.V4S(), 32), "usra v22.4s, v23.4s, #32"); 5271 COMPARE(Usra(v28.V2D(), v29.V2D(), 1), "usra v28.2d, v29.2d, #1"); 5272 COMPARE(Usra(v30.V2D(), v31.V2D(), 64), "usra v30.2d, v31.2d, #64"); 5273 COMPARE(Usra(d0, d1, 7), "usra d0, d1, #7"); 5274 5275 COMPARE(Sli(v1.V8B(), v8.V8B(), 1), "sli v1.8b, v8.8b, #1"); 5276 COMPARE(Sli(v2.V16B(), v9.V16B(), 2), "sli v2.16b, v9.16b, #2"); 5277 COMPARE(Sli(v3.V4H(), v1.V4H(), 3), "sli v3.4h, v1.4h, #3"); 5278 COMPARE(Sli(v4.V8H(), v2.V8H(), 4), "sli v4.8h, v2.8h, #4"); 5279 COMPARE(Sli(v5.V2S(), v3.V2S(), 5), "sli v5.2s, v3.2s, #5"); 5280 COMPARE(Sli(v6.V4S(), v4.V4S(), 6), "sli v6.4s, v4.4s, #6"); 5281 COMPARE(Sli(v7.V2D(), v5.V2D(), 7), "sli v7.2d, v5.2d, #7"); 5282 COMPARE(Sli(d8, d6, 8), "sli d8, d6, #8"); 5283 5284 COMPARE(Shl(v1.V8B(), v8.V8B(), 1), "shl v1.8b, v8.8b, #1"); 5285 COMPARE(Shl(v2.V16B(), v9.V16B(), 2), "shl v2.16b, v9.16b, #2"); 5286 COMPARE(Shl(v3.V4H(), v1.V4H(), 3), "shl v3.4h, v1.4h, #3"); 5287 COMPARE(Shl(v4.V8H(), v2.V8H(), 4), "shl v4.8h, v2.8h, #4"); 5288 COMPARE(Shl(v5.V2S(), v3.V2S(), 5), "shl v5.2s, v3.2s, #5"); 5289 COMPARE(Shl(v6.V4S(), v4.V4S(), 6), "shl v6.4s, v4.4s, #6"); 5290 COMPARE(Shl(v7.V2D(), v5.V2D(), 7), "shl v7.2d, v5.2d, #7"); 5291 COMPARE(Shl(d8, d6, 8), "shl d8, d6, #8"); 5292 5293 COMPARE(Sqshl(v1.V8B(), v8.V8B(), 1), "sqshl v1.8b, v8.8b, #1"); 5294 COMPARE(Sqshl(v2.V16B(), v9.V16B(), 2), "sqshl v2.16b, v9.16b, #2"); 5295 COMPARE(Sqshl(v3.V4H(), v1.V4H(), 3), "sqshl v3.4h, v1.4h, #3"); 5296 COMPARE(Sqshl(v4.V8H(), v2.V8H(), 4), "sqshl v4.8h, v2.8h, #4"); 5297 COMPARE(Sqshl(v5.V2S(), v3.V2S(), 5), "sqshl v5.2s, v3.2s, #5"); 5298 COMPARE(Sqshl(v6.V4S(), v4.V4S(), 6), "sqshl v6.4s, v4.4s, #6"); 5299 COMPARE(Sqshl(v7.V2D(), v5.V2D(), 7), "sqshl v7.2d, v5.2d, #7"); 5300 COMPARE(Sqshl(b8, b7, 1), "sqshl b8, b7, #1"); 5301 COMPARE(Sqshl(h9, h8, 2), "sqshl h9, h8, #2"); 5302 COMPARE(Sqshl(s10, s9, 3), "sqshl s10, s9, #3"); 5303 COMPARE(Sqshl(d11, d10, 4), "sqshl d11, d10, #4"); 5304 5305 COMPARE(Sqshlu(v1.V8B(), v8.V8B(), 1), "sqshlu v1.8b, v8.8b, #1"); 5306 COMPARE(Sqshlu(v2.V16B(), v9.V16B(), 2), "sqshlu v2.16b, v9.16b, #2"); 5307 COMPARE(Sqshlu(v3.V4H(), v1.V4H(), 3), "sqshlu v3.4h, v1.4h, #3"); 5308 COMPARE(Sqshlu(v4.V8H(), v2.V8H(), 4), "sqshlu v4.8h, v2.8h, #4"); 5309 COMPARE(Sqshlu(v5.V2S(), v3.V2S(), 5), "sqshlu v5.2s, v3.2s, #5"); 5310 COMPARE(Sqshlu(v6.V4S(), v4.V4S(), 6), "sqshlu v6.4s, v4.4s, #6"); 5311 COMPARE(Sqshlu(v7.V2D(), v5.V2D(), 7), "sqshlu v7.2d, v5.2d, #7"); 5312 COMPARE(Sqshlu(b8, b7, 1), "sqshlu b8, b7, #1"); 5313 COMPARE(Sqshlu(h9, h8, 2), "sqshlu h9, h8, #2"); 5314 COMPARE(Sqshlu(s10, s9, 3), "sqshlu s10, s9, #3"); 5315 COMPARE(Sqshlu(d11, d10, 4), "sqshlu d11, d10, #4"); 5316 5317 COMPARE(Uqshl(v1.V8B(), v8.V8B(), 1), "uqshl v1.8b, v8.8b, #1"); 5318 COMPARE(Uqshl(v2.V16B(), v9.V16B(), 2), "uqshl v2.16b, v9.16b, #2"); 5319 COMPARE(Uqshl(v3.V4H(), v1.V4H(), 3), "uqshl v3.4h, v1.4h, #3"); 5320 COMPARE(Uqshl(v4.V8H(), v2.V8H(), 4), "uqshl v4.8h, v2.8h, #4"); 5321 COMPARE(Uqshl(v5.V2S(), v3.V2S(), 5), "uqshl v5.2s, v3.2s, #5"); 5322 COMPARE(Uqshl(v6.V4S(), v4.V4S(), 6), "uqshl v6.4s, v4.4s, #6"); 5323 COMPARE(Uqshl(v7.V2D(), v5.V2D(), 7), "uqshl v7.2d, v5.2d, #7"); 5324 COMPARE(Uqshl(b8, b7, 1), "uqshl b8, b7, #1"); 5325 COMPARE(Uqshl(h9, h8, 2), "uqshl h9, h8, #2"); 5326 COMPARE(Uqshl(s10, s9, 3), "uqshl s10, s9, #3"); 5327 COMPARE(Uqshl(d11, d10, 4), "uqshl d11, d10, #4"); 5328 5329 COMPARE(Sshll(v1.V8H(), v8.V8B(), 1), "sshll v1.8h, v8.8b, #1"); 5330 COMPARE(Sshll(v3.V4S(), v1.V4H(), 3), "sshll v3.4s, v1.4h, #3"); 5331 COMPARE(Sshll(v5.V2D(), v3.V2S(), 5), "sshll v5.2d, v3.2s, #5"); 5332 COMPARE(Sshll2(v2.V8H(), v9.V16B(), 2), "sshll2 v2.8h, v9.16b, #2"); 5333 COMPARE(Sshll2(v4.V4S(), v2.V8H(), 4), "sshll2 v4.4s, v2.8h, #4"); 5334 COMPARE(Sshll2(v6.V2D(), v4.V4S(), 6), "sshll2 v6.2d, v4.4s, #6"); 5335 5336 COMPARE(Sshll(v1.V8H(), v8.V8B(), 0), "sxtl v1.8h, v8.8b"); 5337 COMPARE(Sshll(v3.V4S(), v1.V4H(), 0), "sxtl v3.4s, v1.4h"); 5338 COMPARE(Sshll(v5.V2D(), v3.V2S(), 0), "sxtl v5.2d, v3.2s"); 5339 COMPARE(Sshll2(v2.V8H(), v9.V16B(), 0), "sxtl2 v2.8h, v9.16b"); 5340 COMPARE(Sshll2(v4.V4S(), v2.V8H(), 0), "sxtl2 v4.4s, v2.8h"); 5341 COMPARE(Sshll2(v6.V2D(), v4.V4S(), 0), "sxtl2 v6.2d, v4.4s"); 5342 5343 COMPARE(Sxtl(v1.V8H(), v8.V8B()), "sxtl v1.8h, v8.8b"); 5344 COMPARE(Sxtl(v3.V4S(), v1.V4H()), "sxtl v3.4s, v1.4h"); 5345 COMPARE(Sxtl(v5.V2D(), v3.V2S()), "sxtl v5.2d, v3.2s"); 5346 COMPARE(Sxtl2(v2.V8H(), v9.V16B()), "sxtl2 v2.8h, v9.16b"); 5347 COMPARE(Sxtl2(v4.V4S(), v2.V8H()), "sxtl2 v4.4s, v2.8h"); 5348 COMPARE(Sxtl2(v6.V2D(), v4.V4S()), "sxtl2 v6.2d, v4.4s"); 5349 5350 COMPARE(Ushll(v1.V8H(), v8.V8B(), 1), "ushll v1.8h, v8.8b, #1"); 5351 COMPARE(Ushll(v3.V4S(), v1.V4H(), 3), "ushll v3.4s, v1.4h, #3"); 5352 COMPARE(Ushll(v5.V2D(), v3.V2S(), 5), "ushll v5.2d, v3.2s, #5"); 5353 COMPARE(Ushll2(v2.V8H(), v9.V16B(), 2), "ushll2 v2.8h, v9.16b, #2"); 5354 COMPARE(Ushll2(v4.V4S(), v2.V8H(), 4), "ushll2 v4.4s, v2.8h, #4"); 5355 COMPARE(Ushll2(v6.V2D(), v4.V4S(), 6), "ushll2 v6.2d, v4.4s, #6"); 5356 5357 COMPARE(Ushll(v1.V8H(), v8.V8B(), 0), "uxtl v1.8h, v8.8b"); 5358 COMPARE(Ushll(v3.V4S(), v1.V4H(), 0), "uxtl v3.4s, v1.4h"); 5359 COMPARE(Ushll(v5.V2D(), v3.V2S(), 0), "uxtl v5.2d, v3.2s"); 5360 COMPARE(Ushll2(v2.V8H(), v9.V16B(), 0), "uxtl2 v2.8h, v9.16b"); 5361 COMPARE(Ushll2(v4.V4S(), v2.V8H(), 0), "uxtl2 v4.4s, v2.8h"); 5362 COMPARE(Ushll2(v6.V2D(), v4.V4S(), 0), "uxtl2 v6.2d, v4.4s"); 5363 5364 COMPARE(Uxtl(v1.V8H(), v8.V8B()), "uxtl v1.8h, v8.8b"); 5365 COMPARE(Uxtl(v3.V4S(), v1.V4H()), "uxtl v3.4s, v1.4h"); 5366 COMPARE(Uxtl(v5.V2D(), v3.V2S()), "uxtl v5.2d, v3.2s"); 5367 COMPARE(Uxtl2(v2.V8H(), v9.V16B()), "uxtl2 v2.8h, v9.16b"); 5368 COMPARE(Uxtl2(v4.V4S(), v2.V8H()), "uxtl2 v4.4s, v2.8h"); 5369 COMPARE(Uxtl2(v6.V2D(), v4.V4S()), "uxtl2 v6.2d, v4.4s"); 5370 5371 COMPARE(Sri(v1.V8B(), v8.V8B(), 1), "sri v1.8b, v8.8b, #1"); 5372 COMPARE(Sri(v2.V16B(), v9.V16B(), 2), "sri v2.16b, v9.16b, #2"); 5373 COMPARE(Sri(v3.V4H(), v1.V4H(), 3), "sri v3.4h, v1.4h, #3"); 5374 COMPARE(Sri(v4.V8H(), v2.V8H(), 4), "sri v4.8h, v2.8h, #4"); 5375 COMPARE(Sri(v5.V2S(), v3.V2S(), 5), "sri v5.2s, v3.2s, #5"); 5376 COMPARE(Sri(v6.V4S(), v4.V4S(), 6), "sri v6.4s, v4.4s, #6"); 5377 COMPARE(Sri(v7.V2D(), v5.V2D(), 7), "sri v7.2d, v5.2d, #7"); 5378 COMPARE(Sri(d8, d6, 8), "sri d8, d6, #8"); 5379 5380 COMPARE(Shrn(v0.V8B(), v1.V8H(), 1), "shrn v0.8b, v1.8h, #1"); 5381 COMPARE(Shrn(v1.V4H(), v2.V4S(), 2), "shrn v1.4h, v2.4s, #2"); 5382 COMPARE(Shrn(v2.V2S(), v3.V2D(), 3), "shrn v2.2s, v3.2d, #3"); 5383 COMPARE(Shrn2(v0.V16B(), v1.V8H(), 4), "shrn2 v0.16b, v1.8h, #4"); 5384 COMPARE(Shrn2(v1.V8H(), v2.V4S(), 5), "shrn2 v1.8h, v2.4s, #5"); 5385 COMPARE(Shrn2(v2.V4S(), v3.V2D(), 6), "shrn2 v2.4s, v3.2d, #6"); 5386 5387 COMPARE(Rshrn(v0.V8B(), v1.V8H(), 1), "rshrn v0.8b, v1.8h, #1"); 5388 COMPARE(Rshrn(v1.V4H(), v2.V4S(), 2), "rshrn v1.4h, v2.4s, #2"); 5389 COMPARE(Rshrn(v2.V2S(), v3.V2D(), 3), "rshrn v2.2s, v3.2d, #3"); 5390 COMPARE(Rshrn2(v0.V16B(), v1.V8H(), 4), "rshrn2 v0.16b, v1.8h, #4"); 5391 COMPARE(Rshrn2(v1.V8H(), v2.V4S(), 5), "rshrn2 v1.8h, v2.4s, #5"); 5392 COMPARE(Rshrn2(v2.V4S(), v3.V2D(), 6), "rshrn2 v2.4s, v3.2d, #6"); 5393 5394 COMPARE(Uqshrn(v0.V8B(), v1.V8H(), 1), "uqshrn v0.8b, v1.8h, #1"); 5395 COMPARE(Uqshrn(v1.V4H(), v2.V4S(), 2), "uqshrn v1.4h, v2.4s, #2"); 5396 COMPARE(Uqshrn(v2.V2S(), v3.V2D(), 3), "uqshrn v2.2s, v3.2d, #3"); 5397 COMPARE(Uqshrn2(v0.V16B(), v1.V8H(), 4), "uqshrn2 v0.16b, v1.8h, #4"); 5398 COMPARE(Uqshrn2(v1.V8H(), v2.V4S(), 5), "uqshrn2 v1.8h, v2.4s, #5"); 5399 COMPARE(Uqshrn2(v2.V4S(), v3.V2D(), 6), "uqshrn2 v2.4s, v3.2d, #6"); 5400 COMPARE(Uqshrn(b0, h1, 1), "uqshrn b0, h1, #1"); 5401 COMPARE(Uqshrn(h1, s2, 2), "uqshrn h1, s2, #2"); 5402 COMPARE(Uqshrn(s2, d3, 3), "uqshrn s2, d3, #3"); 5403 5404 COMPARE(Uqrshrn(v0.V8B(), v1.V8H(), 1), "uqrshrn v0.8b, v1.8h, #1"); 5405 COMPARE(Uqrshrn(v1.V4H(), v2.V4S(), 2), "uqrshrn v1.4h, v2.4s, #2"); 5406 COMPARE(Uqrshrn(v2.V2S(), v3.V2D(), 3), "uqrshrn v2.2s, v3.2d, #3"); 5407 COMPARE(Uqrshrn2(v0.V16B(), v1.V8H(), 4), "uqrshrn2 v0.16b, v1.8h, #4"); 5408 COMPARE(Uqrshrn2(v1.V8H(), v2.V4S(), 5), "uqrshrn2 v1.8h, v2.4s, #5"); 5409 COMPARE(Uqrshrn2(v2.V4S(), v3.V2D(), 6), "uqrshrn2 v2.4s, v3.2d, #6"); 5410 COMPARE(Uqrshrn(b0, h1, 1), "uqrshrn b0, h1, #1"); 5411 COMPARE(Uqrshrn(h1, s2, 2), "uqrshrn h1, s2, #2"); 5412 COMPARE(Uqrshrn(s2, d3, 3), "uqrshrn s2, d3, #3"); 5413 5414 COMPARE(Sqshrn(v0.V8B(), v1.V8H(), 1), "sqshrn v0.8b, v1.8h, #1"); 5415 COMPARE(Sqshrn(v1.V4H(), v2.V4S(), 2), "sqshrn v1.4h, v2.4s, #2"); 5416 COMPARE(Sqshrn(v2.V2S(), v3.V2D(), 3), "sqshrn v2.2s, v3.2d, #3"); 5417 COMPARE(Sqshrn2(v0.V16B(), v1.V8H(), 4), "sqshrn2 v0.16b, v1.8h, #4"); 5418 COMPARE(Sqshrn2(v1.V8H(), v2.V4S(), 5), "sqshrn2 v1.8h, v2.4s, #5"); 5419 COMPARE(Sqshrn2(v2.V4S(), v3.V2D(), 6), "sqshrn2 v2.4s, v3.2d, #6"); 5420 COMPARE(Sqshrn(b0, h1, 1), "sqshrn b0, h1, #1"); 5421 COMPARE(Sqshrn(h1, s2, 2), "sqshrn h1, s2, #2"); 5422 COMPARE(Sqshrn(s2, d3, 3), "sqshrn s2, d3, #3"); 5423 5424 COMPARE(Sqrshrn(v0.V8B(), v1.V8H(), 1), "sqrshrn v0.8b, v1.8h, #1"); 5425 COMPARE(Sqrshrn(v1.V4H(), v2.V4S(), 2), "sqrshrn v1.4h, v2.4s, #2"); 5426 COMPARE(Sqrshrn(v2.V2S(), v3.V2D(), 3), "sqrshrn v2.2s, v3.2d, #3"); 5427 COMPARE(Sqrshrn2(v0.V16B(), v1.V8H(), 4), "sqrshrn2 v0.16b, v1.8h, #4"); 5428 COMPARE(Sqrshrn2(v1.V8H(), v2.V4S(), 5), "sqrshrn2 v1.8h, v2.4s, #5"); 5429 COMPARE(Sqrshrn2(v2.V4S(), v3.V2D(), 6), "sqrshrn2 v2.4s, v3.2d, #6"); 5430 COMPARE(Sqrshrn(b0, h1, 1), "sqrshrn b0, h1, #1"); 5431 COMPARE(Sqrshrn(h1, s2, 2), "sqrshrn h1, s2, #2"); 5432 COMPARE(Sqrshrn(s2, d3, 3), "sqrshrn s2, d3, #3"); 5433 5434 COMPARE(Sqshrun(v0.V8B(), v1.V8H(), 1), "sqshrun v0.8b, v1.8h, #1"); 5435 COMPARE(Sqshrun(v1.V4H(), v2.V4S(), 2), "sqshrun v1.4h, v2.4s, #2"); 5436 COMPARE(Sqshrun(v2.V2S(), v3.V2D(), 3), "sqshrun v2.2s, v3.2d, #3"); 5437 COMPARE(Sqshrun2(v0.V16B(), v1.V8H(), 4), "sqshrun2 v0.16b, v1.8h, #4"); 5438 COMPARE(Sqshrun2(v1.V8H(), v2.V4S(), 5), "sqshrun2 v1.8h, v2.4s, #5"); 5439 COMPARE(Sqshrun2(v2.V4S(), v3.V2D(), 6), "sqshrun2 v2.4s, v3.2d, #6"); 5440 COMPARE(Sqshrun(b0, h1, 1), "sqshrun b0, h1, #1"); 5441 COMPARE(Sqshrun(h1, s2, 2), "sqshrun h1, s2, #2"); 5442 COMPARE(Sqshrun(s2, d3, 3), "sqshrun s2, d3, #3"); 5443 5444 COMPARE(Sqrshrun(v0.V8B(), v1.V8H(), 1), "sqrshrun v0.8b, v1.8h, #1"); 5445 COMPARE(Sqrshrun(v1.V4H(), v2.V4S(), 2), "sqrshrun v1.4h, v2.4s, #2"); 5446 COMPARE(Sqrshrun(v2.V2S(), v3.V2D(), 3), "sqrshrun v2.2s, v3.2d, #3"); 5447 COMPARE(Sqrshrun2(v0.V16B(), v1.V8H(), 4), "sqrshrun2 v0.16b, v1.8h, #4"); 5448 COMPARE(Sqrshrun2(v1.V8H(), v2.V4S(), 5), "sqrshrun2 v1.8h, v2.4s, #5"); 5449 COMPARE(Sqrshrun2(v2.V4S(), v3.V2D(), 6), "sqrshrun2 v2.4s, v3.2d, #6"); 5450 COMPARE(Sqrshrun(b0, h1, 1), "sqrshrun b0, h1, #1"); 5451 COMPARE(Sqrshrun(h1, s2, 2), "sqrshrun h1, s2, #2"); 5452 COMPARE(Sqrshrun(s2, d3, 3), "sqrshrun s2, d3, #3"); 5453 5454 COMPARE(Scvtf(v5.V2S(), v3.V2S(), 11), "scvtf v5.2s, v3.2s, #11"); 5455 COMPARE(Scvtf(v6.V4S(), v4.V4S(), 12), "scvtf v6.4s, v4.4s, #12"); 5456 COMPARE(Scvtf(v7.V2D(), v5.V2D(), 33), "scvtf v7.2d, v5.2d, #33"); 5457 COMPARE(Scvtf(s8, s6, 13), "scvtf s8, s6, #13"); 5458 COMPARE(Scvtf(d8, d6, 34), "scvtf d8, d6, #34"); 5459 5460 COMPARE(Ucvtf(v5.V2S(), v3.V2S(), 11), "ucvtf v5.2s, v3.2s, #11"); 5461 COMPARE(Ucvtf(v6.V4S(), v4.V4S(), 12), "ucvtf v6.4s, v4.4s, #12"); 5462 COMPARE(Ucvtf(v7.V2D(), v5.V2D(), 33), "ucvtf v7.2d, v5.2d, #33"); 5463 COMPARE(Ucvtf(s8, s6, 13), "ucvtf s8, s6, #13"); 5464 COMPARE(Ucvtf(d8, d6, 34), "ucvtf d8, d6, #34"); 5465 5466 COMPARE(Fcvtzs(v5.V2S(), v3.V2S(), 11), "fcvtzs v5.2s, v3.2s, #11"); 5467 COMPARE(Fcvtzs(v6.V4S(), v4.V4S(), 12), "fcvtzs v6.4s, v4.4s, #12"); 5468 COMPARE(Fcvtzs(v7.V2D(), v5.V2D(), 33), "fcvtzs v7.2d, v5.2d, #33"); 5469 COMPARE(Fcvtzs(s8, s6, 13), "fcvtzs s8, s6, #13"); 5470 COMPARE(Fcvtzs(d8, d6, 34), "fcvtzs d8, d6, #34"); 5471 5472 COMPARE(Fcvtzu(v5.V2S(), v3.V2S(), 11), "fcvtzu v5.2s, v3.2s, #11"); 5473 COMPARE(Fcvtzu(v6.V4S(), v4.V4S(), 12), "fcvtzu v6.4s, v4.4s, #12"); 5474 COMPARE(Fcvtzu(v7.V2D(), v5.V2D(), 33), "fcvtzu v7.2d, v5.2d, #33"); 5475 COMPARE(Fcvtzu(s8, s6, 13), "fcvtzu s8, s6, #13"); 5476 COMPARE(Fcvtzu(d8, d6, 34), "fcvtzu d8, d6, #34"); 5477 5478 CLEANUP(); 5479} 5480 5481TEST(address_map) { 5482 // Check that we can disassemble from a fake base address. 5483 SETUP(); 5484 5485 disasm->MapCodeAddress(0, reinterpret_cast<Instruction*>(buf)); 5486 COMPARE(ldr(x0, 0), "ldr x0, pc+0 (addr 0x0)"); 5487 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr -0x4)"); 5488 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x4)"); 5489 COMPARE(prfm(PLIL1KEEP, 0), "prfm plil1keep, pc+0 (addr 0x0)"); 5490 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr -0x4)"); 5491 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x4)"); 5492 COMPARE(adr(x0, 0), "adr x0, #+0x0 (addr 0x0)"); 5493 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr -0x1)"); 5494 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x1)"); 5495 COMPARE(adrp(x0, 0), "adrp x0, #+0x0 (addr 0x0)"); 5496 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr -0x1000)"); 5497 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x1000)"); 5498 COMPARE(b(0), "b #+0x0 (addr 0x0)"); 5499 COMPARE(b(-1), "b #-0x4 (addr -0x4)"); 5500 COMPARE(b(1), "b #+0x4 (addr 0x4)"); 5501 5502 disasm->MapCodeAddress(0x1234, reinterpret_cast<Instruction*>(buf)); 5503 COMPARE(ldr(x0, 0), "ldr x0, pc+0 (addr 0x1234)"); 5504 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr 0x1230)"); 5505 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x1238)"); 5506 COMPARE(prfm(PLIL1KEEP, 0), "prfm plil1keep, pc+0 (addr 0x1234)"); 5507 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr 0x1230)"); 5508 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x1238)"); 5509 COMPARE(adr(x0, 0), "adr x0, #+0x0 (addr 0x1234)"); 5510 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr 0x1233)"); 5511 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x1235)"); 5512 COMPARE(adrp(x0, 0), "adrp x0, #+0x0 (addr 0x1000)"); 5513 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr 0x0)"); 5514 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x2000)"); 5515 COMPARE(b(0), "b #+0x0 (addr 0x1234)"); 5516 COMPARE(b(-1), "b #-0x4 (addr 0x1230)"); 5517 COMPARE(b(1), "b #+0x4 (addr 0x1238)"); 5518 5519 // Check that 64-bit addresses work. 5520 disasm->MapCodeAddress(UINT64_C(0x100000000), 5521 reinterpret_cast<Instruction*>(buf)); 5522 COMPARE(ldr(x0, 0), "ldr x0, pc+0 (addr 0x100000000)"); 5523 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr 0xfffffffc)"); 5524 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x100000004)"); 5525 COMPARE(prfm(PLIL1KEEP, 0), "prfm plil1keep, pc+0 (addr 0x100000000)"); 5526 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr 0xfffffffc)"); 5527 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x100000004)"); 5528 COMPARE(adr(x0, 0), "adr x0, #+0x0 (addr 0x100000000)"); 5529 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr 0xffffffff)"); 5530 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x100000001)"); 5531 COMPARE(adrp(x0, 0), "adrp x0, #+0x0 (addr 0x100000000)"); 5532 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr 0xfffff000)"); 5533 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x100001000)"); 5534 COMPARE(b(0), "b #+0x0 (addr 0x100000000)"); 5535 COMPARE(b(-1), "b #-0x4 (addr 0xfffffffc)"); 5536 COMPARE(b(1), "b #+0x4 (addr 0x100000004)"); 5537 5538 disasm->MapCodeAddress(0xfffffffc, reinterpret_cast<Instruction*>(buf)); 5539 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x100000000)"); 5540 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x100000000)"); 5541 COMPARE(b(1), "b #+0x4 (addr 0x100000000)"); 5542 COMPARE(adr(x0, 4), "adr x0, #+0x4 (addr 0x100000000)"); 5543 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x100000000)"); 5544 5545 // Check that very large offsets are handled properly. This detects misuse of 5546 // the host's ptrdiff_t type when run on a 32-bit host. Only adrp is capable 5547 // of encoding such offsets. 5548 disasm->MapCodeAddress(0, reinterpret_cast<Instruction*>(buf)); 5549 COMPARE(adrp(x0, 0x000fffff), "adrp x0, #+0xfffff000 (addr 0xfffff000)"); 5550 COMPARE(adrp(x0, -0x00100000), "adrp x0, #-0x100000000 (addr -0x100000000)"); 5551 5552 CLEANUP(); 5553} 5554 5555} // namespace vixl 5556