test/MC/AArch64/neon-diagnostics.s

   1 // RUN: not llvm-mc -triple aarch64-none-linux-gnu -mattr=+neon < %s 2> %t
   2 // RUN: FileCheck --check-prefix=CHECK-ERROR < %t %s
   3
   4 //------------------------------------------------------------------------------
   5 // Vector Integer Add/sub
   6 //------------------------------------------------------------------------------
   7
   8         // Mismatched vector types
   9         add v0.16b, v1.8b, v2.8b
  10         sub v0.2d, v1.2d, v2.2s
  11
  12 // CHECK-ERROR: error: invalid operand for instruction
  13 // CHECK-ERROR:         add v0.16b, v1.8b, v2.8b
  14 // CHECK-ERROR:                        ^
  15 // CHECK-ERROR: error: invalid operand for instruction
  16 // CHECK-ERROR:         sub v0.2d, v1.2d, v2.2s
  17 // CHECK-ERROR:                              ^
  18
  19 //------------------------------------------------------------------------------
  20 // Vector Floating-Point Add/sub
  21 //------------------------------------------------------------------------------
  22
  23         // Mismatched and invalid vector types
  24         fadd v0.2d, v1.2s, v2.2s
  25         fsub v0.4s, v1.2s, v2.4s
  26         fsub v0.8b, v1.8b, v2.8b
  27
  28 // CHECK-ERROR: error: invalid operand for instruction
  29 // CHECK-ERROR:         fadd v0.2d, v1.2s, v2.2s
  30 // CHECK-ERROR:                        ^
  31 // CHECK-ERROR: error: invalid operand for instruction
  32 // CHECK-ERROR:         fsub v0.4s, v1.2s, v2.4s
  33 // CHECK-ERROR:                        ^
  34 // CHECK-ERROR: error: invalid operand for instruction
  35 // CHECK-ERROR:         fsub v0.8b, v1.8b, v2.8b
  36 // CHECK-ERROR:                  ^
  37
  38 //----------------------------------------------------------------------
  39 // Vector Integer Mul
  40 //----------------------------------------------------------------------
  41
  42         // Mismatched and invalid vector types
  43         mul v0.16b, v1.8b, v2.8b
  44         mul v0.2d, v1.2d, v2.2d
  45
  46 // CHECK-ERROR: error: invalid operand for instruction
  47 // CHECK-ERROR:         mul v0.16b, v1.8b, v2.8b
  48 // CHECK-ERROR:                        ^
  49 // CHECK-ERROR: error: invalid operand for instruction
  50 // CHECK-ERROR:         mul v0.2d, v1.2d, v2.2d
  51 // CHECK-ERROR:                ^
  52
  53 //----------------------------------------------------------------------
  54 // Vector Floating-Point Mul/Div
  55 //----------------------------------------------------------------------
  56         // Mismatched vector types
  57         fmul v0.16b, v1.8b, v2.8b
  58         fdiv v0.2s, v1.2d, v2.2d
  59
  60 // CHECK-ERROR: error: invalid operand for instruction
  61 // CHECK-ERROR:         fmul v0.16b, v1.8b, v2.8b
  62 // CHECK-ERROR:                         ^
  63 // CHECK-ERROR: error: invalid operand for instruction
  64 // CHECK-ERROR:         fdiv v0.2s, v1.2d, v2.2d
  65 // CHECK-ERROR:                        ^
  66
  67 //----------------------------------------------------------------------
  68 // Vector And Orr Eor Bsl Bit Bif, Orn, Bic,
  69 //----------------------------------------------------------------------
  70         // Mismatched and invalid vector types
  71         and v0.8b, v1.16b, v2.8b
  72         orr v0.4h, v1.4h, v2.4h
  73         eor v0.2s, v1.2s, v2.2s
  74         bsl v0.8b, v1.16b, v2.8b
  75         bsl v0.2s, v1.2s, v2.2s
  76         bit v0.2d, v1.2d, v2.2d
  77         bif v0.4h, v1.4h, v2.4h
  78         orn v0.8b, v1.16b, v2.16b
  79         bic v0.2d, v1.2d, v2.2d
  80
  81 // CHECK-ERROR: error: invalid operand for instruction
  82 // CHECK-ERROR:         and v0.8b, v1.16b, v2.8b
  83 // CHECK-ERROR:                       ^
  84 // CHECK-ERROR: error: immediate must be an integer in range [0, 255]
  85 // CHECK-ERROR:         orr v0.4h, v1.4h, v2.4h
  86 // CHECK-ERROR:                ^
  87 // CHECK-ERROR: error: invalid operand for instruction
  88 // CHECK-ERROR:         eor v0.2s, v1.2s, v2.2s
  89 // CHECK-ERROR:                ^
  90 // CHECK-ERROR: error: invalid operand for instruction
  91 // CHECK-ERROR:         bsl v0.8b, v1.16b, v2.8b
  92 // CHECK-ERROR:                       ^
  93 // CHECK-ERROR: error: invalid operand for instruction
  94 // CHECK-ERROR:         bsl v0.2s, v1.2s, v2.2s
  95 // CHECK-ERROR:                ^
  96 // CHECK-ERROR: error: invalid operand for instruction
  97 // CHECK-ERROR:         bit v0.2d, v1.2d, v2.2d
  98 // CHECK-ERROR:                ^
  99 // CHECK-ERROR: error: invalid operand for instruction
 100 // CHECK-ERROR:         bif v0.4h, v1.4h, v2.4h
 101 // CHECK-ERROR:                ^
 102 // CHECK-ERROR: error: invalid operand for instruction
 103 // CHECK-ERROR:         orn v0.8b, v1.16b, v2.16b
 104 // CHECK-ERROR:                        ^
 105 // CHECK-ERROR: error: invalid operand for instruction
 106 // CHECK-ERROR:         bic v0.2d, v1.2d, v2.2d
 107 // CHECK-ERROR:                ^
 108
 109 //----------------------------------------------------------------------
 110 // Vector Integer Multiply-accumulate and Multiply-subtract
 111 //----------------------------------------------------------------------
 112
 113         // Mismatched and invalid vector types
 114         mla v0.16b, v1.8b, v2.8b
 115         mls v0.2d, v1.2d, v2.2d
 116
 117 // CHECK-ERROR: error: invalid operand for instruction
 118 // CHECK-ERROR:         mla v0.16b, v1.8b, v2.8b
 119 // CHECK-ERROR:                        ^
 120 // CHECK-ERROR: error: invalid operand for instruction
 121 // CHECK-ERROR:         mls v0.2d, v1.2d, v2.2d
 122 // CHECK-ERROR:                ^
 123
 124 //----------------------------------------------------------------------
 125 // Vector Floating-Point Multiply-accumulate and Multiply-subtract
 126 //----------------------------------------------------------------------
 127         // Mismatched vector types
 128         fmla v0.2s, v1.2d, v2.2d
 129         fmls v0.16b, v1.8b, v2.8b
 130
 131 // CHECK-ERROR: error: invalid operand for instruction
 132 // CHECK-ERROR:         fmla v0.2s, v1.2d, v2.2d
 133 // CHECK-ERROR:                        ^
 134 // CHECK-ERROR: error: invalid operand for instruction
 135 // CHECK-ERROR:         fmls v0.16b, v1.8b, v2.8b
 136 // CHECK-ERROR:                         ^
 137
 138
 139 //----------------------------------------------------------------------
 140 // Vector Move Immediate Shifted
 141 // Vector Move Inverted Immediate Shifted
 142 // Vector Bitwise Bit Clear (AND NOT) - immediate
 143 // Vector Bitwise OR - immedidate
 144 //----------------------------------------------------------------------
 145       // out of range immediate (0 to 0xff)
 146       movi v0.2s, #-1
 147       mvni v1.4s, #256
 148       // out of range shift (0, 8, 16, 24 and 0, 8)
 149       bic v15.4h, #1, lsl #7
 150       orr v31.2s, #1, lsl #25
 151       movi v5.4h, #10, lsl #16
 152       // invalid vector type (2s, 4s, 4h, 8h)
 153       movi v5.8b, #1, lsl #8
 154
 155 // CHECK-ERROR: error: immediate must be an integer in range [0, 255]
 156 // CHECK-ERROR:          movi v0.2s, #-1
 157 // CHECK-ERROR:                      ^
 158 // CHECK-ERROR: error: immediate must be an integer in range [0, 255]
 159 // CHECK-ERROR:         mvni v1.4s, #256
 160 // CHECK-ERROR:                     ^
 161 // CHECK-ERROR: error: invalid operand for instruction
 162 // CHECK-ERROR:         bic v15.4h, #1, lsl #7
 163 // CHECK-ERROR:                         ^
 164 // CHECK-ERROR: error: invalid operand for instruction
 165 // CHECK-ERROR:         orr v31.2s, #1, lsl #25
 166 // CHECK-ERROR:                         ^
 167 // CHECK-ERROR: error: invalid operand for instruction
 168 // CHECK-ERROR:         movi v5.4h, #10, lsl #16
 169 // CHECK-ERROR:                          ^
 170 // CHECK-ERROR: error: invalid operand for instruction
 171 // CHECK-ERROR:         movi v5.8b, #1, lsl #8
 172 // CHECK-ERROR:                         ^
 173 //----------------------------------------------------------------------
 174 // Vector Move Immediate Masked
 175 // Vector Move Inverted Immediate Masked
 176 //----------------------------------------------------------------------
 177       // out of range immediate (0 to 0xff)
 178       movi v0.2s, #-1, msl #8
 179       mvni v7.4s, #256, msl #16
 180       // out of range shift (8, 16)
 181       movi v3.2s, #1, msl #0
 182       mvni v17.4s, #255, msl #32
 183       // invalid vector type (2s, 4s)
 184       movi v5.4h, #31, msl #8
 185
 186 // CHECK-ERROR: error: immediate must be an integer in range [0, 255]
 187 // CHECK-ERROR:         movi v0.2s, #-1, msl #8
 188 // CHECK-ERROR:                     ^
 189 // CHECK-ERROR: error: immediate must be an integer in range [0, 255]
 190 // CHECK-ERROR:         mvni v7.4s, #256, msl #16
 191 // CHECK-ERROR:                     ^
 192 // CHECK-ERROR: error: invalid operand for instruction
 193 // CHECK-ERROR:         movi v3.2s, #1, msl #0
 194 // CHECK-ERROR:                         ^
 195 // CHECK-ERROR: error: invalid operand for instruction
 196 // CHECK-ERROR:         mvni v17.4s, #255, msl #32
 197 // CHECK-ERROR:                            ^
 198 // CHECK-ERROR: error: invalid operand for instruction
 199 // CHECK-ERROR:         movi v5.4h, #31, msl #8
 200 // CHECK-ERROR:                          ^
 201
 202 //----------------------------------------------------------------------
 203 // Vector Immediate - per byte
 204 //----------------------------------------------------------------------
 205         // out of range immediate (0 to 0xff)
 206         movi v0.8b, #-1
 207         movi v1.16b, #256
 208
 209 // CHECK-ERROR: error: immediate must be an integer in range [0, 255]
 210 // CHECK-ERROR:         movi v0.8b, #-1
 211 // CHECK-ERROR:                     ^
 212 // CHECK-ERROR: error: immediate must be an integer in range [0, 255]
 213 // CHECK-ERROR:         movi v1.16b, #256
 214 // CHECK-ERROR:                      ^
 215
 216 //----------------------------------------------------------------------
 217 // Scalar Floating-point Reciprocal Estimate
 218 //----------------------------------------------------------------------
 219
 220     frecpe s19, h14
 221     frecpe d13, s13
 222
 223 // CHECK-ERROR: error: invalid operand for instruction
 224 // CHECK-ERROR:        frecpe s19, h14
 225 // CHECK-ERROR:                    ^
 226 // CHECK-ERROR: error: invalid operand for instruction
 227 // CHECK-ERROR:        frecpe d13, s13
 228 // CHECK-ERROR:                    ^
 229
 230 //----------------------------------------------------------------------
 231 // Scalar Floating-point Reciprocal Exponent
 232 //----------------------------------------------------------------------
 233
 234     frecpx s18, h10
 235     frecpx d16, s19
 236
 237 // CHECK-ERROR: error: invalid operand for instruction
 238 // CHECK-ERROR:        frecpx s18, h10
 239 // CHECK-ERROR:                    ^
 240 // CHECK-ERROR: error: invalid operand for instruction
 241 // CHECK-ERROR:        frecpx d16, s19
 242 // CHECK-ERROR:                    ^
 243
 244 //----------------------------------------------------------------------
 245 // Scalar Floating-point Reciprocal Square Root Estimate
 246 //----------------------------------------------------------------------
 247
 248     frsqrte s22, h13
 249     frsqrte d21, s12
 250
 251 // CHECK-ERROR: error: invalid operand for instruction
 252 // CHECK-ERROR:        frsqrte s22, h13
 253 // CHECK-ERROR:                     ^
 254 // CHECK-ERROR: error: invalid operand for instruction
 255 // CHECK-ERROR:        frsqrte d21, s12
 256 // CHECK-ERROR:                     ^
 257
 258 //----------------------------------------------------------------------
 259 // Vector Move Immediate - bytemask, per doubleword
 260 //---------------------------------------------------------------------
 261         // invalid bytemask (0x00 or 0xff)
 262         movi v0.2d, #0x10ff00ff00ff00ff
 263
 264 // CHECK:ERROR: error: invalid operand for instruction
 265 // CHECK:ERROR:         movi v0.2d, #0x10ff00ff00ff00ff
 266 // CHECK:ERROR:                     ^
 267
 268 //----------------------------------------------------------------------
 269 // Vector Move Immediate - bytemask, one doubleword
 270 //----------------------------------------------------------------------
 271         // invalid bytemask (0x00 or 0xff)
 272         movi v0.2d, #0xffff00ff001f00ff
 273
 274 // CHECK:ERROR: error: invalid operand for instruction
 275 // CHECK:ERROR:         movi v0.2d, #0xffff00ff001f00ff
 276 // CHECK:ERROR:                     ^
 277 //----------------------------------------------------------------------
 278 // Vector Floating Point Move Immediate
 279 //----------------------------------------------------------------------
 280         // invalid vector type (2s, 4s, 2d)
 281          fmov v0.4h, #1.0
 282          // invalid immediate (negative hexadecimal encoding)
 283          fmov v0.4s, #-0x0
 284
 285 // CHECK:ERROR: error: invalid operand for instruction
 286 // CHECK:ERROR:         fmov v0.4h, #1.0
 287 // CHECK:ERROR:              ^
 288 // CHECK-ERROR: error: encoded floating point value out of range
 289 // CHECK-ERROR:         fmov v0.4s, #-0x0
 290 // CHECK-ERROR:                     ^
 291
 292 //----------------------------------------------------------------------
 293 // Vector Move -  register
 294 //----------------------------------------------------------------------
 295       // invalid vector type (8b, 16b)
 296       mov v0.2s, v31.8b
 297 // CHECK:ERROR: error: invalid operand for instruction
 298 // CHECK:ERROR:         mov v0.2s, v31.8b
 299 // CHECK:ERROR:                ^
 300
 301 //----------------------------------------------------------------------
 302 // Vector Absolute Difference and Accumulate (Signed, Unsigned)
 303 //----------------------------------------------------------------------
 304
 305         // Mismatched and invalid vector types (2d)
 306         saba v0.16b, v1.8b, v2.8b
 307         uaba v0.2d, v1.2d, v2.2d
 308
 309 // CHECK-ERROR: error: invalid operand for instruction
 310 // CHECK-ERROR:         saba v0.16b, v1.8b, v2.8b
 311 // CHECK-ERROR:                        ^
 312 // CHECK-ERROR: error: invalid operand for instruction
 313 // CHECK-ERROR:         uaba v0.2d, v1.2d, v2.2d
 314 // CHECK-ERROR:                ^
 315
 316 //----------------------------------------------------------------------
 317 // Vector Absolute Difference and Accumulate (Signed, Unsigned)
 318 // Vector Absolute Difference (Signed, Unsigned)
 319
 320         // Mismatched and invalid vector types (2d)
 321         uaba v0.16b, v1.8b, v2.8b
 322         saba v0.2d, v1.2d, v2.2d
 323         uabd v0.4s, v1.2s, v2.2s
 324         sabd v0.4h, v1.8h, v8.8h
 325
 326 // CHECK-ERROR: error: invalid operand for instruction
 327 // CHECK-ERROR:         uaba v0.16b, v1.8b, v2.8b
 328 // CHECK-ERROR:                        ^
 329 // CHECK-ERROR: error: invalid operand for instruction
 330 // CHECK-ERROR:         saba v0.2d, v1.2d, v2.2d
 331 // CHECK-ERROR:                ^
 332 // CHECK-ERROR: error: invalid operand for instruction
 333 // CHECK-ERROR:         uabd v0.4s, v1.2s, v2.2s
 334 // CHECK-ERROR:                        ^
 335 // CHECK-ERROR: error: invalid operand for instruction
 336 // CHECK-ERROR:         sabd v0.4h, v1.8h, v8.8h
 337 // CHECK-ERROR:                        ^
 338
 339 //----------------------------------------------------------------------
 340 // Vector Absolute Difference (Floating Point)
 341 //----------------------------------------------------------------------
 342         // Mismatched and invalid vector types
 343         fabd v0.2s, v1.4s, v2.2d
 344         fabd v0.4h, v1.4h, v2.4h
 345
 346 // CHECK-ERROR: error: invalid operand for instruction
 347 // CHECK-ERROR:         fabd v0.2s, v1.4s, v2.2d
 348 // CHECK-ERROR:                        ^
 349 // CHECK-ERROR: error: instruction requires: fullfp16
 350 // CHECK-ERROR:         fabd v0.4h, v1.4h, v2.4h
 351 // CHECK-ERROR:                 ^
 352 //----------------------------------------------------------------------
 353 // Vector Multiply (Polynomial)
 354 //----------------------------------------------------------------------
 355
 356         // Mismatched and invalid vector types
 357          pmul v0.8b, v1.8b, v2.16b
 358          pmul v0.2s, v1.2s, v2.2s
 359
 360 // CHECK-ERROR: error: invalid operand for instruction
 361 // CHECK-ERROR:         pmul v0.8b, v1.8b, v2.16b
 362 // CHECK-ERROR:                               ^
 363 // CHECK-ERROR: error: invalid operand for instruction
 364 // CHECK-ERROR:         pmul v0.2s, v1.2s, v2.2s
 365 // CHECK-ERROR:                 ^
 366
 367 //----------------------------------------------------------------------
 368 // Scalar Integer Add and Sub
 369 //----------------------------------------------------------------------
 370
 371       // Mismatched registers
 372          add d0, s1, d2
 373          sub s1, d1, d2
 374
 375 // CHECK-ERROR: error: invalid operand for instruction
 376 // CHECK-ERROR:         add d0, s1, d2
 377 // CHECK-ERROR:                 ^
 378 // CHECK-ERROR: error: invalid operand for instruction
 379 // CHECK-ERROR:         sub s1, d1, d2
 380 // CHECK-ERROR:             ^
 381
 382 //----------------------------------------------------------------------
 383 // Vector Reciprocal Step (Floating Point)
 384 //----------------------------------------------------------------------
 385
 386         // Mismatched and invalid vector types
 387          frecps v0.4s, v1.2d, v2.4s
 388          frecps v0.8h, v1.8h, v2.8h
 389
 390 // CHECK-ERROR: error: invalid operand for instruction
 391 // CHECK-ERROR:        frecps v0.4s, v1.2d, v2.4s
 392 // CHECK-ERROR:                         ^
 393 // CHECK-ERROR: error: instruction requires: fullfp16
 394 // CHECK-ERROR:        frecps v0.8h, v1.8h, v2.8h
 395 // CHECK-ERROR:                  ^
 396
 397 //----------------------------------------------------------------------
 398 // Vector Reciprocal Square Root Step (Floating Point)
 399 //----------------------------------------------------------------------
 400
 401         // Mismatched and invalid vector types
 402          frsqrts v0.2d, v1.2d, v2.2s
 403          frsqrts v0.4h, v1.4h, v2.4h
 404
 405 // CHECK-ERROR: error: invalid operand for instruction
 406 // CHECK-ERROR:        frsqrts v0.2d, v1.2d, v2.2s
 407 // CHECK-ERROR:                                 ^
 408 // CHECK-ERROR: error: instruction requires: fullfp16
 409 // CHECK-ERROR:        frsqrts v0.4h, v1.4h, v2.4h
 410 // CHECK-ERROR:                   ^
 411
 412
 413 //----------------------------------------------------------------------
 414 // Vector Absolute Compare Mask Less Than Or Equal (Floating Point)
 415 //----------------------------------------------------------------------
 416
 417         // Mismatched and invalid vector types
 418         facge v0.2d, v1.2s, v2.2d
 419         facge v0.4h, v1.4h, v2.4h
 420         facle v0.8h, v1.4h, v2.4h
 421
 422 // CHECK-ERROR: error: invalid operand for instruction
 423 // CHECK-ERROR:        facge v0.2d, v1.2s, v2.2d
 424 // CHECK-ERROR:                        ^
 425 // CHECK-ERROR: error: instruction requires: fullfp16
 426 // CHECK-ERROR:        facge v0.4h, v1.4h, v2.4h
 427 // CHECK-ERROR:                 ^
 428 // CHECK-ERROR: error: invalid operand for instruction
 429 // CHECK-ERROR:        facle v0.8h, v1.4h, v2.4h
 430 // CHECK-ERROR:                 ^
 431 //----------------------------------------------------------------------
 432 // Vector Absolute Compare Mask Less Than (Floating Point)
 433 //----------------------------------------------------------------------
 434
 435         // Mismatched and invalid vector types
 436         facgt v0.2d, v1.2d, v2.4s
 437         facgt v0.8h, v1.8h, v2.8h
 438         faclt v0.8b, v1.8b, v2.8b
 439
 440 // CHECK-ERROR: error: invalid operand for instruction
 441 // CHECK-ERROR:        facgt v0.2d, v1.2d, v2.4s
 442 // CHECK-ERROR:                               ^
 443 // CHECK-ERROR: error: instruction requires: fullfp16
 444 // CHECK-ERROR:        facgt v0.8h, v1.8h, v2.8h
 445 // CHECK-ERROR:                 ^
 446 // CHECK-ERROR: error: invalid operand for instruction
 447 // CHECK-ERROR:        faclt v0.8b, v1.8b, v2.8b
 448 // CHECK-ERROR:                 ^
 449
 450
 451 //----------------------------------------------------------------------
 452 // Vector Compare Mask Equal (Integer)
 453 //----------------------------------------------------------------------
 454
 455          // Mismatched vector types
 456          cmeq c0.2d, v1.2d, v2.2s
 457
 458 // CHECK-ERROR: error: invalid operand for instruction
 459 // CHECK-ERROR:        cmeq c0.2d, v1.2d, v2.2s
 460 // CHECK-ERROR:                              ^
 461
 462 //----------------------------------------------------------------------
 463 // Vector Compare Mask Higher or Same (Unsigned Integer)
 464 // Vector Compare Mask Less or Same (Unsigned Integer)
 465 // CMLS is alias for CMHS with operands reversed.
 466 //----------------------------------------------------------------------
 467
 468          // Mismatched vector types
 469          cmhs c0.4h, v1.8b, v2.8b
 470          cmls c0.16b, v1.16b, v2.2d
 471
 472 // CHECK-ERROR: error: invalid operand for instruction
 473 // CHECK-ERROR:        cmhs c0.4h, v1.8b, v2.8b
 474 // CHECK-ERROR:                       ^
 475 // CHECK-ERROR: error: invalid operand for instruction
 476 // CHECK-ERROR:        cmls c0.16b, v1.16b, v2.2d
 477 // CHECK-ERROR:                                ^
 478
 479 //----------------------------------------------------------------------
 480 // Vector Compare Mask Greater Than or Equal (Integer)
 481 // Vector Compare Mask Less Than or Equal (Integer)
 482 // CMLE is alias for CMGE with operands reversed.
 483 //----------------------------------------------------------------------
 484
 485          // Mismatched vector types
 486          cmge c0.8h, v1.8b, v2.8b
 487          cmle c0.4h, v1.2s, v2.2s
 488
 489 // CHECK-ERROR: error: invalid operand for instruction
 490 // CHECK-ERROR:        cmge c0.8h, v1.8b, v2.8b
 491 // CHECK-ERROR:                       ^
 492 // CHECK-ERROR: error: invalid operand for instruction
 493 // CHECK-ERROR:         cmle c0.4h, v1.2s, v2.2s
 494 // CHECK-ERROR:                        ^
 495
 496 //----------------------------------------------------------------------
 497 // Vector Compare Mask Higher (Unsigned Integer)
 498 // Vector Compare Mask Lower (Unsigned Integer)
 499 // CMLO is alias for CMHI with operands reversed.
 500 //----------------------------------------------------------------------
 501
 502          // Mismatched vector types
 503          cmhi c0.4s, v1.4s, v2.16b
 504          cmlo c0.8b, v1.8b, v2.2s
 505
 506 // CHECK-ERROR: error: invalid operand for instruction
 507 // CHECK-ERROR:        cmhi c0.4s, v1.4s, v2.16b
 508 // CHECK-ERROR:                              ^
 509 // CHECK-ERROR: error: invalid operand for instruction
 510 // CHECK-ERROR:         cmlo c0.8b, v1.8b, v2.2s
 511 // CHECK-ERROR:                               ^
 512
 513 //----------------------------------------------------------------------
 514 // Vector Compare Mask Greater Than (Integer)
 515 // Vector Compare Mask Less Than (Integer)
 516 // CMLT is alias for CMGT with operands reversed.
 517 //----------------------------------------------------------------------
 518
 519          // Mismatched vector types
 520          cmgt c0.8b, v1.4s, v2.16b
 521          cmlt c0.8h, v1.16b, v2.4s
 522
 523 // CHECK-ERROR: error: invalid operand for instruction
 524 // CHECK-ERROR:         cmgt c0.8b, v1.4s, v2.16b
 525 // CHECK-ERROR:                        ^
 526 // CHECK-ERROR: error: invalid operand for instruction
 527 // CHECK-ERROR:         cmlt c0.8h, v1.16b, v2.4s
 528 // CHECK-ERROR:                        ^
 529
 530 //----------------------------------------------------------------------
 531 // Vector Compare Mask Bitwise Test (Integer)
 532 //----------------------------------------------------------------------
 533
 534          // Mismatched vector types
 535          cmtst c0.16b, v1.16b, v2.4s
 536
 537 // CHECK-ERROR: error: invalid operand for instruction
 538 // CHECK-ERROR:         cmtst c0.16b, v1.16b, v2.4s
 539 // CHECK-ERROR:                                  ^
 540
 541 //----------------------------------------------------------------------
 542 // Vector Compare Mask Equal (Floating Point)
 543 //----------------------------------------------------------------------
 544
 545         // Mismatched and invalid vector types
 546         fcmeq v0.2d, v1.2s, v2.2d
 547         fcmeq v0.16b, v1.16b, v2.16b
 548         fcmeq v0.8b, v1.4h, v2.4h
 549
 550 // CHECK-ERROR: error: invalid operand for instruction
 551 // CHECK-ERROR:        fcmeq v0.2d, v1.2s, v2.2d
 552 // CHECK-ERROR:                        ^
 553 // CHECK-ERROR: error: invalid operand for instruction
 554 // CHECK-ERROR:        fcmeq v0.16b, v1.16b, v2.16b
 555 // CHECK-ERROR:                 ^
 556 // CHECK-ERROR: error: invalid operand for instruction
 557 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, v2.4h
 558 // CHECK-ERROR:                 ^
 559
 560 //----------------------------------------------------------------------
 561 // Vector Compare Mask Greater Than Or Equal (Floating Point)
 562 // Vector Compare Mask Less Than Or Equal (Floating Point)
 563 // FCMLE is alias for FCMGE with operands reversed.
 564 //----------------------------------------------------------------------
 565
 566         // Mismatched and invalid vector types
 567          fcmge v31.4s, v29.2s, v28.4s
 568          fcmge v3.8b, v8.2s, v12.2s
 569          fcmle v17.8h, v15.2d, v13.2d
 570
 571 // CHECK-ERROR: error: invalid operand for instruction
 572 // CHECK-ERROR:        fcmge v31.4s, v29.2s, v28.4s
 573 // CHECK-ERROR:                          ^
 574 // CHECK-ERROR: error: invalid operand for instruction
 575 // CHECK-ERROR:        fcmge v3.8b, v8.2s, v12.2s
 576 // CHECK-ERROR:                 ^
 577 // CHECK-ERROR: error: invalid operand for instruction
 578 // CHECK-ERROR:        fcmle v17.8h, v15.2d, v13.2d
 579 // CHECK-ERROR:                 ^
 580
 581 //----------------------------------------------------------------------
 582 // Vector Compare Mask Greater Than (Floating Point)
 583 // Vector Compare Mask Less Than (Floating Point)
 584 // FCMLT is alias for FCMGT with operands reversed.
 585 //----------------------------------------------------------------------
 586
 587         // Mismatched and invalid vector types
 588          fcmgt v0.2d, v31.2s, v16.2s
 589          fcmgt v4.4s, v7.4s, v15.4h
 590          fcmlt v29.2d, v5.2d, v2.16b
 591
 592 // CHECK-ERROR: error: invalid operand for instruction
 593 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, v16.2s
 594 // CHECK-ERROR:                         ^
 595
 596 // CHECK-ERROR: error: invalid operand for instruction
 597 // CHECK-ERROR:        fcmgt v4.4s, v7.4s, v15.4h
 598 // CHECK-ERROR:                                ^
 599 // CHECK-ERROR: error: invalid operand for instruction
 600 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, v2.16b
 601 // CHECK-ERROR:                                ^
 602
 603 //----------------------------------------------------------------------
 604 // Vector Compare Mask Equal to Zero (Integer)
 605 //----------------------------------------------------------------------
 606         // Mismatched vector types and invalid imm
 607          // Mismatched vector types
 608          cmeq c0.2d, v1.2s, #0
 609          cmeq c0.2d, v1.2d, #1
 610
 611 // CHECK-ERROR: error: invalid operand for instruction
 612 // CHECK-ERROR:        cmeq c0.2d, v1.2s, #0
 613 // CHECK-ERROR:                       ^
 614 // CHECK-ERROR: error: invalid operand for instruction
 615 // CHECK-ERROR:        cmeq c0.2d, v1.2d, #1
 616 // CHECK-ERROR:                            ^
 617
 618 //----------------------------------------------------------------------
 619 // Vector Compare Mask Greater Than or Equal to Zero (Signed Integer)
 620 //----------------------------------------------------------------------
 621         // Mismatched vector types and invalid imm
 622          cmge c0.8h, v1.8b, #0
 623          cmge c0.4s, v1.4s, #-1
 624
 625 // CHECK-ERROR: error: invalid operand for instruction
 626 // CHECK-ERROR:        cmge c0.8h, v1.8b, #0
 627 // CHECK-ERROR:                       ^
 628 // CHECK-ERROR: error: invalid operand for instruction
 629 // CHECK-ERROR:         cmge c0.4s, v1.4s, #-1
 630 // CHECK-ERROR:                             ^
 631
 632 //----------------------------------------------------------------------
 633 // Vector Compare Mask Greater Than Zero (Signed Integer)
 634 //----------------------------------------------------------------------
 635         // Mismatched vector types and invalid imm
 636          cmgt c0.8b, v1.4s, #0
 637          cmgt c0.8b, v1.8b, #-255
 638
 639 // CHECK-ERROR: error: invalid operand for instruction
 640 // CHECK-ERROR:         cmgt c0.8b, v1.4s, #0
 641 // CHECK-ERROR:                        ^
 642 // CHECK-ERROR: error: invalid operand for instruction
 643 // CHECK-ERROR:         cmgt c0.8b, v1.8b, #-255
 644 // CHECK-ERROR:                             ^
 645
 646 //----------------------------------------------------------------------
 647 // Vector Compare Mask Less Than or Equal To Zero (Signed Integer)
 648 //----------------------------------------------------------------------
 649         // Mismatched vector types and invalid imm
 650          cmle c0.4h, v1.2s, #0
 651          cmle c0.16b, v1.16b, #16
 652
 653 // CHECK-ERROR: error: invalid operand for instruction
 654 // CHECK-ERROR:        cmle c0.4h, v1.2s, #0
 655 // CHECK-ERROR:                       ^
 656 // CHECK-ERROR: error: invalid operand for instruction
 657 // CHECK-ERROR:         cmle c0.16b, v1.16b, #16
 658 // CHECK-ERROR:                               ^
 659 //----------------------------------------------------------------------
 660 // Vector Compare Mask Less Than Zero (Signed Integer)
 661 //----------------------------------------------------------------------
 662         // Mismatched vector types and invalid imm
 663          cmlt c0.8h, v1.16b, #0
 664          cmlt c0.8h, v1.8h, #-15
 665
 666 // CHECK-ERROR: error: invalid operand for instruction
 667 // CHECK-ERROR:         cmlt c0.8h, v1.16b, #0
 668 // CHECK-ERROR:                        ^
 669 // CHECK-ERROR: error: invalid operand for instruction
 670 // CHECK-ERROR:         cmlt c0.8h, v1.8h, #-15
 671 // CHECK-ERROR:                             ^
 672
 673 //----------------------------------------------------------------------
 674 // Vector Compare Mask Equal to Zero (Floating Point)
 675 //----------------------------------------------------------------------
 676
 677         // Mismatched and invalid vector types, invalid imm
 678         fcmeq v0.2d, v1.2s, #0.0
 679         fcmeq v0.16b, v1.16b, #0.0
 680         fcmeq v0.8b, v1.4h, #1.0
 681         fcmeq v0.8b, v1.4h, #1
 682
 683 // CHECK-ERROR: error: invalid operand for instruction
 684 // CHECK-ERROR:        fcmeq v0.2d, v1.2s, #0.0
 685 // CHECK-ERROR:                        ^
 686 // CHECK-ERROR: error: invalid operand for instruction
 687 // CHECK-ERROR:        fcmeq v0.16b, v1.16b, #0.0
 688 // CHECK-ERROR:                 ^
 689
 690
 691 // CHECK-ERROR: error: expected floating-point constant #0.0
 692 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1.0
 693 // CHECK-ERROR:                             ^
 694 // CHECK-ERROR: error: invalid operand for instruction
 695 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1
 696 // CHECK-ERROR:                             ^
 697
 698 //----------------------------------------------------------------------
 699 // Vector Compare Mask Greater Than or Equal to Zero (Floating Point)
 700 //----------------------------------------------------------------------
 701
 702         // Mismatched and invalid vector types, invalid imm
 703          fcmge v31.4s, v29.2s, #0.0
 704          fcmge v3.8b, v8.2s, #0.0
 705          fcmle v17.8h, v15.2d, #-1.0
 706          fcmle v17.8h, v15.2d, #2
 707
 708 // CHECK-ERROR: error: invalid operand for instruction
 709 // CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
 710 // CHECK-ERROR:                          ^
 711 // CHECK-ERROR: error: invalid operand for instruction
 712 // CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
 713 // CHECK-ERROR:                 ^
 714
 715
 716 // CHECK-ERROR: error: expected floating-point constant #0.0
 717 // CHECK-ERROR:        fcmle v17.8h, v15.2d, #-1.0
 718 // CHECK-ERROR:                               ^
 719 // CHECK-ERROR: error: invalid operand for instruction
 720 // CHECK-ERROR:        fcmle v17.8h, v15.2d, #2
 721 // CHECK-ERROR:                               ^
 722
 723 //----------------------------------------------------------------------
 724 // Vector Compare Mask Greater Than Zero (Floating Point)
 725 //----------------------------------------------------------------------
 726         // Mismatched and invalid vector types, invalid imm
 727          fcmgt v0.2d, v31.2s, #0.0
 728          fcmgt v4.4s, v7.4h, #0.0
 729          fcmlt v29.2d, v5.2d, #255.0
 730          fcmlt v29.2d, v5.2d, #255
 731
 732 // CHECK-ERROR: error: invalid operand for instruction
 733 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
 734 // CHECK-ERROR:                         ^
 735 // CHECK-ERROR: error: invalid operand for instruction
 736 // CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
 737 // CHECK-ERROR:                        ^
 738
 739
 740 // CHECK-ERROR: error: expected floating-point constant #0.0
 741 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255.0
 742 // CHECK-ERROR:                              ^
 743 // CHECK-ERROR: error: invalid operand for instruction
 744 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255
 745 // CHECK-ERROR:                              ^
 746
 747 //----------------------------------------------------------------------
 748 // Vector Compare Mask Less Than or Equal To Zero (Floating Point)
 749 //----------------------------------------------------------------------
 750         // Mismatched and invalid vector types, invalid imm
 751          fcmge v31.4s, v29.2s, #0.0
 752          fcmge v3.8b, v8.2s, #0.0
 753          fcmle v17.2d, v15.2d, #15.0
 754          fcmle v17.2d, v15.2d, #15
 755
 756 // CHECK-ERROR: error: invalid operand for instruction
 757 // CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
 758 // CHECK-ERROR:                          ^
 759 // CHECK-ERROR: error: invalid operand for instruction
 760 // CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
 761 // CHECK-ERROR:                 ^
 762
 763
 764 // CHECK-ERROR: error: expected floating-point constant #0.0
 765 // CHECK-ERROR:        fcmle v17.2d, v15.2d, #15.0
 766 // CHECK-ERROR:                               ^
 767 // CHECK-ERROR: error: invalid operand for instruction
 768 // CHECK-ERROR:        fcmle v17.2d, v15.2d, #15
 769 // CHECK-ERROR:                              ^
 770
 771 //----------------------------------------------------------------------
 772 // Vector Compare Mask Less Than Zero (Floating Point)
 773 //----------------------------------------------------------------------
 774         // Mismatched and invalid vector types, invalid imm
 775          fcmgt v0.2d, v31.2s, #0.0
 776          fcmgt v4.4s, v7.4h, #0.0
 777          fcmlt v29.2d, v5.2d, #16.0
 778          fcmlt v29.2d, v5.2d, #2
 779
 780 // CHECK-ERROR: error: invalid operand for instruction
 781 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
 782 // CHECK-ERROR:                         ^
 783 // CHECK-ERROR: error: invalid operand for instruction
 784 // CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
 785 // CHECK-ERROR:                        ^
 786
 787
 788 // CHECK-ERROR: error: expected floating-point constant #0.0
 789 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #16.0
 790 // CHECK-ERROR:                              ^
 791 // CHECK-ERROR: error: invalid operand for instruction
 792 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #2
 793 // CHECK-ERROR:                              ^
 794
 795 /-----------------------------------------------------------------------
 796 // Vector Integer Halving Add (Signed)
 797 // Vector Integer Halving Add (Unsigned)
 798 // Vector Integer Halving Sub (Signed)
 799 // Vector Integer Halving Sub (Unsigned)
 800 //----------------------------------------------------------------------
 801         // Mismatched and invalid vector types (2d)
 802         shadd v0.2d, v1.2d, v2.2d
 803         uhadd v4.2s, v5.2s, v5.4h
 804         shsub v11.4h, v12.8h, v13.4h
 805         uhsub v31.16b, v29.8b, v28.8b
 806
 807 // CHECK-ERROR: error: invalid operand for instruction
 808 // CHECK-ERROR:        shadd v0.2d, v1.2d, v2.2d
 809 // CHECK-ERROR:                 ^
 810 // CHECK-ERROR: error: invalid operand for instruction
 811 // CHECK-ERROR:        uhadd v4.2s, v5.2s, v5.4h
 812 // CHECK-ERROR:                               ^
 813 // CHECK-ERROR: error: invalid operand for instruction
 814 // CHECK-ERROR:        shsub v11.4h, v12.8h, v13.4h
 815 // CHECK-ERROR:                          ^
 816 // CHECK-ERROR: error: invalid operand for instruction
 817 // CHECK-ERROR:        uhsub v31.16b, v29.8b, v28.8b
 818 // CHECK-ERROR:                          ^
 819
 820 //----------------------------------------------------------------------
 821 // Vector Integer Rouding Halving Add (Signed)
 822 // Vector Integer Rouding Halving Add (Unsigned)
 823 //----------------------------------------------------------------------
 824
 825         // Mismatched and invalid vector types (2d)
 826         srhadd v0.2s, v1.2s, v2.2d
 827         urhadd v0.16b, v1.16b, v2.8h
 828
 829 // CHECK-ERROR: error: invalid operand for instruction
 830 // CHECK-ERROR:        srhadd v0.2s, v1.2s, v2.2d
 831 // CHECK-ERROR:                                ^
 832 // CHECK-ERROR: error: invalid operand for instruction
 833 // CHECK-ERROR:        urhadd v0.16b, v1.16b, v2.8h
 834 // CHECK-ERROR:                                  ^
 835
 836 //----------------------------------------------------------------------
 837 // Vector Integer Saturating Add (Signed)
 838 // Vector Integer Saturating Add (Unsigned)
 839 // Vector Integer Saturating Sub (Signed)
 840 // Vector Integer Saturating Sub (Unsigned)
 841 //----------------------------------------------------------------------
 842
 843         // Mismatched vector types
 844         sqadd v0.2s, v1.2s, v2.2d
 845         uqadd v31.8h, v1.4h, v2.4h
 846         sqsub v10.8h, v1.16b, v2.16b
 847         uqsub v31.8b, v1.8b, v2.4s
 848
 849 // CHECK-ERROR: error: invalid operand for instruction
 850 // CHECK-ERROR:        sqadd v0.2s, v1.2s, v2.2d
 851 // CHECK-ERROR:                               ^
 852 // CHECK-ERROR: error: invalid operand for instruction
 853 // CHECK-ERROR:        uqadd v31.8h, v1.4h, v2.4h
 854 // CHECK-ERROR:                         ^
 855 // CHECK-ERROR: error: invalid operand for instruction
 856 // CHECK-ERROR:        sqsub v10.8h, v1.16b, v2.16b
 857 // CHECK-ERROR:                         ^
 858 // CHECK-ERROR: error: invalid operand for instruction
 859 // CHECK-ERROR:        uqsub v31.8b, v1.8b, v2.4s
 860 // CHECK-ERROR:                                ^
 861
 862 //----------------------------------------------------------------------
 863 // Scalar Integer Saturating Add (Signed)
 864 // Scalar Integer Saturating Add (Unsigned)
 865 // Scalar Integer Saturating Sub (Signed)
 866 // Scalar Integer Saturating Sub (Unsigned)
 867 //----------------------------------------------------------------------
 868
 869       // Mismatched registers
 870          sqadd d0, s31, d2
 871          uqadd s0, s1, d2
 872          sqsub b0, b2, s18
 873          uqsub h1, h2, d2
 874
 875 // CHECK-ERROR: error: invalid operand for instruction
 876 // CHECK-ERROR:        sqadd d0, s31, d2
 877 // CHECK-ERROR:                  ^
 878 // CHECK-ERROR: error: invalid operand for instruction
 879 // CHECK-ERROR:        uqadd s0, s1, d2
 880 // CHECK-ERROR:                      ^
 881 // CHECK-ERROR: error: invalid operand for instruction
 882 // CHECK-ERROR:        sqsub b0, b2, s18
 883 // CHECK-ERROR:                      ^
 884 // CHECK-ERROR: error: invalid operand for instruction
 885 // CHECK-ERROR:        uqsub h1, h2, d2
 886 // CHECK-ERROR:                      ^
 887
 888 //----------------------------------------------------------------------
 889 // Scalar Integer Saturating Doubling Multiply Half High (Signed)
 890 //----------------------------------------------------------------------
 891
 892     sqdmulh h10, s11, h12
 893     sqdmulh s20, h21, s2
 894
 895 // CHECK-ERROR: error: invalid operand for instruction
 896 // CHECK-ERROR:        sqdmulh h10, s11, h12
 897 // CHECK-ERROR:                     ^
 898 // CHECK-ERROR: error: invalid operand for instruction
 899 // CHECK-ERROR:        sqdmulh s20, h21, s2
 900 // CHECK-ERROR:                     ^
 901
 902 //------------------------------------------------------------------------
 903 // Scalar Integer Saturating Rounding Doubling Multiply Half High (Signed)
 904 //------------------------------------------------------------------------
 905
 906     sqrdmulh h10, s11, h12
 907     sqrdmulh s20, h21, s2
 908
 909 // CHECK-ERROR: error: invalid operand for instruction
 910 // CHECK-ERROR:        sqrdmulh h10, s11, h12
 911 // CHECK-ERROR:                      ^
 912 // CHECK-ERROR: error: invalid operand for instruction
 913 // CHECK-ERROR:        sqrdmulh s20, h21, s2
 914 // CHECK-ERROR:                      ^
 915
 916 //----------------------------------------------------------------------
 917 // Vector Shift Left (Signed and Unsigned Integer)
 918 //----------------------------------------------------------------------
 919         // Mismatched vector types
 920         sshl v0.4s, v15.2s, v16.2s
 921         ushl v1.16b, v25.16b, v6.8h
 922
 923 // CHECK-ERROR: error: invalid operand for instruction
 924 // CHECK-ERROR:        sshl v0.4s, v15.2s, v16.2s
 925 // CHECK-ERROR:                        ^
 926 // CHECK-ERROR: error: invalid operand for instruction
 927 // CHECK-ERROR:        ushl v1.16b, v25.16b, v6.8h
 928 // CHECK-ERROR:                                 ^
 929
 930 //----------------------------------------------------------------------
 931 // Vector Saturating Shift Left (Signed and Unsigned Integer)
 932 //----------------------------------------------------------------------
 933         // Mismatched vector types
 934         sqshl v0.2s, v15.4s, v16.2d
 935         uqshl v1.8b, v25.4h, v6.8h
 936
 937 // CHECK-ERROR: error: invalid operand for instruction
 938 // CHECK-ERROR:        sqshl v0.2s, v15.4s, v16.2d
 939 // CHECK-ERROR:                         ^
 940 // CHECK-ERROR: error: invalid operand for instruction
 941 // CHECK-ERROR:        uqshl v1.8b, v25.4h, v6.8h
 942 // CHECK-ERROR:                         ^
 943
 944 //----------------------------------------------------------------------
 945 // Vector Rouding Shift Left (Signed and Unsigned Integer)
 946 //----------------------------------------------------------------------
 947         // Mismatched vector types
 948         srshl v0.8h, v15.8h, v16.16b
 949         urshl v1.2d, v25.2d, v6.4s
 950
 951 // CHECK-ERROR: error: invalid operand for instruction
 952 // CHECK-ERROR:        srshl v0.8h, v15.8h, v16.16b
 953 // CHECK-ERROR:                                 ^
 954 // CHECK-ERROR: error: invalid operand for instruction
 955 // CHECK-ERROR:        urshl v1.2d, v25.2d, v6.4s
 956 // CHECK-ERROR:                                ^
 957
 958 //----------------------------------------------------------------------
 959 // Vector Saturating Rouding Shift Left (Signed and Unsigned Integer)
 960 //----------------------------------------------------------------------
 961         // Mismatched vector types
 962         sqrshl v0.2s, v15.8h, v16.16b
 963         uqrshl v1.4h, v25.4h,  v6.2d
 964
 965 // CHECK-ERROR: error: invalid operand for instruction
 966 // CHECK-ERROR:        sqrshl v0.2s, v15.8h, v16.16b
 967 // CHECK-ERROR:                          ^
 968 // CHECK-ERROR: error: invalid operand for instruction
 969 // CHECK-ERROR:        uqrshl v1.4h, v25.4h,  v6.2d
 970 // CHECK-ERROR:                                  ^
 971
 972 //----------------------------------------------------------------------
 973 // Scalar Integer Shift Left (Signed, Unsigned)
 974 //----------------------------------------------------------------------
 975         // Mismatched and invalid vector types
 976         sshl d0, d1, s2
 977         ushl b2, b0, b1
 978
 979 // CHECK-ERROR: error: invalid operand for instruction
 980 // CHECK-ERROR:        sshl d0, d1, s2
 981 // CHECK-ERROR:                     ^
 982 // CHECK-ERROR: error: invalid operand for instruction
 983 // CHECK-ERROR:        ushl b2, b0, b1
 984 // CHECK-ERROR:             ^
 985
 986 //----------------------------------------------------------------------
 987 // Scalar Integer Saturating Shift Left (Signed, Unsigned)
 988 //----------------------------------------------------------------------
 989
 990         // Mismatched vector types
 991         sqshl b0, s1, b0
 992         uqshl h0, b1, h0
 993         sqshl s0, h1, s0
 994         uqshl d0, b1, d0
 995
 996 // CHECK-ERROR: error: invalid operand for instruction
 997 // CHECK-ERROR:        sqshl b0, s1, b0
 998 // CHECK-ERROR:                  ^
 999 // CHECK-ERROR: error: invalid operand for instruction
1000 // CHECK-ERROR:        uqshl h0, b1, h0
1001 // CHECK-ERROR:                  ^
1002 // CHECK-ERROR: error: invalid operand for instruction
1003 // CHECK-ERROR:        sqshl s0, h1, s0
1004 // CHECK-ERROR:                  ^
1005 // CHECK-ERROR: error: invalid operand for instruction
1006 // CHECK-ERROR:        uqshl d0, b1, d0
1007 // CHECK-ERROR:                  ^
1008
1009 //----------------------------------------------------------------------
1010 // Scalar Integer Rouding Shift Left (Signed, Unsigned)
1011 //----------------------------------------------------------------------
1012         // Mismatched and invalid vector types
1013         srshl h0, h1, h2
1014         urshl s0, s1, s2
1015
1016 // CHECK-ERROR: error: invalid operand for instruction
1017 // CHECK-ERROR:        srshl h0, h1, h2
1018 // CHECK-ERROR:              ^
1019 // CHECK-ERROR: error: invalid operand for instruction
1020 // CHECK-ERROR:        urshl s0, s1, s2
1021 // CHECK-ERROR:              ^
1022
1023
1024 //----------------------------------------------------------------------
1025 // Scalar Integer Saturating Rounding Shift Left (Signed, Unsigned)
1026 //----------------------------------------------------------------------
1027
1028         // Mismatched vector types
1029         sqrshl b0, b1, s0
1030         uqrshl h0, h1, b0
1031         sqrshl s0, s1, h0
1032         uqrshl d0, d1, b0
1033
1034 // CHECK-ERROR: error: invalid operand for instruction
1035 // CHECK-ERROR:        sqrshl b0, b1, s0
1036 // CHECK-ERROR:                       ^
1037 // CHECK-ERROR: error: invalid operand for instruction
1038 // CHECK-ERROR:        uqrshl h0, h1, b0
1039 // CHECK-ERROR:                       ^
1040 // CHECK-ERROR: error: invalid operand for instruction
1041 // CHECK-ERROR:        sqrshl s0, s1, h0
1042 // CHECK-ERROR:                       ^
1043 // CHECK-ERROR: error: invalid operand for instruction
1044 // CHECK-ERROR:        uqrshl d0, d1, b0
1045 // CHECK-ERROR:                       ^
1046
1047
1048 //----------------------------------------------------------------------
1049 // Vector Maximum (Signed, Unsigned)
1050 //----------------------------------------------------------------------
1051         // Mismatched and invalid vector types
1052         smax v0.2d, v1.2d, v2.2d
1053         umax v0.4h, v1.4h, v2.2s
1054
1055 // CHECK-ERROR: error: invalid operand for instruction
1056 // CHECK-ERROR:        smax v0.2d, v1.2d, v2.2d
1057 // CHECK-ERROR:                ^
1058 // CHECK-ERROR: error: invalid operand for instruction
1059 // CHECK-ERROR:        umax v0.4h, v1.4h, v2.2s
1060 // CHECK-ERROR:                              ^
1061
1062 //----------------------------------------------------------------------
1063 // Vector Minimum (Signed, Unsigned)
1064 //----------------------------------------------------------------------
1065         // Mismatched and invalid vector types
1066         smin v0.2d, v1.2d, v2.2d
1067         umin v0.2s, v1.2s, v2.8b
1068
1069 // CHECK-ERROR: error: invalid operand for instruction
1070 // CHECK-ERROR:        smin v0.2d, v1.2d, v2.2d
1071 // CHECK-ERROR:                ^
1072 // CHECK-ERROR: error: invalid operand for instruction
1073 // CHECK-ERROR:        umin v0.2s, v1.2s, v2.8b
1074 // CHECK-ERROR:                             ^
1075
1076
1077 //----------------------------------------------------------------------
1078 // Vector Maximum (Floating Point)
1079 //----------------------------------------------------------------------
1080         // Mismatched and invalid vector types
1081         fmax v0.2s, v1.2s, v2.4s
1082         fmax v0.8b, v1.8b, v2.8b
1083
1084 // CHECK-ERROR: error: invalid operand for instruction
1085 // CHECK-ERROR:        fmax v0.2s, v1.2s, v2.4s
1086 // CHECK-ERROR:                              ^
1087 // CHECK-ERROR: error: invalid operand for instruction
1088 // CHECK-ERROR:        fmax v0.8b, v1.8b, v2.8b
1089 // CHECK-ERROR:                ^
1090 //----------------------------------------------------------------------
1091 // Vector Minimum (Floating Point)
1092 //----------------------------------------------------------------------
1093         // Mismatched and invalid vector types
1094         fmin v0.4s, v1.4s, v2.2d
1095         fmin v0.8h, v1.8h, v2.8h
1096
1097 // CHECK-ERROR: error: invalid operand for instruction
1098 // CHECK-ERROR:        fmin v0.4s, v1.4s, v2.2d
1099 // CHECK-ERROR:                              ^
1100 // CHECK-ERROR: error: instruction requires: fullfp16
1101 // CHECK-ERROR:        fmin v0.8h, v1.8h, v2.8h
1102 // CHECK-ERROR:                ^
1103
1104 //----------------------------------------------------------------------
1105 // Vector maxNum (Floating Point)
1106 //----------------------------------------------------------------------
1107         // Mismatched and invalid vector types
1108         fmaxnm v0.2s, v1.2s, v2.2d
1109         fmaxnm v0.4h, v1.8h, v2.4h
1110
1111 // CHECK-ERROR: error: invalid operand for instruction
1112 // CHECK-ERROR:        fmaxnm v0.2s, v1.2s, v2.2d
1113 // CHECK-ERROR:                                ^
1114 // CHECK-ERROR: error: invalid operand for instruction
1115 // CHECK-ERROR:        fmaxnm v0.4h, v1.8h, v2.4h
1116 // CHECK-ERROR:                  ^
1117
1118 //----------------------------------------------------------------------
1119 // Vector minNum (Floating Point)
1120 //----------------------------------------------------------------------
1121         // Mismatched and invalid vector types
1122         fminnm v0.4s, v1.2s, v2.4s
1123         fminnm v0.16b, v0.16b, v0.16b
1124
1125 // CHECK-ERROR: error: invalid operand for instruction
1126 // CHECK-ERROR:        fminnm v0.4s, v1.2s, v2.4s
1127 // CHECK-ERROR:                         ^
1128 // CHECK-ERROR: error: invalid operand for instruction
1129 // CHECK-ERROR:        fminnm v0.16b, v0.16b, v0.16b
1130 // CHECK-ERROR:                  ^
1131
1132
1133 //----------------------------------------------------------------------
1134 // Vector Maximum Pairwise (Signed, Unsigned)
1135 //----------------------------------------------------------------------
1136         // Mismatched and invalid vector types
1137         smaxp v0.2d, v1.2d, v2.2d
1138         umaxp v0.4h, v1.4h, v2.2s
1139
1140 // CHECK-ERROR: error: invalid operand for instruction
1141 // CHECK-ERROR:        smaxp v0.2d, v1.2d, v2.2d
1142 // CHECK-ERROR:                 ^
1143 // CHECK-ERROR: error: invalid operand for instruction
1144 // CHECK-ERROR:        umaxp v0.4h, v1.4h, v2.2s
1145 // CHECK-ERROR:                               ^
1146
1147 //----------------------------------------------------------------------
1148 // Vector Minimum Pairwise (Signed, Unsigned)
1149 //----------------------------------------------------------------------
1150         // Mismatched and invalid vector types
1151         sminp v0.2d, v1.2d, v2.2d
1152         uminp v0.2s, v1.2s, v2.8b
1153
1154 // CHECK-ERROR: error: invalid operand for instruction
1155 // CHECK-ERROR:        sminp v0.2d, v1.2d, v2.2d
1156 // CHECK-ERROR:                 ^
1157 // CHECK-ERROR: error: invalid operand for instruction
1158 // CHECK-ERROR:        uminp v0.2s, v1.2s, v2.8b
1159 // CHECK-ERROR:                               ^
1160
1161
1162 //----------------------------------------------------------------------
1163 // Vector Maximum Pairwise (Floating Point)
1164 //----------------------------------------------------------------------
1165         // Mismatched and invalid vector types
1166         fmaxp v0.2s, v1.2s, v2.4s
1167         fmaxp v0.8b, v1.8b, v2.8b
1168
1169 // CHECK-ERROR: error: invalid operand for instruction
1170 // CHECK-ERROR:        fmaxp v0.2s, v1.2s, v2.4s
1171 // CHECK-ERROR:                               ^
1172 // CHECK-ERROR: error: invalid operand for instruction
1173 // CHECK-ERROR:        fmaxp v0.8b, v1.8b, v2.8b
1174 // CHECK-ERROR:                 ^
1175 //----------------------------------------------------------------------
1176 // Vector Minimum Pairwise (Floating Point)
1177 //----------------------------------------------------------------------
1178         // Mismatched and invalid vector types
1179         fminp v0.4s, v1.4s, v2.2d
1180         fminp v0.8h, v1.8h, v2.8h
1181
1182 // CHECK-ERROR: error: invalid operand for instruction
1183 // CHECK-ERROR:        fminp v0.4s, v1.4s, v2.2d
1184 // CHECK-ERROR:                               ^
1185 // CHECK-ERROR: error: instruction requires: fullfp16
1186 // CHECK-ERROR:        fminp v0.8h, v1.8h, v2.8h
1187 // CHECK-ERROR:                 ^
1188
1189 //----------------------------------------------------------------------
1190 // Vector maxNum Pairwise (Floating Point)
1191 //----------------------------------------------------------------------
1192         // Mismatched and invalid vector types
1193         fmaxnmp v0.2s, v1.2s, v2.2d
1194         fmaxnmp v0.4h, v1.8h, v2.4h
1195
1196 // CHECK-ERROR: error: invalid operand for instruction
1197 // CHECK-ERROR:        fmaxnmp v0.2s, v1.2s, v2.2d
1198 // CHECK-ERROR:                                 ^
1199 // CHECK-ERROR: error: invalid operand for instruction
1200 // CHECK-ERROR:        fmaxnmp v0.4h, v1.8h, v2.4h
1201 // CHECK-ERROR:                   ^
1202
1203 //----------------------------------------------------------------------
1204 // Vector minNum Pairwise (Floating Point)
1205 //----------------------------------------------------------------------
1206         // Mismatched and invalid vector types
1207         fminnmp v0.4s, v1.2s, v2.4s
1208         fminnmp v0.16b, v0.16b, v0.16b
1209
1210 // CHECK-ERROR: error: invalid operand for instruction
1211 // CHECK-ERROR:        fminnmp v0.4s, v1.2s, v2.4s
1212 // CHECK-ERROR:                          ^
1213 // CHECK-ERROR: error: invalid operand for instruction
1214 // CHECK-ERROR:        fminnmp v0.16b, v0.16b, v0.16b
1215 // CHECK-ERROR:                   ^
1216
1217
1218 //----------------------------------------------------------------------
1219 // Vector Add Pairwise (Integer)
1220 //----------------------------------------------------------------------
1221
1222         // Mismatched vector types
1223         addp v0.16b, v1.8b, v2.8b
1224
1225 // CHECK-ERROR: error: invalid operand for instruction
1226 // CHECK-ERROR:         addp v0.16b, v1.8b, v2.8b
1227 // CHECK-ERROR:                         ^
1228
1229 //----------------------------------------------------------------------
1230 // Vector Add Pairwise (Floating Point)
1231 //----------------------------------------------------------------------
1232         // Mismatched and invalid vector types
1233         faddp v0.16b, v1.8b, v2.8b
1234         faddp v0.2d, v1.2d, v2.8h
1235
1236 // CHECK-ERROR: error: invalid operand for instruction
1237 // CHECK-ERROR:         faddp v0.16b, v1.8b, v2.8b
1238 // CHECK-ERROR:                  ^
1239 // CHECK-ERROR: error: invalid operand for instruction
1240 // CHECK-ERROR:         faddp v0.2d, v1.2d, v2.8h
1241 // CHECK-ERROR:                                ^
1242
1243
1244 //----------------------------------------------------------------------
1245 // Vector Saturating Doubling Multiply High
1246 //----------------------------------------------------------------------
1247          // Mismatched and invalid vector types
1248          sqdmulh v2.4h, v25.8h, v3.4h
1249          sqdmulh v12.2d, v5.2d, v13.2d
1250          sqdmulh v3.8b, v1.8b, v30.8b
1251
1252 // CHECK-ERROR: error: invalid operand for instruction
1253 // CHECK-ERROR:         sqdmulh v2.4h, v25.8h, v3.4h
1254 // CHECK-ERROR:                            ^
1255 // CHECK-ERROR: error: invalid operand for instruction
1256 // CHECK-ERROR:         sqdmulh v12.2d, v5.2d, v13.2d
1257 // CHECK-ERROR:                     ^
1258 // CHECK-ERROR: error: invalid operand for instruction
1259 // CHECK-ERROR:         sqdmulh v3.8b, v1.8b, v30.8b
1260 // CHECK-ERROR:                    ^
1261
1262 //----------------------------------------------------------------------
1263 // Vector Saturating Rouding Doubling Multiply High
1264 //----------------------------------------------------------------------
1265          // Mismatched and invalid vector types
1266          sqrdmulh v2.2s, v25.4s, v3.4s
1267          sqrdmulh v12.16b, v5.16b, v13.16b
1268          sqrdmulh v3.4h, v1.4h, v30.2d
1269
1270
1271 // CHECK-ERROR: error: invalid operand for instruction
1272 // CHECK-ERROR:         sqrdmulh v2.2s, v25.4s, v3.4s
1273 // CHECK-ERROR:                             ^
1274 // CHECK-ERROR: error: invalid operand for instruction
1275 // CHECK-ERROR:         sqrdmulh v12.16b, v5.16b, v13.16b
1276 // CHECK-ERROR:                       ^
1277 // CHECK-ERROR: error: invalid operand for instruction
1278 // CHECK-ERROR:         sqrdmulh v3.4h, v1.4h, v30.2d
1279 // CHECK-ERROR:                                    ^
1280
1281 //----------------------------------------------------------------------
1282 // Vector Multiply Extended
1283 //----------------------------------------------------------------------
1284          // Mismatched and invalid vector types
1285       fmulx v21.2s, v5.2s, v13.2d
1286       fmulx v1.4h, v25.4h, v3.4h
1287
1288 // CHECK-ERROR: error: invalid operand for instruction
1289 // CHECK-ERROR:         fmulx v21.2s, v5.2s, v13.2d
1290 // CHECK-ERROR:                                  ^
1291 // CHECK-ERROR: error: instruction requires: fullfp16
1292 // CHECK-ERROR:         fmulx v1.4h, v25.4h, v3.4h
1293 // CHECK-ERROR:                  ^
1294
1295 //------------------------------------------------------------------------------
1296 // Vector Shift Left by Immediate
1297 //------------------------------------------------------------------------------
1298          // Mismatched vector types and out of range
1299          shl v0.4s, v15,2s, #3
1300          shl v0.2d, v17.4s, #3
1301          shl v0.8b, v31.8b, #-1
1302          shl v0.8b, v31.8b, #8
1303          shl v0.4s, v21.4s, #32
1304          shl v0.2d, v1.2d, #64
1305
1306
1307 // CHECK-ERROR: error: unexpected token in argument list
1308 // CHECK-ERROR:         shl v0.4s, v15,2s, #3
1309 // CHECK-ERROR:                         ^
1310
1311 // CHECK-ERROR: error: invalid operand for instruction
1312 // CHECK-ERROR:         shl v0.2d, v17.4s, #3
1313 // CHECK-ERROR:                        ^
1314 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1315 // CHECK-ERROR:         shl v0.8b, v31.8b, #-1
1316 // CHECK-ERROR:                            ^
1317 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1318 // CHECK-ERROR:         shl v0.8b, v31.8b, #8
1319 // CHECK-ERROR:                            ^
1320 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1321 // CHECK-ERROR:         shl v0.4s, v21.4s, #32
1322 // CHECK-ERROR:                            ^
1323 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1324 // CHECK-ERROR:         shl v0.2d, v1.2d, #64
1325 // CHECK-ERROR:                           ^
1326
1327 //----------------------------------------------------------------------
1328 // Vector Shift Left Long by Immediate
1329 //----------------------------------------------------------------------
1330         // Mismatched vector types
1331         sshll v0.4s, v15.2s, #3
1332         ushll v1.16b, v25.16b, #6
1333         sshll2 v0.2d, v3.8s, #15
1334         ushll2 v1.4s, v25.4s, #7
1335
1336         // Out of range
1337         sshll v0.8h, v1.8b, #-1
1338         sshll v0.8h, v1.8b, #9
1339         ushll v0.4s, v1.4h, #17
1340         ushll v0.2d, v1.2s, #33
1341         sshll2 v0.8h, v1.16b, #9
1342         sshll2 v0.4s, v1.8h, #17
1343         ushll2 v0.2d, v1.4s, #33
1344
1345 // CHECK-ERROR: error: invalid operand for instruction
1346 // CHECK-ERROR:        sshll v0.4s, v15.2s, #3
1347 // CHECK-ERROR:                         ^
1348 // CHECK-ERROR: error: invalid operand for instruction
1349 // CHECK-ERROR:        ushll v1.16b, v25.16b, #6
1350 // CHECK-ERROR:                 ^
1351 // CHECK-ERROR: error: invalid vector kind qualifier
1352 // CHECK-ERROR:        sshll2 v0.2d, v3.8s, #15
1353 // CHECK-ERROR:                      ^
1354 // CHECK-ERROR: error: invalid operand for instruction
1355 // CHECK-ERROR:        ushll2 v1.4s, v25.4s, #7
1356 // CHECK-ERROR:                          ^
1357 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1358 // CHECK-ERROR:        sshll v0.8h, v1.8b, #-1
1359 // CHECK-ERROR:                            ^
1360 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1361 // CHECK-ERROR:        sshll v0.8h, v1.8b, #9
1362 // CHECK-ERROR:                            ^
1363 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1364 // CHECK-ERROR:        ushll v0.4s, v1.4h, #17
1365 // CHECK-ERROR:                            ^
1366 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1367 // CHECK-ERROR:        ushll v0.2d, v1.2s, #33
1368 // CHECK-ERROR:                            ^
1369 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1370 // CHECK-ERROR:        sshll2 v0.8h, v1.16b, #9
1371 // CHECK-ERROR:                              ^
1372 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1373 // CHECK-ERROR:        sshll2 v0.4s, v1.8h, #17
1374 // CHECK-ERROR:                             ^
1375 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1376 // CHECK-ERROR:        ushll2 v0.2d, v1.4s, #33
1377 // CHECK-ERROR:                             ^
1378
1379
1380 //------------------------------------------------------------------------------
1381 // Vector shift right by immediate
1382 //------------------------------------------------------------------------------
1383          sshr v0.8b, v1.8h, #3
1384          sshr v0.4h, v1.4s, #3
1385          sshr v0.2s, v1.2d, #3
1386          sshr v0.16b, v1.16b, #9
1387          sshr v0.8h, v1.8h, #17
1388          sshr v0.4s, v1.4s, #33
1389          sshr v0.2d, v1.2d, #65
1390
1391 // CHECK-ERROR: error: invalid operand for instruction
1392 // CHECK-ERROR:         sshr v0.8b, v1.8h, #3
1393 // CHECK-ERROR:                        ^
1394 // CHECK-ERROR: error: invalid operand for instruction
1395 // CHECK-ERROR:         sshr v0.4h, v1.4s, #3
1396 // CHECK-ERROR:                        ^
1397 // CHECK-ERROR: error: invalid operand for instruction
1398 // CHECK-ERROR:         sshr v0.2s, v1.2d, #3
1399 // CHECK-ERROR:                        ^
1400 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1401 // CHECK-ERROR:         sshr v0.16b, v1.16b, #9
1402 // CHECK-ERROR:                              ^
1403 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1404 // CHECK-ERROR:         sshr v0.8h, v1.8h, #17
1405 // CHECK-ERROR:                            ^
1406 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1407 // CHECK-ERROR:         sshr v0.4s, v1.4s, #33
1408 // CHECK-ERROR:                            ^
1409 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1410 // CHECK-ERROR:         sshr v0.2d, v1.2d, #65
1411 // CHECK-ERROR:                            ^
1412
1413 //------------------------------------------------------------------------------
1414 // Vector  shift right by immediate
1415 //------------------------------------------------------------------------------
1416          ushr v0.8b, v1.8h, #3
1417          ushr v0.4h, v1.4s, #3
1418          ushr v0.2s, v1.2d, #3
1419          ushr v0.16b, v1.16b, #9
1420          ushr v0.8h, v1.8h, #17
1421          ushr v0.4s, v1.4s, #33
1422          ushr v0.2d, v1.2d, #65
1423
1424 // CHECK-ERROR: error: invalid operand for instruction
1425 // CHECK-ERROR:         ushr v0.8b, v1.8h, #3
1426 // CHECK-ERROR:                        ^
1427 // CHECK-ERROR: error: invalid operand for instruction
1428 // CHECK-ERROR:         ushr v0.4h, v1.4s, #3
1429 // CHECK-ERROR:                        ^
1430 // CHECK-ERROR: error: invalid operand for instruction
1431 // CHECK-ERROR:         ushr v0.2s, v1.2d, #3
1432 // CHECK-ERROR:                        ^
1433 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1434 // CHECK-ERROR:         ushr v0.16b, v1.16b, #9
1435 // CHECK-ERROR:                              ^
1436 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1437 // CHECK-ERROR:         ushr v0.8h, v1.8h, #17
1438 // CHECK-ERROR:                            ^
1439 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1440 // CHECK-ERROR:         ushr v0.4s, v1.4s, #33
1441 // CHECK-ERROR:                            ^
1442 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1443 // CHECK-ERROR:         ushr v0.2d, v1.2d, #65
1444 // CHECK-ERROR:                            ^
1445
1446 //------------------------------------------------------------------------------
1447 // Vector shift right and accumulate by immediate
1448 //------------------------------------------------------------------------------
1449          ssra v0.8b, v1.8h, #3
1450          ssra v0.4h, v1.4s, #3
1451          ssra v0.2s, v1.2d, #3
1452          ssra v0.16b, v1.16b, #9
1453          ssra v0.8h, v1.8h, #17
1454          ssra v0.4s, v1.4s, #33
1455          ssra v0.2d, v1.2d, #65
1456
1457 // CHECK-ERROR: error: invalid operand for instruction
1458 // CHECK-ERROR:         ssra v0.8b, v1.8h, #3
1459 // CHECK-ERROR:                        ^
1460 // CHECK-ERROR: error: invalid operand for instruction
1461 // CHECK-ERROR:         ssra v0.4h, v1.4s, #3
1462 // CHECK-ERROR:                        ^
1463 // CHECK-ERROR: error: invalid operand for instruction
1464 // CHECK-ERROR:         ssra v0.2s, v1.2d, #3
1465 // CHECK-ERROR:                        ^
1466 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1467 // CHECK-ERROR:         ssra v0.16b, v1.16b, #9
1468 // CHECK-ERROR:                              ^
1469 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1470 // CHECK-ERROR:         ssra v0.8h, v1.8h, #17
1471 // CHECK-ERROR:                            ^
1472 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1473 // CHECK-ERROR:         ssra v0.4s, v1.4s, #33
1474 // CHECK-ERROR:                            ^
1475 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1476 // CHECK-ERROR:         ssra v0.2d, v1.2d, #65
1477 // CHECK-ERROR:                            ^
1478
1479 //------------------------------------------------------------------------------
1480 // Vector  shift right and accumulate by immediate
1481 //------------------------------------------------------------------------------
1482          usra v0.8b, v1.8h, #3
1483          usra v0.4h, v1.4s, #3
1484          usra v0.2s, v1.2d, #3
1485          usra v0.16b, v1.16b, #9
1486          usra v0.8h, v1.8h, #17
1487          usra v0.4s, v1.4s, #33
1488          usra v0.2d, v1.2d, #65
1489
1490 // CHECK-ERROR: error: invalid operand for instruction
1491 // CHECK-ERROR:         usra v0.8b, v1.8h, #3
1492 // CHECK-ERROR:                        ^
1493 // CHECK-ERROR: error: invalid operand for instruction
1494 // CHECK-ERROR:         usra v0.4h, v1.4s, #3
1495 // CHECK-ERROR:                        ^
1496 // CHECK-ERROR: error: invalid operand for instruction
1497 // CHECK-ERROR:         usra v0.2s, v1.2d, #3
1498 // CHECK-ERROR:                        ^
1499 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1500 // CHECK-ERROR:         usra v0.16b, v1.16b, #9
1501 // CHECK-ERROR:                              ^
1502 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1503 // CHECK-ERROR:         usra v0.8h, v1.8h, #17
1504 // CHECK-ERROR:                            ^
1505 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1506 // CHECK-ERROR:         usra v0.4s, v1.4s, #33
1507 // CHECK-ERROR:                            ^
1508 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1509 // CHECK-ERROR:         usra v0.2d, v1.2d, #65
1510 // CHECK-ERROR:                            ^
1511
1512 //------------------------------------------------------------------------------
1513 // Vector rounding shift right by immediate
1514 //------------------------------------------------------------------------------
1515          srshr v0.8b, v1.8h, #3
1516          srshr v0.4h, v1.4s, #3
1517          srshr v0.2s, v1.2d, #3
1518          srshr v0.16b, v1.16b, #9
1519          srshr v0.8h, v1.8h, #17
1520          srshr v0.4s, v1.4s, #33
1521          srshr v0.2d, v1.2d, #65
1522
1523 // CHECK-ERROR: error: invalid operand for instruction
1524 // CHECK-ERROR:         srshr v0.8b, v1.8h, #3
1525 // CHECK-ERROR:                         ^
1526 // CHECK-ERROR: error: invalid operand for instruction
1527 // CHECK-ERROR:         srshr v0.4h, v1.4s, #3
1528 // CHECK-ERROR:                         ^
1529 // CHECK-ERROR: error: invalid operand for instruction
1530 // CHECK-ERROR:         srshr v0.2s, v1.2d, #3
1531 // CHECK-ERROR:                         ^
1532 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1533 // CHECK-ERROR:         srshr v0.16b, v1.16b, #9
1534 // CHECK-ERROR:                               ^
1535 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1536 // CHECK-ERROR:         srshr v0.8h, v1.8h, #17
1537 // CHECK-ERROR:                             ^
1538 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1539 // CHECK-ERROR:         srshr v0.4s, v1.4s, #33
1540 // CHECK-ERROR:                             ^
1541 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1542 // CHECK-ERROR:         srshr v0.2d, v1.2d, #65
1543 // CHECK-ERROR:                             ^
1544
1545 //------------------------------------------------------------------------------
1546 // Vecotr rounding shift right by immediate
1547 //------------------------------------------------------------------------------
1548          urshr v0.8b, v1.8h, #3
1549          urshr v0.4h, v1.4s, #3
1550          urshr v0.2s, v1.2d, #3
1551          urshr v0.16b, v1.16b, #9
1552          urshr v0.8h, v1.8h, #17
1553          urshr v0.4s, v1.4s, #33
1554          urshr v0.2d, v1.2d, #65
1555
1556 // CHECK-ERROR: error: invalid operand for instruction
1557 // CHECK-ERROR:         urshr v0.8b, v1.8h, #3
1558 // CHECK-ERROR:                         ^
1559 // CHECK-ERROR: error: invalid operand for instruction
1560 // CHECK-ERROR:         urshr v0.4h, v1.4s, #3
1561 // CHECK-ERROR:                         ^
1562 // CHECK-ERROR: error: invalid operand for instruction
1563 // CHECK-ERROR:         urshr v0.2s, v1.2d, #3
1564 // CHECK-ERROR:                         ^
1565 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1566 // CHECK-ERROR:         urshr v0.16b, v1.16b, #9
1567 // CHECK-ERROR:                               ^
1568 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1569 // CHECK-ERROR:         urshr v0.8h, v1.8h, #17
1570 // CHECK-ERROR:                             ^
1571 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1572 // CHECK-ERROR:         urshr v0.4s, v1.4s, #33
1573 // CHECK-ERROR:                             ^
1574 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1575 // CHECK-ERROR:         urshr v0.2d, v1.2d, #65
1576 // CHECK-ERROR:                             ^
1577
1578 //------------------------------------------------------------------------------
1579 // Vector rounding shift right and accumulate by immediate
1580 //------------------------------------------------------------------------------
1581          srsra v0.8b, v1.8h, #3
1582          srsra v0.4h, v1.4s, #3
1583          srsra v0.2s, v1.2d, #3
1584          srsra v0.16b, v1.16b, #9
1585          srsra v0.8h, v1.8h, #17
1586          srsra v0.4s, v1.4s, #33
1587          srsra v0.2d, v1.2d, #65
1588
1589 // CHECK-ERROR: error: invalid operand for instruction
1590 // CHECK-ERROR:         srsra v0.8b, v1.8h, #3
1591 // CHECK-ERROR:                         ^
1592 // CHECK-ERROR: error: invalid operand for instruction
1593 // CHECK-ERROR:         srsra v0.4h, v1.4s, #3
1594 // CHECK-ERROR:                         ^
1595 // CHECK-ERROR: error: invalid operand for instruction
1596 // CHECK-ERROR:         srsra v0.2s, v1.2d, #3
1597 // CHECK-ERROR:                         ^
1598 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1599 // CHECK-ERROR:         srsra v0.16b, v1.16b, #9
1600 // CHECK-ERROR:                               ^
1601 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1602 // CHECK-ERROR:         srsra v0.8h, v1.8h, #17
1603 // CHECK-ERROR:                             ^
1604 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1605 // CHECK-ERROR:         srsra v0.4s, v1.4s, #33
1606 // CHECK-ERROR:                             ^
1607 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1608 // CHECK-ERROR:         srsra v0.2d, v1.2d, #65
1609 // CHECK-ERROR:                             ^
1610
1611 //------------------------------------------------------------------------------
1612 // Vector rounding shift right and accumulate by immediate
1613 //------------------------------------------------------------------------------
1614          ursra v0.8b, v1.8h, #3
1615          ursra v0.4h, v1.4s, #3
1616          ursra v0.2s, v1.2d, #3
1617          ursra v0.16b, v1.16b, #9
1618          ursra v0.8h, v1.8h, #17
1619          ursra v0.4s, v1.4s, #33
1620          ursra v0.2d, v1.2d, #65
1621
1622 // CHECK-ERROR: error: invalid operand for instruction
1623 // CHECK-ERROR:         ursra v0.8b, v1.8h, #3
1624 // CHECK-ERROR:                         ^
1625 // CHECK-ERROR: error: invalid operand for instruction
1626 // CHECK-ERROR:         ursra v0.4h, v1.4s, #3
1627 // CHECK-ERROR:                         ^
1628 // CHECK-ERROR: error: invalid operand for instruction
1629 // CHECK-ERROR:         ursra v0.2s, v1.2d, #3
1630 // CHECK-ERROR:                         ^
1631 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1632 // CHECK-ERROR:         ursra v0.16b, v1.16b, #9
1633 // CHECK-ERROR:                               ^
1634 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1635 // CHECK-ERROR:         ursra v0.8h, v1.8h, #17
1636 // CHECK-ERROR:                             ^
1637 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1638 // CHECK-ERROR:         ursra v0.4s, v1.4s, #33
1639 // CHECK-ERROR:                             ^
1640 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1641 // CHECK-ERROR:         ursra v0.2d, v1.2d, #65
1642 // CHECK-ERROR:                             ^
1643
1644 //------------------------------------------------------------------------------
1645 // Vector shift right and insert by immediate
1646 //------------------------------------------------------------------------------
1647          sri v0.8b, v1.8h, #3
1648          sri v0.4h, v1.4s, #3
1649          sri v0.2s, v1.2d, #3
1650          sri v0.16b, v1.16b, #9
1651          sri v0.8h, v1.8h, #17
1652          sri v0.4s, v1.4s, #33
1653          sri v0.2d, v1.2d, #65
1654
1655 // CHECK-ERROR: error: invalid operand for instruction
1656 // CHECK-ERROR:         sri v0.8b, v1.8h, #3
1657 // CHECK-ERROR:                       ^
1658 // CHECK-ERROR: error: invalid operand for instruction
1659 // CHECK-ERROR:         sri v0.4h, v1.4s, #3
1660 // CHECK-ERROR:                       ^
1661 // CHECK-ERROR: error: invalid operand for instruction
1662 // CHECK-ERROR:         sri v0.2s, v1.2d, #3
1663 // CHECK-ERROR:                       ^
1664 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1665 // CHECK-ERROR:         sri v0.16b, v1.16b, #9
1666 // CHECK-ERROR:                             ^
1667 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1668 // CHECK-ERROR:         sri v0.8h, v1.8h, #17
1669 // CHECK-ERROR:                           ^
1670 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1671 // CHECK-ERROR:         sri v0.4s, v1.4s, #33
1672 // CHECK-ERROR:                           ^
1673 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1674 // CHECK-ERROR:         sri v0.2d, v1.2d, #65
1675 // CHECK-ERROR:                           ^
1676
1677 //------------------------------------------------------------------------------
1678 // Vector shift left and insert by immediate
1679 //------------------------------------------------------------------------------
1680          sli v0.8b, v1.8h, #3
1681          sli v0.4h, v1.4s, #3
1682          sli v0.2s, v1.2d, #3
1683          sli v0.16b, v1.16b, #8
1684          sli v0.8h, v1.8h, #16
1685          sli v0.4s, v1.4s, #32
1686          sli v0.2d, v1.2d, #64
1687
1688 // CHECK-ERROR: error: invalid operand for instruction
1689 // CHECK-ERROR:         sli v0.8b, v1.8h, #3
1690 // CHECK-ERROR:                       ^
1691 // CHECK-ERROR: error: invalid operand for instruction
1692 // CHECK-ERROR:         sli v0.4h, v1.4s, #3
1693 // CHECK-ERROR:                       ^
1694 // CHECK-ERROR: error: invalid operand for instruction
1695 // CHECK-ERROR:         sli v0.2s, v1.2d, #3
1696 // CHECK-ERROR:                       ^
1697 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1698 // CHECK-ERROR:         sli v0.16b, v1.16b, #8
1699 // CHECK-ERROR:                             ^
1700 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1701 // CHECK-ERROR:         sli v0.8h, v1.8h, #16
1702 // CHECK-ERROR:                           ^
1703 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1704 // CHECK-ERROR:         sli v0.4s, v1.4s, #32
1705 // CHECK-ERROR:                           ^
1706 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1707 // CHECK-ERROR:         sli v0.2d, v1.2d, #64
1708 // CHECK-ERROR:                           ^
1709
1710 //------------------------------------------------------------------------------
1711 // Vector saturating shift left unsigned by immediate
1712 //------------------------------------------------------------------------------
1713          sqshlu v0.8b, v1.8h, #3
1714          sqshlu v0.4h, v1.4s, #3
1715          sqshlu v0.2s, v1.2d, #3
1716          sqshlu v0.16b, v1.16b, #8
1717          sqshlu v0.8h, v1.8h, #16
1718          sqshlu v0.4s, v1.4s, #32
1719          sqshlu v0.2d, v1.2d, #64
1720
1721 // CHECK-ERROR: error: invalid operand for instruction
1722 // CHECK-ERROR:         sqshlu v0.8b, v1.8h, #3
1723 // CHECK-ERROR:                          ^
1724 // CHECK-ERROR: error: invalid operand for instruction
1725 // CHECK-ERROR:         sqshlu v0.4h, v1.4s, #3
1726 // CHECK-ERROR:                          ^
1727 // CHECK-ERROR: error: invalid operand for instruction
1728 // CHECK-ERROR:         sqshlu v0.2s, v1.2d, #3
1729 // CHECK-ERROR:                          ^
1730 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1731 // CHECK-ERROR:         sqshlu v0.16b, v1.16b, #8
1732 // CHECK-ERROR:                                ^
1733 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1734 // CHECK-ERROR:         sqshlu v0.8h, v1.8h, #16
1735 // CHECK-ERROR:                              ^
1736 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1737 // CHECK-ERROR:         sqshlu v0.4s, v1.4s, #32
1738 // CHECK-ERROR:                              ^
1739 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1740 // CHECK-ERROR:         sqshlu v0.2d, v1.2d, #64
1741 // CHECK-ERROR:                              ^
1742
1743 //------------------------------------------------------------------------------
1744 // Vector saturating shift left by immediate
1745 //------------------------------------------------------------------------------
1746          sqshl v0.8b, v1.8h, #3
1747          sqshl v0.4h, v1.4s, #3
1748          sqshl v0.2s, v1.2d, #3
1749          sqshl v0.16b, v1.16b, #8
1750          sqshl v0.8h, v1.8h, #16
1751          sqshl v0.4s, v1.4s, #32
1752          sqshl v0.2d, v1.2d, #64
1753
1754 // CHECK-ERROR: error: invalid operand for instruction
1755 // CHECK-ERROR:         sqshl v0.8b, v1.8h, #3
1756 // CHECK-ERROR:                         ^
1757 // CHECK-ERROR: error: invalid operand for instruction
1758 // CHECK-ERROR:         sqshl v0.4h, v1.4s, #3
1759 // CHECK-ERROR:                         ^
1760 // CHECK-ERROR: error: invalid operand for instruction
1761 // CHECK-ERROR:         sqshl v0.2s, v1.2d, #3
1762 // CHECK-ERROR:                         ^
1763 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1764 // CHECK-ERROR:         sqshl v0.16b, v1.16b, #8
1765 // CHECK-ERROR:                               ^
1766 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1767 // CHECK-ERROR:         sqshl v0.8h, v1.8h, #16
1768 // CHECK-ERROR:                             ^
1769 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1770 // CHECK-ERROR:         sqshl v0.4s, v1.4s, #32
1771 // CHECK-ERROR:                             ^
1772 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1773 // CHECK-ERROR:         sqshl v0.2d, v1.2d, #64
1774 // CHECK-ERROR:                             ^
1775
1776 //------------------------------------------------------------------------------
1777 // Vector saturating shift left by immediate
1778 //------------------------------------------------------------------------------
1779          uqshl v0.8b, v1.8h, #3
1780          uqshl v0.4h, v1.4s, #3
1781          uqshl v0.2s, v1.2d, #3
1782          uqshl v0.16b, v1.16b, #8
1783          uqshl v0.8h, v1.8h, #16
1784          uqshl v0.4s, v1.4s, #32
1785          uqshl v0.2d, v1.2d, #64
1786
1787 // CHECK-ERROR: error: invalid operand for instruction
1788 // CHECK-ERROR:         uqshl v0.8b, v1.8h, #3
1789 // CHECK-ERROR:                         ^
1790 // CHECK-ERROR: error: invalid operand for instruction
1791 // CHECK-ERROR:         uqshl v0.4h, v1.4s, #3
1792 // CHECK-ERROR:                         ^
1793 // CHECK-ERROR: error: invalid operand for instruction
1794 // CHECK-ERROR:         uqshl v0.2s, v1.2d, #3
1795 // CHECK-ERROR:                         ^
1796 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1797 // CHECK-ERROR:         uqshl v0.16b, v1.16b, #8
1798 // CHECK-ERROR:                               ^
1799 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1800 // CHECK-ERROR:         uqshl v0.8h, v1.8h, #16
1801 // CHECK-ERROR:                             ^
1802 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1803 // CHECK-ERROR:         uqshl v0.4s, v1.4s, #32
1804 // CHECK-ERROR:                             ^
1805 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1806 // CHECK-ERROR:         uqshl v0.2d, v1.2d, #64
1807 // CHECK-ERROR:                             ^
1808
1809 //------------------------------------------------------------------------------
1810 // Vector shift right narrow by immediate
1811 //------------------------------------------------------------------------------
1812          shrn v0.8b, v1.8b, #3
1813          shrn v0.4h, v1.4h, #3
1814          shrn v0.2s, v1.2s, #3
1815          shrn2 v0.16b, v1.8h, #17
1816          shrn2 v0.8h, v1.4s, #33
1817          shrn2 v0.4s, v1.2d, #65
1818
1819 // CHECK-ERROR: error: invalid operand for instruction
1820 // CHECK-ERROR:         shrn v0.8b, v1.8b, #3
1821 // CHECK-ERROR:                        ^
1822 // CHECK-ERROR: error: invalid operand for instruction
1823 // CHECK-ERROR:         shrn v0.4h, v1.4h, #3
1824 // CHECK-ERROR:                        ^
1825 // CHECK-ERROR: error: invalid operand for instruction
1826 // CHECK-ERROR:         shrn v0.2s, v1.2s, #3
1827 // CHECK-ERROR:                        ^
1828 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1829 // CHECK-ERROR:         shrn2 v0.16b, v1.8h, #17
1830 // CHECK-ERROR:                              ^
1831 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1832 // CHECK-ERROR:         shrn2 v0.8h, v1.4s, #33
1833 // CHECK-ERROR:                             ^
1834 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1835 // CHECK-ERROR:         shrn2 v0.4s, v1.2d, #65
1836 // CHECK-ERROR:                             ^
1837
1838 //------------------------------------------------------------------------------
1839 // Vector saturating shift right unsigned narrow by immediate
1840 //------------------------------------------------------------------------------
1841          sqshrun v0.8b, v1.8b, #3
1842          sqshrun v0.4h, v1.4h, #3
1843          sqshrun v0.2s, v1.2s, #3
1844          sqshrun2 v0.16b, v1.8h, #17
1845          sqshrun2 v0.8h, v1.4s, #33
1846          sqshrun2 v0.4s, v1.2d, #65
1847
1848 // CHECK-ERROR: error: invalid operand for instruction
1849 // CHECK-ERROR:         sqshrun v0.8b, v1.8b, #3
1850 // CHECK-ERROR:                           ^
1851 // CHECK-ERROR: error: invalid operand for instruction
1852 // CHECK-ERROR:         sqshrun v0.4h, v1.4h, #3
1853 // CHECK-ERROR:                           ^
1854 // CHECK-ERROR: error: invalid operand for instruction
1855 // CHECK-ERROR:         sqshrun v0.2s, v1.2s, #3
1856 // CHECK-ERROR:                           ^
1857 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1858 // CHECK-ERROR:         sqshrun2 v0.16b, v1.8h, #17
1859 // CHECK-ERROR:                                 ^
1860 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1861 // CHECK-ERROR:         sqshrun2 v0.8h, v1.4s, #33
1862 // CHECK-ERROR:                                ^
1863 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1864 // CHECK-ERROR:         sqshrun2 v0.4s, v1.2d, #65
1865 // CHECK-ERROR:                                ^
1866
1867 //------------------------------------------------------------------------------
1868 // Vector rounding shift right narrow by immediate
1869 //------------------------------------------------------------------------------
1870          rshrn v0.8b, v1.8b, #3
1871          rshrn v0.4h, v1.4h, #3
1872          rshrn v0.2s, v1.2s, #3
1873          rshrn2 v0.16b, v1.8h, #17
1874          rshrn2 v0.8h, v1.4s, #33
1875          rshrn2 v0.4s, v1.2d, #65
1876
1877 // CHECK-ERROR: error: invalid operand for instruction
1878 // CHECK-ERROR:         rshrn v0.8b, v1.8b, #3
1879 // CHECK-ERROR:                         ^
1880 // CHECK-ERROR: error: invalid operand for instruction
1881 // CHECK-ERROR:         rshrn v0.4h, v1.4h, #3
1882 // CHECK-ERROR:                         ^
1883 // CHECK-ERROR: error: invalid operand for instruction
1884 // CHECK-ERROR:         rshrn v0.2s, v1.2s, #3
1885 // CHECK-ERROR:                         ^
1886 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1887 // CHECK-ERROR:         rshrn2 v0.16b, v1.8h, #17
1888 // CHECK-ERROR:                               ^
1889 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1890 // CHECK-ERROR:         rshrn2 v0.8h, v1.4s, #33
1891 // CHECK-ERROR:                              ^
1892 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1893 // CHECK-ERROR:         rshrn2 v0.4s, v1.2d, #65
1894 // CHECK-ERROR:                              ^
1895
1896 //------------------------------------------------------------------------------
1897 // Vector saturating shift right rounded unsigned narrow by immediate
1898 //------------------------------------------------------------------------------
1899          sqrshrun v0.8b, v1.8b, #3
1900          sqrshrun v0.4h, v1.4h, #3
1901          sqrshrun v0.2s, v1.2s, #3
1902          sqrshrun2 v0.16b, v1.8h, #17
1903          sqrshrun2 v0.8h, v1.4s, #33
1904          sqrshrun2 v0.4s, v1.2d, #65
1905
1906 // CHECK-ERROR: error: invalid operand for instruction
1907 // CHECK-ERROR:         sqrshrun v0.8b, v1.8b, #3
1908 // CHECK-ERROR:                            ^
1909 // CHECK-ERROR: error: invalid operand for instruction
1910 // CHECK-ERROR:         sqrshrun v0.4h, v1.4h, #3
1911 // CHECK-ERROR:                            ^
1912 // CHECK-ERROR: error: invalid operand for instruction
1913 // CHECK-ERROR:         sqrshrun v0.2s, v1.2s, #3
1914 // CHECK-ERROR:                            ^
1915 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1916 // CHECK-ERROR:         sqrshrun2 v0.16b, v1.8h, #17
1917 // CHECK-ERROR:                                  ^
1918 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1919 // CHECK-ERROR:         sqrshrun2 v0.8h, v1.4s, #33
1920 // CHECK-ERROR:                                 ^
1921 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1922 // CHECK-ERROR:         sqrshrun2 v0.4s, v1.2d, #65
1923 // CHECK-ERROR:                                 ^
1924
1925 //------------------------------------------------------------------------------
1926 // Vector saturating shift right narrow by immediate
1927 //------------------------------------------------------------------------------
1928          sqshrn v0.8b, v1.8b, #3
1929          sqshrn v0.4h, v1.4h, #3
1930          sqshrn v0.2s, v1.2s, #3
1931          sqshrn2 v0.16b, v1.8h, #17
1932          sqshrn2 v0.8h, v1.4s, #33
1933          sqshrn2 v0.4s, v1.2d, #65
1934
1935 // CHECK-ERROR: error: invalid operand for instruction
1936 // CHECK-ERROR:         sqshrn v0.8b, v1.8b, #3
1937 // CHECK-ERROR:                          ^
1938 // CHECK-ERROR: error: invalid operand for instruction
1939 // CHECK-ERROR:         sqshrn v0.4h, v1.4h, #3
1940 // CHECK-ERROR:                          ^
1941 // CHECK-ERROR: error: invalid operand for instruction
1942 // CHECK-ERROR:         sqshrn v0.2s, v1.2s, #3
1943 // CHECK-ERROR:                          ^
1944 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1945 // CHECK-ERROR:         sqshrn2 v0.16b, v1.8h, #17
1946 // CHECK-ERROR:                                ^
1947 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1948 // CHECK-ERROR:         sqshrn2 v0.8h, v1.4s, #33
1949 // CHECK-ERROR:                               ^
1950 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1951 // CHECK-ERROR:         sqshrn2 v0.4s, v1.2d, #65
1952 // CHECK-ERROR:                               ^
1953
1954 //------------------------------------------------------------------------------
1955 // Vector saturating shift right narrow by immediate
1956 //------------------------------------------------------------------------------
1957          uqshrn v0.8b, v1.8b, #3
1958          uqshrn v0.4h, v1.4h, #3
1959          uqshrn v0.2s, v1.2s, #3
1960          uqshrn2 v0.16b, v1.8h, #17
1961          uqshrn2 v0.8h, v1.4s, #33
1962          uqshrn2 v0.4s, v1.2d, #65
1963
1964 // CHECK-ERROR: error: invalid operand for instruction
1965 // CHECK-ERROR:         uqshrn v0.8b, v1.8b, #3
1966 // CHECK-ERROR:                          ^
1967 // CHECK-ERROR: error: invalid operand for instruction
1968 // CHECK-ERROR:         uqshrn v0.4h, v1.4h, #3
1969 // CHECK-ERROR:                          ^
1970 // CHECK-ERROR: error: invalid operand for instruction
1971 // CHECK-ERROR:         uqshrn v0.2s, v1.2s, #3
1972 // CHECK-ERROR:                          ^
1973 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1974 // CHECK-ERROR:         uqshrn2 v0.16b, v1.8h, #17
1975 // CHECK-ERROR:                                ^
1976 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1977 // CHECK-ERROR:         uqshrn2 v0.8h, v1.4s, #33
1978 // CHECK-ERROR:                               ^
1979 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1980 // CHECK-ERROR:         uqshrn2 v0.4s, v1.2d, #65
1981 // CHECK-ERROR:                               ^
1982
1983 //------------------------------------------------------------------------------
1984 // Vector saturating shift right rounded narrow by immediate
1985 //------------------------------------------------------------------------------
1986          sqrshrn v0.8b, v1.8b, #3
1987          sqrshrn v0.4h, v1.4h, #3
1988          sqrshrn v0.2s, v1.2s, #3
1989          sqrshrn2 v0.16b, v1.8h, #17
1990          sqrshrn2 v0.8h, v1.4s, #33
1991          sqrshrn2 v0.4s, v1.2d, #65
1992
1993 // CHECK-ERROR: error: invalid operand for instruction
1994 // CHECK-ERROR:         sqrshrn v0.8b, v1.8b, #3
1995 // CHECK-ERROR:                           ^
1996 // CHECK-ERROR: error: invalid operand for instruction
1997 // CHECK-ERROR:         sqrshrn v0.4h, v1.4h, #3
1998 // CHECK-ERROR:                           ^
1999 // CHECK-ERROR: error: invalid operand for instruction
2000 // CHECK-ERROR:         sqrshrn v0.2s, v1.2s, #3
2001 // CHECK-ERROR:                           ^
2002 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
2003 // CHECK-ERROR:         sqrshrn2 v0.16b, v1.8h, #17
2004 // CHECK-ERROR:                                 ^
2005 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
2006 // CHECK-ERROR:         sqrshrn2 v0.8h, v1.4s, #33
2007 // CHECK-ERROR:                                ^
2008 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2009 // CHECK-ERROR:         sqrshrn2 v0.4s, v1.2d, #65
2010 // CHECK-ERROR:                                ^
2011
2012 //------------------------------------------------------------------------------
2013 // Vector saturating shift right rounded narrow by immediate
2014 //------------------------------------------------------------------------------
2015          uqrshrn v0.8b, v1.8b, #3
2016          uqrshrn v0.4h, v1.4h, #3
2017          uqrshrn v0.2s, v1.2s, #3
2018          uqrshrn2 v0.16b, v1.8h, #17
2019          uqrshrn2 v0.8h, v1.4s, #33
2020          uqrshrn2 v0.4s, v1.2d, #65
2021
2022 // CHECK-ERROR: error: invalid operand for instruction
2023 // CHECK-ERROR:         uqrshrn v0.8b, v1.8b, #3
2024 // CHECK-ERROR:                           ^
2025 // CHECK-ERROR: error: invalid operand for instruction
2026 // CHECK-ERROR:         uqrshrn v0.4h, v1.4h, #3
2027 // CHECK-ERROR:                           ^
2028 // CHECK-ERROR: error: invalid operand for instruction
2029 // CHECK-ERROR:         uqrshrn v0.2s, v1.2s, #3
2030 // CHECK-ERROR:                           ^
2031 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
2032 // CHECK-ERROR:         uqrshrn2 v0.16b, v1.8h, #17
2033 // CHECK-ERROR:                                 ^
2034 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
2035 // CHECK-ERROR:         uqrshrn2 v0.8h, v1.4s, #33
2036 // CHECK-ERROR:                                ^
2037 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2038 // CHECK-ERROR:         uqrshrn2 v0.4s, v1.2d, #65
2039 // CHECK-ERROR:                                ^
2040
2041 //------------------------------------------------------------------------------
2042 // Fixed-point convert to floating-point
2043 //------------------------------------------------------------------------------
2044          scvtf v0.2s, v1.2d, #3
2045          scvtf v0.4s, v1.4h, #3
2046          scvtf v0.2d, v1.2s, #3
2047          ucvtf v0.2s, v1.2s, #33
2048          ucvtf v0.4s, v1.4s, #33
2049          ucvtf v0.2d, v1.2d, #65
2050
2051 // CHECK-ERROR: error: invalid operand for instruction
2052 // CHECK-ERROR:         scvtf v0.2s, v1.2d, #3
2053 // CHECK-ERROR:                         ^
2054 // CHECK-ERROR: error: invalid operand for instruction
2055 // CHECK-ERROR:         scvtf v0.4s, v1.4h, #3
2056 // CHECK-ERROR:                         ^
2057 // CHECK-ERROR: error: invalid operand for instruction
2058 // CHECK-ERROR:         scvtf v0.2d, v1.2s, #3
2059 // CHECK-ERROR:                         ^
2060 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2061 // CHECK-ERROR:         ucvtf v0.2s, v1.2s, #33
2062 // CHECK-ERROR:                             ^
2063 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2064 // CHECK-ERROR:         ucvtf v0.4s, v1.4s, #33
2065 // CHECK-ERROR:                             ^
2066 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
2067 // CHECK-ERROR:         ucvtf v0.2d, v1.2d, #65
2068 // CHECK-ERROR:                             ^
2069
2070 //------------------------------------------------------------------------------
2071 // Floating-point convert to fixed-point
2072 //------------------------------------------------------------------------------
2073          fcvtzs v0.2s, v1.2d, #3
2074          fcvtzs v0.4s, v1.4h, #3
2075          fcvtzs v0.2d, v1.2s, #3
2076          fcvtzu v0.2s, v1.2s, #33
2077          fcvtzu v0.4s, v1.4s, #33
2078          fcvtzu v0.2d, v1.2d, #65
2079
2080 // CHECK-ERROR: error: invalid operand for instruction
2081 // CHECK-ERROR:         fcvtzs v0.2s, v1.2d, #3
2082 // CHECK-ERROR:                          ^
2083 // CHECK-ERROR: error: invalid operand for instruction
2084 // CHECK-ERROR:         fcvtzs v0.4s, v1.4h, #3
2085 // CHECK-ERROR:                          ^
2086 // CHECK-ERROR: error: invalid operand for instruction
2087 // CHECK-ERROR:         fcvtzs v0.2d, v1.2s, #3
2088 // CHECK-ERROR:                          ^
2089 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2090 // CHECK-ERROR:         fcvtzu v0.2s, v1.2s, #33
2091 // CHECK-ERROR:                              ^
2092 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2093 // CHECK-ERROR:         fcvtzu v0.4s, v1.4s, #33
2094 // CHECK-ERROR:                              ^
2095 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
2096 // CHECK-ERROR:         fcvtzu v0.2d, v1.2d, #65
2097 // CHECK-ERROR:                              ^
2098
2099 //----------------------------------------------------------------------
2100 // Vector operation on 3 operands with different types
2101 //----------------------------------------------------------------------
2102
2103         // Mismatched and invalid vector types
2104         saddl v0.8h, v1.8h, v2.8b
2105         saddl v0.4s, v1.4s, v2.4h
2106         saddl v0.2d, v1.2d, v2.2s
2107
2108 // CHECK-ERROR: error: invalid operand for instruction
2109 // CHECK-ERROR:        saddl v0.8h, v1.8h, v2.8b
2110 // CHECK-ERROR:                        ^
2111 // CHECK-ERROR: error: invalid operand for instruction
2112 // CHECK-ERROR:        saddl v0.4s, v1.4s, v2.4h
2113 // CHECK-ERROR:                        ^
2114 // CHECK-ERROR: error: invalid operand for instruction
2115 // CHECK-ERROR:        saddl v0.2d, v1.2d, v2.2s
2116 // CHECK-ERROR:                        ^
2117
2118         saddl2 v0.4s, v1.8s, v2.8h
2119         saddl2 v0.8h, v1.16h, v2.16b
2120         saddl2 v0.2d, v1.4d, v2.4s
2121
2122 // CHECK-ERROR: error: invalid vector kind qualifier
2123 // CHECK-ERROR:        saddl2 v0.4s, v1.8s, v2.8h
2124 // CHECK-ERROR:                      ^
2125 // CHECK-ERROR: error: invalid vector kind qualifier
2126 // CHECK-ERROR:        saddl2 v0.8h, v1.16h, v2.16b
2127 // CHECK-ERROR:                      ^
2128 // CHECK-ERROR: error: invalid vector kind qualifier
2129 // CHECK-ERROR:        saddl2 v0.2d, v1.4d, v2.4s
2130 // CHECK-ERROR:                      ^
2131
2132         uaddl v0.8h, v1.8h, v2.8b
2133         uaddl v0.4s, v1.4s, v2.4h
2134         uaddl v0.2d, v1.2d, v2.2s
2135
2136 // CHECK-ERROR: error: invalid operand for instruction
2137 // CHECK-ERROR:        uaddl v0.8h, v1.8h, v2.8b
2138 // CHECK-ERROR:                        ^
2139 // CHECK-ERROR: error: invalid operand for instruction
2140 // CHECK-ERROR:        uaddl v0.4s, v1.4s, v2.4h
2141 // CHECK-ERROR:                        ^
2142 // CHECK-ERROR: error: invalid operand for instruction
2143 // CHECK-ERROR:        uaddl v0.2d, v1.2d, v2.2s
2144 // CHECK-ERROR:                        ^
2145
2146         uaddl2 v0.8h, v1.16h, v2.16b
2147         uaddl2 v0.4s, v1.8s, v2.8h
2148         uaddl2 v0.2d, v1.4d, v2.4s
2149
2150 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2151 // CHECK-ERROR-NEXT:        uaddl2 v0.8h, v1.16h, v2.16b
2152 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2153 // CHECK-ERROR-NEXT:        uaddl2 v0.4s, v1.8s, v2.8h
2154 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2155 // CHECK-ERROR-NEXT:        uaddl2 v0.2d, v1.4d, v2.4s
2156
2157         ssubl v0.8h, v1.8h, v2.8b
2158         ssubl v0.4s, v1.4s, v2.4h
2159         ssubl v0.2d, v1.2d, v2.2s
2160
2161 // CHECK-ERROR: [[@LINE-4]]:22: error: invalid operand for instruction
2162 // CHECK-ERROR-NEXT:        ssubl v0.8h, v1.8h, v2.8b
2163 // CHECK-ERROR: error: invalid operand for instruction
2164 // CHECK-ERROR:        ssubl v0.4s, v1.4s, v2.4h
2165 // CHECK-ERROR:                        ^
2166 // CHECK-ERROR: error: invalid operand for instruction
2167 // CHECK-ERROR:        ssubl v0.2d, v1.2d, v2.2s
2168 // CHECK-ERROR:                        ^
2169
2170         ssubl2 v0.8h, v1.16h, v2.16b
2171         ssubl2 v0.4s, v1.8s, v2.8h
2172         ssubl2 v0.2d, v1.4d, v2.4s
2173
2174 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2175 // CHECK-ERROR:        ssubl2 v0.8h, v1.16h, v2.16b
2176 // CHECK-ERROR:                      ^
2177 // CHECK-ERROR: error: invalid vector kind qualifier
2178 // CHECK-ERROR:        ssubl2 v0.4s, v1.8s, v2.8h
2179 // CHECK-ERROR:                      ^
2180 // CHECK-ERROR: error: invalid vector kind qualifier
2181 // CHECK-ERROR:        ssubl2 v0.2d, v1.4d, v2.4s
2182 // CHECK-ERROR:                      ^
2183
2184         usubl v0.8h, v1.8h, v2.8b
2185         usubl v0.4s, v1.4s, v2.4h
2186         usubl v0.2d, v1.2d, v2.2s
2187
2188 // CHECK-ERROR: error: invalid operand for instruction
2189 // CHECK-ERROR:        usubl v0.8h, v1.8h, v2.8b
2190 // CHECK-ERROR:                        ^
2191 // CHECK-ERROR: error: invalid operand for instruction
2192 // CHECK-ERROR:        usubl v0.4s, v1.4s, v2.4h
2193 // CHECK-ERROR:                        ^
2194 // CHECK-ERROR: error: invalid operand for instruction
2195 // CHECK-ERROR:        usubl v0.2d, v1.2d, v2.2s
2196 // CHECK-ERROR:                        ^
2197
2198         usubl2 v0.8h, v1.16h, v2.16b
2199         usubl2 v0.4s, v1.8s, v2.8h
2200         usubl2 v0.2d, v1.4d, v2.4s
2201
2202 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2203 // CHECK-ERROR:        usubl2 v0.8h, v1.16h, v2.16b
2204 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2205 // CHECK-ERROR:        usubl2 v0.4s, v1.8s, v2.8h
2206 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2207 // CHECK-ERROR:        usubl2 v0.2d, v1.4d, v2.4s
2208
2209         sabal v0.8h, v1.8h, v2.8b
2210         sabal v0.4s, v1.4s, v2.4h
2211         sabal v0.2d, v1.2d, v2.2s
2212
2213 // CHECK-ERROR: error: invalid operand for instruction
2214 // CHECK-ERROR:        sabal v0.8h, v1.8h, v2.8b
2215 // CHECK-ERROR:                        ^
2216 // CHECK-ERROR: error: invalid operand for instruction
2217 // CHECK-ERROR:        sabal v0.4s, v1.4s, v2.4h
2218 // CHECK-ERROR:                        ^
2219 // CHECK-ERROR: error: invalid operand for instruction
2220 // CHECK-ERROR:        sabal v0.2d, v1.2d, v2.2s
2221 // CHECK-ERROR:                        ^
2222
2223         sabal2 v0.8h, v1.16h, v2.16b
2224         sabal2 v0.4s, v1.8s, v2.8h
2225         sabal2 v0.2d, v1.4d, v2.4s
2226
2227 // CHECK-ERROR: error: invalid vector kind qualifier
2228 // CHECK-ERROR:        sabal2 v0.8h, v1.16h, v2.16b
2229 // CHECK-ERROR:                      ^
2230 // CHECK-ERROR: error: invalid vector kind qualifier
2231 // CHECK-ERROR:        sabal2 v0.4s, v1.8s, v2.8h
2232 // CHECK-ERROR:                      ^
2233 // CHECK-ERROR: error: invalid vector kind qualifier
2234 // CHECK-ERROR:        sabal2 v0.2d, v1.4d, v2.4s
2235 // CHECK-ERROR:                      ^
2236
2237         uabal v0.8h, v1.8h, v2.8b
2238         uabal v0.4s, v1.4s, v2.4h
2239         uabal v0.2d, v1.2d, v2.2s
2240
2241 // CHECK-ERROR: error: invalid operand for instruction
2242 // CHECK-ERROR:        uabal v0.8h, v1.8h, v2.8b
2243 // CHECK-ERROR:                        ^
2244 // CHECK-ERROR: error: invalid operand for instruction
2245 // CHECK-ERROR:        uabal v0.4s, v1.4s, v2.4h
2246 // CHECK-ERROR:                        ^
2247 // CHECK-ERROR: error: invalid operand for instruction
2248 // CHECK-ERROR:        uabal v0.2d, v1.2d, v2.2s
2249 // CHECK-ERROR:                        ^
2250
2251         uabal2 v0.8h, v1.16h, v2.16b
2252         uabal2 v0.4s, v1.8s, v2.8h
2253         uabal2 v0.2d, v1.4d, v2.4s
2254
2255 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2256 // CHECK-ERROR:        uabal2 v0.8h, v1.16h, v2.16b
2257 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2258 // CHECK-ERROR:        uabal2 v0.4s, v1.8s, v2.8h
2259 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2260 // CHECK-ERROR:        uabal2 v0.2d, v1.4d, v2.4s
2261
2262         sabdl v0.8h, v1.8h, v2.8b
2263         sabdl v0.4s, v1.4s, v2.4h
2264         sabdl v0.2d, v1.2d, v2.2s
2265
2266 // CHECK-ERROR: error: invalid operand for instruction
2267 // CHECK-ERROR:        sabdl v0.8h, v1.8h, v2.8b
2268 // CHECK-ERROR:                        ^
2269 // CHECK-ERROR: error: invalid operand for instruction
2270 // CHECK-ERROR:        sabdl v0.4s, v1.4s, v2.4h
2271 // CHECK-ERROR:                        ^
2272 // CHECK-ERROR: error: invalid operand for instruction
2273 // CHECK-ERROR:        sabdl v0.2d, v1.2d, v2.2s
2274 // CHECK-ERROR:                        ^
2275
2276         sabdl2 v0.8h, v1.16h, v2.16b
2277         sabdl2 v0.4s, v1.8s, v2.8h
2278         sabdl2 v0.2d, v1.4d, v2.4s
2279
2280 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2281 // CHECK-ERROR:        sabdl2 v0.8h, v1.16h, v2.16b
2282 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2283 // CHECK-ERROR:        sabdl2 v0.4s, v1.8s, v2.8h
2284 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2285 // CHECK-ERROR:        sabdl2 v0.2d, v1.4d, v2.4s
2286
2287         uabdl v0.8h, v1.8h, v2.8b
2288         uabdl v0.4s, v1.4s, v2.4h
2289         uabdl v0.2d, v1.2d, v2.2s
2290
2291 // CHECK-ERROR: error: invalid operand for instruction
2292 // CHECK-ERROR:        uabdl v0.8h, v1.8h, v2.8b
2293 // CHECK-ERROR:                        ^
2294 // CHECK-ERROR: error: invalid operand for instruction
2295 // CHECK-ERROR:        uabdl v0.4s, v1.4s, v2.4h
2296 // CHECK-ERROR:                        ^
2297 // CHECK-ERROR: error: invalid operand for instruction
2298 // CHECK-ERROR:        uabdl v0.2d, v1.2d, v2.2s
2299 // CHECK-ERROR:                        ^
2300
2301         uabdl2 v0.8h, v1.16h, v2.16b
2302         uabdl2 v0.4s, v1.8s, v2.8h
2303         uabdl2 v0.2d, v1.4d, v2.4s
2304
2305 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2306 // CHECK-ERROR:        uabdl2 v0.8h, v1.16h, v2.16b
2307 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2308 // CHECK-ERROR:        uabdl2 v0.4s, v1.8s, v2.8h
2309 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2310 // CHECK-ERROR:        uabdl2 v0.2d, v1.4d, v2.4s
2311
2312         smlal v0.8h, v1.8h, v2.8b
2313         smlal v0.4s, v1.4s, v2.4h
2314         smlal v0.2d, v1.2d, v2.2s
2315
2316 // CHECK-ERROR: error: invalid operand for instruction
2317 // CHECK-ERROR:        smlal v0.8h, v1.8h, v2.8b
2318 // CHECK-ERROR:                        ^
2319 // CHECK-ERROR: error: invalid operand for instruction
2320 // CHECK-ERROR:        smlal v0.4s, v1.4s, v2.4h
2321 // CHECK-ERROR:                        ^
2322 // CHECK-ERROR: error: invalid operand for instruction
2323 // CHECK-ERROR:        smlal v0.2d, v1.2d, v2.2s
2324 // CHECK-ERROR:                        ^
2325
2326         smlal2 v0.8h, v1.16h, v2.16b
2327         smlal2 v0.4s, v1.8s, v2.8h
2328         smlal2 v0.2d, v1.4d, v2.4s
2329
2330 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2331 // CHECK-ERROR:        smlal2 v0.8h, v1.16h, v2.16b
2332 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2333 // CHECK-ERROR:        smlal2 v0.4s, v1.8s, v2.8h
2334 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2335 // CHECK-ERROR:        smlal2 v0.2d, v1.4d, v2.4s
2336
2337         umlal v0.8h, v1.8h, v2.8b
2338         umlal v0.4s, v1.4s, v2.4h
2339         umlal v0.2d, v1.2d, v2.2s
2340
2341 // CHECK-ERROR: [[@LINE-4]]:22: error: invalid operand for instruction
2342 // CHECK-ERROR:        umlal v0.8h, v1.8h, v2.8b
2343 // CHECK-ERROR: [[@LINE-5]]:22: error: invalid operand for instruction
2344 // CHECK-ERROR:        umlal v0.4s, v1.4s, v2.4h
2345 // CHECK-ERROR: [[@LINE-6]]:22: error: invalid operand for instruction
2346 // CHECK-ERROR:        umlal v0.2d, v1.2d, v2.2s
2347
2348         umlal2 v0.8h, v1.16h, v2.16b
2349         umlal2 v0.4s, v1.8s, v2.8h
2350         umlal2 v0.2d, v1.4d, v2.4s
2351
2352 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2353 // CHECK-ERROR:        umlal2 v0.8h, v1.16h, v2.16b
2354 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2355 // CHECK-ERROR:        umlal2 v0.4s, v1.8s, v2.8h
2356 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2357 // CHECK-ERROR:        umlal2 v0.2d, v1.4d, v2.4s
2358
2359         smlsl v0.8h, v1.8h, v2.8b
2360         smlsl v0.4s, v1.4s, v2.4h
2361         smlsl v0.2d, v1.2d, v2.2s
2362
2363 // CHECK-ERROR: [[@LINE-4]]:22: error: invalid operand for instruction
2364 // CHECK-ERROR:        smlsl v0.8h, v1.8h, v2.8b
2365 // CHECK-ERROR: [[@LINE-5]]:22: error: invalid operand for instruction
2366 // CHECK-ERROR:        smlsl v0.4s, v1.4s, v2.4h
2367 // CHECK-ERROR: [[@LINE-6]]:22: error: invalid operand for instruction
2368 // CHECK-ERROR:        smlsl v0.2d, v1.2d, v2.2s
2369
2370         smlsl2 v0.8h, v1.16h, v2.16b
2371         smlsl2 v0.4s, v1.8s, v2.8h
2372         smlsl2 v0.2d, v1.4d, v2.4s
2373
2374 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2375 // CHECK-ERROR:        smlsl2 v0.8h, v1.16h, v2.16b
2376 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2377 // CHECK-ERROR:        smlsl2 v0.4s, v1.8s, v2.8h
2378 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2379 // CHECK-ERROR:        smlsl2 v0.2d, v1.4d, v2.4s
2380
2381         umlsl v0.8h, v1.8h, v2.8b
2382         umlsl v0.4s, v1.4s, v2.4h
2383         umlsl v0.2d, v1.2d, v2.2s
2384
2385 // CHECK-ERROR: error: invalid operand for instruction
2386 // CHECK-ERROR:        umlsl v0.8h, v1.8h, v2.8b
2387 // CHECK-ERROR:                        ^
2388 // CHECK-ERROR: error: invalid operand for instruction
2389 // CHECK-ERROR:        umlsl v0.4s, v1.4s, v2.4h
2390 // CHECK-ERROR:                        ^
2391 // CHECK-ERROR: error: invalid operand for instruction
2392 // CHECK-ERROR:        umlsl v0.2d, v1.2d, v2.2s
2393 // CHECK-ERROR:                        ^
2394
2395         umlsl2 v0.8h, v1.16h, v2.16b
2396         umlsl2 v0.4s, v1.8s, v2.8h
2397         umlsl2 v0.2d, v1.4d, v2.4s
2398
2399 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2400 // CHECK-ERROR:        umlsl2 v0.8h, v1.16h, v2.16b
2401 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2402 // CHECK-ERROR:        umlsl2 v0.4s, v1.8s, v2.8h
2403 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2404 // CHECK-ERROR:        umlsl2 v0.2d, v1.4d, v2.4s
2405
2406         smull v0.8h, v1.8h, v2.8b
2407         smull v0.4s, v1.4s, v2.4h
2408         smull v0.2d, v1.2d, v2.2s
2409
2410 // CHECK-ERROR: error: invalid operand for instruction
2411 // CHECK-ERROR:        smull v0.8h, v1.8h, v2.8b
2412 // CHECK-ERROR:                        ^
2413 // CHECK-ERROR: error: invalid operand for instruction
2414 // CHECK-ERROR:        smull v0.4s, v1.4s, v2.4h
2415 // CHECK-ERROR:                        ^
2416 // CHECK-ERROR: error: invalid operand for instruction
2417 // CHECK-ERROR:        smull v0.2d, v1.2d, v2.2s
2418 // CHECK-ERROR:                        ^
2419
2420         smull2 v0.8h, v1.16h, v2.16b
2421         smull2 v0.4s, v1.8s, v2.8h
2422         smull2 v0.2d, v1.4d, v2.4s
2423
2424 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2425 // CHECK-ERROR:        smull2 v0.8h, v1.16h, v2.16b
2426 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2427 // CHECK-ERROR:        smull2 v0.4s, v1.8s, v2.8h
2428 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2429 // CHECK-ERROR:        smull2 v0.2d, v1.4d, v2.4s
2430
2431         umull v0.8h, v1.8h, v2.8b
2432         umull v0.4s, v1.4s, v2.4h
2433         umull v0.2d, v1.2d, v2.2s
2434
2435 // CHECK-ERROR: error: invalid operand for instruction
2436 // CHECK-ERROR:        umull v0.8h, v1.8h, v2.8b
2437 // CHECK-ERROR:                        ^
2438 // CHECK-ERROR: error: invalid operand for instruction
2439 // CHECK-ERROR:        umull v0.4s, v1.4s, v2.4h
2440 // CHECK-ERROR:                        ^
2441 // CHECK-ERROR: error: invalid operand for instruction
2442 // CHECK-ERROR:        umull v0.2d, v1.2d, v2.2s
2443 // CHECK-ERROR:                        ^
2444
2445         umull2 v0.8h, v1.16h, v2.16b
2446         umull2 v0.4s, v1.8s, v2.8h
2447         umull2 v0.2d, v1.4d, v2.4s
2448
2449 // CHECK-ERROR: [[@LINE-4]]:23: error: invalid vector kind qualifier
2450 // CHECK-ERROR:        umull2 v0.8h, v1.16h, v2.16b
2451 // CHECK-ERROR: [[@LINE-5]]:23: error: invalid vector kind qualifier
2452 // CHECK-ERROR:        umull2 v0.4s, v1.8s, v2.8h
2453 // CHECK-ERROR: [[@LINE-6]]:23: error: invalid vector kind qualifier
2454 // CHECK-ERROR:        umull2 v0.2d, v1.4d, v2.4s
2455
2456 //------------------------------------------------------------------------------
2457 // Long - Variant 2
2458 //------------------------------------------------------------------------------
2459
2460         sqdmlal v0.4s, v1.4s, v2.4h
2461         sqdmlal v0.2d, v1.2d, v2.2s
2462
2463 // CHECK-ERROR: error: invalid operand for instruction
2464 // CHECK-ERROR:        sqdmlal v0.4s, v1.4s, v2.4h
2465 // CHECK-ERROR:                          ^
2466 // CHECK-ERROR: error: invalid operand for instruction
2467 // CHECK-ERROR:        sqdmlal v0.2d, v1.2d, v2.2s
2468 // CHECK-ERROR:                          ^
2469
2470         sqdmlal2 v0.4s, v1.8s, v2.8h
2471         sqdmlal2 v0.2d, v1.4d, v2.4s
2472
2473 // CHECK-ERROR: [[@LINE-3]]:25: error: invalid vector kind qualifier
2474 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8s, v2.8h
2475 // CHECK-ERROR: [[@LINE-4]]:25: error: invalid vector kind qualifier
2476 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4d, v2.4s
2477
2478         // Mismatched vector types
2479         sqdmlal v0.8h, v1.8b, v2.8b
2480         sqdmlal2 v0.8h, v1.16b, v2.16b
2481
2482 // CHECK-ERROR: error: invalid operand for instruction
2483 // CHECK-ERROR:        sqdmlal v0.8h, v1.8b, v2.8b
2484 // CHECK-ERROR:                   ^
2485 // CHECK-ERROR: error: invalid operand for instruction
2486 // CHECK-ERROR:        sqdmlal2 v0.8h, v1.16b, v2.16b
2487 // CHECK-ERROR:                    ^
2488
2489         sqdmlsl v0.4s, v1.4s, v2.4h
2490         sqdmlsl v0.2d, v1.2d, v2.2s
2491
2492 // CHECK-ERROR: error: invalid operand for instruction
2493 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4s, v2.4h
2494 // CHECK-ERROR:                          ^
2495 // CHECK-ERROR: error: invalid operand for instruction
2496 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2d, v2.2s
2497 // CHECK-ERROR:                          ^
2498
2499         sqdmlsl2 v0.4s, v1.8s, v2.8h
2500         sqdmlsl2 v0.2d, v1.4d, v2.4s
2501
2502 // CHECK-ERROR: [[@LINE-3]]:25: error: invalid vector kind qualifier
2503 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8s, v2.8h
2504 // CHECK-ERROR: [[@LINE-4]]:25: error: invalid vector kind qualifier
2505 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4d, v2.4s
2506
2507         // Mismatched vector types
2508         sqdmlsl v0.8h, v1.8b, v2.8b
2509         sqdmlsl2 v0.8h, v1.16b, v2.16b
2510
2511 // CHECK-ERROR: error: invalid operand for instruction
2512 // CHECK-ERROR:        sqdmlsl v0.8h, v1.8b, v2.8b
2513 // CHECK-ERROR:                   ^
2514 // CHECK-ERROR: error: invalid operand for instruction
2515 // CHECK-ERROR:        sqdmlsl2 v0.8h, v1.16b, v2.16b
2516 // CHECK-ERROR:                    ^
2517
2518
2519         sqdmull v0.4s, v1.4s, v2.4h
2520         sqdmull v0.2d, v1.2d, v2.2s
2521
2522 // CHECK-ERROR: error: invalid operand for instruction
2523 // CHECK-ERROR:        sqdmull v0.4s, v1.4s, v2.4h
2524 // CHECK-ERROR:                          ^
2525 // CHECK-ERROR: error: invalid operand for instruction
2526 // CHECK-ERROR:        sqdmull v0.2d, v1.2d, v2.2s
2527 // CHECK-ERROR:                          ^
2528
2529         sqdmull2 v0.4s, v1.8s, v2.8h
2530         sqdmull2 v0.2d, v1.4d, v2.4s
2531
2532 // CHECK-ERROR: [[@LINE-3]]:25: error: invalid vector kind qualifier
2533 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8s, v2.8h
2534 // CHECK-ERROR: [[@LINE-4]]:25: error: invalid vector kind qualifier
2535 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4d, v2.4s
2536
2537         // Mismatched vector types
2538         sqdmull v0.8h, v1.8b, v2.8b
2539         sqdmull2 v0.8h, v1.16b, v2.16b
2540
2541 // CHECK-ERROR: error: invalid operand for instruction
2542 // CHECK-ERROR:        sqdmull v0.8h, v1.8b, v2.8b
2543 // CHECK-ERROR:                   ^
2544 // CHECK-ERROR: error: invalid operand for instruction
2545 // CHECK-ERROR:        sqdmull2 v0.8h, v1.16b, v2.16b
2546 // CHECK-ERROR:                    ^
2547
2548
2549 //------------------------------------------------------------------------------
2550 // Long - Variant 3
2551 //------------------------------------------------------------------------------
2552
2553         pmull v0.8h, v1.8h, v2.8b
2554
2555 // CHECK-ERROR: error: invalid operand for instruction
2556 // CHECK-ERROR:        pmull v0.8h, v1.8h, v2.8b
2557 // CHECK-ERROR:                        ^
2558
2559         pmull v0.1q, v1.2d, v2.2d
2560
2561 // CHECK-ERROR: error: invalid operand for instruction
2562 // CHECK-ERROR:        pmull v0.1q, v1.2d, v2.2d
2563 // CHECK-ERROR:                     ^
2564
2565         // Mismatched vector types
2566         pmull v0.4s, v1.4h, v2.4h
2567         pmull v0.2d, v1.2s, v2.2s
2568
2569 // CHECK-ERROR: error: invalid operand for instruction
2570 // CHECK-ERROR:        pmull v0.4s, v1.4h, v2.4h
2571 // CHECK-ERROR:                 ^
2572 // CHECK-ERROR: error: invalid operand for instruction
2573 // CHECK-ERROR:        pmull v0.2d, v1.2s, v2.2s
2574 // CHECK-ERROR:                 ^
2575
2576
2577         pmull2 v0.8h, v1.16h, v2.16b
2578 // CHECK-ERROR: [[@LINE-1]]:23: error: invalid vector kind qualifier
2579 // CHECK-ERROR:        pmull2 v0.8h, v1.16h, v2.16b
2580
2581         pmull2 v0.q, v1.2d, v2.2d
2582 // CHECK-ERROR: [[@LINE-1]]:16: error: invalid vector kind qualifier
2583 // CHECK-ERROR:        pmull2 v0.q, v1.2d, v2.2d
2584
2585         // Mismatched vector types
2586         pmull2 v0.4s, v1.8h v2.8h
2587         pmull2 v0.2d, v1.4s, v2.4s
2588
2589
2590 // CHECK-ERROR: error: unexpected token in argument list
2591 // CHECK-ERROR:        pmull2 v0.4s, v1.8h v2.8h
2592 // CHECK-ERROR:                            ^
2593
2594 // CHECK-ERROR: error: invalid operand for instruction
2595 // CHECK-ERROR:        pmull2 v0.2d, v1.4s, v2.4s
2596 // CHECK-ERROR:                  ^
2597
2598 //------------------------------------------------------------------------------
2599 // Widen
2600 //------------------------------------------------------------------------------
2601
2602         saddw v0.8h, v1.8h, v2.8h
2603         saddw v0.4s, v1.4s, v2.4s
2604         saddw v0.2d, v1.2d, v2.2d
2605
2606 // CHECK-ERROR: error: invalid operand for instruction
2607 // CHECK-ERROR:        saddw v0.8h, v1.8h, v2.8h
2608 // CHECK-ERROR:                               ^
2609 // CHECK-ERROR: error: invalid operand for instruction
2610 // CHECK-ERROR:        saddw v0.4s, v1.4s, v2.4s
2611 // CHECK-ERROR:                               ^
2612 // CHECK-ERROR: error: invalid operand for instruction
2613 // CHECK-ERROR:        saddw v0.2d, v1.2d, v2.2d
2614 // CHECK-ERROR:                               ^
2615
2616         saddw2 v0.8h, v1.8h, v2.16h
2617         saddw2 v0.4s, v1.4s, v2.8s
2618         saddw2 v0.2d, v1.2d, v2.4d
2619
2620 // CHECK-ERROR: [[@LINE-4]]:30: error: invalid vector kind qualifier
2621 // CHECK-ERROR:        saddw2 v0.8h, v1.8h, v2.16h
2622 // CHECK-ERROR: [[@LINE-5]]:30: error: invalid vector kind qualifier
2623 // CHECK-ERROR:        saddw2 v0.4s, v1.4s, v2.8s
2624 // CHECK-ERROR: [[@LINE-6]]:30: error: invalid vector kind qualifier
2625 // CHECK-ERROR:        saddw2 v0.2d, v1.2d, v2.4d
2626
2627         uaddw v0.8h, v1.8h, v2.8h
2628         uaddw v0.4s, v1.4s, v2.4s
2629         uaddw v0.2d, v1.2d, v2.2d
2630
2631 // CHECK-ERROR: error: invalid operand for instruction
2632 // CHECK-ERROR:        uaddw v0.8h, v1.8h, v2.8h
2633 // CHECK-ERROR:                               ^
2634 // CHECK-ERROR: error: invalid operand for instruction
2635 // CHECK-ERROR:        uaddw v0.4s, v1.4s, v2.4s
2636 // CHECK-ERROR:                               ^
2637 // CHECK-ERROR: error: invalid operand for instruction
2638 // CHECK-ERROR:        uaddw v0.2d, v1.2d, v2.2d
2639 // CHECK-ERROR:                               ^
2640
2641         uaddw2 v0.8h, v1.8h, v2.16h
2642         uaddw2 v0.4s, v1.4s, v2.8s
2643         uaddw2 v0.2d, v1.2d, v2.4d
2644
2645 // CHECK-ERROR: [[@LINE-4]]:30: error: invalid vector kind qualifier
2646 // CHECK-ERROR:        uaddw2 v0.8h, v1.8h, v2.16h
2647 // CHECK-ERROR: [[@LINE-5]]:30: error: invalid vector kind qualifier
2648 // CHECK-ERROR:        uaddw2 v0.4s, v1.4s, v2.8s
2649 // CHECK-ERROR: [[@LINE-6]]:30: error: invalid vector kind qualifier
2650 // CHECK-ERROR:        uaddw2 v0.2d, v1.2d, v2.4d
2651
2652         ssubw v0.8h, v1.8h, v2.8h
2653         ssubw v0.4s, v1.4s, v2.4s
2654         ssubw v0.2d, v1.2d, v2.2d
2655
2656 // CHECK-ERROR: error: invalid operand for instruction
2657 // CHECK-ERROR:        ssubw v0.8h, v1.8h, v2.8h
2658 // CHECK-ERROR:                               ^
2659 // CHECK-ERROR: error: invalid operand for instruction
2660 // CHECK-ERROR:        ssubw v0.4s, v1.4s, v2.4s
2661 // CHECK-ERROR:                               ^
2662 // CHECK-ERROR: error: invalid operand for instruction
2663 // CHECK-ERROR:        ssubw v0.2d, v1.2d, v2.2d
2664 // CHECK-ERROR:                               ^
2665
2666         ssubw2 v0.8h, v1.8h, v2.16h
2667         ssubw2 v0.4s, v1.4s, v2.8s
2668         ssubw2 v0.2d, v1.2d, v2.4d
2669
2670 // CHECK-ERROR: [[@LINE-4]]:30: error: invalid vector kind qualifier
2671 // CHECK-ERROR:        ssubw2 v0.8h, v1.8h, v2.16h
2672 // CHECK-ERROR: [[@LINE-5]]:30: error: invalid vector kind qualifier
2673 // CHECK-ERROR:        ssubw2 v0.4s, v1.4s, v2.8s
2674 // CHECK-ERROR: [[@LINE-6]]:30: error: invalid vector kind qualifier
2675 // CHECK-ERROR:        ssubw2 v0.2d, v1.2d, v2.4d
2676
2677         usubw v0.8h, v1.8h, v2.8h
2678         usubw v0.4s, v1.4s, v2.4s
2679         usubw v0.2d, v1.2d, v2.2d
2680
2681 // CHECK-ERROR: error: invalid operand for instruction
2682 // CHECK-ERROR:        usubw v0.8h, v1.8h, v2.8h
2683 // CHECK-ERROR:                               ^
2684 // CHECK-ERROR: error: invalid operand for instruction
2685 // CHECK-ERROR:        usubw v0.4s, v1.4s, v2.4s
2686 // CHECK-ERROR:                               ^
2687 // CHECK-ERROR: error: invalid operand for instruction
2688 // CHECK-ERROR:        usubw v0.2d, v1.2d, v2.2d
2689 // CHECK-ERROR:                               ^
2690
2691         usubw2 v0.8h, v1.8h, v2.16h
2692         usubw2 v0.4s, v1.4s, v2.8s
2693         usubw2 v0.2d, v1.2d, v2.4d
2694
2695 // CHECK-ERROR: [[@LINE-4]]:30: error: invalid vector kind qualifier
2696 // CHECK-ERROR:        usubw2 v0.8h, v1.8h, v2.16h
2697 // CHECK-ERROR: [[@LINE-5]]:30: error: invalid vector kind qualifier
2698 // CHECK-ERROR:        usubw2 v0.4s, v1.4s, v2.8s
2699 // CHECK-ERROR: [[@LINE-6]]:30: error: invalid vector kind qualifier
2700 // CHECK-ERROR:        usubw2 v0.2d, v1.2d, v2.4d
2701
2702 //------------------------------------------------------------------------------
2703 // Narrow
2704 //------------------------------------------------------------------------------
2705
2706         addhn v0.8b, v1.8h, v2.8d
2707         addhn v0.4h, v1.4s, v2.4h
2708         addhn v0.2s, v1.2d, v2.2s
2709
2710 // CHECK-ERROR: [[@LINE-4]]:29: error: invalid vector kind qualifier
2711 // CHECK-ERROR:        addhn v0.8b, v1.8h, v2.8d
2712 // CHECK-ERROR: [[@LINE-5]]:29: error: invalid operand for instruction
2713 // CHECK-ERROR:        addhn v0.4h, v1.4s, v2.4h
2714 // CHECK-ERROR: [[@LINE-6]]:29: error: invalid operand for instruction
2715 // CHECK-ERROR:        addhn v0.2s, v1.2d, v2.2s
2716
2717         addhn2 v0.16b, v1.8h, v2.8b
2718         addhn2 v0.8h, v1.4s, v2.4h
2719         addhn2 v0.4s, v1.2d, v2.2s
2720
2721 // CHECK-ERROR: error: invalid operand for instruction
2722 // CHECK-ERROR:        addhn2 v0.16b, v1.8h, v2.8b
2723 // CHECK-ERROR:                                 ^
2724 // CHECK-ERROR: error: invalid operand for instruction
2725 // CHECK-ERROR:        addhn2 v0.8h, v1.4s, v2.4h
2726 // CHECK-ERROR:                                ^
2727 // CHECK-ERROR: error: invalid operand for instruction
2728 // CHECK-ERROR:        addhn2 v0.4s, v1.2d, v2.2s
2729 // CHECK-ERROR:                                ^
2730
2731         raddhn v0.8b, v1.8h, v2.8b
2732         raddhn v0.4h, v1.4s, v2.4h
2733         raddhn v0.2s, v1.2d, v2.2s
2734
2735 // CHECK-ERROR: error: invalid operand for instruction
2736 // CHECK-ERROR:        raddhn v0.8b, v1.8h, v2.8b
2737 // CHECK-ERROR:                                ^
2738 // CHECK-ERROR: error: invalid operand for instruction
2739 // CHECK-ERROR:        raddhn v0.4h, v1.4s, v2.4h
2740 // CHECK-ERROR:                                ^
2741 // CHECK-ERROR: error: invalid operand for instruction
2742 // CHECK-ERROR:        raddhn v0.2s, v1.2d, v2.2s
2743 // CHECK-ERROR:                                ^
2744
2745         raddhn2 v0.16b, v1.8h, v2.8b
2746         raddhn2 v0.8h, v1.4s, v2.4h
2747         raddhn2 v0.4s, v1.2d, v2.2s
2748
2749 // CHECK-ERROR: error: invalid operand for instruction
2750 // CHECK-ERROR:        raddhn2 v0.16b, v1.8h, v2.8b
2751 // CHECK-ERROR:                                  ^
2752 // CHECK-ERROR: error: invalid operand for instruction
2753 // CHECK-ERROR:        raddhn2 v0.8h, v1.4s, v2.4h
2754 // CHECK-ERROR:                                 ^
2755 // CHECK-ERROR: error: invalid operand for instruction
2756 // CHECK-ERROR:        raddhn2 v0.4s, v1.2d, v2.2s
2757 // CHECK-ERROR:                                 ^
2758
2759         rsubhn v0.8b, v1.8h, v2.8b
2760         rsubhn v0.4h, v1.4s, v2.4h
2761         rsubhn v0.2s, v1.2d, v2.2s
2762
2763 // CHECK-ERROR: error: invalid operand for instruction
2764 // CHECK-ERROR:        rsubhn v0.8b, v1.8h, v2.8b
2765 // CHECK-ERROR:                                ^
2766 // CHECK-ERROR: error: invalid operand for instruction
2767 // CHECK-ERROR:        rsubhn v0.4h, v1.4s, v2.4h
2768 // CHECK-ERROR:                                ^
2769 // CHECK-ERROR: error: invalid operand for instruction
2770 // CHECK-ERROR:        rsubhn v0.2s, v1.2d, v2.2s
2771 // CHECK-ERROR:                                ^
2772
2773         rsubhn2 v0.16b, v1.8h, v2.8b
2774         rsubhn2 v0.8h, v1.4s, v2.4h
2775         rsubhn2 v0.4s, v1.2d, v2.2s
2776
2777 // CHECK-ERROR: error: invalid operand for instruction
2778 // CHECK-ERROR:        rsubhn2 v0.16b, v1.8h, v2.8b
2779 // CHECK-ERROR:                                  ^
2780 // CHECK-ERROR: error: invalid operand for instruction
2781 // CHECK-ERROR:        rsubhn2 v0.8h, v1.4s, v2.4h
2782 // CHECK-ERROR:                                 ^
2783 // CHECK-ERROR: error: invalid operand for instruction
2784 // CHECK-ERROR:        rsubhn2 v0.4s, v1.2d, v2.2s
2785 // CHECK-ERROR:                                 ^
2786
2787 //----------------------------------------------------------------------
2788 // Scalar Reduce Add Pairwise (Integer)
2789 //----------------------------------------------------------------------
2790          // invalid vector types
2791       addp s0, d1.2d
2792       addp d0, d1.2s
2793
2794 // CHECK-ERROR: error: invalid operand for instruction
2795 // CHECK-ERROR:          addp s0, d1.2d
2796 // CHECK-ERROR:               ^
2797 // CHECK-ERROR: error: invalid operand for instruction
2798 // CHECK-ERROR:          addp d0, d1.2s
2799 // CHECK-ERROR:                      ^
2800
2801 //----------------------------------------------------------------------
2802 // Scalar Reduce Add Pairwise (Floating Point)
2803 //----------------------------------------------------------------------
2804          // invalid vector types
2805       faddp s0, d1.2d
2806       faddp d0, d1.2s
2807
2808 // CHECK-ERROR: error: invalid operand for instruction
2809 // CHECK-ERROR:          faddp s0, d1.2d
2810 // CHECK-ERROR:                    ^
2811 // CHECK-ERROR: error: invalid operand for instruction
2812 // CHECK-ERROR:          faddp d0, d1.2s
2813 // CHECK-ERROR:                    ^
2814
2815 //----------------------------------------------------------------------
2816 // Scalar Reduce Maximum Pairwise (Floating Point)
2817 //----------------------------------------------------------------------
2818          // mismatched and invalid vector types
2819       fmaxp s0, v1.2d
2820       fmaxp d31, v2.2s
2821       fmaxp h3, v2.2s
2822
2823 // CHECK-ERROR: error: invalid operand for instruction
2824 // CHECK-ERROR:          fmaxp s0, v1.2d
2825 // CHECK-ERROR:                       ^
2826 // CHECK-ERROR: error: invalid operand for instruction
2827 // CHECK-ERROR:          fmaxp d31, v2.2s
2828 // CHECK-ERROR:                        ^
2829 // CHECK-ERROR: error: invalid operand for instruction
2830 // CHECK-ERROR:          fmaxp h3, v2.2s
2831 // CHECK-ERROR:                ^
2832
2833
2834 //----------------------------------------------------------------------
2835 // Scalar Reduce Minimum Pairwise (Floating Point)
2836 //----------------------------------------------------------------------
2837          // mismatched and invalid vector types
2838       fminp s0, v1.4h
2839       fminp d31, v2.8h
2840       fminp b3, v2.2s
2841
2842 // CHECK-ERROR: error: invalid operand for instruction
2843 // CHECK-ERROR:          fminp s0, v1.4h
2844 // CHECK-ERROR:                       ^
2845 // CHECK-ERROR: error: invalid operand for instruction
2846 // CHECK-ERROR:          fminp d31, v2.8h
2847 // CHECK-ERROR:                        ^
2848 // CHECK-ERROR: error: invalid operand for instruction
2849 // CHECK-ERROR:          fminp b3, v2.2s
2850 // CHECK-ERROR:                ^
2851
2852
2853 //----------------------------------------------------------------------
2854 // Scalar Reduce maxNum Pairwise (Floating Point)
2855 //----------------------------------------------------------------------
2856          // mismatched and invalid vector types
2857       fmaxnmp s0, v1.8b
2858       fmaxnmp d31, v2.16b
2859       fmaxnmp v1.2s, v2.2s
2860
2861 // CHECK-ERROR: error: invalid operand for instruction
2862 // CHECK-ERROR:          fmaxnmp s0, v1.8b
2863 // CHECK-ERROR:                         ^
2864 // CHECK-ERROR: error: invalid operand for instruction
2865 // CHECK-ERROR:          fmaxnmp d31, v2.16b
2866 // CHECK-ERROR:                          ^
2867 // CHECK-ERROR: error: too few operands for instruction
2868 // CHECK-ERROR:          fmaxnmp v1.2s, v2.2s
2869 // CHECK-ERROR:          ^
2870
2871 //----------------------------------------------------------------------
2872 // Scalar Reduce minNum Pairwise (Floating Point)
2873 //----------------------------------------------------------------------
2874          // mismatched and invalid vector types
2875       fminnmp s0, v1.2d
2876       fminnmp d31, v2.4s
2877       fminnmp v1.4s, v2.2d
2878
2879 // CHECK-ERROR: error: invalid operand for instruction
2880 // CHECK-ERROR:          fminnmp s0, v1.2d
2881 // CHECK-ERROR:                         ^
2882 // CHECK-ERROR: error: invalid operand for instruction
2883 // CHECK-ERROR:          fminnmp d31, v2.4s
2884 // CHECK-ERROR:                          ^
2885 // CHECK-ERROR: error: invalid operand for instruction
2886 // CHECK-ERROR:          fminnmp v1.4s, v2.2d
2887 // CHECK-ERROR:          ^
2888
2889       mla v0.2d, v1.2d, v16.d[1]
2890       mla v0.2s, v1.2s, v2.s[4]
2891       mla v0.4s, v1.4s, v2.s[4]
2892       mla v0.2h, v1.2h, v2.h[1]
2893       mla v0.4h, v1.4h, v2.h[8]
2894       mla v0.8h, v1.8h, v2.h[8]
2895       mla v0.4h, v1.4h, v16.h[2]
2896       mla v0.8h, v1.8h, v16.h[2]
2897
2898 // CHECK-ERROR: error: invalid operand for instruction
2899 // CHECK-ERROR:        mla v0.2d, v1.2d, v16.d[1]
2900 // CHECK-ERROR:               ^
2901 // CHECK-ERROR: vector lane must be an integer in range
2902 // CHECK-ERROR:        mla v0.2s, v1.2s, v2.s[4]
2903 // CHECK-ERROR:                               ^
2904 // CHECK-ERROR: vector lane must be an integer in range
2905 // CHECK-ERROR:        mla v0.4s, v1.4s, v2.s[4]
2906 // CHECK-ERROR:                               ^
2907 // CHECK-ERROR: error: invalid operand for instruction
2908 // CHECK-ERROR:        mla v0.2h, v1.2h, v2.h[1]
2909 // CHECK-ERROR:            ^
2910 // CHECK-ERROR: vector lane must be an integer in range
2911 // CHECK-ERROR:        mla v0.4h, v1.4h, v2.h[8]
2912 // CHECK-ERROR:                               ^
2913 // CHECK-ERROR: vector lane must be an integer in range
2914 // CHECK-ERROR:        mla v0.8h, v1.8h, v2.h[8]
2915 // CHECK-ERROR:                               ^
2916 // CHECK-ERROR: error: invalid operand for instruction
2917 // CHECK-ERROR:        mla v0.4h, v1.4h, v16.h[2]
2918 // CHECK-ERROR:                          ^
2919 // CHECK-ERROR: error: invalid operand for instruction
2920 // CHECK-ERROR:        mla v0.8h, v1.8h, v16.h[2]
2921 // CHECK-ERROR:                              ^
2922
2923       mls v0.2d, v1.2d, v16.d[1]
2924       mls v0.2s, v1.2s, v2.s[4]
2925       mls v0.4s, v1.4s, v2.s[4]
2926       mls v0.2h, v1.2h, v2.h[1]
2927       mls v0.4h, v1.4h, v2.h[8]
2928       mls v0.8h, v1.8h, v2.h[8]
2929       mls v0.4h, v1.4h, v16.h[2]
2930       mls v0.8h, v1.8h, v16.h[2]
2931
2932 // CHECK-ERROR: error: invalid operand for instruction
2933 // CHECK-ERROR:        mls v0.2d, v1.2d, v16.d[1]
2934 // CHECK-ERROR:               ^
2935 // CHECK-ERROR: vector lane must be an integer in range
2936 // CHECK-ERROR:        mls v0.2s, v1.2s, v2.s[4]
2937 // CHECK-ERROR:                               ^
2938 // CHECK-ERROR: vector lane must be an integer in range
2939 // CHECK-ERROR:        mls v0.4s, v1.4s, v2.s[4]
2940 // CHECK-ERROR:                               ^
2941 // CHECK-ERROR: error: invalid operand for instruction
2942 // CHECK-ERROR:        mls v0.2h, v1.2h, v2.h[1]
2943 // CHECK-ERROR:            ^
2944 // CHECK-ERROR: vector lane must be an integer in range
2945 // CHECK-ERROR:        mls v0.4h, v1.4h, v2.h[8]
2946 // CHECK-ERROR:                               ^
2947 // CHECK-ERROR: vector lane must be an integer in range
2948 // CHECK-ERROR:        mls v0.8h, v1.8h, v2.h[8]
2949 // CHECK-ERROR:                               ^
2950 // CHECK-ERROR: error: invalid operand for instruction
2951 // CHECK-ERROR:        mls v0.4h, v1.4h, v16.h[2]
2952 // CHECK-ERROR:                          ^
2953 // CHECK-ERROR: error: invalid operand for instruction
2954 // CHECK-ERROR:        mls v0.8h, v1.8h, v16.h[2]
2955 // CHECK-ERROR:                              ^
2956
2957       fmla v0.4h, v1.4h, v2.h[2]
2958       fmla v0.8h, v1.8h, v2.h[2]
2959       fmla v0.2s, v1.2s, v2.s[4]
2960       fmla v0.2s, v1.2s, v22.s[4]
2961       fmla v3.4s, v8.4s, v2.s[4]
2962       fmla v3.4s, v8.4s, v22.s[4]
2963       fmla v0.2d, v1.2d, v2.d[2]
2964       fmla v0.2d, v1.2d, v22.d[2]
2965
2966 // CHECK-ERROR: error: instruction requires: fullfp16
2967 // CHECK-ERROR:        fmla v0.4h, v1.4h, v2.h[2]
2968 // CHECK-ERROR:                ^
2969 // CHECK-ERROR: error: instruction requires: fullfp16
2970 // CHECK-ERROR:        fmla v0.8h, v1.8h, v2.h[2]
2971 // CHECK-ERROR:                ^
2972 // CHECK-ERROR: vector lane must be an integer in range
2973 // CHECK-ERROR:        fmla v0.2s, v1.2s, v2.s[4]
2974 // CHECK-ERROR:                                ^
2975 // CHECK-ERROR: vector lane must be an integer in range
2976 // CHECK-ERROR:        fmla v0.2s, v1.2s, v22.s[4]
2977 // CHECK-ERROR:                                 ^
2978 // CHECK-ERROR: vector lane must be an integer in range
2979 // CHECK-ERROR:        fmla v3.4s, v8.4s, v2.s[4]
2980 // CHECK-ERROR:                                ^
2981 // CHECK-ERROR: vector lane must be an integer in range
2982 // CHECK-ERROR:        fmla v3.4s, v8.4s, v22.s[4]
2983 // CHECK-ERROR:                                 ^
2984 // CHECK-ERROR: vector lane must be an integer in range
2985 // CHECK-ERROR:        fmla v0.2d, v1.2d, v2.d[2]
2986 // CHECK-ERROR:                                ^
2987 // CHECK-ERROR: vector lane must be an integer in range
2988 // CHECK-ERROR:        fmla v0.2d, v1.2d, v22.d[2]
2989 // CHECK-ERROR:                                 ^
2990
2991       fmls v0.4h, v1.4h, v2.h[2]
2992       fmls v0.8h, v1.8h, v2.h[2]
2993       fmls v0.2s, v1.2s, v2.s[4]
2994       fmls v0.2s, v1.2s, v22.s[4]
2995       fmls v3.4s, v8.4s, v2.s[4]
2996       fmls v3.4s, v8.4s, v22.s[4]
2997       fmls v0.2d, v1.2d, v2.d[2]
2998       fmls v0.2d, v1.2d, v22.d[2]
2999
3000 // CHECK-ERROR: error: instruction requires: fullfp16
3001 // CHECK-ERROR:        fmls v0.4h, v1.4h, v2.h[2]
3002 // CHECK-ERROR:                ^
3003 // CHECK-ERROR: error: instruction requires: fullfp16
3004 // CHECK-ERROR:        fmls v0.8h, v1.8h, v2.h[2]
3005 // CHECK-ERROR:                ^
3006 // CHECK-ERROR: vector lane must be an integer in range
3007 // CHECK-ERROR:        fmls v0.2s, v1.2s, v2.s[4]
3008 // CHECK-ERROR:                                ^
3009 // CHECK-ERROR: vector lane must be an integer in range
3010 // CHECK-ERROR:        fmls v0.2s, v1.2s, v22.s[4]
3011 // CHECK-ERROR:                                 ^
3012 // CHECK-ERROR: vector lane must be an integer in range
3013 // CHECK-ERROR:        fmls v3.4s, v8.4s, v2.s[4]
3014 // CHECK-ERROR:                                ^
3015 // CHECK-ERROR: vector lane must be an integer in range
3016 // CHECK-ERROR:        fmls v3.4s, v8.4s, v22.s[4]
3017 // CHECK-ERROR:                                 ^
3018 // CHECK-ERROR: vector lane must be an integer in range
3019 // CHECK-ERROR:        fmls v0.2d, v1.2d, v2.d[2]
3020 // CHECK-ERROR:                                ^
3021 // CHECK-ERROR: vector lane must be an integer in range
3022 // CHECK-ERROR:        fmls v0.2d, v1.2d, v22.d[2]
3023 // CHECK-ERROR:                                 ^
3024
3025       smlal v0.4h, v1.4h, v2.h[2]
3026       smlal v0.4s, v1.4h, v2.h[8]
3027       smlal v0.4s, v1.4h, v16.h[2]
3028       smlal v0.2s, v1.2s, v2.s[1]
3029       smlal v0.2d, v1.2s, v2.s[4]
3030       smlal v0.2d, v1.2s, v22.s[4]
3031       smlal2 v0.4h, v1.8h, v1.h[2]
3032       smlal2 v0.4s, v1.8h, v1.h[8]
3033       smlal2 v0.4s, v1.8h, v16.h[2]
3034       smlal2 v0.2s, v1.4s, v1.s[2]
3035       smlal2 v0.2d, v1.4s, v1.s[4]
3036       smlal2 v0.2d, v1.4s, v22.s[4]
3037
3038 // CHECK-ERROR: error: invalid operand for instruction
3039 // CHECK-ERROR:        smlal v0.4h, v1.4h, v2.h[2]
3040 // CHECK-ERROR:              ^
3041 // CHECK-ERROR: vector lane must be an integer in range
3042 // CHECK-ERROR:        smlal v0.4s, v1.4h, v2.h[8]
3043 // CHECK-ERROR:                                 ^
3044 // CHECK-ERROR: error: invalid operand for instruction
3045 // CHECK-ERROR:        smlal v0.4s, v1.4h, v16.h[2]
3046 // CHECK-ERROR:                            ^
3047 // CHECK-ERROR: error: invalid operand for instruction
3048 // CHECK-ERROR:        smlal v0.2s, v1.2s, v2.s[1]
3049 // CHECK-ERROR:                                 ^
3050 // CHECK-ERROR: vector lane must be an integer in range
3051 // CHECK-ERROR:        smlal v0.2d, v1.2s, v2.s[4]
3052 // CHECK-ERROR:                                 ^
3053 // CHECK-ERROR: vector lane must be an integer in range
3054 // CHECK-ERROR:        smlal v0.2d, v1.2s, v22.s[4]
3055 // CHECK-ERROR:                                  ^
3056 // CHECK-ERROR: error: invalid operand for instruction
3057 // CHECK-ERROR:        smlal2 v0.4h, v1.8h, v1.h[2]
3058 // CHECK-ERROR:               ^
3059 // CHECK-ERROR: vector lane must be an integer in range
3060 // CHECK-ERROR:        smlal2 v0.4s, v1.8h, v1.h[8]
3061 // CHECK-ERROR:                                  ^
3062 // CHECK-ERROR: error: invalid operand for instruction
3063 // CHECK-ERROR:        smlal2 v0.4s, v1.8h, v16.h[2]
3064 // CHECK-ERROR:                                 ^
3065 // CHECK-ERROR: error: invalid operand for instruction
3066 // CHECK-ERROR:        smlal2 v0.2s, v1.4s, v1.s[2]
3067 // CHECK-ERROR:               ^
3068 // CHECK-ERROR: vector lane must be an integer in range
3069 // CHECK-ERROR:        smlal2 v0.2d, v1.4s, v1.s[4]
3070 // CHECK-ERROR:                                  ^
3071 // CHECK-ERROR: vector lane must be an integer in range
3072 // CHECK-ERROR:        smlal2 v0.2d, v1.4s, v22.s[4]
3073 // CHECK-ERROR:                                   ^
3074
3075       smlsl v0.4h, v1.4h, v2.h[2]
3076       smlsl v0.4s, v1.4h, v2.h[8]
3077       smlsl v0.4s, v1.4h, v16.h[2]
3078       smlsl v0.2s, v1.2s, v2.s[1]
3079       smlsl v0.2d, v1.2s, v2.s[4]
3080       smlsl v0.2d, v1.2s, v22.s[4]
3081       smlsl2 v0.4h, v1.8h, v1.h[2]
3082       smlsl2 v0.4s, v1.8h, v1.h[8]
3083       smlsl2 v0.4s, v1.8h, v16.h[2]
3084       smlsl2 v0.2s, v1.4s, v1.s[2]
3085       smlsl2 v0.2d, v1.4s, v1.s[4]
3086       smlsl2 v0.2d, v1.4s, v22.s[4]
3087
3088 // CHECK-ERROR: error: invalid operand for instruction
3089 // CHECK-ERROR:        smlsl v0.4h, v1.4h, v2.h[2]
3090 // CHECK-ERROR:              ^
3091 // CHECK-ERROR: vector lane must be an integer in range
3092 // CHECK-ERROR:        smlsl v0.4s, v1.4h, v2.h[8]
3093 // CHECK-ERROR:                                 ^
3094 // CHECK-ERROR: error: invalid operand for instruction
3095 // CHECK-ERROR:        smlsl v0.4s, v1.4h, v16.h[2]
3096 // CHECK-ERROR:                            ^
3097 // CHECK-ERROR: error: invalid operand for instruction
3098 // CHECK-ERROR:        smlsl v0.2s, v1.2s, v2.s[1]
3099 // CHECK-ERROR:                                 ^
3100 // CHECK-ERROR: vector lane must be an integer in range
3101 // CHECK-ERROR:        smlsl v0.2d, v1.2s, v2.s[4]
3102 // CHECK-ERROR:                                 ^
3103 // CHECK-ERROR: vector lane must be an integer in range
3104 // CHECK-ERROR:        smlsl v0.2d, v1.2s, v22.s[4]
3105 // CHECK-ERROR:                                  ^
3106 // CHECK-ERROR: error: invalid operand for instruction
3107 // CHECK-ERROR:        smlsl2 v0.4h, v1.8h, v1.h[2]
3108 // CHECK-ERROR:               ^
3109 // CHECK-ERROR: vector lane must be an integer in range
3110 // CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v1.h[8]
3111 // CHECK-ERROR:                                  ^
3112 // CHECK-ERROR: error: invalid operand for instruction
3113 // CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v16.h[2]
3114 // CHECK-ERROR:                                 ^
3115 // CHECK-ERROR: error: invalid operand for instruction
3116 // CHECK-ERROR:        smlsl2 v0.2s, v1.4s, v1.s[2]
3117 // CHECK-ERROR:               ^
3118 // CHECK-ERROR: vector lane must be an integer in range
3119 // CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v1.s[4]
3120 // CHECK-ERROR:                                  ^
3121 // CHECK-ERROR: vector lane must be an integer in range
3122 // CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v22.s[4]
3123 // CHECK-ERROR:                                   ^
3124
3125       umlal v0.4h, v1.4h, v2.h[2]
3126       umlal v0.4s, v1.4h, v2.h[8]
3127       umlal v0.4s, v1.4h, v16.h[2]
3128       umlal v0.2s, v1.2s, v2.s[1]
3129       umlal v0.2d, v1.2s, v2.s[4]
3130       umlal v0.2d, v1.2s, v22.s[4]
3131       umlal2 v0.4h, v1.8h, v1.h[2]
3132       umlal2 v0.4s, v1.8h, v1.h[8]
3133       umlal2 v0.4s, v1.8h, v16.h[2]
3134       umlal2 v0.2s, v1.4s, v1.s[2]
3135       umlal2 v0.2d, v1.4s, v1.s[4]
3136       umlal2 v0.2d, v1.4s, v22.s[4]
3137
3138 // CHECK-ERROR: error: invalid operand for instruction
3139 // CHECK-ERROR:        umlal v0.4h, v1.4h, v2.h[2]
3140 // CHECK-ERROR:              ^
3141 // CHECK-ERROR: vector lane must be an integer in range
3142 // CHECK-ERROR:        umlal v0.4s, v1.4h, v2.h[8]
3143 // CHECK-ERROR:                                 ^
3144 // CHECK-ERROR: error: invalid operand for instruction
3145 // CHECK-ERROR:        umlal v0.4s, v1.4h, v16.h[2]
3146 // CHECK-ERROR:                            ^
3147 // CHECK-ERROR: error: invalid operand for instruction
3148 // CHECK-ERROR:        umlal v0.2s, v1.2s, v2.s[1]
3149 // CHECK-ERROR:                                 ^
3150 // CHECK-ERROR: vector lane must be an integer in range
3151 // CHECK-ERROR:        umlal v0.2d, v1.2s, v2.s[4]
3152 // CHECK-ERROR:                                 ^
3153 // CHECK-ERROR: vector lane must be an integer in range
3154 // CHECK-ERROR:        umlal v0.2d, v1.2s, v22.s[4]
3155 // CHECK-ERROR:                                  ^
3156 // CHECK-ERROR: error: invalid operand for instruction
3157 // CHECK-ERROR:        umlal2 v0.4h, v1.8h, v1.h[2]
3158 // CHECK-ERROR:               ^
3159 // CHECK-ERROR: vector lane must be an integer in range
3160 // CHECK-ERROR:        umlal2 v0.4s, v1.8h, v1.h[8]
3161 // CHECK-ERROR:                                  ^
3162 // CHECK-ERROR: error: invalid operand for instruction
3163 // CHECK-ERROR:        umlal2 v0.4s, v1.8h, v16.h[2]
3164 // CHECK-ERROR:                                 ^
3165 // CHECK-ERROR: error: invalid operand for instruction
3166 // CHECK-ERROR:        umlal2 v0.2s, v1.4s, v1.s[2]
3167 // CHECK-ERROR:               ^
3168 // CHECK-ERROR: vector lane must be an integer in range
3169 // CHECK-ERROR:        umlal2 v0.2d, v1.4s, v1.s[4]
3170 // CHECK-ERROR:                                  ^
3171 // CHECK-ERROR: vector lane must be an integer in range
3172 // CHECK-ERROR:        umlal2 v0.2d, v1.4s, v22.s[4]
3173 // CHECK-ERROR:                                   ^
3174
3175       umlsl v0.4h, v1.4h, v2.h[2]
3176       umlsl v0.4s, v1.4h, v2.h[8]
3177       umlsl v0.4s, v1.4h, v16.h[2]
3178       umlsl v0.2s, v1.2s, v2.s[3]
3179       umlsl v0.2d, v1.2s, v2.s[4]
3180       umlsl v0.2d, v1.2s, v22.s[4]
3181       umlsl2 v0.4h, v1.8h, v1.h[2]
3182       umlsl2 v0.4s, v1.8h, v1.h[8]
3183       umlsl2 v0.4s, v1.8h, v16.h[2]
3184       umlsl2 v0.2s, v1.4s, v1.s[2]
3185       umlsl2 v0.2d, v1.4s, v1.s[4]
3186       umlsl2 v0.2d, v1.4s, v22.s[4]
3187
3188 // CHECK-ERROR: error: invalid operand for instruction
3189 // CHECK-ERROR:        umlsl v0.4h, v1.4h, v2.h[2]
3190 // CHECK-ERROR:              ^
3191 // CHECK-ERROR: vector lane must be an integer in range
3192 // CHECK-ERROR:        umlsl v0.4s, v1.4h, v2.h[8]
3193 // CHECK-ERROR:                                 ^
3194 // CHECK-ERROR: error: invalid operand for instruction
3195 // CHECK-ERROR:        umlsl v0.4s, v1.4h, v16.h[2]
3196 // CHECK-ERROR:                            ^
3197 // CHECK-ERROR: error: invalid operand for instruction
3198 // CHECK-ERROR:        umlsl v0.2s, v1.2s, v2.s[3]
3199 // CHECK-ERROR:                                 ^
3200 // CHECK-ERROR: vector lane must be an integer in range
3201 // CHECK-ERROR:        umlsl v0.2d, v1.2s, v2.s[4]
3202 // CHECK-ERROR:                                 ^
3203 // CHECK-ERROR: vector lane must be an integer in range
3204 // CHECK-ERROR:        umlsl v0.2d, v1.2s, v22.s[4]
3205 // CHECK-ERROR:                                  ^
3206 // CHECK-ERROR: error: invalid operand for instruction
3207 // CHECK-ERROR:        umlsl2 v0.4h, v1.8h, v1.h[2]
3208 // CHECK-ERROR:               ^
3209 // CHECK-ERROR: vector lane must be an integer in range
3210 // CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v1.h[8]
3211 // CHECK-ERROR:                                  ^
3212 // CHECK-ERROR: error: invalid operand for instruction
3213 // CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v16.h[2]
3214 // CHECK-ERROR:                                 ^
3215 // CHECK-ERROR: error: invalid operand for instruction
3216 // CHECK-ERROR:        umlsl2 v0.2s, v1.4s, v1.s[2]
3217 // CHECK-ERROR:               ^
3218 // CHECK-ERROR: vector lane must be an integer in range
3219 // CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v1.s[4]
3220 // CHECK-ERROR:                                  ^
3221 // CHECK-ERROR: vector lane must be an integer in range
3222 // CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v22.s[4]
3223 // CHECK-ERROR:                                   ^
3224
3225       sqdmlal v0.4h, v1.4h, v2.h[2]
3226       sqdmlal v0.4s, v1.4h, v2.h[8]
3227       sqdmlal v0.4s, v1.4h, v16.h[2]
3228       sqdmlal v0.2s, v1.2s, v2.s[3]
3229       sqdmlal v0.2d, v1.2s, v2.s[4]
3230       sqdmlal v0.2d, v1.2s, v22.s[4]
3231       sqdmlal2 v0.4h, v1.8h, v1.h[2]
3232       sqdmlal2 v0.4s, v1.8h, v1.h[8]
3233       sqdmlal2 v0.4s, v1.8h, v16.h[2]
3234       sqdmlal2 v0.2s, v1.4s, v1.s[2]
3235       sqdmlal2 v0.2d, v1.4s, v1.s[4]
3236       sqdmlal2 v0.2d, v1.4s, v22.s[4]
3237
3238 // CHECK-ERROR: error: invalid operand for instruction
3239 // CHECK-ERROR:        sqdmlal v0.4h, v1.4h, v2.h[2]
3240 // CHECK-ERROR:                ^
3241 // CHECK-ERROR: vector lane must be an integer in range
3242 // CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v2.h[8]
3243 // CHECK-ERROR:                                   ^
3244 // CHECK-ERROR: error: invalid operand for instruction
3245 // CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v16.h[2]
3246 // CHECK-ERROR:                              ^
3247 // CHECK-ERROR: error: invalid operand for instruction
3248 // CHECK-ERROR:        sqdmlal v0.2s, v1.2s, v2.s[3]
3249 // CHECK-ERROR:                                   ^
3250 // CHECK-ERROR: vector lane must be an integer in range
3251 // CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v2.s[4]
3252 // CHECK-ERROR:                                   ^
3253 // CHECK-ERROR: vector lane must be an integer in range
3254 // CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v22.s[4]
3255 // CHECK-ERROR:                                    ^
3256 // CHECK-ERROR: error: invalid operand for instruction
3257 // CHECK-ERROR:        sqdmlal2 v0.4h, v1.8h, v1.h[2]
3258 // CHECK-ERROR:                 ^
3259 // CHECK-ERROR: vector lane must be an integer in range
3260 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v1.h[8]
3261 // CHECK-ERROR:                                    ^
3262 // CHECK-ERROR: error: invalid operand for instruction
3263 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v16.h[2]
3264 // CHECK-ERROR:                                   ^
3265 // CHECK-ERROR: error: invalid operand for instruction
3266 // CHECK-ERROR:        sqdmlal2 v0.2s, v1.4s, v1.s[2]
3267 // CHECK-ERROR:                 ^
3268 // CHECK-ERROR: vector lane must be an integer in range
3269 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v1.s[4]
3270 // CHECK-ERROR:                                    ^
3271 // CHECK-ERROR: vector lane must be an integer in range
3272 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v22.s[4]
3273 // CHECK-ERROR:                                     ^
3274
3275       sqdmlsl v0.4h, v1.4h, v2.h[2]
3276       sqdmlsl v0.4s, v1.4h, v2.h[8]
3277       sqdmlsl v0.4s, v1.4h, v16.h[2]
3278       sqdmlsl v0.2s, v1.2s, v2.s[3]
3279       sqdmlsl v0.2d, v1.2s, v2.s[4]
3280       sqdmlsl v0.2d, v1.2s, v22.s[4]
3281       sqdmlsl2 v0.4h, v1.8h, v1.h[2]
3282       sqdmlsl2 v0.4s, v1.8h, v1.h[8]
3283       sqdmlsl2 v0.4s, v1.8h, v16.h[2]
3284       sqdmlsl2 v0.2s, v1.4s, v1.s[2]
3285       sqdmlsl2 v0.2d, v1.4s, v1.s[4]
3286       sqdmlsl2 v0.2d, v1.4s, v22.s[4]
3287
3288 // CHECK-ERROR: error: invalid operand for instruction
3289 // CHECK-ERROR:        sqdmlsl v0.4h, v1.4h, v2.h[2]
3290 // CHECK-ERROR:                ^
3291 // CHECK-ERROR: vector lane must be an integer in range
3292 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v2.h[8]
3293 // CHECK-ERROR:                                   ^
3294 // CHECK-ERROR: error: invalid operand for instruction
3295 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v16.h[2]
3296 // CHECK-ERROR:                              ^
3297 // CHECK-ERROR: error: invalid operand for instruction
3298 // CHECK-ERROR:        sqdmlsl v0.2s, v1.2s, v2.s[3]
3299 // CHECK-ERROR:                                   ^
3300 // CHECK-ERROR: vector lane must be an integer in range
3301 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v2.s[4]
3302 // CHECK-ERROR:                                   ^
3303 // CHECK-ERROR: vector lane must be an integer in range
3304 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v22.s[4]
3305 // CHECK-ERROR:                                    ^
3306 // CHECK-ERROR: error: invalid operand for instruction
3307 // CHECK-ERROR:        sqdmlsl2 v0.4h, v1.8h, v1.h[2]
3308 // CHECK-ERROR:                 ^
3309 // CHECK-ERROR: vector lane must be an integer in range
3310 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v1.h[8]
3311 // CHECK-ERROR:                                    ^
3312 // CHECK-ERROR: error: invalid operand for instruction
3313 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v16.h[2]
3314 // CHECK-ERROR:                                   ^
3315 // CHECK-ERROR: error: invalid operand for instruction
3316 // CHECK-ERROR:        sqdmlsl2 v0.2s, v1.4s, v1.s[2]
3317 // CHECK-ERROR:                 ^
3318 // CHECK-ERROR: vector lane must be an integer in range
3319 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v1.s[4]
3320 // CHECK-ERROR:                                    ^
3321 // CHECK-ERROR: vector lane must be an integer in range
3322 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v22.s[4]
3323 // CHECK-ERROR:                                     ^
3324
3325       mul v0.4h, v1.4h, v2.h[8]
3326       mul v0.4h, v1.4h, v16.h[8]
3327       mul v0.8h, v1.8h, v2.h[8]
3328       mul v0.8h, v1.8h, v16.h[8]
3329       mul v0.2s, v1.2s, v2.s[4]
3330       mul v0.2s, v1.2s, v22.s[4]
3331       mul v0.4s, v1.4s, v2.s[4]
3332       mul v0.4s, v1.4s, v22.s[4]
3333       mul v0.2d, v1.2d, v2.d[1]
3334
3335 // CHECK-ERROR: vector lane must be an integer in range
3336 // CHECK-ERROR:        mul v0.4h, v1.4h, v2.h[8]
3337 // CHECK-ERROR:                               ^
3338 // CHECK-ERROR: error: invalid operand for instruction
3339 // CHECK-ERROR:        mul v0.4h, v1.4h, v16.h[8]
3340 // CHECK-ERROR:                                ^
3341 // CHECK-ERROR: vector lane must be an integer in range
3342 // CHECK-ERROR:        mul v0.8h, v1.8h, v2.h[8]
3343 // CHECK-ERROR:                               ^
3344 // CHECK-ERROR: invalid operand for instruction
3345 // CHECK-ERROR:        mul v0.8h, v1.8h, v16.h[8]
3346 // CHECK-ERROR:                                ^
3347 // CHECK-ERROR: vector lane must be an integer in range
3348 // CHECK-ERROR:        mul v0.2s, v1.2s, v2.s[4]
3349 // CHECK-ERROR:                               ^
3350 // CHECK-ERROR: vector lane must be an integer in range
3351 // CHECK-ERROR:        mul v0.2s, v1.2s, v22.s[4]
3352 // CHECK-ERROR:                                ^
3353 // CHECK-ERROR: vector lane must be an integer in range
3354 // CHECK-ERROR:        mul v0.4s, v1.4s, v2.s[4]
3355 // CHECK-ERROR:                               ^
3356 // CHECK-ERROR: vector lane must be an integer in range
3357 // CHECK-ERROR:        mul v0.4s, v1.4s, v22.s[4]
3358 // CHECK-ERROR:                                ^
3359
3360       fmul v0.4h, v1.4h, v2.h[4]
3361       fmul v0.2s, v1.2s, v2.s[4]
3362       fmul v0.2s, v1.2s, v22.s[4]
3363       fmul v0.4s, v1.4s, v2.s[4]
3364       fmul v0.4s, v1.4s, v22.s[4]
3365       fmul v0.2d, v1.2d, v2.d[2]
3366       fmul v0.2d, v1.2d, v22.d[2]
3367
3368 // CHECK-ERROR: error: invalid operand for instruction
3369 // CHECK-ERROR:        mul v0.2d, v1.2d, v2.d[1]
3370 // CHECK-ERROR:               ^
3371 // CHECK-ERROR: error: instruction requires: fullfp16
3372 // CHECK-ERROR:        fmul v0.4h, v1.4h, v2.h[4]
3373 // CHECK-ERROR:                ^
3374 // CHECK-ERROR: vector lane must be an integer in range
3375 // CHECK-ERROR:        fmul v0.2s, v1.2s, v2.s[4]
3376 // CHECK-ERROR:                                ^
3377 // CHECK-ERROR: vector lane must be an integer in range
3378 // CHECK-ERROR:        fmul v0.2s, v1.2s, v22.s[4]
3379 // CHECK-ERROR:                                 ^
3380 // CHECK-ERROR: vector lane must be an integer in range
3381 // CHECK-ERROR:        fmul v0.4s, v1.4s, v2.s[4]
3382 // CHECK-ERROR:                                ^
3383 // CHECK-ERROR: vector lane must be an integer in range
3384 // CHECK-ERROR:        fmul v0.4s, v1.4s, v22.s[4]
3385 // CHECK-ERROR:                                 ^
3386 // CHECK-ERROR: vector lane must be an integer in range
3387 // CHECK-ERROR:        fmul v0.2d, v1.2d, v2.d[2]
3388 // CHECK-ERROR:                                ^
3389 // CHECK-ERROR: vector lane must be an integer in range
3390 // CHECK-ERROR:        fmul v0.2d, v1.2d, v22.d[2]
3391 // CHECK-ERROR:                                 ^
3392
3393       fmulx v0.4h, v1.4h, v2.h[4]
3394       fmulx v0.2s, v1.2s, v2.s[4]
3395       fmulx v0.2s, v1.2s, v22.s[4]
3396       fmulx v0.4s, v1.4s, v2.s[4]
3397       fmulx v0.4s, v1.4s, v22.s[4]
3398       fmulx v0.2d, v1.2d, v2.d[2]
3399       fmulx v0.2d, v1.2d, v22.d[2]
3400
3401 // CHECK-ERROR: error: instruction requires: fullfp16
3402 // CHECK-ERROR:        fmulx v0.4h, v1.4h, v2.h[4]
3403 // CHECK-ERROR:                 ^
3404 // CHECK-ERROR: vector lane must be an integer in range
3405 // CHECK-ERROR:        fmulx v0.2s, v1.2s, v2.s[4]
3406 // CHECK-ERROR:                                 ^
3407 // CHECK-ERROR: vector lane must be an integer in range
3408 // CHECK-ERROR:        fmulx v0.2s, v1.2s, v22.s[4]
3409 // CHECK-ERROR:                                  ^
3410 // CHECK-ERROR: vector lane must be an integer in range
3411 // CHECK-ERROR:        fmulx v0.4s, v1.4s, v2.s[4]
3412 // CHECK-ERROR:                                 ^
3413 // CHECK-ERROR: vector lane must be an integer in range
3414 // CHECK-ERROR:        fmulx v0.4s, v1.4s, v22.s[4]
3415 // CHECK-ERROR:                                  ^
3416 // CHECK-ERROR: vector lane must be an integer in range
3417 // CHECK-ERROR:        fmulx v0.2d, v1.2d, v2.d[2]
3418 // CHECK-ERROR:                                 ^
3419 // CHECK-ERROR: vector lane must be an integer in range
3420 // CHECK-ERROR:        fmulx v0.2d, v1.2d, v22.d[2]
3421 // CHECK-ERROR:                                  ^
3422
3423       smull v0.4h, v1.4h, v2.h[2]
3424       smull v0.4s, v1.4h, v2.h[8]
3425       smull v0.4s, v1.4h, v16.h[4]
3426       smull v0.2s, v1.2s, v2.s[2]
3427       smull v0.2d, v1.2s, v2.s[4]
3428       smull v0.2d, v1.2s, v22.s[4]
3429       smull2 v0.4h, v1.8h, v2.h[2]
3430       smull2 v0.4s, v1.8h, v2.h[8]
3431       smull2 v0.4s, v1.8h, v16.h[4]
3432       smull2 v0.2s, v1.4s, v2.s[2]
3433       smull2 v0.2d, v1.4s, v2.s[4]
3434       smull2 v0.2d, v1.4s, v22.s[4]
3435
3436 // CHECK-ERROR: error: invalid operand for instruction
3437 // CHECK-ERROR:        smull v0.4h, v1.4h, v2.h[2]
3438 // CHECK-ERROR:              ^
3439 // CHECK-ERROR: vector lane must be an integer in range
3440 // CHECK-ERROR:        smull v0.4s, v1.4h, v2.h[8]
3441 // CHECK-ERROR:                                 ^
3442 // CHECK-ERROR: error: invalid operand for instruction
3443 // CHECK-ERROR:        smull v0.4s, v1.4h, v16.h[4]
3444 // CHECK-ERROR:                            ^
3445 // CHECK-ERROR: error: invalid operand for instruction
3446 // CHECK-ERROR:        smull v0.2s, v1.2s, v2.s[2]
3447 // CHECK-ERROR:              ^
3448 // CHECK-ERROR: vector lane must be an integer in range
3449 // CHECK-ERROR:        smull v0.2d, v1.2s, v2.s[4]
3450 // CHECK-ERROR:                                 ^
3451 // CHECK-ERROR: vector lane must be an integer in range
3452 // CHECK-ERROR:        smull v0.2d, v1.2s, v22.s[4]
3453 // CHECK-ERROR:                                  ^
3454 // CHECK-ERROR: error: invalid operand for instruction
3455 // CHECK-ERROR:        smull2 v0.4h, v1.8h, v2.h[2]
3456 // CHECK-ERROR:               ^
3457 // CHECK-ERROR: vector lane must be an integer in range
3458 // CHECK-ERROR:        smull2 v0.4s, v1.8h, v2.h[8]
3459 // CHECK-ERROR:                                  ^
3460 // CHECK-ERROR: error: invalid operand for instruction
3461 // CHECK-ERROR:        smull2 v0.4s, v1.8h, v16.h[4]
3462 // CHECK-ERROR:                                 ^
3463 // CHECK-ERROR: error: invalid operand for instruction
3464 // CHECK-ERROR:        smull2 v0.2s, v1.4s, v2.s[2]
3465 // CHECK-ERROR:               ^
3466 // CHECK-ERROR: vector lane must be an integer in range
3467 // CHECK-ERROR:        smull2 v0.2d, v1.4s, v2.s[4]
3468 // CHECK-ERROR:                                  ^
3469 // CHECK-ERROR: vector lane must be an integer in range
3470 // CHECK-ERROR:        smull2 v0.2d, v1.4s, v22.s[4]
3471 // CHECK-ERROR:                                   ^
3472
3473       umull v0.4h, v1.4h, v2.h[2]
3474       umull v0.4s, v1.4h, v2.h[8]
3475       umull v0.4s, v1.4h, v16.h[4]
3476       umull v0.2s, v1.2s, v2.s[2]
3477       umull v0.2d, v1.2s, v2.s[4]
3478       umull v0.2d, v1.2s, v22.s[4]
3479       umull2 v0.4h, v1.8h, v2.h[2]
3480       umull2 v0.4s, v1.8h, v2.h[8]
3481       umull2 v0.4s, v1.8h, v16.h[4]
3482       umull2 v0.2s, v1.4s, v2.s[2]
3483       umull2 v0.2d, v1.4s, v2.s[4]
3484       umull2 v0.2d, v1.4s, v22.s[4]
3485
3486 // CHECK-ERROR: error: invalid operand for instruction
3487 // CHECK-ERROR:        umull v0.4h, v1.4h, v2.h[2]
3488 // CHECK-ERROR:              ^
3489 // CHECK-ERROR: vector lane must be an integer in range
3490 // CHECK-ERROR:        umull v0.4s, v1.4h, v2.h[8]
3491 // CHECK-ERROR:                                 ^
3492 // CHECK-ERROR: error: invalid operand for instruction
3493 // CHECK-ERROR:        umull v0.4s, v1.4h, v16.h[4]
3494 // CHECK-ERROR:                            ^
3495 // CHECK-ERROR: error: invalid operand for instruction
3496 // CHECK-ERROR:        umull v0.2s, v1.2s, v2.s[2]
3497 // CHECK-ERROR:              ^
3498 // CHECK-ERROR: vector lane must be an integer in range
3499 // CHECK-ERROR:        umull v0.2d, v1.2s, v2.s[4]
3500 // CHECK-ERROR:                                 ^
3501 // CHECK-ERROR: vector lane must be an integer in range
3502 // CHECK-ERROR:        umull v0.2d, v1.2s, v22.s[4]
3503 // CHECK-ERROR:                                  ^
3504 // CHECK-ERROR: error: invalid operand for instruction
3505 // CHECK-ERROR:        umull2 v0.4h, v1.8h, v2.h[2]
3506 // CHECK-ERROR:               ^
3507 // CHECK-ERROR: vector lane must be an integer in range
3508 // CHECK-ERROR:        umull2 v0.4s, v1.8h, v2.h[8]
3509 // CHECK-ERROR:                                  ^
3510 // CHECK-ERROR: error: invalid operand for instruction
3511 // CHECK-ERROR:        umull2 v0.4s, v1.8h, v16.h[4]
3512 // CHECK-ERROR:                                 ^
3513 // CHECK-ERROR: error: invalid operand for instruction
3514 // CHECK-ERROR:        umull2 v0.2s, v1.4s, v2.s[2]
3515 // CHECK-ERROR:               ^
3516 // CHECK-ERROR: vector lane must be an integer in range
3517 // CHECK-ERROR:        umull2 v0.2d, v1.4s, v2.s[4]
3518 // CHECK-ERROR:                                  ^
3519 // CHECK-ERROR: vector lane must be an integer in range
3520 // CHECK-ERROR:        umull2 v0.2d, v1.4s, v22.s[4]
3521 // CHECK-ERROR:                                   ^
3522
3523       sqdmull v0.4h, v1.4h, v2.h[2]
3524       sqdmull v0.4s, v1.4h, v2.h[8]
3525       sqdmull v0.4s, v1.4h, v16.h[4]
3526       sqdmull v0.2s, v1.2s, v2.s[2]
3527       sqdmull v0.2d, v1.2s, v2.s[4]
3528       sqdmull v0.2d, v1.2s, v22.s[4]
3529       sqdmull2 v0.4h, v1.8h, v2.h[2]
3530       sqdmull2 v0.4s, v1.8h, v2.h[8]
3531       sqdmull2 v0.4s, v1.8h, v16.h[4]
3532       sqdmull2 v0.2s, v1.4s, v2.s[2]
3533       sqdmull2 v0.2d, v1.4s, v2.s[4]
3534       sqdmull2 v0.2d, v1.4s, v22.s[4]
3535
3536 // CHECK-ERROR: error: invalid operand for instruction
3537 // CHECK-ERROR:        sqdmull v0.4h, v1.4h, v2.h[2]
3538 // CHECK-ERROR:                ^
3539 // CHECK-ERROR: vector lane must be an integer in range
3540 // CHECK-ERROR:        sqdmull v0.4s, v1.4h, v2.h[8]
3541 // CHECK-ERROR:                                   ^
3542 // CHECK-ERROR: error: invalid operand for instruction
3543 // CHECK-ERROR:        sqdmull v0.4s, v1.4h, v16.h[4]
3544 // CHECK-ERROR:                              ^
3545 // CHECK-ERROR: error: invalid operand for instruction
3546 // CHECK-ERROR:        sqdmull v0.2s, v1.2s, v2.s[2]
3547 // CHECK-ERROR:                ^
3548 // CHECK-ERROR: vector lane must be an integer in range
3549 // CHECK-ERROR:        sqdmull v0.2d, v1.2s, v2.s[4]
3550 // CHECK-ERROR:                                   ^
3551 // CHECK-ERROR: vector lane must be an integer in range
3552 // CHECK-ERROR:        sqdmull v0.2d, v1.2s, v22.s[4]
3553 // CHECK-ERROR:                                    ^
3554 // CHECK-ERROR: error: invalid operand for instruction
3555 // CHECK-ERROR:        sqdmull2 v0.4h, v1.8h, v2.h[2]
3556 // CHECK-ERROR:                 ^
3557 // CHECK-ERROR: vector lane must be an integer in range
3558 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v2.h[8]
3559 // CHECK-ERROR:                                    ^
3560 // CHECK-ERROR: error: invalid operand for instruction
3561 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v16.h[4]
3562 // CHECK-ERROR:                                   ^
3563 // CHECK-ERROR: error: invalid operand for instruction
3564 // CHECK-ERROR:        sqdmull2 v0.2s, v1.4s, v2.s[2]
3565 // CHECK-ERROR:                 ^
3566 // CHECK-ERROR: vector lane must be an integer in range
3567 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v2.s[4]
3568 // CHECK-ERROR:                                    ^
3569 // CHECK-ERROR: vector lane must be an integer in range
3570 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v22.s[4]
3571 // CHECK-ERROR:                                     ^
3572
3573       sqdmulh v0.4h, v1.4h, v2.h[8]
3574       sqdmulh v0.4h, v1.4h, v16.h[2]
3575       sqdmulh v0.8h, v1.8h, v2.h[8]
3576       sqdmulh v0.8h, v1.8h, v16.h[2]
3577       sqdmulh v0.2s, v1.2s, v2.s[4]
3578       sqdmulh v0.2s, v1.2s, v22.s[4]
3579       sqdmulh v0.4s, v1.4s, v2.s[4]
3580       sqdmulh v0.4s, v1.4s, v22.s[4]
3581       sqdmulh v0.2d, v1.2d, v22.d[1]
3582
3583 // CHECK-ERROR: vector lane must be an integer in range
3584 // CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v2.h[8]
3585 // CHECK-ERROR:                                   ^
3586 // CHECK-ERROR: error: invalid operand for instruction
3587 // CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v16.h[2]
3588 // CHECK-ERROR:                              ^
3589 // CHECK-ERROR: vector lane must be an integer in range
3590 // CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v2.h[8]
3591 // CHECK-ERROR:                                   ^
3592 // CHECK-ERROR: error: invalid operand for instruction
3593 // CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v16.h[2]
3594 // CHECK-ERROR:                                  ^
3595 // CHECK-ERROR: vector lane must be an integer in range
3596 // CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v2.s[4]
3597 // CHECK-ERROR:                                   ^
3598 // CHECK-ERROR: vector lane must be an integer in range
3599 // CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v22.s[4]
3600 // CHECK-ERROR:                                    ^
3601 // CHECK-ERROR: vector lane must be an integer in range
3602 // CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v2.s[4]
3603 // CHECK-ERROR:                                   ^
3604 // CHECK-ERROR: vector lane must be an integer in range
3605 // CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v22.s[4]
3606 // CHECK-ERROR:                                    ^
3607 // CHECK-ERROR: error: invalid operand for instruction
3608 // CHECK-ERROR:        sqdmulh v0.2d, v1.2d, v22.d[1]
3609 // CHECK-ERROR:                   ^
3610
3611       sqrdmulh v0.4h, v1.4h, v2.h[8]
3612       sqrdmulh v0.4h, v1.4h, v16.h[2]
3613       sqrdmulh v0.8h, v1.8h, v2.h[8]
3614       sqrdmulh v0.8h, v1.8h, v16.h[2]
3615       sqrdmulh v0.2s, v1.2s, v2.s[4]
3616       sqrdmulh v0.2s, v1.2s, v22.s[4]
3617       sqrdmulh v0.4s, v1.4s, v2.s[4]
3618       sqrdmulh v0.4s, v1.4s, v22.s[4]
3619       sqrdmulh v0.2d, v1.2d, v22.d[1]
3620
3621 // CHECK-ERROR: vector lane must be an integer in range
3622 // CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v2.h[8]
3623 // CHECK-ERROR:                                    ^
3624 // CHECK-ERROR: error: invalid operand for instruction
3625 // CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v16.h[2]
3626 // CHECK-ERROR:                               ^
3627 // CHECK-ERROR: vector lane must be an integer in range
3628 // CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v2.h[8]
3629 // CHECK-ERROR:                                    ^
3630 // CHECK-ERROR: error: invalid operand for instruction
3631 // CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v16.h[2]
3632 // CHECK-ERROR:                                   ^
3633 // CHECK-ERROR: vector lane must be an integer in range
3634 // CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v2.s[4]
3635 // CHECK-ERROR:                                    ^
3636 // CHECK-ERROR: vector lane must be an integer in range
3637 // CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v22.s[4]
3638 // CHECK-ERROR:                                     ^
3639 // CHECK-ERROR: vector lane must be an integer in range
3640 // CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v2.s[4]
3641 // CHECK-ERROR:                                    ^
3642 // CHECK-ERROR: vector lane must be an integer in range
3643 // CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v22.s[4]
3644 // CHECK-ERROR:                                     ^
3645 // CHECK-ERROR: error: invalid operand for instruction
3646 // CHECK-ERROR:        sqrdmulh v0.2d, v1.2d, v22.d[1]
3647 // CHECK-ERROR:                    ^
3648
3649 //----------------------------------------------------------------------
3650 // Across vectors
3651 //----------------------------------------------------------------------
3652
3653         saddlv b0, v1.8b
3654         saddlv b0, v1.16b
3655         saddlv h0, v1.4h
3656         saddlv h0, v1.8h
3657         saddlv s0, v1.2s
3658         saddlv s0, v1.4s
3659         saddlv d0, v1.2s
3660
3661 // CHECK-ERROR: error: invalid operand for instruction
3662 // CHECK-ERROR:        saddlv b0, v1.8b
3663 // CHECK-ERROR:               ^
3664 // CHECK-ERROR: error: invalid operand for instruction
3665 // CHECK-ERROR:        saddlv b0, v1.16b
3666 // CHECK-ERROR:               ^
3667 // CHECK-ERROR: error: invalid operand for instruction
3668 // CHECK-ERROR:        saddlv h0, v1.4h
3669 // CHECK-ERROR:                      ^
3670 // CHECK-ERROR: error: invalid operand for instruction
3671 // CHECK-ERROR:        saddlv h0, v1.8h
3672 // CHECK-ERROR:                      ^
3673 // CHECK-ERROR: error: invalid operand for instruction
3674 // CHECK-ERROR:        saddlv s0, v1.2s
3675 // CHECK-ERROR:                      ^
3676 // CHECK-ERROR: error: invalid operand for instruction
3677 // CHECK-ERROR:        saddlv s0, v1.4s
3678 // CHECK-ERROR:                      ^
3679 // CHECK-ERROR: error: invalid operand for instruction
3680 // CHECK-ERROR:        saddlv d0, v1.2s
3681 // CHECK-ERROR:                   ^
3682
3683         uaddlv b0, v1.8b
3684         uaddlv b0, v1.16b
3685         uaddlv h0, v1.4h
3686         uaddlv h0, v1.8h
3687         uaddlv s0, v1.2s
3688         uaddlv s0, v1.4s
3689         uaddlv d0, v1.2s
3690
3691 // CHECK-ERROR: error: invalid operand for instruction
3692 // CHECK-ERROR:        uaddlv b0, v1.8b
3693 // CHECK-ERROR:               ^
3694 // CHECK-ERROR: error: invalid operand for instruction
3695 // CHECK-ERROR:        uaddlv b0, v1.16b
3696 // CHECK-ERROR:               ^
3697 // CHECK-ERROR: error: invalid operand for instruction
3698 // CHECK-ERROR:        uaddlv h0, v1.4h
3699 // CHECK-ERROR:                      ^
3700 // CHECK-ERROR: error: invalid operand for instruction
3701 // CHECK-ERROR:        uaddlv h0, v1.8h
3702 // CHECK-ERROR:                      ^
3703 // CHECK-ERROR: error: invalid operand for instruction
3704 // CHECK-ERROR:        uaddlv s0, v1.2s
3705 // CHECK-ERROR:                      ^
3706 // CHECK-ERROR: error: invalid operand for instruction
3707 // CHECK-ERROR:        uaddlv s0, v1.4s
3708 // CHECK-ERROR:                      ^
3709 // CHECK-ERROR: error: invalid operand for instruction
3710 // CHECK-ERROR:        uaddlv d0, v1.2s
3711 // CHECK-ERROR:                   ^
3712
3713         smaxv s0, v1.2s
3714         sminv s0, v1.2s
3715         umaxv s0, v1.2s
3716         uminv s0, v1.2s
3717         addv s0, v1.2s
3718
3719 // CHECK-ERROR: error: invalid operand for instruction
3720 // CHECK-ERROR:        smaxv s0, v1.2s
3721 // CHECK-ERROR:                  ^
3722 // CHECK-ERROR: error: invalid operand for instruction
3723 // CHECK-ERROR:        sminv s0, v1.2s
3724 // CHECK-ERROR:                  ^
3725 // CHECK-ERROR: error: invalid operand for instruction
3726 // CHECK-ERROR:        umaxv s0, v1.2s
3727 // CHECK-ERROR:                  ^
3728 // CHECK-ERROR: error: invalid operand for instruction
3729 // CHECK-ERROR:        uminv s0, v1.2s
3730 // CHECK-ERROR:                  ^
3731 // CHECK-ERROR: error: invalid operand for instruction
3732 // CHECK-ERROR:        addv s0, v1.2s
3733 // CHECK-ERROR:                 ^
3734
3735         smaxv d0, v1.2d
3736         sminv d0, v1.2d
3737         umaxv d0, v1.2d
3738         uminv d0, v1.2d
3739         addv d0, v1.2d
3740
3741 // CHECK-ERROR: error: invalid operand for instruction
3742 // CHECK-ERROR:        smaxv d0, v1.2d
3743 // CHECK-ERROR:              ^
3744 // CHECK-ERROR: error: invalid operand for instruction
3745 // CHECK-ERROR:        sminv d0, v1.2d
3746 // CHECK-ERROR:              ^
3747 // CHECK-ERROR: error: invalid operand for instruction
3748 // CHECK-ERROR:        umaxv d0, v1.2d
3749 // CHECK-ERROR:              ^
3750 // CHECK-ERROR: error: invalid operand for instruction
3751 // CHECK-ERROR:        uminv d0, v1.2d
3752 // CHECK-ERROR:              ^
3753 // CHECK-ERROR: error: invalid operand for instruction
3754 // CHECK-ERROR:        addv d0, v1.2d
3755 // CHECK-ERROR:             ^
3756
3757         fmaxnmv b0, v1.16b
3758         fminnmv b0, v1.16b
3759         fmaxv b0, v1.16b
3760         fminv b0, v1.16b
3761
3762 // CHECK-ERROR: error: invalid operand for instruction
3763 // CHECK-ERROR:        fmaxnmv b0, v1.16b
3764 // CHECK-ERROR:                ^
3765 // CHECK-ERROR: error: invalid operand for instruction
3766 // CHECK-ERROR:        fminnmv b0, v1.16b
3767 // CHECK-ERROR:                ^
3768 // CHECK-ERROR: error: invalid operand for instruction
3769 // CHECK-ERROR:        fmaxv b0, v1.16b
3770 // CHECK-ERROR:              ^
3771 // CHECK-ERROR: error: invalid operand for instruction
3772 // CHECK-ERROR:        fminv b0, v1.16b
3773 // CHECK-ERROR:              ^
3774
3775         fmaxnmv h0, v1.8h
3776         fminnmv h0, v1.8h
3777         fmaxv h0, v1.8h
3778         fminv h0, v1.8h
3779
3780 // CHECK-ERROR: error: instruction requires: fullfp16
3781 // CHECK-ERROR:        fmaxnmv h0, v1.8h
3782 // CHECK-ERROR:                ^
3783 // CHECK-ERROR: error: instruction requires: fullfp16
3784 // CHECK-ERROR:        fminnmv h0, v1.8h
3785 // CHECK-ERROR:                ^
3786 // CHECK-ERROR: error: instruction requires: fullfp16
3787 // CHECK-ERROR:        fmaxv h0, v1.8h
3788 // CHECK-ERROR:              ^
3789 // CHECK-ERROR: error: instruction requires: fullfp16
3790 // CHECK-ERROR:        fminv h0, v1.8h
3791 // CHECK-ERROR:              ^
3792
3793         fmaxnmv d0, v1.2d
3794         fminnmv d0, v1.2d
3795         fmaxv d0, v1.2d
3796         fminv d0, v1.2d
3797
3798 // CHECK-ERROR: error: invalid operand for instruction
3799 // CHECK-ERROR:        fmaxnmv d0, v1.2d
3800 // CHECK-ERROR:                ^
3801 // CHECK-ERROR: error: invalid operand for instruction
3802 // CHECK-ERROR:        fminnmv d0, v1.2d
3803 // CHECK-ERROR:                ^
3804 // CHECK-ERROR: error: invalid operand for instruction
3805 // CHECK-ERROR:        fmaxv d0, v1.2d
3806 // CHECK-ERROR:              ^
3807 // CHECK-ERROR: error: invalid operand for instruction
3808 // CHECK-ERROR:        fminv d0, v1.2d
3809 // CHECK-ERROR:              ^
3810
3811 //----------------------------------------------------------------------
3812 // Floating-point Multiply Extended
3813 //----------------------------------------------------------------------
3814
3815     fmulx s20, h22, s15
3816     fmulx d23, d11, s1
3817
3818 // CHECK-ERROR: error: invalid operand for instruction
3819 // CHECK-ERROR:          fmulx s20, h22, s15
3820 // CHECK-ERROR:                     ^
3821 // CHECK-ERROR: error: invalid operand for instruction
3822 // CHECK-ERROR:          fmulx d23, d11, s1
3823 // CHECK-ERROR:                          ^
3824
3825 //----------------------------------------------------------------------
3826 // Floating-point Reciprocal Step
3827 //----------------------------------------------------------------------
3828
3829     frecps s21, s16, h13
3830     frecps d22, s30, d21
3831
3832 // CHECK-ERROR: error: invalid operand for instruction
3833 // CHECK-ERROR:          frecps s21, s16, h13
3834 // CHECK-ERROR:                           ^
3835 // CHECK-ERROR: error: invalid operand for instruction
3836 // CHECK-ERROR:          frecps d22, s30, d21
3837 // CHECK-ERROR:                      ^
3838
3839 //----------------------------------------------------------------------
3840 // Floating-point Reciprocal Square Root Step
3841 //----------------------------------------------------------------------
3842
3843     frsqrts s21, h5, s12
3844     frsqrts d8, s22, d18
3845
3846 // CHECK-ERROR: error: invalid operand for instruction
3847 // CHECK-ERROR:          frsqrts s21, h5, s12
3848 // CHECK-ERROR:                       ^
3849 // CHECK-ERROR: error: invalid operand for instruction
3850 // CHECK-ERROR:          frsqrts d8, s22, d18
3851 // CHECK-ERROR:                      ^
3852
3853 //----------------------------------------------------------------------
3854 // Vector load/store multiple N-element structure (class SIMD lselem)
3855 //----------------------------------------------------------------------
3856          ld1 {x3}, [x2]
3857          ld1 {v4}, [x0]
3858          ld1 {v32.16b}, [x0]
3859          ld1 {v15.8h}, [x32]
3860 // CHECK-ERROR: error: vector register expected
3861 // CHECK-ERROR:        ld1 {x3}, [x2]
3862 // CHECK-ERROR:             ^
3863 // CHECK-ERROR: error: invalid operand for instruction
3864 // CHECK-ERROR:        ld1 {v4}, [x0]
3865 // CHECK-ERROR:             ^
3866 // CHECK-ERROR: error: vector register expected
3867 // CHECK-ERROR:        ld1 {v32.16b}, [x0]
3868 // CHECK-ERROR:             ^
3869 // CHECK-ERROR: error: invalid operand for instruction
3870 // CHECK-ERROR:        ld1 {v15.8h}, [x32]
3871 // CHECK-ERROR:                       ^
3872
3873          ld1 {v0.16b, v2.16b}, [x0]
3874          ld1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
3875          ld1 v0.8b, v1.8b}, [x0]
3876          ld1 {v0.8h-v4.8h}, [x0]
3877          ld1 {v1.8h-v1.8h}, [x0]
3878          ld1 {v15.8h-v17.4h}, [x15]
3879          ld1 {v0.8b-v2.8b, [x0]
3880 // CHECK-ERROR: error: registers must be sequential
3881 // CHECK-ERROR:        ld1 {v0.16b, v2.16b}, [x0]
3882 // CHECK-ERROR:                     ^
3883 // CHECK-ERROR: error: invalid number of vectors
3884 // CHECK-ERROR:        ld1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
3885 // CHECK-ERROR:                                         ^
3886 // CHECK-ERROR: error: unexpected token in argument list
3887 // CHECK-ERROR:        ld1 v0.8b, v1.8b}, [x0]
3888 // CHECK-ERROR:            ^
3889 // CHECK-ERROR: error: invalid number of vectors
3890 // CHECK-ERROR:        ld1 {v0.8h-v4.8h}, [x0]
3891 // CHECK-ERROR:                   ^
3892 // CHECK-ERROR: error: invalid number of vectors
3893 // CHECK-ERROR:        ld1 {v1.8h-v1.8h}, [x0]
3894 // CHECK-ERROR:                   ^
3895 // CHECK-ERROR: error: mismatched register size suffix
3896 // CHECK-ERROR:        ld1 {v15.8h-v17.4h}, [x15]
3897 // CHECK-ERROR:                        ^
3898 // CHECK-ERROR: error: '}' expected
3899 // CHECK-ERROR:        ld1 {v0.8b-v2.8b, [x0]
3900 // CHECK-ERROR:                        ^
3901
3902          ld2 {v15.8h, v16.4h}, [x15]
3903          ld2 {v0.8b, v2.8b}, [x0]
3904          ld2 {v15.4h, v16.4h, v17.4h}, [x32]
3905          ld2 {v15.8h-v16.4h}, [x15]
3906          ld2 {v0.2d-v2.2d}, [x0]
3907 // CHECK-ERROR: error: mismatched register size suffix
3908 // CHECK-ERROR:        ld2 {v15.8h, v16.4h}, [x15]
3909 // CHECK-ERROR:                     ^
3910 // CHECK-ERROR: error: registers must be sequential
3911 // CHECK-ERROR:        ld2 {v0.8b, v2.8b}, [x0]
3912 // CHECK-ERROR:                    ^
3913 // CHECK-ERROR:        ld2 {v15.4h, v16.4h, v17.4h}, [x32]
3914 // CHECK-ERROR:            ^
3915 // CHECK-ERROR: error: mismatched register size suffix
3916 // CHECK-ERROR:        ld2 {v15.8h-v16.4h}, [x15]
3917 // CHECK-ERROR:                        ^
3918 // CHECK-ERROR: error: invalid operand for instruction
3919 // CHECK-ERROR:        ld2 {v0.2d-v2.2d}, [x0]
3920 // CHECK-ERROR:            ^
3921
3922          ld3 {v15.8h, v16.8h, v17.4h}, [x15]
3923          ld3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
3924          ld3 {v0.8b, v2.8b, v3.8b}, [x0]
3925          ld3 {v15.8h-v17.4h}, [x15]
3926          ld3 {v31.4s-v2.4s}, [sp]
3927 // CHECK-ERROR: error: mismatched register size suffix
3928 // CHECK-ERROR:        ld3 {v15.8h, v16.8h, v17.4h}, [x15]
3929 // CHECK-ERROR:                             ^
3930 // CHECK-ERROR: error: mismatched register size suffix
3931 // CHECK-ERROR:        ld3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
3932 // CHECK-ERROR:                    ^
3933 // CHECK-ERROR: error: registers must be sequential
3934 // CHECK-ERROR:        ld3 {v0.8b, v2.8b, v3.8b}, [x0]
3935 // CHECK-ERROR:                    ^
3936 // CHECK-ERROR: error: mismatched register size suffix
3937 // CHECK-ERROR:        ld3 {v15.8h-v17.4h}, [x15]
3938 // CHECK-ERROR:                        ^
3939 // CHECK-ERROR: error: invalid operand for instruction
3940 // CHECK-ERROR:        ld3 {v31.4s-v2.4s}, [sp]
3941 // CHECK-ERROR:            ^
3942
3943          ld4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
3944          ld4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
3945          ld4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
3946          ld4 {v15.8h-v18.4h}, [x15]
3947          ld4 {v31.2s-v1.2s}, [x31]
3948 // CHECK-ERROR: error: mismatched register size suffix
3949 // CHECK-ERROR:        ld4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
3950 // CHECK-ERROR:                             ^
3951 // CHECK-ERROR: error: registers must be sequential
3952 // CHECK-ERROR:        ld4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
3953 // CHECK-ERROR:                    ^
3954 // CHECK-ERROR: error: invalid number of vectors
3955 // CHECK-ERROR:        ld4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
3956 // CHECK-ERROR:                                             ^
3957 // CHECK-ERROR: error: mismatched register size suffix
3958 // CHECK-ERROR:        ld4 {v15.8h-v18.4h}, [x15]
3959 // CHECK-ERROR:                        ^
3960 // CHECK-ERROR: error: invalid operand for instruction
3961 // CHECK-ERROR:        ld4 {v31.2s-v1.2s}, [x31]
3962 // CHECK-ERROR:            ^
3963
3964          st1 {x3}, [x2]
3965          st1 {v4}, [x0]
3966          st1 {v32.16b}, [x0]
3967          st1 {v15.8h}, [x32]
3968 // CHECK-ERROR: error: vector register expected
3969 // CHECK-ERROR:        st1 {x3}, [x2]
3970 // CHECK-ERROR:             ^
3971 // CHECK-ERROR: error: invalid operand for instruction
3972 // CHECK-ERROR:        st1 {v4}, [x0]
3973 // CHECK-ERROR:             ^
3974 // CHECK-ERROR: error: vector register expected
3975 // CHECK-ERROR:        st1 {v32.16b}, [x0]
3976 // CHECK-ERROR:             ^
3977 // CHECK-ERROR: error: invalid operand for instruction
3978 // CHECK-ERROR:        st1 {v15.8h}, [x32]
3979 // CHECK-ERROR:                       ^
3980
3981          st1 {v0.16b, v2.16b}, [x0]
3982          st1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
3983          st1 v0.8b, v1.8b}, [x0]
3984          st1 {v0.8h-v4.8h}, [x0]
3985          st1 {v1.8h-v1.8h}, [x0]
3986          st1 {v15.8h-v17.4h}, [x15]
3987          st1 {v0.8b-v2.8b, [x0]
3988 // CHECK-ERROR: error: registers must be sequential
3989 // CHECK-ERROR:        st1 {v0.16b, v2.16b}, [x0]
3990 // CHECK-ERROR:                     ^
3991 // CHECK-ERROR: error: invalid number of vectors
3992 // CHECK-ERROR:        st1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
3993 // CHECK-ERROR:                                         ^
3994 // CHECK-ERROR: error: unexpected token in argument list
3995 // CHECK-ERROR:        st1 v0.8b, v1.8b}, [x0]
3996 // CHECK-ERROR:            ^
3997 // CHECK-ERROR: error: invalid number of vectors
3998 // CHECK-ERROR:        st1 {v0.8h-v4.8h}, [x0]
3999 // CHECK-ERROR:                   ^
4000 // CHECK-ERROR: error: invalid number of vectors
4001 // CHECK-ERROR:        st1 {v1.8h-v1.8h}, [x0]
4002 // CHECK-ERROR:                   ^
4003 // CHECK-ERROR: error: mismatched register size suffix
4004 // CHECK-ERROR:        st1 {v15.8h-v17.4h}, [x15]
4005 // CHECK-ERROR:                        ^
4006 // CHECK-ERROR: error: '}' expected
4007 // CHECK-ERROR:        st1 {v0.8b-v2.8b, [x0]
4008 // CHECK-ERROR:                        ^
4009
4010          st2 {v15.8h, v16.4h}, [x15]
4011          st2 {v0.8b, v2.8b}, [x0]
4012          st2 {v15.4h, v16.4h, v17.4h}, [x30]
4013          st2 {v15.8h-v16.4h}, [x15]
4014          st2 {v0.2d-v2.2d}, [x0]
4015 // CHECK-ERROR: error: mismatched register size suffix
4016 // CHECK-ERROR:        st2 {v15.8h, v16.4h}, [x15]
4017 // CHECK-ERROR:                     ^
4018 // CHECK-ERROR: error: registers must be sequential
4019 // CHECK-ERROR:        st2 {v0.8b, v2.8b}, [x0]
4020 // CHECK-ERROR:                    ^
4021 // CHECK-ERROR: error: invalid operand for instruction
4022 // CHECK-ERROR:        st2 {v15.4h, v16.4h, v17.4h}, [x30]
4023 // CHECK-ERROR:            ^
4024 // CHECK-ERROR: error: mismatched register size suffix
4025 // CHECK-ERROR:        st2 {v15.8h-v16.4h}, [x15]
4026 // CHECK-ERROR:                        ^
4027 // CHECK-ERROR: error: invalid operand for instruction
4028 // CHECK-ERROR:        st2 {v0.2d-v2.2d}, [x0]
4029 // CHECK-ERROR:            ^
4030
4031          st3 {v15.8h, v16.8h, v17.4h}, [x15]
4032          st3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
4033          st3 {v0.8b, v2.8b, v3.8b}, [x0]
4034          st3 {v15.8h-v17.4h}, [x15]
4035          st3 {v31.4s-v2.4s}, [sp]
4036 // CHECK-ERROR: error: mismatched register size suffix
4037 // CHECK-ERROR:        st3 {v15.8h, v16.8h, v17.4h}, [x15]
4038 // CHECK-ERROR:                             ^
4039 // CHECK-ERROR: error: mismatched register size suffix
4040 // CHECK-ERROR:        st3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
4041 // CHECK-ERROR:                    ^
4042 // CHECK-ERROR: error: registers must be sequential
4043 // CHECK-ERROR:        st3 {v0.8b, v2.8b, v3.8b}, [x0]
4044 // CHECK-ERROR:                    ^
4045 // CHECK-ERROR: error: mismatched register size suffix
4046 // CHECK-ERROR:        st3 {v15.8h-v17.4h}, [x15]
4047 // CHECK-ERROR:                        ^
4048 // CHECK-ERROR: error: invalid operand for instruction
4049 // CHECK-ERROR:        st3 {v31.4s-v2.4s}, [sp]
4050 // CHECK-ERROR:            ^
4051
4052          st4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
4053          st4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
4054          st4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
4055          st4 {v15.8h-v18.4h}, [x15]
4056          st4 {v31.2s-v1.2s}, [x31]
4057 // CHECK-ERROR: error: mismatched register size suffix
4058 // CHECK-ERROR:        st4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
4059 // CHECK-ERROR:                             ^
4060 // CHECK-ERROR: error: registers must be sequential
4061 // CHECK-ERROR:        st4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
4062 // CHECK-ERROR:                    ^
4063 // CHECK-ERROR: error: invalid number of vectors
4064 // CHECK-ERROR:        st4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
4065 // CHECK-ERROR:                                             ^
4066 // CHECK-ERROR: error: mismatched register size suffix
4067 // CHECK-ERROR:        st4 {v15.8h-v18.4h}, [x15]
4068 // CHECK-ERROR:                        ^
4069 // CHECK-ERROR: error: invalid operand for instruction
4070 // CHECK-ERROR:        st4 {v31.2s-v1.2s}, [x31]
4071 // CHECK-ERROR:            ^
4072
4073 //----------------------------------------------------------------------
4074 // Vector post-index load/store multiple N-element structure
4075 // (class SIMD lselem-post)
4076 //----------------------------------------------------------------------
4077          ld1 {v0.16b}, [x0], #8
4078          ld1 {v0.8h, v1.16h}, [x0], x1
4079          ld1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4080 // CHECK-ERROR: error: invalid operand for instruction
4081 // CHECK-ERROR:          ld1 {v0.16b}, [x0], #8
4082 // CHECK-ERROR:                              ^
4083 // CHECK-ERROR: error: invalid vector kind qualifier
4084 // CHECK-ERROR:          ld1 {v0.8h, v1.16h}, [x0], x1
4085 // CHECK-ERROR:                      ^
4086 // CHECK-ERROR:  error: invalid operand for instruction
4087 // CHECK-ERROR:          ld1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4088 // CHECK-ERROR:                                                  ^
4089
4090          ld2 {v0.16b, v1.16b}, [x0], #16
4091          ld3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4092          ld4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4093 // CHECK-ERROR:  error: invalid operand for instruction
4094 // CHECK-ERROR:          ld2 {v0.16b, v1.16b}, [x0], #16
4095 // CHECK-ERROR:                                      ^
4096 // CHECK-ERROR:  error: invalid operand for instruction
4097 // CHECK-ERROR:          ld3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4098 // CHECK-ERROR:                                           ^
4099 // CHECK-ERROR: error: mismatched register size suffix
4100 // CHECK-ERROR:          ld4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4101 // CHECK-ERROR:                                     ^
4102
4103          st1 {v0.16b}, [x0], #8
4104          st1 {v0.8h, v1.16h}, [x0], x1
4105          st1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4106 // CHECK-ERROR:  error: invalid operand for instruction
4107 // CHECK-ERROR:          st1 {v0.16b}, [x0], #8
4108 // CHECK-ERROR:                              ^
4109 // CHECK-ERROR: error: invalid vector kind qualifier
4110 // CHECK-ERROR:          st1 {v0.8h, v1.16h}, [x0], x1
4111 // CHECK-ERROR:                      ^
4112 // CHECK-ERROR:  error: invalid operand for instruction
4113 // CHECK-ERROR:          st1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4114                                                  ^
4115
4116          st2 {v0.16b, v1.16b}, [x0], #16
4117          st3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4118          st4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4119 // CHECK-ERROR:  error: invalid operand for instruction
4120 // CHECK-ERROR:          st2 {v0.16b, v1.16b}, [x0], #16
4121 // CHECK-ERROR:                                      ^
4122 // CHECK-ERROR:  error: invalid operand for instruction
4123 // CHECK-ERROR:          st3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4124 // CHECK-ERROR:                                           ^
4125 // CHECK-ERROR: error: mismatched register size suffix
4126 // CHECK-ERROR:          st4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4127 // CHECK-ERROR:                                     ^
4128
4129 //------------------------------------------------------------------------------
4130 // Load single N-element structure to all lanes of N consecutive
4131 // registers (N = 1,2,3,4)
4132 //------------------------------------------------------------------------------
4133          ld1r {x1}, [x0]
4134          ld2r {v31.4s, v0.2s}, [sp]
4135          ld3r {v0.8b, v1.8b, v2.8b, v3.8b}, [x0]
4136          ld4r {v31.2s, v0.2s, v1.2d, v2.2s}, [sp]
4137 // CHECK-ERROR: error: vector register expected
4138 // CHECK-ERROR: ld1r {x1}, [x0]
4139 // CHECK-ERROR:       ^
4140 // CHECK-ERROR: error: mismatched register size suffix
4141 // CHECK-ERROR: ld2r {v31.4s, v0.2s}, [sp]
4142 // CHECK-ERROR:               ^
4143 // CHECK-ERROR: error: invalid operand for instruction
4144 // CHECK-ERROR: ld3r {v0.8b, v1.8b, v2.8b, v3.8b}, [x0]
4145 // CHECK-ERROR:      ^
4146 // CHECK-ERROR: error: mismatched register size suffix
4147 // CHECK-ERROR: ld4r {v31.2s, v0.2s, v1.2d, v2.2s}, [sp]
4148 // CHECK-ERROR:                      ^
4149
4150 //------------------------------------------------------------------------------
4151 // Load/Store single N-element structure to/from one lane of N consecutive
4152 // registers (N = 1, 2,3,4)
4153 //------------------------------------------------------------------------------
4154          ld1 {v0.b}[16], [x0]
4155          ld2 {v15.h, v16.h}[8], [x15]
4156          ld3 {v31.s, v0.s, v1.s}[-1], [sp]
4157          ld4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4158 // CHECK-ERROR: vector lane must be an integer in range
4159 // CHECK-ERROR: ld1 {v0.b}[16], [x0]
4160 // CHECK-ERROR:            ^
4161 // CHECK-ERROR: vector lane must be an integer in range
4162 // CHECK-ERROR: ld2 {v15.h, v16.h}[8], [x15]
4163 // CHECK-ERROR:                    ^
4164 // CHECK-ERROR: error: vector lane must be an integer in range
4165 // CHECK-ERROR: ld3 {v31.s, v0.s, v1.s}[-1], [sp]
4166 // CHECK-ERROR:                         ^
4167 // CHECK-ERROR: vector lane must be an integer in range
4168 // CHECK-ERROR: ld4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4169 // CHECK-ERROR:                              ^
4170
4171          st1 {v0.d}[16], [x0]
4172          st2 {v31.s, v0.s}[3], [8]
4173          st3 {v15.h, v16.h, v17.h}[-1], [x15]
4174          st4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4175 // CHECK-ERROR: vector lane must be an integer in range
4176 // CHECK-ERROR: st1 {v0.d}[16], [x0]
4177 // CHECK-ERROR:            ^
4178 // CHECK-ERROR: error: invalid operand for instruction
4179 // CHECK-ERROR: st2 {v31.s, v0.s}[3], [8]
4180 // CHECK-ERROR:                        ^
4181 // CHECK-ERROR: error: vector lane must be an integer in range
4182 // CHECK-ERROR: st3 {v15.h, v16.h, v17.h}[-1], [x15]
4183 // CHECK-ERROR:                           ^
4184 // CHECK-ERROR: vector lane must be an integer in range
4185 // CHECK-ERROR: st4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4186 // CHECK-ERROR:                              ^
4187
4188 //------------------------------------------------------------------------------
4189 // Post-index of load single N-element structure to all lanes of N consecutive
4190 // registers (N = 1,2,3,4)
4191 //------------------------------------------------------------------------------
4192          ld1r {v15.8h}, [x15], #5
4193          ld2r {v0.2d, v1.2d}, [x0], #7
4194          ld3r {v15.4h, v16.4h, v17.4h}, [x15], #1
4195          ld4r {v31.1d, v0.1d, v1.1d, v2.1d}, [sp], sp
4196 // CHECK-ERROR: error: invalid operand for instruction
4197 // CHECK-ERROR: ld1r {v15.8h}, [x15], #5
4198 // CHECK-ERROR:                       ^
4199 // CHECK-ERROR: error: invalid operand for instruction
4200 // CHECK-ERROR: ld2r {v0.2d, v1.2d}, [x0], #7
4201 // CHECK-ERROR:                            ^
4202 // CHECK-ERROR: error: invalid operand for instruction
4203 // CHECK-ERROR: ld3r {v15.4h, v16.4h, v17.4h}, [x15], #1
4204 // CHECK-ERROR:                                       ^
4205 // CHECK-ERROR: error: invalid operand for instruction
4206 // CHECK-ERROR: ld4r {v31.1d, v0.1d, v1.1d, v2.1d}, [sp], sp
4207 // CHECK-ERROR:                                           ^
4208
4209 //------------------------------------------------------------------------------
4210 // Post-index of Load/Store single N-element structure to/from one lane of N
4211 // consecutive registers (N = 1, 2,3,4)
4212 //------------------------------------------------------------------------------
4213          ld1 {v0.b}[0], [x0], #2
4214          ld2 {v15.h, v16.h}[0], [x15], #3
4215          ld3 {v31.s, v0.s, v1.d}[0], [sp], x9
4216          ld4 {v0.d, v1.d, v2.d, v3.d}[1], [x0], #24
4217 // CHECK-ERROR: error: invalid operand for instruction
4218 // CHECK-ERROR: ld1 {v0.b}[0], [x0], #2
4219 // CHECK-ERROR:                      ^
4220 // CHECK-ERROR: error: invalid operand for instruction
4221 // CHECK-ERROR: ld2 {v15.h, v16.h}[0], [x15], #3
4222 // CHECK-ERROR:                               ^
4223 // CHECK-ERROR: error: mismatched register size suffix
4224 // CHECK-ERROR: ld3 {v31.s, v0.s, v1.d}[0], [sp], x9
4225 // CHECK-ERROR:                      ^
4226 // CHECK-ERROR: error: invalid operand for instruction
4227 // CHECK-ERROR: ld4 {v0.d, v1.d, v2.d, v3.d}[1], [x0], #24
4228 // CHECK-ERROR:                                        ^
4229
4230          st1 {v0.d}[0], [x0], #7
4231          st2 {v31.s, v0.s}[0], [sp], #6
4232          st3 {v15.h, v16.h, v17.h}[0], [x15], #8
4233          st4 {v0.b, v1.b, v2.b, v3.b}[1], [x0], #1
4234 // CHECK-ERROR: error: invalid operand for instruction
4235 // CHECK-ERROR: st1 {v0.d}[0], [x0], #7
4236 // CHECK-ERROR:                      ^
4237 // CHECK-ERROR: error: invalid operand for instruction
4238 // CHECK-ERROR: st2 {v31.s, v0.s}[0], [sp], #6
4239 // CHECK-ERROR:                             ^
4240 // CHECK-ERROR: error: invalid operand for instruction
4241 // CHECK-ERROR: st3 {v15.h, v16.h, v17.h}[0], [x15], #8
4242 // CHECK-ERROR:                                      ^
4243 // CHECK-ERROR: error: invalid operand for instruction
4244 // CHECK-ERROR: st4 {v0.b, v1.b, v2.b, v3.b}[1], [x0], #1
4245 // CHECK-ERROR:                                        ^
4246
4247
4248          ins v2.b[16], w1
4249          ins v7.h[8], w14
4250          ins v20.s[5], w30
4251          ins v1.d[2], x7
4252          ins v2.b[3], b1
4253          ins v7.h[2], h14
4254          ins v20.s[1], s30
4255          ins v1.d[0], d7
4256
4257 // CHECK-ERROR: vector lane must be an integer in range
4258 // CHECK-ERROR:         ins v2.b[16], w1
4259 // CHECK-ERROR:                  ^
4260 // CHECK-ERROR: vector lane must be an integer in range
4261 // CHECK-ERROR:         ins v7.h[8], w14
4262 // CHECK-ERROR:                  ^
4263 // CHECK-ERROR: vector lane must be an integer in range
4264 // CHECK-ERROR:         ins v20.s[5], w30
4265 // CHECK-ERROR:                   ^
4266 // CHECK-ERROR: vector lane must be an integer in range
4267 // CHECK-ERROR:         ins v1.d[2], x7
4268 // CHECK-ERROR:                  ^
4269 // CHECK-ERROR: error: invalid operand for instruction
4270 // CHECK-ERROR:         ins v2.b[3], b1
4271 // CHECK-ERROR:                      ^
4272 // CHECK-ERROR: error: invalid operand for instruction
4273 // CHECK-ERROR:         ins v7.h[2], h14
4274 // CHECK-ERROR:                      ^
4275 // CHECK-ERROR: error: invalid operand for instruction
4276 // CHECK-ERROR:         ins v20.s[1], s30
4277 // CHECK-ERROR:                       ^
4278 // CHECK-ERROR: error: invalid operand for instruction
4279 // CHECK-ERROR:         ins v1.d[0], d7
4280 // CHECK-ERROR:                      ^
4281
4282          smov w1, v0.b[16]
4283          smov w14, v6.h[8]
4284          smov x1, v0.b[16]
4285          smov x14, v6.h[8]
4286          smov x20, v9.s[5]
4287          smov w1, v0.d[0]
4288          smov w14, v6.d[1]
4289          smov x1, v0.d[0]
4290          smov x14, v6.d[1]
4291          smov x20, v9.d[0]
4292
4293 // CHECK-ERROR: vector lane must be an integer in range
4294 // CHECK-ERROR:         smov w1, v0.b[16]
4295 // CHECK-ERROR:                       ^
4296 // CHECK-ERROR: vector lane must be an integer in range
4297 // CHECK-ERROR:         smov w14, v6.h[8]
4298 // CHECK-ERROR:                        ^
4299 // CHECK-ERROR: vector lane must be an integer in range
4300 // CHECK-ERROR:         smov x1, v0.b[16]
4301 // CHECK-ERROR:                       ^
4302 // CHECK-ERROR: vector lane must be an integer in range
4303 // CHECK-ERROR:         smov x14, v6.h[8]
4304 // CHECK-ERROR:                        ^
4305 // CHECK-ERROR: vector lane must be an integer in range
4306 // CHECK-ERROR:         smov x20, v9.s[5]
4307 // CHECK-ERROR:                        ^
4308 // CHECK-ERROR: error: invalid operand for instruction
4309 // CHECK-ERROR:         smov w1, v0.d[0]
4310 // CHECK-ERROR:                     ^
4311 // CHECK-ERROR: error: invalid operand for instruction
4312 // CHECK-ERROR:         smov w14, v6.d[1]
4313 // CHECK-ERROR:                      ^
4314 // CHECK-ERROR: error: invalid operand for instruction
4315 // CHECK-ERROR:         smov x1, v0.d[0]
4316 // CHECK-ERROR:                     ^
4317 // CHECK-ERROR: error: invalid operand for instruction
4318 // CHECK-ERROR:         smov x14, v6.d[1]
4319 // CHECK-ERROR:                      ^
4320 // CHECK-ERROR: error: invalid operand for instruction
4321 // CHECK-ERROR:         smov x20, v9.d[0]
4322 // CHECK-ERROR:                      ^
4323
4324          umov w1, v0.b[16]
4325          umov w14, v6.h[8]
4326          umov w20, v9.s[5]
4327          umov x7, v18.d[3]
4328          umov w1, v0.d[0]
4329          umov s20, v9.s[2]
4330          umov d7, v18.d[1]
4331
4332 // CHECK-ERROR: vector lane must be an integer in range
4333 // CHECK-ERROR:         umov w1, v0.b[16]
4334 // CHECK-ERROR:                       ^
4335 // CHECK-ERROR: vector lane must be an integer in range
4336 // CHECK-ERROR:         umov w14, v6.h[8]
4337 // CHECK-ERROR:                        ^
4338 // CHECK-ERROR: vector lane must be an integer in range
4339 // CHECK-ERROR:         umov w20, v9.s[5]
4340 // CHECK-ERROR:                        ^
4341 // CHECK-ERROR: vector lane must be an integer in range
4342 // CHECK-ERROR:         umov x7, v18.d[3]
4343 // CHECK-ERROR:                        ^
4344 // CHECK-ERROR: error: invalid operand for instruction
4345 // CHECK-ERROR:         umov w1, v0.d[0]
4346 // CHECK-ERROR:                     ^
4347 // CHECK-ERROR: error: invalid operand for instruction
4348 // CHECK-ERROR:         umov s20, v9.s[2]
4349 // CHECK-ERROR:              ^
4350 // CHECK-ERROR: error: invalid operand for instruction
4351 // CHECK-ERROR:         umov d7, v18.d[1]
4352 // CHECK-ERROR:              ^
4353
4354          Ins v1.h[2], v3.b[6]
4355          Ins v6.h[7], v7.s[2]
4356          Ins v15.d[0], v22.s[2]
4357          Ins v0.d[0], v4.b[1]
4358
4359 // CHECK-ERROR: error: invalid operand for instruction
4360 // CHECK-ERROR:         Ins v1.h[2], v3.b[6]
4361 // CHECK-ERROR:                         ^
4362 // CHECK-ERROR: error: invalid operand for instruction
4363 // CHECK-ERROR:         Ins v6.h[7], v7.s[2]
4364 // CHECK-ERROR:                         ^
4365 // CHECK-ERROR: error: invalid operand for instruction
4366 // CHECK-ERROR:         Ins v15.d[0], v22.s[2]
4367 // CHECK-ERROR:                           ^
4368 // CHECK-ERROR: error: invalid operand for instruction
4369 // CHECK-ERROR:         Ins v0.d[0], v4.b[1]
4370 // CHECK-ERROR:                         ^
4371
4372          dup v1.8h, v2.b[2]
4373          dup v11.4s, v7.h[7]
4374          dup v17.2d, v20.s[0]
4375          dup v1.16b, v2.h[2]
4376          dup v11.8h, v7.s[3]
4377          dup v17.4s, v20.d[0]
4378          dup v5.2d, v1.b[1]
4379
4380 // CHECK-ERROR: error: invalid operand for instruction
4381 // CHECK-ERROR:         dup v1.8h, v2.b[2]
4382 // CHECK-ERROR:                       ^
4383 // CHECK-ERROR: error: invalid operand for instruction
4384 // CHECK-ERROR:         dup v11.4s, v7.h[7]
4385 // CHECK-ERROR:                        ^
4386 // CHECK-ERROR: error: invalid operand for instruction
4387 // CHECK-ERROR:         dup v17.2d, v20.s[0]
4388 // CHECK-ERROR:                         ^
4389 // CHECK-ERROR: error: invalid operand for instruction
4390 // CHECK-ERROR:         dup v1.16b, v2.h[2]
4391 // CHECK-ERROR:                        ^
4392 // CHECK-ERROR: invalid operand for instruction
4393 // CHECK-ERROR:         dup v11.8h, v7.s[3]
4394 // CHECK-ERROR:                        ^
4395 // CHECK-ERROR: invalid operand for instruction
4396 // CHECK-ERROR:         dup v17.4s, v20.d[0]
4397 // CHECK-ERROR:                         ^
4398 // CHECK-ERROR: invalid operand for instruction
4399 // CHECK-ERROR:         dup v5.2d, v1.b[1]
4400 // CHECK-ERROR:                       ^
4401
4402          dup v1.8b, b1
4403          dup v11.4h, h14
4404          dup v17.2s, s30
4405          dup v1.16b, d2
4406          dup v11.8s, w16
4407          dup v17.4d, w28
4408          dup v5.2d, w0
4409
4410 // CHECK-ERROR: error: invalid operand for instruction
4411 // CHECK-ERROR:         dup v1.8b, b1
4412 // CHECK-ERROR:                    ^
4413 // CHECK-ERROR: error: invalid operand for instruction
4414 // CHECK-ERROR:         dup v11.4h, h14
4415 // CHECK-ERROR:                     ^
4416 // CHECK-ERROR: error: invalid operand for instruction
4417 // CHECK-ERROR:         dup v17.2s, s30
4418 // CHECK-ERROR:                     ^
4419 // CHECK-ERROR: error: invalid operand for instruction
4420 // CHECK-ERROR:         dup v1.16b, d2
4421 // CHECK-ERROR:                     ^
4422 // CHECK-ERROR: error: invalid vector kind qualifier
4423 // CHECK-ERROR:         dup v11.8s, w16
4424 // CHECK-ERROR:             ^
4425 // CHECK-ERROR: error: invalid vector kind qualifier
4426 // CHECK-ERROR:         dup v17.4d, w28
4427 // CHECK-ERROR:             ^
4428 // CHECK-ERROR: error: invalid operand for instruction
4429 // CHECK-ERROR:         dup v5.2d, w0
4430 // CHECK-ERROR:                    ^
4431
4432 //----------------------------------------------------------------------
4433 // Scalar Compare Bitwise Equal
4434 //----------------------------------------------------------------------
4435
4436          cmeq b20, d21, d22
4437
4438 // CHECK-ERROR: error: invalid operand for instruction
4439 // CHECK-ERROR:          cmeq b20, d21, d22
4440 // CHECK-ERROR:               ^
4441
4442 //----------------------------------------------------------------------
4443 // Scalar Compare Bitwise Equal To Zero
4444 //----------------------------------------------------------------------
4445
4446          cmeq d20, b21, #0
4447
4448 // CHECK-ERROR: error: invalid operand for instruction
4449 // CHECK-ERROR:          cmeq d20, b21, #0
4450 // CHECK-ERROR:                    ^
4451
4452 //----------------------------------------------------------------------
4453 // Scalar Compare Unsigned Higher Or Same
4454 //----------------------------------------------------------------------
4455
4456          cmhs b20, d21, d22
4457
4458 // CHECK-ERROR: error: invalid operand for instruction
4459 // CHECK-ERROR:          cmhs b20, d21, d22
4460 // CHECK-ERROR:               ^
4461
4462
4463 //----------------------------------------------------------------------
4464 // Scalar Compare Signed Greather Than Or Equal
4465 //----------------------------------------------------------------------
4466
4467          cmge b20, d21, d22
4468
4469 // CHECK-ERROR: error: invalid operand for instruction
4470 // CHECK-ERROR:          cmge b20, d21, d22
4471 // CHECK-ERROR:               ^
4472
4473 //----------------------------------------------------------------------
4474 // Scalar Compare Signed Greather Than Or Equal To Zero
4475 //----------------------------------------------------------------------
4476
4477          cmge d20, b21, #0
4478
4479 // CHECK-ERROR: error: invalid operand for instruction
4480 // CHECK-ERROR:          cmge d20, b21, #0
4481 // CHECK-ERROR:                    ^
4482
4483 //----------------------------------------------------------------------
4484 // Scalar Compare Unsigned Higher
4485 //----------------------------------------------------------------------
4486
4487          cmhi b20, d21, d22
4488
4489 // CHECK-ERROR: error: invalid operand for instruction
4490 // CHECK-ERROR:          cmhi b20, d21, d22
4491 // CHECK-ERROR:               ^
4492
4493 //----------------------------------------------------------------------
4494 // Scalar Compare Signed Greater Than
4495 //----------------------------------------------------------------------
4496
4497          cmgt b20, d21, d22
4498
4499 // CHECK-ERROR: error: invalid operand for instruction
4500 // CHECK-ERROR:          cmgt b20, d21, d22
4501 // CHECK-ERROR:               ^
4502
4503 //----------------------------------------------------------------------
4504 // Scalar Compare Signed Greater Than Zero
4505 //----------------------------------------------------------------------
4506
4507          cmgt d20, b21, #0
4508
4509 // CHECK-ERROR: error: invalid operand for instruction
4510 // CHECK-ERROR:          cmgt d20, b21, #0
4511 // CHECK-ERROR:                    ^
4512
4513 //----------------------------------------------------------------------
4514 // Scalar Compare Signed Less Than Or Equal To Zero
4515 //----------------------------------------------------------------------
4516
4517          cmle d20, b21, #0
4518
4519 // CHECK-ERROR: error: invalid operand for instruction
4520 // CHECK-ERROR:          cmle d20, b21, #0
4521 // CHECK-ERROR:                    ^
4522
4523 //----------------------------------------------------------------------
4524 // Scalar Compare Less Than Zero
4525 //----------------------------------------------------------------------
4526
4527          cmlt d20, b21, #0
4528
4529 // CHECK-ERROR: error: invalid operand for instruction
4530 // CHECK-ERROR:          cmlt d20, b21, #0
4531 // CHECK-ERROR:                    ^
4532
4533 //----------------------------------------------------------------------
4534 // Scalar Compare Bitwise Test Bits
4535 //----------------------------------------------------------------------
4536
4537          cmtst b20, d21, d22
4538
4539 // CHECK-ERROR: error: invalid operand for instruction
4540 // CHECK-ERROR:          cmtst b20, d21, d22
4541 // CHECK-ERROR:                ^
4542
4543 //----------------------------------------------------------------------
4544 // Scalar Floating-point Compare Mask Equal
4545 //----------------------------------------------------------------------
4546
4547          fcmeq s10, h11, s12
4548          fcmeq d20, s21, d22
4549
4550 // CHECK-ERROR: error: invalid operand for instruction
4551 // CHECK-ERROR:          fcmeq s10, h11, s12
4552 // CHECK-ERROR:                     ^
4553 // CHECK-ERROR: error: invalid operand for instruction
4554 // CHECK-ERROR:          fcmeq d20, s21, d22
4555 // CHECK-ERROR:                     ^
4556
4557 //----------------------------------------------------------------------
4558 // Scalar Floating-point Compare Mask Equal To Zero
4559 //----------------------------------------------------------------------
4560
4561          fcmeq h10, s11, #0.0
4562          fcmeq d20, s21, #0.0
4563
4564 // CHECK-ERROR: error: invalid operand for instruction
4565 // CHECK-ERROR:          fcmeq h10, s11, #0.0
4566 // CHECK-ERROR:                ^
4567 // CHECK-ERROR: error: invalid operand for instruction
4568 // CHECK-ERROR:          fcmeq d20, s21, #0.0
4569 // CHECK-ERROR:                     ^
4570
4571 //----------------------------------------------------------------------
4572 // Scalar Floating-point Compare Mask Greater Than Or Equal
4573 //----------------------------------------------------------------------
4574
4575          fcmge s10, h11, s12
4576          fcmge d20, s21, d22
4577
4578 // CHECK-ERROR: error: invalid operand for instruction
4579 // CHECK-ERROR:          fcmge s10, h11, s12
4580 // CHECK-ERROR:                     ^
4581 // CHECK-ERROR: error: invalid operand for instruction
4582 // CHECK-ERROR:          fcmge d20, s21, d22
4583 // CHECK-ERROR:                     ^
4584
4585 //----------------------------------------------------------------------
4586 // Scalar Floating-point Compare Mask Greater Than Or Equal To Zero
4587 //----------------------------------------------------------------------
4588
4589          fcmge h10, s11, #0.0
4590          fcmge d20, s21, #0.0
4591
4592 // CHECK-ERROR: error: invalid operand for instruction
4593 // CHECK-ERROR:          fcmge h10, s11, #0.0
4594 // CHECK-ERROR:                ^
4595 // CHECK-ERROR: error: invalid operand for instruction
4596 // CHECK-ERROR:          fcmge d20, s21, #0.0
4597 // CHECK-ERROR:                     ^
4598
4599 //----------------------------------------------------------------------
4600 // Scalar Floating-point Compare Mask Greather Than
4601 //----------------------------------------------------------------------
4602
4603          fcmgt s10, h11, s12
4604          fcmgt d20, s21, d22
4605
4606 // CHECK-ERROR: error: invalid operand for instruction
4607 // CHECK-ERROR:          fcmgt s10, h11, s12
4608 // CHECK-ERROR:                     ^
4609 // CHECK-ERROR: error: invalid operand for instruction
4610 // CHECK-ERROR:          fcmgt d20, s21, d22
4611 // CHECK-ERROR:                     ^
4612
4613 //----------------------------------------------------------------------
4614 // Scalar Floating-point Compare Mask Greather Than Zero
4615 //----------------------------------------------------------------------
4616
4617          fcmgt h10, s11, #0.0
4618          fcmgt d20, s21, #0.0
4619
4620 // CHECK-ERROR: error: invalid operand for instruction
4621 // CHECK-ERROR:          fcmgt h10, s11, #0.0
4622 // CHECK-ERROR:                ^
4623 // CHECK-ERROR: error: invalid operand for instruction
4624 // CHECK-ERROR:          fcmgt d20, s21, #0.0
4625 // CHECK-ERROR:                     ^
4626
4627 //----------------------------------------------------------------------
4628 // Scalar Floating-point Compare Mask Less Than Or Equal To Zero
4629 //----------------------------------------------------------------------
4630
4631          fcmle h10, s11, #0.0
4632          fcmle d20, s21, #0.0
4633
4634 // CHECK-ERROR: error: invalid operand for instruction
4635 // CHECK-ERROR:          fcmle h10, s11, #0.0
4636 // CHECK-ERROR:                ^
4637 // CHECK-ERROR: error: invalid operand for instruction
4638 // CHECK-ERROR:          fcmle d20, s21, #0.0
4639 // CHECK-ERROR:                     ^
4640
4641 //----------------------------------------------------------------------
4642 // Scalar Floating-point Compare Mask Less Than
4643 //----------------------------------------------------------------------
4644
4645          fcmlt h10, s11, #0.0
4646          fcmlt d20, s21, #0.0
4647
4648 // CHECK-ERROR: error: invalid operand for instruction
4649 // CHECK-ERROR:          fcmlt h10, s11, #0.0
4650 // CHECK-ERROR:                     ^
4651 // CHECK-ERROR: error: invalid operand for instruction
4652 // CHECK-ERROR:          fcmlt d20, s21, #0.0
4653 // CHECK-ERROR:                     ^
4654
4655 //----------------------------------------------------------------------
4656 // Scalar Floating-point Absolute Compare Mask Greater Than Or Equal
4657 //----------------------------------------------------------------------
4658
4659          facge s10, h11, s12
4660          facge d20, s21, d22
4661
4662 // CHECK-ERROR: error: invalid operand for instruction
4663 // CHECK-ERROR:          facge s10, h11, s12
4664 // CHECK-ERROR:                     ^
4665 // CHECK-ERROR: error: invalid operand for instruction
4666 // CHECK-ERROR:          facge d20, s21, d22
4667 // CHECK-ERROR:                     ^
4668
4669 //----------------------------------------------------------------------
4670 // Scalar Floating-point Absolute Compare Mask Greater Than
4671 //----------------------------------------------------------------------
4672
4673          facgt s10, h11, s12
4674          facgt d20, d21, s22
4675
4676 // CHECK-ERROR: error: invalid operand for instruction
4677 // CHECK-ERROR:          facgt s10, h11, s12
4678 // CHECK-ERROR:                     ^
4679 // CHECK-ERROR: error: invalid operand for instruction
4680 // CHECK-ERROR:          facgt d20, d21, s22
4681 // CHECK-ERROR:                          ^
4682
4683 //----------------------------------------------------------------------
4684 // Scalar Signed Saturating Accumulated of Unsigned Value
4685 //----------------------------------------------------------------------
4686
4687         suqadd b0, h1
4688         suqadd h0, s1
4689         suqadd s0, d1
4690         suqadd d0, b0
4691
4692 // CHECK-ERROR: error: invalid operand for instruction
4693 // CHECK-ERROR:        suqadd b0, h1
4694 // CHECK-ERROR:                   ^
4695 // CHECK-ERROR: error: invalid operand for instruction
4696 // CHECK-ERROR:        suqadd h0, s1
4697 // CHECK-ERROR:                   ^
4698 // CHECK-ERROR: error: invalid operand for instruction
4699 // CHECK-ERROR:        suqadd s0, d1
4700 // CHECK-ERROR:                   ^
4701 // CHECK-ERROR: error: invalid operand for instruction
4702 // CHECK-ERROR:        suqadd d0, b0
4703 // CHECK-ERROR:                   ^
4704
4705 //----------------------------------------------------------------------
4706 // Scalar Unsigned Saturating Accumulated of Signed Value
4707 //----------------------------------------------------------------------
4708
4709         usqadd b0, h1
4710         usqadd h0, s1
4711         usqadd s0, d1
4712         usqadd d0, b1
4713
4714 // CHECK-ERROR: error: invalid operand for instruction
4715 // CHECK-ERROR:        usqadd b0, h1
4716 // CHECK-ERROR:                   ^
4717 // CHECK-ERROR: error: invalid operand for instruction
4718 // CHECK-ERROR:        usqadd h0, s1
4719 // CHECK-ERROR:                   ^
4720 // CHECK-ERROR: error: invalid operand for instruction
4721 // CHECK-ERROR:        usqadd s0, d1
4722 // CHECK-ERROR:                   ^
4723 // CHECK-ERROR: error: invalid operand for instruction
4724 // CHECK-ERROR:        usqadd d0, b1
4725 // CHECK-ERROR:                   ^
4726
4727 //----------------------------------------------------------------------
4728 // Scalar Absolute Value
4729 //----------------------------------------------------------------------
4730
4731     abs d29, s24
4732
4733 // CHECK-ERROR: error: invalid operand for instruction
4734 // CHECK-ERROR:        abs d29, s24
4735 // CHECK-ERROR:                 ^
4736
4737 //----------------------------------------------------------------------
4738 // Scalar Negate
4739 //----------------------------------------------------------------------
4740
4741     neg d29, s24
4742
4743 // CHECK-ERROR: error: invalid operand for instruction
4744 // CHECK-ERROR:        neg d29, s24
4745 // CHECK-ERROR:                 ^
4746
4747 //----------------------------------------------------------------------
4748 // Signed Saturating Doubling Multiply-Add Long
4749 //----------------------------------------------------------------------
4750
4751     sqdmlal s17, h27, s12
4752     sqdmlal d19, s24, d12
4753
4754 // CHECK-ERROR: error: invalid operand for instruction
4755 // CHECK-ERROR:        sqdmlal s17, h27, s12
4756 // CHECK-ERROR:                          ^
4757 // CHECK-ERROR: error: invalid operand for instruction
4758 // CHECK-ERROR:        sqdmlal d19, s24, d12
4759 // CHECK-ERROR:                          ^
4760
4761 //----------------------------------------------------------------------
4762 // Signed Saturating Doubling Multiply-Subtract Long
4763 //----------------------------------------------------------------------
4764
4765     sqdmlsl s14, h12, s25
4766     sqdmlsl d12, s23, d13
4767
4768 // CHECK-ERROR: error: invalid operand for instruction
4769 // CHECK-ERROR:        sqdmlsl s14, h12, s25
4770 // CHECK-ERROR:                          ^
4771 // CHECK-ERROR: error: invalid operand for instruction
4772 // CHECK-ERROR:        sqdmlsl d12, s23, d13
4773 // CHECK-ERROR:                          ^
4774
4775 //----------------------------------------------------------------------
4776 // Signed Saturating Doubling Multiply Long
4777 //----------------------------------------------------------------------
4778
4779     sqdmull s12, h22, s12
4780     sqdmull d15, s22, d12
4781
4782 // CHECK-ERROR: error: invalid operand for instruction
4783 // CHECK-ERROR:        sqdmull s12, h22, s12
4784 // CHECK-ERROR:                          ^
4785 // CHECK-ERROR: error: invalid operand for instruction
4786 // CHECK-ERROR:        sqdmull d15, s22, d12
4787 // CHECK-ERROR:                          ^
4788
4789 //----------------------------------------------------------------------
4790 // Scalar Signed Saturating Extract Unsigned Narrow
4791 //----------------------------------------------------------------------
4792
4793     sqxtun b19, b14
4794     sqxtun h21, h15
4795     sqxtun s20, s12
4796
4797 // CHECK-ERROR: error: invalid operand for instruction
4798 // CHECK-ERROR:        sqxtun b19, b14
4799 // CHECK-ERROR:                    ^
4800 // CHECK-ERROR: error: invalid operand for instruction
4801 // CHECK-ERROR:        sqxtun h21, h15
4802 // CHECK-ERROR:                    ^
4803 // CHECK-ERROR: error: invalid operand for instruction
4804 // CHECK-ERROR:        sqxtun s20, s12
4805 // CHECK-ERROR:                    ^
4806
4807 //----------------------------------------------------------------------
4808 // Scalar Signed Saturating Extract Signed Narrow
4809 //----------------------------------------------------------------------
4810
4811     sqxtn b18, b18
4812     sqxtn h20, h17
4813     sqxtn s19, s14
4814
4815 // CHECK-ERROR: error: invalid operand for instruction
4816 // CHECK-ERROR:        sqxtn b18, b18
4817 // CHECK-ERROR:                   ^
4818 // CHECK-ERROR: error: invalid operand for instruction
4819 // CHECK-ERROR:        sqxtn h20, h17
4820 // CHECK-ERROR:                   ^
4821 // CHECK-ERROR: error: invalid operand for instruction
4822 // CHECK-ERROR:        sqxtn s19, s14
4823 // CHECK-ERROR:                   ^
4824
4825
4826 //----------------------------------------------------------------------
4827 // Scalar Unsigned Saturating Extract Narrow
4828 //----------------------------------------------------------------------
4829
4830     uqxtn b18, b18
4831     uqxtn h20, h17
4832     uqxtn s19, s14
4833
4834 // CHECK-ERROR: error: invalid operand for instruction
4835 // CHECK-ERROR:        uqxtn b18, b18
4836 // CHECK-ERROR:                   ^
4837 // CHECK-ERROR: error: invalid operand for instruction
4838 // CHECK-ERROR:        uqxtn h20, h17
4839 // CHECK-ERROR:                   ^
4840 // CHECK-ERROR: error: invalid operand for instruction
4841 // CHECK-ERROR:        uqxtn s19, s14
4842 // CHECK-ERROR:                   ^
4843
4844 //----------------------------------------------------------------------
4845 // Scalar Signed Shift Right (Immediate)
4846 //----------------------------------------------------------------------
4847         sshr d15, d16, #99
4848
4849 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4850 // CHECK-ERROR:        sshr d15, d16, #99
4851 // CHECK-ERROR:                       ^
4852
4853         sshr d15, s16, #31
4854
4855 // CHECK-ERROR: error: invalid operand for instruction
4856 // CHECK-ERROR:        sshr d15, s16, #31
4857 // CHECK-ERROR:                  ^
4858
4859 //----------------------------------------------------------------------
4860 // Scalar Unsigned Shift Right (Immediate)
4861 //----------------------------------------------------------------------
4862
4863         ushr d10, d17, #99
4864
4865 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4866 // CHECK-ERROR:        ushr d10, d17, #99
4867 // CHECK-ERROR:                       ^
4868
4869 //----------------------------------------------------------------------
4870 // Scalar Signed Rounding Shift Right (Immediate)
4871 //----------------------------------------------------------------------
4872
4873         srshr d19, d18, #99
4874
4875 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4876 // CHECK-ERROR:        srshr d19, d18, #99
4877 // CHECK-ERROR:                        ^
4878
4879 //----------------------------------------------------------------------
4880 // Scalar Unigned Rounding Shift Right (Immediate)
4881 //----------------------------------------------------------------------
4882
4883         urshr d20, d23, #99
4884
4885 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4886 // CHECK-ERROR:        urshr d20, d23, #99
4887 // CHECK-ERROR:                        ^
4888
4889 //----------------------------------------------------------------------
4890 // Scalar Signed Shift Right and Accumulate (Immediate)
4891 //----------------------------------------------------------------------
4892
4893         ssra d18, d12, #99
4894
4895 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4896 // CHECK-ERROR:        ssra d18, d12, #99
4897 // CHECK-ERROR:                       ^
4898
4899 //----------------------------------------------------------------------
4900 // Scalar Unsigned Shift Right and Accumulate (Immediate)
4901 //----------------------------------------------------------------------
4902
4903         usra d20, d13, #99
4904
4905 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4906 // CHECK-ERROR:        usra d20, d13, #99
4907 // CHECK-ERROR:                       ^
4908
4909 //----------------------------------------------------------------------
4910 // Scalar Signed Rounding Shift Right and Accumulate (Immediate)
4911 //----------------------------------------------------------------------
4912
4913         srsra d15, d11, #99
4914
4915 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4916 // CHECK-ERROR:        srsra d15, d11, #99
4917 // CHECK-ERROR:                        ^
4918
4919 //----------------------------------------------------------------------
4920 // Scalar Unsigned Rounding Shift Right and Accumulate (Immediate)
4921 //----------------------------------------------------------------------
4922
4923         ursra d18, d10, #99
4924
4925 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4926 // CHECK-ERROR:        ursra d18, d10, #99
4927 // CHECK-ERROR:                        ^
4928
4929 //----------------------------------------------------------------------
4930 // Scalar Shift Left (Immediate)
4931 //----------------------------------------------------------------------
4932
4933         shl d7, d10, #99
4934
4935 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
4936 // CHECK-ERROR:        shl d7, d10, #99
4937 // CHECK-ERROR:                     ^
4938
4939         shl d7, s16, #31
4940
4941 // CHECK-ERROR: error: invalid operand for instruction
4942 // CHECK-ERROR:        shl d7, s16, #31
4943 // CHECK-ERROR:                ^
4944
4945 //----------------------------------------------------------------------
4946 // Signed Saturating Shift Left (Immediate)
4947 //----------------------------------------------------------------------
4948
4949         sqshl b11, b19, #99
4950         sqshl h13, h18, #99
4951         sqshl s14, s17, #99
4952         sqshl d15, d16, #99
4953
4954 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
4955 // CHECK-ERROR:        sqshl b11, b19, #99
4956 // CHECK-ERROR:                        ^
4957 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
4958 // CHECK-ERROR:        sqshl h13, h18, #99
4959 // CHECK-ERROR:                        ^
4960 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
4961 // CHECK-ERROR:        sqshl s14, s17, #99
4962 // CHECK-ERROR:                        ^
4963 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
4964 // CHECK-ERROR:        sqshl d15, d16, #99
4965 // CHECK-ERROR:                        ^
4966
4967 //----------------------------------------------------------------------
4968 // Unsigned Saturating Shift Left (Immediate)
4969 //----------------------------------------------------------------------
4970
4971         uqshl b18, b15, #99
4972         uqshl h11, h18, #99
4973         uqshl s14, s19, #99
4974         uqshl d15, d12, #99
4975
4976 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
4977 // CHECK-ERROR:        uqshl b18, b15, #99
4978 // CHECK-ERROR:                        ^
4979 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
4980 // CHECK-ERROR:        uqshl h11, h18, #99
4981 // CHECK-ERROR:                        ^
4982 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
4983 // CHECK-ERROR:        uqshl s14, s19, #99
4984 // CHECK-ERROR:                        ^
4985 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
4986 // CHECK-ERROR:        uqshl d15, d12, #99
4987 // CHECK-ERROR:                        ^
4988
4989 //----------------------------------------------------------------------
4990 // Signed Saturating Shift Left Unsigned (Immediate)
4991 //----------------------------------------------------------------------
4992
4993         sqshlu b15, b18, #99
4994         sqshlu h19, h17, #99
4995         sqshlu s16, s14, #99
4996         sqshlu d11, d13, #99
4997
4998 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
4999 // CHECK-ERROR:        sqshlu  b15, b18, #99
5000 // CHECK-ERROR:                          ^
5001 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
5002 // CHECK-ERROR:        sqshlu  h19, h17, #99
5003 // CHECK-ERROR:                          ^
5004 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
5005 // CHECK-ERROR:        sqshlu  s16, s14, #99
5006 // CHECK-ERROR:                          ^
5007 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
5008 // CHECK-ERROR:        sqshlu  d11, d13, #99
5009 // CHECK-ERROR:                          ^
5010
5011 //----------------------------------------------------------------------
5012 // Shift Right And Insert (Immediate)
5013 //----------------------------------------------------------------------
5014
5015         sri d10, d12, #99
5016
5017 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
5018 // CHECK-ERROR:        sri d10, d12, #99
5019 // CHECK-ERROR:                      ^
5020
5021 //----------------------------------------------------------------------
5022 // Shift Left And Insert (Immediate)
5023 //----------------------------------------------------------------------
5024
5025         sli d10, d14, #99
5026
5027 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
5028 // CHECK-ERROR:        sli d10, d14, #99
5029 // CHECK-ERROR:                      ^
5030
5031 //----------------------------------------------------------------------
5032 // Signed Saturating Shift Right Narrow (Immediate)
5033 //----------------------------------------------------------------------
5034
5035         sqshrn b10, h15, #99
5036         sqshrn h17, s10, #99
5037         sqshrn s18, d10, #99
5038
5039 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5040 // CHECK-ERROR:        sqshrn  b10, h15, #99
5041 // CHECK-ERROR:                          ^
5042 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5043 // CHECK-ERROR:        sqshrn  h17, s10, #99
5044 // CHECK-ERROR:                          ^
5045 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5046 // CHECK-ERROR:        sqshrn  s18, d10, #99
5047 // CHECK-ERROR:                          ^
5048
5049 //----------------------------------------------------------------------
5050 // Unsigned Saturating Shift Right Narrow (Immediate)
5051 //----------------------------------------------------------------------
5052
5053         uqshrn b12, h10, #99
5054         uqshrn h10, s14, #99
5055         uqshrn s10, d12, #99
5056
5057 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5058 // CHECK-ERROR:        uqshrn  b12, h10, #99
5059 // CHECK-ERROR:                          ^
5060 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5061 // CHECK-ERROR:        uqshrn  h10, s14, #99
5062 // CHECK-ERROR:                          ^
5063 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5064 // CHECK-ERROR:        uqshrn  s10, d12, #99
5065 // CHECK-ERROR:                          ^
5066
5067 //----------------------------------------------------------------------
5068 // Signed Saturating Rounded Shift Right Narrow (Immediate)
5069 //----------------------------------------------------------------------
5070
5071         sqrshrn b10, h13, #99
5072         sqrshrn h15, s10, #99
5073         sqrshrn s15, d12, #99
5074
5075 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5076 // CHECK-ERROR:        sqrshrn b10, h13, #99
5077 // CHECK-ERROR:                          ^
5078 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5079 // CHECK-ERROR:        sqrshrn h15, s10, #99
5080 // CHECK-ERROR:                          ^
5081 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5082 // CHECK-ERROR:        sqrshrn s15, d12, #99
5083 // CHECK-ERROR:                          ^
5084
5085 //----------------------------------------------------------------------
5086 // Unsigned Saturating Rounded Shift Right Narrow (Immediate)
5087 //----------------------------------------------------------------------
5088
5089         uqrshrn b10, h12, #99
5090         uqrshrn h12, s10, #99
5091         uqrshrn s10, d10, #99
5092
5093 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5094 // CHECK-ERROR:        uqrshrn b10, h12, #99
5095 // CHECK-ERROR:                          ^
5096 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5097 // CHECK-ERROR:        uqrshrn h12, s10, #99
5098 // CHECK-ERROR:                          ^
5099 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5100 // CHECK-ERROR:        uqrshrn s10, d10, #99
5101 // CHECK-ERROR:                          ^
5102
5103 //----------------------------------------------------------------------
5104 // Signed Saturating Shift Right Unsigned Narrow (Immediate)
5105 //----------------------------------------------------------------------
5106
5107         sqshrun b15, h10, #99
5108         sqshrun h20, s14, #99
5109         sqshrun s10, d15, #99
5110
5111 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5112 // CHECK-ERROR:        sqshrun b15, h10, #99
5113 // CHECK-ERROR:                          ^
5114 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5115 // CHECK-ERROR:        sqshrun h20, s14, #99
5116 // CHECK-ERROR:                          ^
5117 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5118 // CHECK-ERROR:        sqshrun s10, d15, #99
5119 // CHECK-ERROR:                          ^
5120
5121 //----------------------------------------------------------------------
5122 // Signed Saturating Rounded Shift Right Unsigned Narrow (Immediate)
5123 //----------------------------------------------------------------------
5124
5125         sqrshrun b17, h10, #99
5126         sqrshrun h10, s13, #99
5127         sqrshrun s22, d16, #99
5128
5129 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5130 // CHECK-ERROR:        sqrshrun b17, h10, #99
5131 // CHECK-ERROR:                           ^
5132 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5133 // CHECK-ERROR:        sqrshrun h10, s13, #99
5134 // CHECK-ERROR:                           ^
5135 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5136 // CHECK-ERROR:        sqrshrun s22, d16, #99
5137 // CHECK-ERROR:                           ^
5138
5139 //----------------------------------------------------------------------
5140 // Scalar Signed Fixed-point Convert To Floating-Point (Immediate)
5141 //----------------------------------------------------------------------
5142
5143     scvtf s22, s13, #0
5144     scvtf s22, s13, #33
5145     scvtf d21, d12, #65
5146     scvtf d21, s12, #31
5147
5148 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5149 // CHECK-ERROR:        scvtf s22, s13, #0
5150 // CHECK-ERROR:                        ^
5151 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5152 // CHECK-ERROR:        scvtf s22, s13, #33
5153 // CHECK-ERROR:                        ^
5154 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
5155 // CHECK-ERROR:        scvtf d21, d12, #65
5156 // CHECK-ERROR:                        ^
5157 // CHECK-ERROR: error: invalid operand for instruction
5158 // CHECK-ERROR:        scvtf d21, s12, #31
5159 // CHECK-ERROR:                   ^
5160
5161 //----------------------------------------------------------------------
5162 // Scalar Unsigned Fixed-point Convert To Floating-Point (Immediate)
5163 //----------------------------------------------------------------------
5164
5165     ucvtf s22, s13, #34
5166     ucvtf d21, d14, #65
5167     ucvtf d21, s14, #64
5168
5169 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5170 // CHECK-ERROR:        ucvtf s22, s13, #34
5171 // CHECK-ERROR:                        ^
5172 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
5173 // CHECK-ERROR:        ucvtf d21, d14, #65
5174 // CHECK-ERROR:                        ^
5175 // CHECK-ERROR: error: invalid operand for instruction
5176 // CHECK-ERROR:        ucvtf d21, s14, #64
5177 // CHECK-ERROR:                   ^
5178
5179 //------------------------------------------------------------------------------
5180 // Element reverse
5181 //------------------------------------------------------------------------------
5182          rev64 v6.2d, v8.2d
5183          rev32 v30.2s, v31.2s
5184          rev32 v30.4s, v31.4s
5185          rev32 v30.2d, v31.2d
5186          rev16 v21.4h, v1.4h
5187          rev16 v21.8h, v1.8h
5188          rev16 v21.2s, v1.2s
5189          rev16 v21.4s, v1.4s
5190          rev16 v21.2d, v1.2d
5191
5192 // CHECK-ERROR: error: invalid operand for instruction
5193 // CHECK-ERROR:         rev64 v6.2d, v8.2d
5194 // CHECK-ERROR:                  ^
5195 // CHECK-ERROR: error: invalid operand for instruction
5196 // CHECK-ERROR:         rev32 v30.2s, v31.2s
5197 // CHECK-ERROR:                   ^
5198 // CHECK-ERROR: error: invalid operand for instruction
5199 // CHECK-ERROR:         rev32 v30.4s, v31.4s
5200 // CHECK-ERROR:                   ^
5201 // CHECK-ERROR: error: invalid operand for instruction
5202 // CHECK-ERROR:         rev32 v30.2d, v31.2d
5203 // CHECK-ERROR:                   ^
5204 // CHECK-ERROR: error: invalid operand for instruction
5205 // CHECK-ERROR:         rev16 v21.4h, v1.4h
5206 // CHECK-ERROR:                   ^
5207 // CHECK-ERROR: error: invalid operand for instruction
5208 // CHECK-ERROR:         rev16 v21.8h, v1.8h
5209 // CHECK-ERROR:                   ^
5210 // CHECK-ERROR: error: invalid operand for instruction
5211 // CHECK-ERROR:         rev16 v21.2s, v1.2s
5212 // CHECK-ERROR:                   ^
5213 // CHECK-ERROR: error: invalid operand for instruction
5214 // CHECK-ERROR:         rev16 v21.4s, v1.4s
5215 // CHECK-ERROR:                   ^
5216 // CHECK-ERROR: error: invalid operand for instruction
5217 // CHECK-ERROR:         rev16 v21.2d, v1.2d
5218 // CHECK-ERROR:                   ^
5219
5220 //------------------------------------------------------------------------------
5221 // Signed integer pairwise add long
5222 //------------------------------------------------------------------------------
5223
5224          saddlp v3.8h, v21.8h
5225          saddlp v8.8b, v5.8b
5226          saddlp v9.8h, v1.4s
5227          saddlp v0.4s, v1.2d
5228
5229 // CHECK-ERROR: error: invalid operand for instruction
5230 // CHECK-ERROR:         saddlp v3.8h, v21.8h
5231 // CHECK-ERROR:                           ^
5232 // CHECK-ERROR: error: invalid operand for instruction
5233 // CHECK-ERROR:         saddlp v8.8b, v5.8b
5234 // CHECK-ERROR:                   ^
5235 // CHECK-ERROR: error: invalid operand for instruction
5236 // CHECK-ERROR:         saddlp v9.8h, v1.4s
5237 // CHECK-ERROR:                          ^
5238 // CHECK-ERROR: error: invalid operand for instruction
5239 // CHECK-ERROR:         saddlp v0.4s, v1.2d
5240 // CHECK-ERROR:                          ^
5241
5242 //------------------------------------------------------------------------------
5243 // Unsigned integer pairwise add long
5244 //------------------------------------------------------------------------------
5245
5246          uaddlp v3.8h, v21.8h
5247          uaddlp v8.8b, v5.8b
5248          uaddlp v9.8h, v1.4s
5249          uaddlp v0.4s, v1.2d
5250
5251 // CHECK-ERROR: error: invalid operand for instruction
5252 // CHECK-ERROR:         uaddlp v3.8h, v21.8h
5253 // CHECK-ERROR:                           ^
5254 // CHECK-ERROR: error: invalid operand for instruction
5255 // CHECK-ERROR:         uaddlp v8.8b, v5.8b
5256 // CHECK-ERROR:                   ^
5257 // CHECK-ERROR: error: invalid operand for instruction
5258 // CHECK-ERROR:         uaddlp v9.8h, v1.4s
5259 // CHECK-ERROR:                          ^
5260 // CHECK-ERROR: error: invalid operand for instruction
5261 // CHECK-ERROR:         uaddlp v0.4s, v1.2d
5262 // CHECK-ERROR:                          ^
5263
5264 //------------------------------------------------------------------------------
5265 // Signed integer pairwise add and accumulate long
5266 //------------------------------------------------------------------------------
5267
5268          sadalp v3.16b, v21.16b
5269          sadalp v8.4h, v5.4h
5270          sadalp v9.4s, v1.4s
5271          sadalp v0.4h, v1.2s
5272          sadalp v12.2d, v4.8h
5273
5274 // CHECK-ERROR: error: invalid operand for instruction
5275 // CHECK-ERROR:         sadalp v3.16b, v21.16b
5276 // CHECK-ERROR:                   ^
5277 // CHECK-ERROR: error: invalid operand for instruction
5278 // CHECK-ERROR:         sadalp v8.4h, v5.4h
5279 // CHECK-ERROR:                          ^
5280 // CHECK-ERROR: error: invalid operand for instruction
5281 // CHECK-ERROR:         sadalp v9.4s, v1.4s
5282 // CHECK-ERROR:                          ^
5283 // CHECK-ERROR: error: invalid operand for instruction
5284 // CHECK-ERROR:         sadalp v0.4h, v1.2s
5285 // CHECK-ERROR:                          ^
5286 // CHECK-ERROR: error: invalid operand for instruction
5287 // CHECK-ERROR:         sadalp v12.2d, v4.8h
5288 // CHECK-ERROR:                           ^
5289
5290 //------------------------------------------------------------------------------
5291 // Unsigned integer pairwise add and accumulate long
5292 //------------------------------------------------------------------------------
5293
5294          uadalp v3.16b, v21.16b
5295          uadalp v8.4h, v5.4h
5296          uadalp v9.4s, v1.4s
5297          uadalp v0.4h, v1.2s
5298          uadalp v12.2d, v4.8h
5299
5300 // CHECK-ERROR: error: invalid operand for instruction
5301 // CHECK-ERROR:         uadalp v3.16b, v21.16b
5302 // CHECK-ERROR:                   ^
5303 // CHECK-ERROR: error: invalid operand for instruction
5304 // CHECK-ERROR:         uadalp v8.4h, v5.4h
5305 // CHECK-ERROR:                          ^
5306 // CHECK-ERROR: error: invalid operand for instruction
5307 // CHECK-ERROR:         uadalp v9.4s, v1.4s
5308 // CHECK-ERROR:                          ^
5309 // CHECK-ERROR: error: invalid operand for instruction
5310 // CHECK-ERROR:         uadalp v0.4h, v1.2s
5311 // CHECK-ERROR:                          ^
5312 // CHECK-ERROR: error: invalid operand for instruction
5313 // CHECK-ERROR:         uadalp v12.2d, v4.8h
5314 // CHECK-ERROR:                           ^
5315
5316 //------------------------------------------------------------------------------
5317 // Signed integer saturating accumulate of unsigned value
5318 //------------------------------------------------------------------------------
5319
5320          suqadd v0.16b, v31.8b
5321          suqadd v1.8b, v9.8h
5322          suqadd v13.4h, v21.4s
5323          suqadd v4.2s, v0.2d
5324
5325 // CHECK-ERROR: error: invalid operand for instruction
5326 // CHECK-ERROR:         suqadd v0.16b, v31.8b
5327 // CHECK-ERROR:                        ^
5328 // CHECK-ERROR: error: invalid operand for instruction
5329 // CHECK-ERROR:         suqadd v1.8b, v9.8h
5330 // CHECK-ERROR:                       ^
5331 // CHECK-ERROR: error: invalid operand for instruction
5332 // CHECK-ERROR:         suqadd v13.4h, v21.4s
5333 // CHECK-ERROR:                        ^
5334 // CHECK-ERROR: error: invalid operand for instruction
5335 // CHECK-ERROR:         suqadd v4.2s, v0.2d
5336 // CHECK-ERROR:                       ^
5337
5338 //------------------------------------------------------------------------------
5339 // Unsigned integer saturating accumulate of signed value
5340 //------------------------------------------------------------------------------
5341
5342          usqadd v0.16b, v31.8b
5343          usqadd v2.8h, v4.4h
5344          usqadd v13.4h, v21.4s
5345          usqadd v4.2s, v0.2d
5346
5347 // CHECK-ERROR: error: invalid operand for instruction
5348 // CHECK-ERROR:         usqadd v0.16b, v31.8b
5349 // CHECK-ERROR:                        ^
5350 // CHECK-ERROR: error: invalid operand for instruction
5351 // CHECK-ERROR:         usqadd v2.8h, v4.4h
5352 // CHECK-ERROR:                       ^
5353 // CHECK-ERROR: error: invalid operand for instruction
5354 // CHECK-ERROR:         usqadd v13.4h, v21.4s
5355 // CHECK-ERROR:                        ^
5356 // CHECK-ERROR: error: invalid operand for instruction
5357 // CHECK-ERROR:         usqadd v4.2s, v0.2d
5358 // CHECK-ERROR:                       ^
5359
5360 //------------------------------------------------------------------------------
5361 // Integer saturating absolute
5362 //------------------------------------------------------------------------------
5363
5364          sqabs v0.16b, v31.8b
5365          sqabs v2.8h, v4.4h
5366          sqabs v6.4s, v8.2s
5367          sqabs v6.2d, v8.2s
5368
5369 // CHECK-ERROR: error: invalid operand for instruction
5370 // CHECK-ERROR:         sqabs v0.16b, v31.8b
5371 // CHECK-ERROR:                       ^
5372 // CHECK-ERROR: error: invalid operand for instruction
5373 // CHECK-ERROR:         sqabs v2.8h, v4.4h
5374 // CHECK-ERROR:                      ^
5375 // CHECK-ERROR: error: invalid operand for instruction
5376 // CHECK-ERROR:         sqabs v6.4s, v8.2s
5377 // CHECK-ERROR:                      ^
5378 // CHECK-ERROR: error: invalid operand for instruction
5379 // CHECK-ERROR:         sqabs v6.2d, v8.2s
5380 // CHECK-ERROR:                      ^
5381
5382 //------------------------------------------------------------------------------
5383 // Signed integer saturating negate
5384 //------------------------------------------------------------------------------
5385
5386          sqneg v0.16b, v31.8b
5387          sqneg v2.8h, v4.4h
5388          sqneg v6.4s, v8.2s
5389          sqneg v6.2d, v8.2s
5390
5391 // CHECK-ERROR: error: invalid operand for instruction
5392 // CHECK-ERROR:         sqneg v0.16b, v31.8b
5393 // CHECK-ERROR:                       ^
5394 // CHECK-ERROR: error: invalid operand for instruction
5395 // CHECK-ERROR:         sqneg v2.8h, v4.4h
5396 // CHECK-ERROR:                      ^
5397 // CHECK-ERROR: error: invalid operand for instruction
5398 // CHECK-ERROR:         sqneg v6.4s, v8.2s
5399 // CHECK-ERROR:                      ^
5400 // CHECK-ERROR: error: invalid operand for instruction
5401 // CHECK-ERROR:         sqneg v6.2d, v8.2s
5402 // CHECK-ERROR:                      ^
5403
5404 //------------------------------------------------------------------------------
5405 // Integer absolute
5406 //------------------------------------------------------------------------------
5407
5408          abs v0.16b, v31.8b
5409          abs v2.8h, v4.4h
5410          abs v6.4s, v8.2s
5411          abs v6.2d, v8.2s
5412
5413 // CHECK-ERROR: error: invalid operand for instruction
5414 // CHECK-ERROR:         abs v0.16b, v31.8b
5415 // CHECK-ERROR:                     ^
5416 // CHECK-ERROR: error: invalid operand for instruction
5417 // CHECK-ERROR:         abs v2.8h, v4.4h
5418 // CHECK-ERROR:                    ^
5419 // CHECK-ERROR: error: invalid operand for instruction
5420 // CHECK-ERROR:         abs v6.4s, v8.2s
5421 // CHECK-ERROR:                    ^
5422 // CHECK-ERROR: error: invalid operand for instruction
5423 // CHECK-ERROR:         abs v6.2d, v8.2s
5424 // CHECK-ERROR:                    ^
5425
5426 //------------------------------------------------------------------------------
5427 // Integer count leading sign bits
5428 //------------------------------------------------------------------------------
5429
5430          cls v0.2d, v31.2d
5431
5432 // CHECK-ERROR: error: invalid operand for instruction
5433 // CHECK-ERROR:         cls v0.2d, v31.2d
5434 // CHECK-ERROR:                ^
5435
5436 //------------------------------------------------------------------------------
5437 // Integer count leading zeros
5438 //------------------------------------------------------------------------------
5439
5440          clz v0.2d, v31.2d
5441
5442 // CHECK-ERROR: error: invalid operand for instruction
5443 // CHECK-ERROR:         clz v0.2d, v31.2d
5444 // CHECK-ERROR:                ^
5445
5446 //------------------------------------------------------------------------------
5447 // Population count
5448 //------------------------------------------------------------------------------
5449
5450          cnt v2.8h, v4.8h
5451          cnt v6.4s, v8.4s
5452          cnt v6.2d, v8.2d
5453          cnt v13.4h, v21.4h
5454          cnt v4.2s, v0.2s
5455
5456 // CHECK-ERROR: error: invalid operand for instruction
5457 // CHECK-ERROR:         cnt v2.8h, v4.8h
5458 // CHECK-ERROR:                ^
5459 // CHECK-ERROR: error: invalid operand for instruction
5460 // CHECK-ERROR:         cnt v6.4s, v8.4s
5461 // CHECK-ERROR:                ^
5462 // CHECK-ERROR: error: invalid operand for instruction
5463 // CHECK-ERROR:         cnt v6.2d, v8.2d
5464 // CHECK-ERROR:                ^
5465 // CHECK-ERROR: error: invalid operand for instruction
5466 // CHECK-ERROR:         cnt v13.4h, v21.4h
5467 // CHECK-ERROR:                 ^
5468 // CHECK-ERROR: error: invalid operand for instruction
5469 // CHECK-ERROR:         cnt v4.2s, v0.2s
5470 // CHECK-ERROR:                ^
5471
5472
5473 //------------------------------------------------------------------------------
5474 // Bitwise NOT
5475 //------------------------------------------------------------------------------
5476
5477          not v2.8h, v4.8h
5478          not v6.4s, v8.4s
5479          not v6.2d, v8.2d
5480          not v13.4h, v21.4h
5481          not v4.2s, v0.2s
5482
5483 // CHECK-ERROR: error: invalid operand for instruction
5484 // CHECK-ERROR:         not v2.8h, v4.8h
5485 // CHECK-ERROR:                ^
5486 // CHECK-ERROR: error: invalid operand for instruction
5487 // CHECK-ERROR:         not v6.4s, v8.4s
5488 // CHECK-ERROR:                ^
5489 // CHECK-ERROR: error: invalid operand for instruction
5490 // CHECK-ERROR:         not v6.2d, v8.2d
5491 // CHECK-ERROR:                ^
5492 // CHECK-ERROR: error: invalid operand for instruction
5493 // CHECK-ERROR:         not v13.4h, v21.4h
5494 // CHECK-ERROR:                 ^
5495 // CHECK-ERROR: error: invalid operand for instruction
5496 // CHECK-ERROR:         not v4.2s, v0.2s
5497 // CHECK-ERROR:                ^
5498
5499 //------------------------------------------------------------------------------
5500 // Bitwise reverse
5501 //------------------------------------------------------------------------------
5502
5503          rbit v2.8h, v4.8h
5504          rbit v6.4s, v8.4s
5505          rbit v6.2d, v8.2d
5506          rbit v13.4h, v21.4h
5507          rbit v4.2s, v0.2s
5508
5509 // CHECK-ERROR: error: invalid operand for instruction
5510 // CHECK-ERROR:         rbit v2.8h, v4.8h
5511 // CHECK-ERROR:                 ^
5512 // CHECK-ERROR: error: invalid operand for instruction
5513 // CHECK-ERROR:         rbit v6.4s, v8.4s
5514 // CHECK-ERROR:                 ^
5515 // CHECK-ERROR: error: invalid operand for instruction
5516 // CHECK-ERROR:         rbit v6.2d, v8.2d
5517 // CHECK-ERROR:                 ^
5518 // CHECK-ERROR: error: invalid operand for instruction
5519 // CHECK-ERROR:         rbit v13.4h, v21.4h
5520 // CHECK-ERROR:                  ^
5521 // CHECK-ERROR: error: invalid operand for instruction
5522 // CHECK-ERROR:         rbit v4.2s, v0.2s
5523 // CHECK-ERROR:                 ^
5524
5525 //------------------------------------------------------------------------------
5526 // Floating-point absolute
5527 //------------------------------------------------------------------------------
5528
5529          fabs v0.16b, v31.16b
5530          fabs v2.8h, v4.8h
5531          fabs v1.8b, v9.8b
5532          fabs v13.4h, v21.4h
5533
5534 // CHECK-ERROR: error: invalid operand for instruction
5535 // CHECK-ERROR:         fabs v0.16b, v31.16b
5536 // CHECK-ERROR:                 ^
5537 // CHECK-ERROR: error: instruction requires: fullfp16
5538 // CHECK-ERROR:         fabs v2.8h, v4.8h
5539 // CHECK-ERROR:                 ^
5540 // CHECK-ERROR: error: invalid operand for instruction
5541 // CHECK-ERROR:         fabs v1.8b, v9.8b
5542 // CHECK-ERROR:                 ^
5543 // CHECK-ERROR: error: instruction requires: fullfp16
5544 // CHECK-ERROR:         fabs v13.4h, v21.4h
5545 // CHECK-ERROR:                  ^
5546
5547 //------------------------------------------------------------------------------
5548 // Floating-point negate
5549 //------------------------------------------------------------------------------
5550
5551          fneg v0.16b, v31.16b
5552          fneg v2.8h, v4.8h
5553          fneg v1.8b, v9.8b
5554          fneg v13.4h, v21.4h
5555
5556 // CHECK-ERROR: error: invalid operand for instruction
5557 // CHECK-ERROR:         fneg v0.16b, v31.16b
5558 // CHECK-ERROR:                 ^
5559 // CHECK-ERROR: error: instruction requires: fullfp16
5560 // CHECK-ERROR:         fneg v2.8h, v4.8h
5561 // CHECK-ERROR:                 ^
5562 // CHECK-ERROR: error: invalid operand for instruction
5563 // CHECK-ERROR:         fneg v1.8b, v9.8b
5564 // CHECK-ERROR:                 ^
5565 // CHECK-ERROR: error: instruction requires: fullfp16
5566 // CHECK-ERROR:         fneg v13.4h, v21.4h
5567 // CHECK-ERROR:                  ^
5568
5569 //------------------------------------------------------------------------------
5570 // Integer extract and narrow
5571 //------------------------------------------------------------------------------
5572
5573          xtn v0.16b, v31.8h
5574          xtn v2.8h, v4.4s
5575          xtn v6.4s, v8.2d
5576          xtn2 v1.8b, v9.8h
5577          xtn2 v13.4h, v21.4s
5578          xtn2 v4.2s, v0.2d
5579
5580 // CHECK-ERROR: error: invalid operand for instruction
5581 // CHECK-ERROR:         xtn v0.16b, v31.8h
5582 // CHECK-ERROR:             ^
5583 // CHECK-ERROR: error: invalid operand for instruction
5584 // CHECK-ERROR:         xtn v2.8h, v4.4s
5585 // CHECK-ERROR:             ^
5586 // CHECK-ERROR: error: invalid operand for instruction
5587 // CHECK-ERROR:         xtn v6.4s, v8.2d
5588 // CHECK-ERROR:             ^
5589 // CHECK-ERROR: error: invalid operand for instruction
5590 // CHECK-ERROR:         xtn2 v1.8b, v9.8h
5591 // CHECK-ERROR:              ^
5592 // CHECK-ERROR: error: invalid operand for instruction
5593 // CHECK-ERROR:         xtn2 v13.4h, v21.4s
5594 // CHECK-ERROR:              ^
5595 // CHECK-ERROR: error: invalid operand for instruction
5596 // CHECK-ERROR:         xtn2 v4.2s, v0.2d
5597 // CHECK-ERROR:              ^
5598
5599 //------------------------------------------------------------------------------
5600 // Signed integer saturating extract and unsigned narrow
5601 //------------------------------------------------------------------------------
5602
5603          sqxtun v0.16b, v31.8h
5604          sqxtun v2.8h, v4.4s
5605          sqxtun v6.4s, v8.2d
5606          sqxtun2 v1.8b, v9.8h
5607          sqxtun2 v13.4h, v21.4s
5608          sqxtun2 v4.2s, v0.2d
5609
5610 // CHECK-ERROR: error: invalid operand for instruction
5611 // CHECK-ERROR:         sqxtun v0.16b, v31.8h
5612 // CHECK-ERROR:                ^
5613 // CHECK-ERROR: error: invalid operand for instruction
5614 // CHECK-ERROR:         sqxtun v2.8h, v4.4s
5615 // CHECK-ERROR:                ^
5616 // CHECK-ERROR: error: invalid operand for instruction
5617 // CHECK-ERROR:         sqxtun v6.4s, v8.2d
5618 // CHECK-ERROR:                ^
5619 // CHECK-ERROR: error: invalid operand for instruction
5620 // CHECK-ERROR:         sqxtun2 v1.8b, v9.8h
5621 // CHECK-ERROR:                 ^
5622 // CHECK-ERROR: error: invalid operand for instruction
5623 // CHECK-ERROR:         sqxtun2 v13.4h, v21.4s
5624 // CHECK-ERROR:                 ^
5625 // CHECK-ERROR: error: invalid operand for instruction
5626 // CHECK-ERROR:         sqxtun2 v4.2s, v0.2d
5627 // CHECK-ERROR:                 ^
5628
5629 //------------------------------------------------------------------------------
5630 // Signed integer saturating extract and narrow
5631 //------------------------------------------------------------------------------
5632
5633          sqxtn v0.16b, v31.8h
5634          sqxtn v2.8h, v4.4s
5635          sqxtn v6.4s, v8.2d
5636          sqxtn2 v1.8b, v9.8h
5637          sqxtn2 v13.4h, v21.4s
5638          sqxtn2 v4.2s, v0.2d
5639
5640 // CHECK-ERROR: error: invalid operand for instruction
5641 // CHECK-ERROR:         sqxtn v0.16b, v31.8h
5642 // CHECK-ERROR:               ^
5643 // CHECK-ERROR: error: invalid operand for instruction
5644 // CHECK-ERROR:         sqxtn v2.8h, v4.4s
5645 // CHECK-ERROR:               ^
5646 // CHECK-ERROR: error: invalid operand for instruction
5647 // CHECK-ERROR:         sqxtn v6.4s, v8.2d
5648 // CHECK-ERROR:               ^
5649 // CHECK-ERROR: error: invalid operand for instruction
5650 // CHECK-ERROR:         sqxtn2 v1.8b, v9.8h
5651 // CHECK-ERROR:                ^
5652 // CHECK-ERROR: error: invalid operand for instruction
5653 // CHECK-ERROR:         sqxtn2 v13.4h, v21.4s
5654 // CHECK-ERROR:                ^
5655 // CHECK-ERROR: error: invalid operand for instruction
5656 // CHECK-ERROR:         sqxtn2 v4.2s, v0.2d
5657 // CHECK-ERROR:                ^
5658
5659 //------------------------------------------------------------------------------
5660 // Unsigned integer saturating extract and narrow
5661 //------------------------------------------------------------------------------
5662
5663          uqxtn v0.16b, v31.8h
5664          uqxtn v2.8h, v4.4s
5665          uqxtn v6.4s, v8.2d
5666          uqxtn2 v1.8b, v9.8h
5667          uqxtn2 v13.4h, v21.4s
5668          uqxtn2 v4.2s, v0.2d
5669
5670 // CHECK-ERROR: error: invalid operand for instruction
5671 // CHECK-ERROR:         uqxtn v0.16b, v31.8h
5672 // CHECK-ERROR:               ^
5673 // CHECK-ERROR: error: invalid operand for instruction
5674 // CHECK-ERROR:         uqxtn v2.8h, v4.4s
5675 // CHECK-ERROR:               ^
5676 // CHECK-ERROR: error: invalid operand for instruction
5677 // CHECK-ERROR:         uqxtn v6.4s, v8.2d
5678 // CHECK-ERROR:               ^
5679 // CHECK-ERROR: error: invalid operand for instruction
5680 // CHECK-ERROR:         uqxtn2 v1.8b, v9.8h
5681 // CHECK-ERROR:                ^
5682 // CHECK-ERROR: error: invalid operand for instruction
5683 // CHECK-ERROR:         uqxtn2 v13.4h, v21.4s
5684 // CHECK-ERROR:                ^
5685 // CHECK-ERROR: error: invalid operand for instruction
5686 // CHECK-ERROR:         uqxtn2 v4.2s, v0.2d
5687 // CHECK-ERROR:                ^
5688
5689 //------------------------------------------------------------------------------
5690 // Integer shift left long
5691 //------------------------------------------------------------------------------
5692
5693          shll2 v2.8h, v4.16b, #7
5694          shll2 v6.4s, v8.8h, #15
5695          shll2 v6.2d, v8.4s, #31
5696          shll v2.8h, v4.16b, #8
5697          shll v6.4s, v8.8h, #16
5698          shll v6.2d, v8.4s, #32
5699          shll v2.8h, v4.8b, #8
5700          shll v6.4s, v8.4h, #16
5701          shll v6.2d, v8.2s, #32
5702          shll2 v2.8h, v4.8b, #5
5703          shll2 v6.4s, v8.4h, #14
5704          shll2 v6.2d, v8.2s, #1
5705
5706 // CHECK-ERROR: error: invalid operand for instruction
5707 // CHECK-ERROR:         shll2 v2.8h, v4.16b, #7
5708 // CHECK-ERROR:                              ^
5709 // CHECK-ERROR: error: invalid operand for instruction
5710 // CHECK-ERROR:         shll2 v6.4s, v8.8h, #15
5711 // CHECK-ERROR:                             ^
5712 // CHECK-ERROR: error: invalid operand for instruction
5713 // CHECK-ERROR:         shll2 v6.2d, v8.4s, #31
5714 // CHECK-ERROR:                             ^
5715 // CHECK-ERROR: error: invalid operand for instruction
5716 // CHECK-ERROR:         shll v2.8h, v4.16b, #8
5717 // CHECK-ERROR:                     ^
5718 // CHECK-ERROR: error: invalid operand for instruction
5719 // CHECK-ERROR:         shll v6.4s, v8.8h, #16
5720 // CHECK-ERROR:                     ^
5721 // CHECK-ERROR: error: invalid operand for instruction
5722 // CHECK-ERROR:         shll v6.2d, v8.4s, #32
5723 // CHECK-ERROR:                     ^
5724 // CHECK-ERROR: error: invalid operand for instruction
5725 // CHECK-ERROR:         shll2 v2.8h, v4.8b, #5
5726 // CHECK-ERROR:                      ^
5727 // CHECK-ERROR: error: invalid operand for instruction
5728 // CHECK-ERROR:         shll2 v6.4s, v8.4h, #14
5729 // CHECK-ERROR:                      ^
5730 // CHECK-ERROR: error: invalid operand for instruction
5731 // CHECK-ERROR:         shll2 v6.2d, v8.2s, #1
5732 // CHECK-ERROR:                      ^
5733
5734 //------------------------------------------------------------------------------
5735 // Floating-point convert downsize
5736 //------------------------------------------------------------------------------
5737
5738          fcvtn v2.8h, v4.4s
5739          fcvtn v6.4s, v8.2d
5740          fcvtn2 v13.4h, v21.4s
5741          fcvtn2 v4.2s, v0.2d
5742
5743 // CHECK-ERROR: error: invalid operand for instruction
5744 // CHECK-ERROR:         fcvtn v2.8h, v4.4s
5745 // CHECK-ERROR:               ^
5746 // CHECK-ERROR: error: invalid operand for instruction
5747 // CHECK-ERROR:         fcvtn v6.4s, v8.2d
5748 // CHECK-ERROR:               ^
5749 // CHECK-ERROR: error: invalid operand for instruction
5750 // CHECK-ERROR:         fcvtn2 v13.4h, v21.4s
5751 // CHECK-ERROR:                ^
5752 // CHECK-ERROR: error: invalid operand for instruction
5753 // CHECK-ERROR:         fcvtn2 v4.2s, v0.2d
5754 // CHECK-ERROR:                ^
5755
5756 //------------------------------------------------------------------------------
5757 // Floating-point convert downsize with inexact
5758 //------------------------------------------------------------------------------
5759
5760          fcvtxn v6.4s, v8.2d
5761          fcvtxn2 v4.2s, v0.2d
5762
5763 // CHECK-ERROR: error: invalid operand for instruction
5764 // CHECK-ERROR:         fcvtxn v6.4s, v8.2d
5765 // CHECK-ERROR:                ^
5766 // CHECK-ERROR: error: invalid operand for instruction
5767 // CHECK-ERROR:         fcvtxn2 v4.2s, v0.2d
5768 // CHECK-ERROR:                 ^
5769
5770 //------------------------------------------------------------------------------
5771 // Floating-point convert upsize
5772 //------------------------------------------------------------------------------
5773
5774          fcvtl2 v9.4s, v1.4h
5775          fcvtl2 v0.2d, v1.2s
5776          fcvtl v12.4s, v4.8h
5777          fcvtl v17.2d, v28.4s
5778
5779 // CHECK-ERROR: error: invalid operand for instruction
5780 // CHECK-ERROR:         fcvtl2 v9.4s, v1.4h
5781 // CHECK-ERROR:                       ^
5782 // CHECK-ERROR: error: invalid operand for instruction
5783 // CHECK-ERROR:         fcvtl2 v0.2d, v1.2s
5784 // CHECK-ERROR:                       ^
5785 // CHECK-ERROR: error: invalid operand for instruction
5786 // CHECK-ERROR:         fcvtl v12.4s, v4.8h
5787 // CHECK-ERROR:                       ^
5788 // CHECK-ERROR: error: invalid operand for instruction
5789 // CHECK-ERROR:         fcvtl v17.2d, v28.4s
5790 // CHECK-ERROR:                       ^
5791
5792 //------------------------------------------------------------------------------
5793 // Floating-point round to integral
5794 //------------------------------------------------------------------------------
5795
5796          frintn v0.16b, v31.16b
5797          frintn v2.8h, v4.8h
5798          frintn v1.8b, v9.8b
5799          frintn v13.4h, v21.4h
5800
5801          frinta v0.16b, v31.16b
5802          frinta v2.8h, v4.8h
5803          frinta v1.8b, v9.8b
5804          frinta v13.4h, v21.4h
5805
5806          frintp v0.16b, v31.16b
5807          frintp v2.8h, v4.8h
5808          frintp v1.8b, v9.8b
5809          frintp v13.4h, v21.4h
5810
5811          frintm v0.16b, v31.16b
5812          frintm v2.8h, v4.8h
5813          frintm v1.8b, v9.8b
5814          frintm v13.4h, v21.4h
5815
5816          frintx v0.16b, v31.16b
5817          frintx v2.8h, v4.8h
5818          frintx v1.8b, v9.8b
5819          frintx v13.4h, v21.4h
5820
5821          frintz v0.16b, v31.16b
5822          frintz v2.8h, v4.8h
5823          frintz v1.8b, v9.8b
5824          frintz v13.4h, v21.4h
5825
5826          frinti v0.16b, v31.16b
5827          frinti v2.8h, v4.8h
5828          frinti v1.8b, v9.8b
5829          frinti v13.4h, v21.4h
5830
5831          fcvtns v0.16b, v31.16b
5832          fcvtns v2.8h, v4.8h
5833          fcvtns v1.8b, v9.8b
5834          fcvtns v13.4h, v21.4h
5835
5836          fcvtnu v0.16b, v31.16b
5837          fcvtnu v2.8h, v4.8h
5838          fcvtnu v1.8b, v9.8b
5839          fcvtnu v13.4h, v21.4h
5840
5841          fcvtps v0.16b, v31.16b
5842          fcvtps v2.8h, v4.8h
5843          fcvtps v1.8b, v9.8b
5844          fcvtps v13.4h, v21.4h
5845
5846          fcvtpu v0.16b, v31.16b
5847          fcvtpu v2.8h, v4.8h
5848          fcvtpu v1.8b, v9.8b
5849          fcvtpu v13.4h, v21.4h
5850
5851          fcvtms v0.16b, v31.16b
5852          fcvtms v2.8h, v4.8h
5853          fcvtms v1.8b, v9.8b
5854          fcvtms v13.4h, v21.4h
5855
5856          fcvtmu v0.16b, v31.16b
5857          fcvtmu v2.8h, v4.8h
5858          fcvtmu v1.8b, v9.8b
5859          fcvtmu v13.4h, v21.4h
5860
5861          fcvtzs v0.16b, v31.16b
5862          fcvtzs v2.8h, v4.8h
5863          fcvtzs v1.8b, v9.8b
5864          fcvtzs v13.4h, v21.4h
5865
5866          fcvtzu v0.16b, v31.16b
5867          fcvtzu v2.8h, v4.8h
5868          fcvtzu v1.8b, v9.8b
5869          fcvtzu v13.4h, v21.4h
5870
5871          fcvtas v0.16b, v31.16b
5872          fcvtas v2.8h, v4.8h
5873          fcvtas v1.8b, v9.8b
5874          fcvtas v13.4h, v21.4h
5875
5876          fcvtau v0.16b, v31.16b
5877          fcvtau v2.8h, v4.8h
5878          fcvtau v1.8b, v9.8b
5879          fcvtau v13.4h, v21.4h
5880
5881          urecpe v0.16b, v31.16b
5882          urecpe v2.8h, v4.8h
5883          urecpe v1.8b, v9.8b
5884          urecpe v13.4h, v21.4h
5885          urecpe v1.2d, v9.2d
5886
5887          ursqrte v0.16b, v31.16b
5888          ursqrte v2.8h, v4.8h
5889          ursqrte v1.8b, v9.8b
5890          ursqrte v13.4h, v21.4h
5891          ursqrte v1.2d, v9.2d
5892
5893          scvtf v0.16b, v31.16b
5894          scvtf v2.8h, v4.8h
5895          scvtf v1.8b, v9.8b
5896          scvtf v13.4h, v21.4h
5897
5898          ucvtf v0.16b, v31.16b
5899          ucvtf v2.8h, v4.8h
5900          ucvtf v1.8b, v9.8b
5901          ucvtf v13.4h, v21.4h
5902
5903          frecpe v0.16b, v31.16b
5904          frecpe v2.8h, v4.8h
5905          frecpe v1.8b, v9.8b
5906          frecpe v13.4h, v21.4h
5907
5908          frsqrte v0.16b, v31.16b
5909          frsqrte v2.8h, v4.8h
5910          frsqrte v1.8b, v9.8b
5911          frsqrte v13.4h, v21.4h
5912
5913          fsqrt v0.16b, v31.16b
5914          fsqrt v2.8h, v4.8h
5915          fsqrt v1.8b, v9.8b
5916          fsqrt v13.4h, v21.4h
5917
5918 // CHECK-ERROR: error: invalid operand for instruction
5919 // CHECK-ERROR:         frintn v0.16b, v31.16b
5920 // CHECK-ERROR:                   ^
5921 // CHECK-ERROR: error: instruction requires: fullfp16
5922 // CHECK-ERROR:         frintn v2.8h, v4.8h
5923 // CHECK-ERROR:                   ^
5924 // CHECK-ERROR: error: invalid operand for instruction
5925 // CHECK-ERROR:         frintn v1.8b, v9.8b
5926 // CHECK-ERROR:                   ^
5927 // CHECK-ERROR: error: instruction requires: fullfp16
5928 // CHECK-ERROR:         frintn v13.4h, v21.4h
5929 // CHECK-ERROR:                    ^
5930 // CHECK-ERROR: error: invalid operand for instruction
5931 // CHECK-ERROR:         frinta v0.16b, v31.16b
5932 // CHECK-ERROR:                   ^
5933 // CHECK-ERROR: error: instruction requires: fullfp16
5934 // CHECK-ERROR:         frinta v2.8h, v4.8h
5935 // CHECK-ERROR:                   ^
5936 // CHECK-ERROR: error: invalid operand for instruction
5937 // CHECK-ERROR:         frinta v1.8b, v9.8b
5938 // CHECK-ERROR:                   ^
5939 // CHECK-ERROR: error: instruction requires: fullfp16
5940 // CHECK-ERROR:         frinta v13.4h, v21.4h
5941 // CHECK-ERROR:                    ^
5942 // CHECK-ERROR: error: invalid operand for instruction
5943 // CHECK-ERROR:         frintp v0.16b, v31.16b
5944 // CHECK-ERROR:                   ^
5945 // CHECK-ERROR: error: instruction requires: fullfp16
5946 // CHECK-ERROR:         frintp v2.8h, v4.8h
5947 // CHECK-ERROR:                   ^
5948 // CHECK-ERROR: error: invalid operand for instruction
5949 // CHECK-ERROR:         frintp v1.8b, v9.8b
5950 // CHECK-ERROR:                   ^
5951 // CHECK-ERROR: error: instruction requires: fullfp16
5952 // CHECK-ERROR:         frintp v13.4h, v21.4h
5953 // CHECK-ERROR:                    ^
5954 // CHECK-ERROR: error: invalid operand for instruction
5955 // CHECK-ERROR:         frintm v0.16b, v31.16b
5956 // CHECK-ERROR:                   ^
5957 // CHECK-ERROR: error: instruction requires: fullfp16
5958 // CHECK-ERROR:         frintm v2.8h, v4.8h
5959 // CHECK-ERROR:                   ^
5960 // CHECK-ERROR: error: invalid operand for instruction
5961 // CHECK-ERROR:         frintm v1.8b, v9.8b
5962 // CHECK-ERROR:                   ^
5963 // CHECK-ERROR: error: instruction requires: fullfp16
5964 // CHECK-ERROR:         frintm v13.4h, v21.4h
5965 // CHECK-ERROR:                    ^
5966 // CHECK-ERROR: error: invalid operand for instruction
5967 // CHECK-ERROR:         frintx v0.16b, v31.16b
5968 // CHECK-ERROR:                   ^
5969 // CHECK-ERROR: error: instruction requires: fullfp16
5970 // CHECK-ERROR:         frintx v2.8h, v4.8h
5971 // CHECK-ERROR:                   ^
5972 // CHECK-ERROR: error: invalid operand for instruction
5973 // CHECK-ERROR:         frintx v1.8b, v9.8b
5974 // CHECK-ERROR:                   ^
5975 // CHECK-ERROR: error: instruction requires: fullfp16
5976 // CHECK-ERROR:         frintx v13.4h, v21.4h
5977 // CHECK-ERROR:                    ^
5978 // CHECK-ERROR: error: invalid operand for instruction
5979 // CHECK-ERROR:         frintz v0.16b, v31.16b
5980 // CHECK-ERROR:                   ^
5981 // CHECK-ERROR: error: instruction requires: fullfp16
5982 // CHECK-ERROR:         frintz v2.8h, v4.8h
5983 // CHECK-ERROR:                   ^
5984 // CHECK-ERROR: error: invalid operand for instruction
5985 // CHECK-ERROR:         frintz v1.8b, v9.8b
5986 // CHECK-ERROR:                   ^
5987 // CHECK-ERROR: error: instruction requires: fullfp16
5988 // CHECK-ERROR:         frintz v13.4h, v21.4h
5989 // CHECK-ERROR:                    ^
5990 // CHECK-ERROR: error: invalid operand for instruction
5991 // CHECK-ERROR:         frinti v0.16b, v31.16b
5992 // CHECK-ERROR:                   ^
5993 // CHECK-ERROR: error: instruction requires: fullfp16
5994 // CHECK-ERROR:         frinti v2.8h, v4.8h
5995 // CHECK-ERROR:                   ^
5996 // CHECK-ERROR: error: invalid operand for instruction
5997 // CHECK-ERROR:         frinti v1.8b, v9.8b
5998 // CHECK-ERROR:                   ^
5999 // CHECK-ERROR: error: instruction requires: fullfp16
6000 // CHECK-ERROR:         frinti v13.4h, v21.4h
6001 // CHECK-ERROR:                    ^
6002 // CHECK-ERROR: error: invalid operand for instruction
6003 // CHECK-ERROR:         fcvtns v0.16b, v31.16b
6004 // CHECK-ERROR:                   ^
6005 // CHECK-ERROR: error: instruction requires: fullfp16
6006 // CHECK-ERROR:         fcvtns v2.8h, v4.8h
6007 // CHECK-ERROR:                   ^
6008 // CHECK-ERROR: error: invalid operand for instruction
6009 // CHECK-ERROR:         fcvtns v1.8b, v9.8b
6010 // CHECK-ERROR:                   ^
6011 // CHECK-ERROR: error: instruction requires: fullfp16
6012 // CHECK-ERROR:         fcvtns v13.4h, v21.4h
6013 // CHECK-ERROR:                    ^
6014 // CHECK-ERROR: error: invalid operand for instruction
6015 // CHECK-ERROR:         fcvtnu v0.16b, v31.16b
6016 // CHECK-ERROR:                   ^
6017 // CHECK-ERROR: error: instruction requires: fullfp16
6018 // CHECK-ERROR:         fcvtnu v2.8h, v4.8h
6019 // CHECK-ERROR:                   ^
6020 // CHECK-ERROR: error: invalid operand for instruction
6021 // CHECK-ERROR:         fcvtnu v1.8b, v9.8b
6022 // CHECK-ERROR:                   ^
6023 // CHECK-ERROR: error: instruction requires: fullfp16
6024 // CHECK-ERROR:         fcvtnu v13.4h, v21.4h
6025 // CHECK-ERROR:                    ^
6026 // CHECK-ERROR: error: invalid operand for instruction
6027 // CHECK-ERROR:         fcvtps v0.16b, v31.16b
6028 // CHECK-ERROR:                   ^
6029 // CHECK-ERROR: error: instruction requires: fullfp16
6030 // CHECK-ERROR:         fcvtps v2.8h, v4.8h
6031 // CHECK-ERROR:                   ^
6032 // CHECK-ERROR: error: invalid operand for instruction
6033 // CHECK-ERROR:         fcvtps v1.8b, v9.8b
6034 // CHECK-ERROR:                   ^
6035 // CHECK-ERROR: error: instruction requires: fullfp16
6036 // CHECK-ERROR:         fcvtps v13.4h, v21.4h
6037 // CHECK-ERROR:                    ^
6038 // CHECK-ERROR: error: invalid operand for instruction
6039 // CHECK-ERROR:         fcvtpu v0.16b, v31.16b
6040 // CHECK-ERROR:                   ^
6041 // CHECK-ERROR: error: instruction requires: fullfp16
6042 // CHECK-ERROR:         fcvtpu v2.8h, v4.8h
6043 // CHECK-ERROR:                   ^
6044 // CHECK-ERROR: error: invalid operand for instruction
6045 // CHECK-ERROR:         fcvtpu v1.8b, v9.8b
6046 // CHECK-ERROR:                   ^
6047 // CHECK-ERROR: error: instruction requires: fullfp16
6048 // CHECK-ERROR:         fcvtpu v13.4h, v21.4h
6049 // CHECK-ERROR:                    ^
6050 // CHECK-ERROR: error: invalid operand for instruction
6051 // CHECK-ERROR:         fcvtms v0.16b, v31.16b
6052 // CHECK-ERROR:                   ^
6053 // CHECK-ERROR: error: instruction requires: fullfp16
6054 // CHECK-ERROR:         fcvtms v2.8h, v4.8h
6055 // CHECK-ERROR:                   ^
6056 // CHECK-ERROR: error: invalid operand for instruction
6057 // CHECK-ERROR:         fcvtms v1.8b, v9.8b
6058 // CHECK-ERROR:                   ^
6059 // CHECK-ERROR: error: instruction requires: fullfp16
6060 // CHECK-ERROR:         fcvtms v13.4h, v21.4h
6061 // CHECK-ERROR:                    ^
6062 // CHECK-ERROR: error: invalid operand for instruction
6063 // CHECK-ERROR:         fcvtmu v0.16b, v31.16b
6064 // CHECK-ERROR:                   ^
6065 // CHECK-ERROR: error: instruction requires: fullfp16
6066 // CHECK-ERROR:         fcvtmu v2.8h, v4.8h
6067 // CHECK-ERROR:                   ^
6068 // CHECK-ERROR: error: invalid operand for instruction
6069 // CHECK-ERROR:         fcvtmu v1.8b, v9.8b
6070 // CHECK-ERROR:                   ^
6071 // CHECK-ERROR: error: instruction requires: fullfp16
6072 // CHECK-ERROR:         fcvtmu v13.4h, v21.4h
6073 // CHECK-ERROR:                    ^
6074 // CHECK-ERROR: error: invalid operand for instruction
6075 // CHECK-ERROR:         fcvtzs v0.16b, v31.16b
6076 // CHECK-ERROR:                   ^
6077 // CHECK-ERROR: error: instruction requires: fullfp16
6078 // CHECK-ERROR:         fcvtzs v2.8h, v4.8h
6079 // CHECK-ERROR:                   ^
6080 // CHECK-ERROR: error: invalid operand for instruction
6081 // CHECK-ERROR:         fcvtzs v1.8b, v9.8b
6082 // CHECK-ERROR:                   ^
6083 // CHECK-ERROR: error: instruction requires: fullfp16
6084 // CHECK-ERROR:         fcvtzs v13.4h, v21.4h
6085 // CHECK-ERROR:                    ^
6086 // CHECK-ERROR: error: invalid operand for instruction
6087 // CHECK-ERROR:         fcvtzu v0.16b, v31.16b
6088 // CHECK-ERROR:                   ^
6089 // CHECK-ERROR: error: instruction requires: fullfp16
6090 // CHECK-ERROR:         fcvtzu v2.8h, v4.8h
6091 // CHECK-ERROR:                   ^
6092 // CHECK-ERROR: error: invalid operand for instruction
6093 // CHECK-ERROR:         fcvtzu v1.8b, v9.8b
6094 // CHECK-ERROR:                   ^
6095 // CHECK-ERROR: error: instruction requires: fullfp16
6096 // CHECK-ERROR:         fcvtzu v13.4h, v21.4h
6097 // CHECK-ERROR:                    ^
6098 // CHECK-ERROR: error: invalid operand for instruction
6099 // CHECK-ERROR:         fcvtas v0.16b, v31.16b
6100 // CHECK-ERROR:                   ^
6101 // CHECK-ERROR: error: instruction requires: fullfp16
6102 // CHECK-ERROR:         fcvtas v2.8h, v4.8h
6103 // CHECK-ERROR:                   ^
6104 // CHECK-ERROR: error: invalid operand for instruction
6105 // CHECK-ERROR:         fcvtas v1.8b, v9.8b
6106 // CHECK-ERROR:                   ^
6107 // CHECK-ERROR: error: instruction requires: fullfp16
6108 // CHECK-ERROR:         fcvtas v13.4h, v21.4h
6109 // CHECK-ERROR:                    ^
6110 // CHECK-ERROR: error: invalid operand for instruction
6111 // CHECK-ERROR:         fcvtau v0.16b, v31.16b
6112 // CHECK-ERROR:                   ^
6113 // CHECK-ERROR: error: instruction requires: fullfp16
6114 // CHECK-ERROR:         fcvtau v2.8h, v4.8h
6115 // CHECK-ERROR:                   ^
6116 // CHECK-ERROR: error: invalid operand for instruction
6117 // CHECK-ERROR:         fcvtau v1.8b, v9.8b
6118 // CHECK-ERROR:                   ^
6119 // CHECK-ERROR: error: instruction requires: fullfp16
6120 // CHECK-ERROR:         fcvtau v13.4h, v21.4h
6121 // CHECK-ERROR:                    ^
6122 // CHECK-ERROR: error: invalid operand for instruction
6123 // CHECK-ERROR:         urecpe v0.16b, v31.16b
6124 // CHECK-ERROR:                   ^
6125 // CHECK-ERROR: error: invalid operand for instruction
6126 // CHECK-ERROR:         urecpe v2.8h, v4.8h
6127 // CHECK-ERROR:                   ^
6128 // CHECK-ERROR: error: invalid operand for instruction
6129 // CHECK-ERROR:         urecpe v1.8b, v9.8b
6130 // CHECK-ERROR:                   ^
6131 // CHECK-ERROR: error: invalid operand for instruction
6132 // CHECK-ERROR:         urecpe v13.4h, v21.4h
6133 // CHECK-ERROR:                    ^
6134 // CHECK-ERROR: error: invalid operand for instruction
6135 // CHECK-ERROR:         urecpe v1.2d, v9.2d
6136 // CHECK-ERROR:                   ^
6137 // CHECK-ERROR: error: invalid operand for instruction
6138 // CHECK-ERROR:         ursqrte v0.16b, v31.16b
6139 // CHECK-ERROR:                    ^
6140 // CHECK-ERROR: error: invalid operand for instruction
6141 // CHECK-ERROR:         ursqrte v2.8h, v4.8h
6142 // CHECK-ERROR:                    ^
6143 // CHECK-ERROR: error: invalid operand for instruction
6144 // CHECK-ERROR:         ursqrte v1.8b, v9.8b
6145 // CHECK-ERROR:                    ^
6146 // CHECK-ERROR: error: invalid operand for instruction
6147 // CHECK-ERROR:         ursqrte v13.4h, v21.4h
6148 // CHECK-ERROR:                     ^
6149 // CHECK-ERROR: error: invalid operand for instruction
6150 // CHECK-ERROR:         ursqrte v1.2d, v9.2d
6151 // CHECK-ERROR:                    ^
6152 // CHECK-ERROR: error: invalid operand for instruction
6153 // CHECK-ERROR:         scvtf v0.16b, v31.16b
6154 // CHECK-ERROR:                  ^
6155 // CHECK-ERROR: error: instruction requires: fullfp16
6156 // CHECK-ERROR:         scvtf v2.8h, v4.8h
6157 // CHECK-ERROR:                  ^
6158 // CHECK-ERROR: error: invalid operand for instruction
6159 // CHECK-ERROR:         scvtf v1.8b, v9.8b
6160 // CHECK-ERROR:                  ^
6161 // CHECK-ERROR: error: instruction requires: fullfp16
6162 // CHECK-ERROR:         scvtf v13.4h, v21.4h
6163 // CHECK-ERROR:                   ^
6164 // CHECK-ERROR: error: invalid operand for instruction
6165 // CHECK-ERROR:         ucvtf v0.16b, v31.16b
6166 // CHECK-ERROR:                  ^
6167 // CHECK-ERROR: error: instruction requires: fullfp16
6168 // CHECK-ERROR:         ucvtf v2.8h, v4.8h
6169 // CHECK-ERROR:                  ^
6170 // CHECK-ERROR: error: invalid operand for instruction
6171 // CHECK-ERROR:         ucvtf v1.8b, v9.8b
6172 // CHECK-ERROR:                  ^
6173 // CHECK-ERROR: error: instruction requires: fullfp16
6174 // CHECK-ERROR:         ucvtf v13.4h, v21.4h
6175 // CHECK-ERROR:                   ^
6176 // CHECK-ERROR: error: invalid operand for instruction
6177 // CHECK-ERROR:         frecpe v0.16b, v31.16b
6178 // CHECK-ERROR:                   ^
6179 // CHECK-ERROR: error: instruction requires: fullfp16
6180 // CHECK-ERROR:         frecpe v2.8h, v4.8h
6181 // CHECK-ERROR:                   ^
6182 // CHECK-ERROR: error: invalid operand for instruction
6183 // CHECK-ERROR:         frecpe v1.8b, v9.8b
6184 // CHECK-ERROR:                   ^
6185 // CHECK-ERROR: error: instruction requires: fullfp16
6186 // CHECK-ERROR:         frecpe v13.4h, v21.4h
6187 // CHECK-ERROR:                    ^
6188 // CHECK-ERROR: error: invalid operand for instruction
6189 // CHECK-ERROR:         frsqrte v0.16b, v31.16b
6190 // CHECK-ERROR:                    ^
6191 // CHECK-ERROR: error: instruction requires: fullfp16
6192 // CHECK-ERROR:         frsqrte v2.8h, v4.8h
6193 // CHECK-ERROR:                    ^
6194 // CHECK-ERROR: error: invalid operand for instruction
6195 // CHECK-ERROR:         frsqrte v1.8b, v9.8b
6196 // CHECK-ERROR:                    ^
6197 // CHECK-ERROR: error: instruction requires: fullfp16
6198 // CHECK-ERROR:         frsqrte v13.4h, v21.4h
6199 // CHECK-ERROR:                     ^
6200 // CHECK-ERROR: error: invalid operand for instruction
6201 // CHECK-ERROR:         fsqrt v0.16b, v31.16b
6202 // CHECK-ERROR:                  ^
6203 // CHECK-ERROR: error: instruction requires: fullfp16
6204 // CHECK-ERROR:         fsqrt v2.8h, v4.8h
6205 // CHECK-ERROR:                  ^
6206 // CHECK-ERROR: error: invalid operand for instruction
6207 // CHECK-ERROR:         fsqrt v1.8b, v9.8b
6208 // CHECK-ERROR:                  ^
6209 // CHECK-ERROR: error: instruction requires: fullfp16
6210 // CHECK-ERROR:         fsqrt v13.4h, v21.4h
6211 // CHECK-ERROR:                   ^
6212
6213 //----------------------------------------------------------------------
6214 // Scalar Floating-point Convert To Signed Fixed-point (Immediate)
6215 //----------------------------------------------------------------------
6216
6217     fcvtzs s21, s12, #0
6218     fcvtzs d21, d12, #65
6219     fcvtzs s21, d12, #1
6220
6221 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
6222 // CHECK-ERROR:        fcvtzs s21, s12, #0
6223 // CHECK-ERROR:                         ^
6224 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
6225 // CHECK-ERROR:        fcvtzs d21, d12, #65
6226 // CHECK-ERROR:                         ^
6227 // CHECK-ERROR: error: invalid operand for instruction
6228 // CHECK-ERROR:        fcvtzs s21, d12, #1
6229 // CHECK-ERROR:                    ^
6230
6231 //----------------------------------------------------------------------
6232 // Scalar Floating-point Convert To Unsigned Fixed-point (Immediate)
6233 //----------------------------------------------------------------------
6234
6235     fcvtzu s21, s12, #33
6236     fcvtzu d21, d12, #0
6237     fcvtzu s21, d12, #1
6238
6239 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
6240 // CHECK-ERROR:        fcvtzu s21, s12, #33
6241 // CHECK-ERROR:                         ^
6242 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
6243 // CHECK-ERROR:        fcvtzu d21, d12, #0
6244 // CHECK-ERROR:                         ^
6245 // CHECK-ERROR: error: invalid operand for instruction
6246 // CHECK-ERROR:        fcvtzu s21, d12, #1
6247 // CHECK-ERROR:                    ^
6248
6249 //----------------------------------------------------------------------
6250 // Scalar Unsigned Saturating Extract Narrow
6251 //----------------------------------------------------------------------
6252
6253         aese v0.8h, v1.8h
6254         aese v0.4s, v1.4s
6255         aese v0.2d, v1.2d
6256         aesd v0.8h, v1.8h
6257         aesmc v0.8h, v1.8h
6258         aesimc v0.8h, v1.8h
6259
6260 // CHECK:  error: invalid operand for instruction
6261 // CHECK:         aese v0.8h, v1.8h
6262 // CHECK:                 ^
6263 // CHECK:  error: invalid operand for instruction
6264 // CHECK:         aese v0.4s, v1.4s
6265 // CHECK:                 ^
6266 // CHECK:  error: invalid operand for instruction
6267 // CHECK:         aese v0.2d, v1.2d
6268 // CHECK:                 ^
6269 // CHECK:  error: invalid operand for instruction
6270 // CHECK:         aesd v0.8h, v1.8h
6271 // CHECK:                 ^
6272 // CHECK:  error: invalid operand for instruction
6273 // CHECK:         aesmc v0.8h, v1.8h
6274 // CHECK:                  ^
6275 // CHECK:  error: invalid operand for instruction
6276 // CHECK:         aesimc v0.8h, v1.8h
6277 // CHECK:                   ^
6278
6279         sha1h b0, b1
6280         sha1h h0, h1
6281         sha1h d0, d1
6282         sha1h q0, q1
6283         sha1su1 v0.16b, v1.16b
6284         sha1su1 v0.8h, v1.8h
6285         sha1su1 v0.2d, v1.2d
6286         sha256su0 v0.16b, v1.16b
6287
6288 // CHECK:  error: invalid operand for instruction
6289 // CHECK:         sha1h b0, b1
6290 // CHECK:               ^
6291 // CHECK:  error: invalid operand for instruction
6292 // CHECK:         sha1h h0, h1
6293 // CHECK:               ^
6294 // CHECK:  error: invalid operand for instruction
6295 // CHECK:         sha1h d0, d1
6296 // CHECK:               ^
6297 // CHECK:  error: invalid operand for instruction
6298 // CHECK:         sha1h q0, q1
6299 // CHECK:               ^
6300 // CHECK:  error: invalid operand for instruction
6301 // CHECK:         sha1su1 v0.16b, v1.16b
6302 // CHECK:                    ^
6303 // CHECK:  error: invalid operand for instruction
6304 // CHECK:         sha1su1 v0.8h, v1.8h
6305 // CHECK:                    ^
6306 // CHECK:  error: invalid operand for instruction
6307 // CHECK:         sha1su1 v0.2d, v1.2d
6308 // CHECK:                    ^
6309 // CHECK:  error: invalid operand for instruction
6310 // CHECK:         sha256su0 v0.16b, v1.16b
6311 // CHECK:                      ^
6312
6313         sha1c q0, q1, v2.4s
6314         sha1p q0, q1, v2.4s
6315         sha1m q0, q1, v2.4s
6316         sha1su0 v0.16b, v1.16b, v2.16b
6317         sha1su0 v0.8h, v1.8h, v2.8h
6318         sha1su0 v0.2d, v1.2d, v2.2d
6319         sha256h q0, q1, q2
6320         sha256h v0.4s, v1.4s, v2.4s
6321         sha256h2 q0, q1, q2
6322         sha256su1 v0.16b, v1.16b, v2.16b
6323
6324 // CHECK:  error: invalid operand for instruction
6325 // CHECK:         sha1c q0, q1, v2.4s
6326 // CHECK:                   ^
6327 // CHECK:  error: invalid operand for instruction
6328 // CHECK:         sha1p q0, q1, v2.4s
6329 // CHECK:                   ^
6330 // CHECK:  error: invalid operand for instruction
6331 // CHECK:         sha1m q0, q1, v2.4s
6332 // CHECK:                   ^
6333 // CHECK:  error: invalid operand for instruction
6334 // CHECK:         sha1su0 v0.16b, v1.16b, v2.16b
6335 // CHECK:                    ^
6336 // CHECK:  error: invalid operand for instruction
6337 // CHECK:         sha1su0 v0.8h, v1.8h, v2.8h
6338 // CHECK:                    ^
6339 // CHECK:  error: invalid operand for instruction
6340 // CHECK:         sha1su0 v0.2d, v1.2d, v2.2d
6341 // CHECK:                    ^
6342 // CHECK:  error: too few operands for instruction
6343 // CHECK:         sha256h q0, q1, q2
6344 // CHECK:         ^
6345 // CHECK:  error: invalid operand for instruction
6346 // CHECK:         sha256h v0.4s, v1.4s, v2.4s
6347 // CHECK:                    ^
6348 // CHECK:  error: too few operands for instruction
6349 // CHECK:         sha256h2 q0, q1, q2
6350 // CHECK:         ^
6351 // CHECK:  error: invalid operand for instruction
6352 // CHECK:         sha256su1 v0.16b, v1.16b, v2.16b
6353 // CHECK:                      ^
6354
6355 //----------------------------------------------------------------------
6356 // Bitwise extract
6357 //----------------------------------------------------------------------
6358
6359         ext v0.8b, v1.8b, v2.4h, #0x3
6360         ext v0.4h, v1.4h, v2.4h, #0x3
6361         ext v0.2s, v1.2s, v2.2s, #0x1
6362         ext v0.1d, v1.1d, v2.1d, #0x0
6363
6364 // CHECK-ERROR: error: invalid operand for instruction
6365 // CHECK-ERROR:         ext v0.8b, v1.8b, v2.4h, #0x3
6366 // CHECK-ERROR:                              ^
6367 // CHECK-ERROR: error: invalid operand for instruction
6368 // CHECK-ERROR:         ext v0.4h, v1.4h, v2.4h, #0x3
6369 // CHECK-ERROR:                ^
6370 // CHECK-ERROR: error: invalid operand for instruction
6371 // CHECK-ERROR:         ext v0.2s, v1.2s, v2.2s, #0x1
6372 // CHECK-ERROR:                ^
6373 // CHECK-ERROR: error: invalid operand for instruction
6374 // CHECK-ERROR:         ext v0.1d, v1.1d, v2.1d, #0x0
6375 // CHECK-ERROR:                ^
6376
6377         ext v0.16b, v1.16b, v2.8h, #0x3
6378         ext v0.8h, v1.8h, v2.8h, #0x3
6379         ext v0.4s, v1.4s, v2.4s, #0x1
6380         ext v0.2d, v1.2d, v2.2d, #0x0
6381
6382 // CHECK-ERROR: error: invalid operand for instruction
6383 // CHECK-ERROR:         ext v0.16b, v1.16b, v2.8h, #0x3
6384 // CHECK-ERROR:                                ^
6385 // CHECK-ERROR: error: invalid operand for instruction
6386 // CHECK-ERROR:         ext v0.8h, v1.8h, v2.8h, #0x3
6387 // CHECK-ERROR:                ^
6388 // CHECK-ERROR: error: invalid operand for instruction
6389 // CHECK-ERROR:         ext v0.4s, v1.4s, v2.4s, #0x1
6390 // CHECK-ERROR:                ^
6391 // CHECK-ERROR: error: invalid operand for instruction
6392 // CHECK-ERROR:         ext v0.2d, v1.2d, v2.2d, #0x0
6393 // CHECK-ERROR:                ^
6394
6395
6396 //----------------------------------------------------------------------
6397 // Permutation with 3 vectors
6398 //----------------------------------------------------------------------
6399
6400         uzp1 v0.16b, v1.8b, v2.8b
6401 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6402         uzp1 v0.8b, v1.4b, v2.4b
6403 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6404         uzp1 v0.8h, v1.4h, v2.4h
6405 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6406         uzp1 v0.4h, v1.2h, v2.2h
6407 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6408         uzp1 v0.4s, v1.2s, v2.2s
6409 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6410         uzp1 v0.2s, v1.1s, v2.1s
6411 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6412 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6413         uzp1 v0.2d, v1.1d, v2.1d
6414 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6415         uzp1 v0.1d, v1.1d, v2.1d
6416 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6417
6418
6419
6420         uzp2 v0.16b, v1.8b, v2.8b
6421 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6422         uzp2 v0.8b, v1.4b, v2.4b
6423 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6424         uzp2 v0.8h, v1.4h, v2.4h
6425 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6426         uzp2 v0.4h, v1.2h, v2.2h
6427 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6428         uzp2 v0.4s, v1.2s, v2.2s
6429 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6430         uzp2 v0.2s, v1.1s, v2.1s
6431 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6432 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6433         uzp2 v0.2d, v1.1d, v2.1d
6434 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6435         uzp2 v0.1d, v1.1d, v2.1d
6436 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6437
6438
6439
6440         zip1 v0.16b, v1.8b, v2.8b
6441 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6442         zip1 v0.8b, v1.4b, v2.4b
6443 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6444         zip1 v0.8h, v1.4h, v2.4h
6445 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6446         zip1 v0.4h, v1.2h, v2.2h
6447 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6448         zip1 v0.4s, v1.2s, v2.2s
6449 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6450         zip1 v0.2s, v1.1s, v2.1s
6451 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6452 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6453         zip1 v0.2d, v1.1d, v2.1d
6454 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6455         zip1 v0.1d, v1.1d, v2.1d
6456 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6457
6458
6459
6460         zip2 v0.16b, v1.8b, v2.8b
6461 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6462         zip2 v0.8b, v1.4b, v2.4b
6463 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6464         zip2 v0.8h, v1.4h, v2.4h
6465 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6466         zip2 v0.4h, v1.2h, v2.2h
6467 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6468         zip2 v0.4s, v1.2s, v2.2s
6469 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6470         zip2 v0.2s, v1.1s, v2.1s
6471 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6472 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6473         zip2 v0.2d, v1.1d, v2.1d
6474 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6475         zip2 v0.1d, v1.1d, v2.1d
6476 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6477
6478
6479
6480         trn1 v0.16b, v1.8b, v2.8b
6481 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6482         trn1 v0.8b, v1.4b, v2.4b
6483 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6484         trn1 v0.8h, v1.4h, v2.4h
6485 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6486         trn1 v0.4h, v1.2h, v2.2h
6487 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6488         trn1 v0.4s, v1.2s, v2.2s
6489 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6490         trn1 v0.2s, v1.1s, v2.1s
6491 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6492 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6493         trn1 v0.2d, v1.1d, v2.1d
6494 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6495         trn1 v0.1d, v1.1d, v2.1d
6496 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6497
6498
6499
6500         trn2 v0.16b, v1.8b, v2.8b
6501 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6502         trn2 v0.8b, v1.4b, v2.4b
6503 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6504         trn2 v0.8h, v1.4h, v2.4h
6505 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6506         trn2 v0.4h, v1.2h, v2.2h
6507 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6508         trn2 v0.4s, v1.2s, v2.2s
6509 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6510         trn2 v0.2s, v1.1s, v2.1s
6511 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6512 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6513         trn2 v0.2d, v1.1d, v2.1d
6514 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6515         trn2 v0.1d, v1.1d, v2.1d
6516 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6517
6518 //----------------------------------------------------------------------
6519 // Permutation with 3 vectors
6520 //----------------------------------------------------------------------
6521
6522         uzp1 v0.16b, v1.8b, v2.8b
6523 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6524         uzp1 v0.8b, v1.4b, v2.4b
6525 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6526         uzp1 v0.8h, v1.4h, v2.4h
6527 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6528         uzp1 v0.4h, v1.2h, v2.2h
6529 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6530         uzp1 v0.4s, v1.2s, v2.2s
6531 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6532         uzp1 v0.2s, v1.1s, v2.1s
6533 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6534 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6535         uzp1 v0.2d, v1.1d, v2.1d
6536 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6537         uzp1 v0.1d, v1.1d, v2.1d
6538 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6539
6540         uzp2 v0.16b, v1.8b, v2.8b
6541 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6542         uzp2 v0.8b, v1.4b, v2.4b
6543 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6544         uzp2 v0.8h, v1.4h, v2.4h
6545 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6546         uzp2 v0.4h, v1.2h, v2.2h
6547 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6548         uzp2 v0.4s, v1.2s, v2.2s
6549 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6550         uzp2 v0.2s, v1.1s, v2.1s
6551 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6552 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6553         uzp2 v0.2d, v1.1d, v2.1d
6554 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6555         uzp2 v0.1d, v1.1d, v2.1d
6556 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6557
6558         zip1 v0.16b, v1.8b, v2.8b
6559 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6560         zip1 v0.8b, v1.4b, v2.4b
6561 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6562         zip1 v0.8h, v1.4h, v2.4h
6563 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6564         zip1 v0.4h, v1.2h, v2.2h
6565 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6566         zip1 v0.4s, v1.2s, v2.2s
6567 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6568         zip1 v0.2s, v1.1s, v2.1s
6569 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6570 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6571         zip1 v0.2d, v1.1d, v2.1d
6572 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6573         zip1 v0.1d, v1.1d, v2.1d
6574 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6575
6576
6577
6578
6579
6580         zip2 v0.16b, v1.8b, v2.8b
6581 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6582         zip2 v0.8b, v1.4b, v2.4b
6583 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6584         zip2 v0.8h, v1.4h, v2.4h
6585 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6586         zip2 v0.4h, v1.2h, v2.2h
6587 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6588         zip2 v0.4s, v1.2s, v2.2s
6589 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6590         zip2 v0.2s, v1.1s, v2.1s
6591 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6592 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6593         zip2 v0.2d, v1.1d, v2.1d
6594 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6595         zip2 v0.1d, v1.1d, v2.1d
6596 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6597
6598
6599
6600
6601         trn1 v0.16b, v1.8b, v2.8b
6602 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6603         trn1 v0.8b, v1.4b, v2.4b
6604 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6605         trn1 v0.8h, v1.4h, v2.4h
6606 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6607         trn1 v0.4h, v1.2h, v2.2h
6608 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6609         trn1 v0.4s, v1.2s, v2.2s
6610 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6611         trn1 v0.2s, v1.1s, v2.1s
6612 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6613 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6614         trn1 v0.2d, v1.1d, v2.1d
6615 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6616         trn1 v0.1d, v1.1d, v2.1d
6617 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6618
6619
6620
6621         trn2 v0.16b, v1.8b, v2.8b
6622 // CHECK-ERROR: [[@LINE-1]]:22: error: invalid operand for instruction
6623         trn2 v0.8b, v1.4b, v2.4b
6624 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6625         trn2 v0.8h, v1.4h, v2.4h
6626 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6627         trn2 v0.4h, v1.2h, v2.2h
6628 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6629         trn2 v0.4s, v1.2s, v2.2s
6630 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6631         trn2 v0.2s, v1.1s, v2.1s
6632 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid vector kind qualifier
6633 // CHECK-ERROR: [[@LINE-2]]:28: error: invalid vector kind qualifier
6634         trn2 v0.2d, v1.1d, v2.1d
6635 // CHECK-ERROR: [[@LINE-1]]:21: error: invalid operand for instruction
6636         trn2 v0.1d, v1.1d, v2.1d
6637 // CHECK-ERROR: [[@LINE-1]]:14: error: invalid operand for instruction
6638
6639
6640
6641 //----------------------------------------------------------------------
6642 // Floating Point  multiply (scalar, by element)
6643 //----------------------------------------------------------------------
6644       // mismatched and invalid vector types
6645       fmul    s0, s1, v1.h[0]
6646       fmul    h0, h1, v1.s[0]
6647       // invalid lane
6648       fmul    s2, s29, v10.s[4]
6649
6650 // CHECK-ERROR: error: invalid operand for instruction
6651 // CHECK-ERROR:          fmul    s0, s1, v1.h[0]
6652 // CHECK-ERROR:                             ^
6653 // CHECK-ERROR: error: invalid operand for instruction
6654 // CHECK-ERROR:          fmul    h0, h1, v1.s[0]
6655 // CHECK-ERROR:                  ^
6656 // CHECK-ERROR: vector lane must be an integer in range
6657 // CHECK-ERROR:          fmul    s2, s29, v10.s[4]
6658 // CHECK-ERROR:                                 ^
6659
6660 //----------------------------------------------------------------------
6661 // Floating Point  multiply extended (scalar, by element)
6662 //----------------------------------------------------------------------
6663       // mismatched and invalid vector types
6664       fmulx    d0, d1, v1.b[0]
6665       fmulx    h0, h1, v1.d[0]
6666       // invalid lane
6667       fmulx    d2, d29, v10.d[3]
6668
6669 // CHECK-ERROR: error: invalid operand for instruction
6670 // CHECK-ERROR:          fmulx    d0, d1, v1.b[0]
6671 // CHECK-ERROR:                              ^
6672 // CHECK-ERROR: error: invalid operand for instruction
6673 // CHECK-ERROR:          fmulx    h0, h1, v1.d[0]
6674 // CHECK-ERROR:                   ^
6675 // CHECK-ERROR: vector lane must be an integer in range
6676 // CHECK-ERROR:          fmulx    d2, d29, v10.d[3]
6677 // CHECK-ERROR:                                  ^
6678
6679 //----------------------------------------------------------------------
6680 // Floating Point fused multiply-add (scalar, by element)
6681 //----------------------------------------------------------------------
6682       // mismatched and invalid vector types
6683       fmla    b0, b1, v1.b[0]
6684       fmla    d30, s11, v1.d[1]
6685       // invalid lane
6686       fmla    s16, s22, v16.s[5]
6687
6688 // CHECK-ERROR: error: invalid operand for instruction
6689 // CHECK-ERROR:          fmla    b0, b1, v1.b[0]
6690 // CHECK-ERROR:                  ^
6691 // CHECK-ERROR: error: invalid operand for instruction
6692 // CHECK-ERROR:          fmla    d30, s11, v1.d[1]
6693 // CHECK-ERROR:                       ^
6694 // CHECK-ERROR: vector lane must be an integer in range
6695 // CHECK-ERROR:          fmla    s16, s22, v16.s[5]
6696 // CHECK-ERROR:                                  ^
6697
6698 //----------------------------------------------------------------------
6699 // Floating Point fused multiply-subtract (scalar, by element)
6700 //----------------------------------------------------------------------
6701     // mismatched and invalid vector types
6702     fmls    s29, h10, v28.s[1]
6703     fmls    h7, h17, v26.s[2]
6704     // invalid lane
6705     fmls    d16, d22, v16.d[-1]
6706
6707 // CHECK-ERROR: error: invalid operand for instruction
6708 // CHECK-ERROR:          fmls    s29, h10, v28.s[1]
6709 // CHECK-ERROR:                       ^
6710 // CHECK-ERROR: error: invalid operand for instruction
6711 // CHECK-ERROR:          fmls    h7, h17, v26.s[2]
6712 // CHECK-ERROR:                  ^
6713 // CHECK-ERROR: error: vector lane must be an integer in range [0, 1]
6714 // CHECK-ERROR:          fmls    d16, d22, v16.d[-1]
6715 // CHECK-ERROR:                                  ^
6716
6717 //----------------------------------------------------------------------
6718 // Scalar Signed saturating doubling multiply-add long
6719 // (scalar, by element)
6720 //----------------------------------------------------------------------
6721     // mismatched and invalid vector types
6722     sqdmlal s0, h0, v0.s[0]
6723     sqdmlal s8, s9, v14.s[1]
6724     // invalid lane
6725     sqdmlal d4, s5, v1.s[5]
6726     // invalid vector index
6727     sqdmlal s0, h0, v17.h[0]
6728
6729 // CHECK-ERROR: error: invalid operand for instruction
6730 // CHECK-ERROR:          sqdmlal s0, h0, v0.s[0]
6731 // CHECK-ERROR:                             ^
6732 // CHECK-ERROR: error: invalid operand for instruction
6733 // CHECK-ERROR:          sqdmlal s8, s9, v14.s[1]
6734 // CHECK-ERROR:                  ^
6735 // CHECK-ERROR: vector lane must be an integer in range
6736 // CHECK-ERROR:          sqdmlal d4, s5, v1.s[5]
6737 // CHECK-ERROR:                               ^
6738 // CHECK-ERROR: error: invalid operand for instruction
6739 // CHECK-ERROR:          sqdmlal s0, h0, v17.h[0]
6740 // CHECK-ERROR:                           ^
6741
6742 //----------------------------------------------------------------------
6743 // Scalar Signed saturating doubling multiply-subtract long
6744 // (scalar, by element)
6745 //----------------------------------------------------------------------
6746     // mismatched and invalid vector types
6747     sqdmlsl s1, h1, v1.d[0]
6748     sqdmlsl d1, h1, v13.s[0]
6749     // invalid lane
6750     sqdmlsl d1, s1, v13.s[4]
6751     // invalid vector index
6752     sqdmlsl s1, h1, v20.h[7]
6753
6754 // CHECK-ERROR: error: invalid operand for instruction
6755 // CHECK-ERROR:          sqdmlsl s1, h1, v1.d[0]
6756 // CHECK-ERROR:                             ^
6757 // CHECK-ERROR: error: invalid operand for instruction
6758 // CHECK-ERROR:          sqdmlsl d1, h1, v13.s[0]
6759 // CHECK-ERROR:                      ^
6760 // CHECK-ERROR: vector lane must be an integer in range
6761 // CHECK-ERROR:          sqdmlsl d1, s1, v13.s[4]
6762 // CHECK-ERROR:                                ^
6763 // CHECK-ERROR: error: invalid operand for instruction
6764 // CHECK-ERROR:          sqdmlsl s1, h1, v20.h[7]
6765 // CHECK-ERROR:                           ^
6766
6767 //----------------------------------------------------------------------
6768 // Scalar Signed saturating doubling multiply long (scalar, by element)
6769 //----------------------------------------------------------------------
6770     // mismatched and invalid vector types
6771     // invalid lane
6772     // invalid vector index
6773     // mismatched and invalid vector types
6774     sqdmull s1, h1, v1.s[1]
6775     sqdmull s1, s1, v4.s[0]
6776     // invalid lane
6777     sqdmull s12, h17, v9.h[9]
6778     // invalid vector index
6779     sqdmull s1, h1, v16.h[5]
6780
6781 // CHECK-ERROR: error: invalid operand for instruction
6782 // CHECK-ERROR:          sqdmull s1, h1, v1.s[1]
6783 // CHECK-ERROR:                             ^
6784 // CHECK-ERROR: error: invalid operand for instruction
6785 // CHECK-ERROR:          sqdmull s1, s1, v4.s[0]
6786 // CHECK-ERROR:                  ^
6787 // CHECK-ERROR: vector lane must be an integer in range
6788 // CHECK-ERROR:          sqdmull s12, h17, v9.h[9]
6789 // CHECK-ERROR:                                 ^
6790 // CHECK-ERROR: error: invalid operand for instruction
6791 // CHECK-ERROR:          sqdmull s1, h1, v16.h[5]
6792 // CHECK-ERROR:                           ^
6793
6794 //----------------------------------------------------------------------
6795 // Scalar Signed saturating doubling multiply returning
6796 // high half (scalar, by element)
6797 //----------------------------------------------------------------------
6798     // mismatched and invalid vector types
6799     sqdmulh h0, s1, v0.h[0]
6800     sqdmulh s25, s26, v27.h[3]
6801     // invalid lane
6802     sqdmulh s25, s26, v27.s[4]
6803     // invalid vector index
6804     sqdmulh s0, h1, v30.h[0]
6805
6806 // CHECK-ERROR: error: invalid operand for instruction
6807 // CHECK-ERROR:          sqdmulh h0, s1, v0.h[0]
6808 // CHECK-ERROR:                      ^
6809 // CHECK-ERROR: error: invalid operand for instruction
6810 // CHECK-ERROR:          sqdmulh s25, s26, v27.h[3]
6811 // CHECK-ERROR:                  ^
6812 // CHECK-ERROR: vector lane must be an integer in range
6813 // CHECK-ERROR:          sqdmulh s25, s26, v27.s[4]
6814 // CHECK-ERROR:                                  ^
6815 // CHECK-ERROR: error: invalid operand for instruction
6816 // CHECK-ERROR:          sqdmulh s0, h1, v30.h[0]
6817 // CHECK-ERROR:                      ^
6818
6819 //----------------------------------------------------------------------
6820 // Scalar Signed saturating rounding doubling multiply
6821 // returning high half (scalar, by element)
6822 //----------------------------------------------------------------------
6823     // mismatched and invalid vector types
6824     sqrdmulh h31, h30, v14.s[2]
6825     sqrdmulh s5, h6, v7.s[2]
6826     // invalid lane
6827     sqrdmulh h31, h30, v14.h[9]
6828     // invalid vector index
6829     sqrdmulh h31, h30, v20.h[4]
6830
6831 // CHECK-ERROR: error: invalid operand for instruction
6832 // CHECK-ERROR:          sqrdmulh h31, h30, v14.s[2]
6833 // CHECK-ERROR:                                 ^
6834 // CHECK-ERROR: error: invalid operand for instruction
6835 // CHECK-ERROR:          sqrdmulh s5, h6, v7.s[2]
6836 // CHECK-ERROR:                       ^
6837 // CHECK-ERROR: vector lane must be an integer in range
6838 // CHECK-ERROR:          sqrdmulh h31, h30, v14.h[9]
6839 // CHECK-ERROR:                                 ^
6840 // CHECK-ERROR: error: invalid operand for instruction
6841 // CHECK-ERROR:          sqrdmulh h31, h30, v20.h[4]
6842 // CHECK-ERROR:                              ^
6843
6844 //----------------------------------------------------------------------
6845 // Scalar Duplicate element (scalar)
6846 //----------------------------------------------------------------------
6847       // mismatched and invalid vector types
6848       dup b0, v1.d[0]
6849       dup h0, v31.b[8]
6850       dup s0, v2.h[4]
6851       dup d0, v17.s[3]
6852       // invalid  lane
6853       dup d0, v17.d[4]
6854       dup s0, v1.s[7]
6855       dup h0, v31.h[16]
6856       dup b1, v3.b[16]
6857 // CHECK-ERROR: error: invalid operand for instruction
6858 // CHECK-ERROR:          dup b0, v1.d[0]
6859 // CHECK-ERROR:                     ^
6860 // CHECK-ERROR: error: invalid operand for instruction
6861 // CHECK-ERROR:          dup h0, v31.b[8]
6862 // CHECK-ERROR:                      ^
6863 // CHECK-ERROR: error: invalid operand for instruction
6864 // CHECK-ERROR:          dup s0, v2.h[4]
6865 // CHECK-ERROR:                     ^
6866 // CHECK-ERROR: error: invalid operand for instruction
6867 // CHECK-ERROR:          dup d0, v17.s[3]
6868 // CHECK-ERROR:                      ^
6869 // CHECK-ERROR: vector lane must be an integer in range
6870 // CHECK-ERROR:          dup d0, v17.d[4]
6871 // CHECK-ERROR:                        ^
6872 // CHECK-ERROR: vector lane must be an integer in range
6873 // CHECK-ERROR:          dup s0, v1.s[7]
6874 // CHECK-ERROR:                       ^
6875 // CHECK-ERROR: vector lane must be an integer in range
6876 // CHECK-ERROR:          dup h0, v31.h[16]
6877 // CHECK-ERROR:                        ^
6878 // CHECK-ERROR: vector lane must be an integer in range
6879 // CHECK-ERROR:          dup b1, v3.b[16]
6880 // CHECK-ERROR:                       ^
6881
6882 //----------------------------------------------------------------------
6883 // Table look up
6884 //----------------------------------------------------------------------
6885
6886         tbl v0.8b, {v1.8b}, v2.8b
6887         tbl v0.8b, {v1.8b, v2.8b}, v2.8b
6888         tbl v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
6889         tbl v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
6890         tbl v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
6891
6892 // CHECK-ERROR: error: invalid operand for instruction
6893 // CHECK-ERROR:        tbl v0.8b, {v1.8b}, v2.8b
6894 // CHECK-ERROR:                   ^
6895 // CHECK-ERROR: error: invalid operand for instruction
6896 // CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b}, v2.8b
6897 // CHECK-ERROR:                   ^
6898 // CHECK-ERROR: error: invalid operand for instruction
6899 // CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
6900 // CHECK-ERROR:                   ^
6901 // CHECK-ERROR: error: invalid operand for instruction
6902 // CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
6903 // CHECK-ERROR:                   ^
6904 // CHECK-ERROR: error: invalid number of vectors
6905 // CHECK-ERROR:        tbl v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
6906 // CHECK-ERROR:                                                    ^
6907
6908         tbx v0.8b, {v1.8b}, v2.8b
6909         tbx v0.8b, {v1.8b, v2.8b}, v2.8b
6910         tbx v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
6911         tbx v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
6912         tbx v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
6913
6914 // CHECK-ERROR: error: invalid operand for instruction
6915 // CHECK-ERROR:        tbx v0.8b, {v1.8b}, v2.8b
6916 // CHECK-ERROR:                   ^
6917 // CHECK-ERROR: error: invalid operand for instruction
6918 // CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b}, v2.8b
6919 // CHECK-ERROR:                   ^
6920 // CHECK-ERROR: error: invalid operand for instruction
6921 // CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
6922 // CHECK-ERROR:                   ^
6923 // CHECK-ERROR: error: invalid operand for instruction
6924 // CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
6925 // CHECK-ERROR:                   ^
6926 // CHECK-ERROR: error: invalid number of vectors
6927 // CHECK-ERROR:        tbx v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
6928 // CHECK-ERROR:                                                    ^
6929
6930 //----------------------------------------------------------------------
6931 // Scalar Floating-point Convert To Lower Precision Narrow, Rounding To
6932 // Odd
6933 //----------------------------------------------------------------------
6934
6935     fcvtxn s0, s1
6936
6937 // CHECK-ERROR: error: invalid operand for instruction
6938 // CHECK-ERROR:        fcvtxn s0, s1
6939 // CHECK-ERROR:                   ^
6940
6941 //----------------------------------------------------------------------
6942 // Scalar Floating-point Convert To Signed Integer, Rounding To Nearest
6943 // With Ties To Away
6944 //----------------------------------------------------------------------
6945
6946     fcvtas s0, d0
6947     fcvtas d0, s0
6948
6949 // CHECK-ERROR: error: invalid operand for instruction
6950 // CHECK-ERROR:        fcvtas s0, d0
6951 // CHECK-ERROR:                   ^
6952 // CHECK-ERROR: error: invalid operand for instruction
6953 // CHECK-ERROR:        fcvtas d0, s0
6954 // CHECK-ERROR:                   ^
6955
6956 //----------------------------------------------------------------------
6957 // Scalar Floating-point Convert To Unsigned Integer, Rounding To
6958 // Nearest With Ties To Away
6959 //----------------------------------------------------------------------
6960
6961     fcvtau s0, d0
6962     fcvtau d0, s0
6963
6964 // CHECK-ERROR: error: invalid operand for instruction
6965 // CHECK-ERROR:        fcvtau s0, d0
6966 // CHECK-ERROR:                   ^
6967 // CHECK-ERROR: error: invalid operand for instruction
6968 // CHECK-ERROR:        fcvtau d0, s0
6969 // CHECK-ERROR:                   ^
6970
6971 //----------------------------------------------------------------------
6972 // Scalar Floating-point Convert To Signed Integer, Rounding Toward
6973 // Minus Infinity
6974 //----------------------------------------------------------------------
6975
6976     fcvtms s0, d0
6977     fcvtms d0, s0
6978
6979 // CHECK-ERROR: error: invalid operand for instruction
6980 // CHECK-ERROR:        fcvtms s0, d0
6981 // CHECK-ERROR:                   ^
6982 // CHECK-ERROR: error: invalid operand for instruction
6983 // CHECK-ERROR:        fcvtms d0, s0
6984 // CHECK-ERROR:                   ^
6985
6986 //----------------------------------------------------------------------
6987 // Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
6988 // Minus Infinity
6989 //----------------------------------------------------------------------
6990
6991     fcvtmu s0, d0
6992     fcvtmu d0, s0
6993
6994 // CHECK-ERROR: error: invalid operand for instruction
6995 // CHECK-ERROR:        fcvtmu s0, d0
6996 // CHECK-ERROR:                   ^
6997 // CHECK-ERROR: error: invalid operand for instruction
6998 // CHECK-ERROR:        fcvtmu d0, s0
6999 // CHECK-ERROR:                   ^
7000
7001 //----------------------------------------------------------------------
7002 // Scalar Floating-point Convert To Signed Integer, Rounding To Nearest
7003 // With Ties To Even
7004 //----------------------------------------------------------------------
7005
7006     fcvtns s0, d0
7007     fcvtns d0, s0
7008
7009 // CHECK-ERROR: error: invalid operand for instruction
7010 // CHECK-ERROR:        fcvtns s0, d0
7011 // CHECK-ERROR:                   ^
7012 // CHECK-ERROR: error: invalid operand for instruction
7013 // CHECK-ERROR:        fcvtns d0, s0
7014 // CHECK-ERROR:                   ^
7015
7016 //----------------------------------------------------------------------
7017 // Scalar Floating-point Convert To Unsigned Integer, Rounding To
7018 // Nearest With Ties To Even
7019 //----------------------------------------------------------------------
7020
7021     fcvtnu s0, d0
7022     fcvtnu d0, s0
7023
7024 // CHECK-ERROR: error: invalid operand for instruction
7025 // CHECK-ERROR:        fcvtnu s0, d0
7026 // CHECK-ERROR:                   ^
7027 // CHECK-ERROR: error: invalid operand for instruction
7028 // CHECK-ERROR:        fcvtnu d0, s0
7029 // CHECK-ERROR:                   ^
7030
7031 //----------------------------------------------------------------------
7032 // Scalar Floating-point Convert To Signed Integer, Rounding Toward
7033 // Positive Infinity
7034 //----------------------------------------------------------------------
7035
7036     fcvtps s0, d0
7037     fcvtps d0, s0
7038
7039 // CHECK-ERROR: error: invalid operand for instruction
7040 // CHECK-ERROR:        fcvtps s0, d0
7041 // CHECK-ERROR:                   ^
7042 // CHECK-ERROR: error: invalid operand for instruction
7043 // CHECK-ERROR:        fcvtps d0, s0
7044 // CHECK-ERROR:                   ^
7045
7046 //----------------------------------------------------------------------
7047 // Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
7048 // Positive Infinity
7049 //----------------------------------------------------------------------
7050
7051     fcvtpu s0, d0
7052     fcvtpu d0, s0
7053
7054 // CHECK-ERROR: error: invalid operand for instruction
7055 // CHECK-ERROR:        fcvtpu s0, d0
7056 // CHECK-ERROR:                   ^
7057 // CHECK-ERROR: error: invalid operand for instruction
7058 // CHECK-ERROR:        fcvtpu d0, s0
7059 // CHECK-ERROR:                   ^
7060
7061 //----------------------------------------------------------------------
7062 // Scalar Floating-point Convert To Signed Integer, Rounding Toward Zero
7063 //----------------------------------------------------------------------
7064
7065     fcvtzs s0, d0
7066     fcvtzs d0, s0
7067
7068 // CHECK-ERROR: error: invalid operand for instruction
7069 // CHECK-ERROR:        fcvtzs s0, d0
7070 // CHECK-ERROR:                   ^
7071 // CHECK-ERROR: error: invalid operand for instruction
7072 // CHECK-ERROR:        fcvtzs d0, s0
7073 // CHECK-ERROR:                   ^
7074
7075 //----------------------------------------------------------------------
7076 // Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
7077 // Zero
7078 //----------------------------------------------------------------------
7079
7080     fcvtzu s0, d0
7081     fcvtzu d0, s0
7082
7083 // CHECK-ERROR: error: invalid operand for instruction
7084 // CHECK-ERROR:        fcvtzu s0, d0
7085 // CHECK-ERROR:                   ^
7086 // CHECK-ERROR: error: invalid operand for instruction
7087 // CHECK-ERROR:        fcvtzu d0, s0
7088 // CHECK-ERROR:                   ^
7089
7090 //----------------------------------------------------------------------
7091 // Scalar Floating-point Absolute Difference
7092 //----------------------------------------------------------------------
7093
7094
7095     fabd s29, d24, s20
7096     fabd d29, s24, d20
7097
7098 // CHECK-ERROR: error: invalid operand for instruction
7099 // CHECK-ERROR:        fabd s29, d24, s20
7100 // CHECK-ERROR:                  ^
7101 // CHECK-ERROR: error: invalid operand for instruction
7102 // CHECK-ERROR:        fabd d29, s24, d20
7103 // CHECK-ERROR:                  ^