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: invalid operand for instruction
  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: invalid operand for instruction
 156 // CHECK-ERROR:          movi v0.2s, #-1
 157 // CHECK-ERROR:                      ^
 158 // CHECK-ERROR: error: invalid operand for instruction
 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: invalid operand for instruction
 187 // CHECK-ERROR:         movi v0.2s, #-1, msl #8
 188 // CHECK-ERROR:                     ^
 189 // CHECK-ERROR: error: invalid operand for instruction
 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: invalid operand for instruction
 210 // CHECK-ERROR:         movi v0.8b, #-1
 211 // CHECK-ERROR:                     ^
 212 // CHECK-ERROR: error: invalid operand for instruction
 213 // CHECK-ERROR:         movi v1.16b, #256
 214 // CHECK-ERROR:                      ^
 215
 216
 217 //----------------------------------------------------------------------
 218 // Vector Move Immediate - bytemask, per doubleword
 219 //---------------------------------------------------------------------
 220         // invalid bytemask (0x00 or 0xff)
 221         movi v0.2d, #0x10ff00ff00ff00ff
 222
 223 // CHECK:ERROR: error: invalid operand for instruction
 224 // CHECK:ERROR:         movi v0.2d, #0x10ff00ff00ff00ff
 225 // CHECK:ERROR:                     ^
 226
 227 //----------------------------------------------------------------------
 228 // Vector Move Immediate - bytemask, one doubleword
 229 //----------------------------------------------------------------------
 230         // invalid bytemask (0x00 or 0xff)
 231         movi v0.2d, #0xffff00ff001f00ff
 232
 233 // CHECK:ERROR: error: invalid operand for instruction
 234 // CHECK:ERROR:         movi v0.2d, #0xffff00ff001f00ff
 235 // CHECK:ERROR:                     ^
 236 //----------------------------------------------------------------------
 237 // Vector Floating Point Move Immediate
 238 //----------------------------------------------------------------------
 239         // invalid vector type (2s, 4s, 2d)
 240          fmov v0.4h, #1.0
 241
 242 // CHECK:ERROR: error: invalid operand for instruction
 243 // CHECK:ERROR:         fmov v0.4h, #1.0
 244 // CHECK:ERROR:              ^
 245
 246 //----------------------------------------------------------------------
 247 // Vector Move -  register
 248 //----------------------------------------------------------------------
 249       // invalid vector type (8b, 16b)
 250       mov v0.2s, v31.8b
 251 // CHECK:ERROR: error: invalid operand for instruction
 252 // CHECK:ERROR:         mov v0.2s, v31.8b
 253 // CHECK:ERROR:                ^
 254
 255 //----------------------------------------------------------------------
 256 // Vector Absolute Difference and Accumulate (Signed, Unsigned)
 257 //----------------------------------------------------------------------
 258
 259         // Mismatched and invalid vector types (2d)
 260         saba v0.16b, v1.8b, v2.8b
 261         uaba v0.2d, v1.2d, v2.2d
 262
 263 // CHECK-ERROR: error: invalid operand for instruction
 264 // CHECK-ERROR:         saba v0.16b, v1.8b, v2.8b
 265 // CHECK-ERROR:                        ^
 266 // CHECK-ERROR: error: invalid operand for instruction
 267 // CHECK-ERROR:         uaba v0.2d, v1.2d, v2.2d
 268 // CHECK-ERROR:                ^
 269
 270 //----------------------------------------------------------------------
 271 // Vector Absolute Difference and Accumulate (Signed, Unsigned)
 272 // Vector Absolute Difference (Signed, Unsigned)
 273
 274         // Mismatched and invalid vector types (2d)
 275         uaba v0.16b, v1.8b, v2.8b
 276         saba v0.2d, v1.2d, v2.2d
 277         uabd v0.4s, v1.2s, v2.2s
 278         sabd v0.4h, v1.8h, v8.8h
 279
 280 // CHECK-ERROR: error: invalid operand for instruction
 281 // CHECK-ERROR:         uaba v0.16b, v1.8b, v2.8b
 282 // CHECK-ERROR:                        ^
 283 // CHECK-ERROR: error: invalid operand for instruction
 284 // CHECK-ERROR:         saba v0.2d, v1.2d, v2.2d
 285 // CHECK-ERROR:                ^
 286 // CHECK-ERROR: error: invalid operand for instruction
 287 // CHECK-ERROR:         uabd v0.4s, v1.2s, v2.2s
 288 // CHECK-ERROR:                        ^
 289 // CHECK-ERROR: error: invalid operand for instruction
 290 // CHECK-ERROR:         sabd v0.4h, v1.8h, v8.8h
 291 // CHECK-ERROR:                        ^
 292
 293 //----------------------------------------------------------------------
 294 // Vector Absolute Difference (Floating Point)
 295 //----------------------------------------------------------------------
 296         // Mismatched and invalid vector types
 297         fabd v0.2s, v1.4s, v2.2d
 298         fabd v0.4h, v1.4h, v2.4h
 299
 300 // CHECK-ERROR: error: invalid operand for instruction
 301 // CHECK-ERROR:         fabd v0.2s, v1.4s, v2.2d
 302 // CHECK-ERROR:                        ^
 303 // CHECK-ERROR: error: invalid operand for instruction
 304 // CHECK-ERROR:         fabd v0.4h, v1.4h, v2.4h
 305 // CHECK-ERROR:                 ^
 306 //----------------------------------------------------------------------
 307 // Vector Multiply (Polynomial)
 308 //----------------------------------------------------------------------
 309
 310         // Mismatched and invalid vector types
 311          pmul v0.8b, v1.8b, v2.16b
 312          pmul v0.2s, v1.2s, v2.2s
 313
 314 // CHECK-ERROR: error: invalid operand for instruction
 315 // CHECK-ERROR:         pmul v0.8b, v1.8b, v2.16b
 316 // CHECK-ERROR:                               ^
 317 // CHECK-ERROR: error: invalid operand for instruction
 318 // CHECK-ERROR:         pmul v0.2s, v1.2s, v2.2s
 319 // CHECK-ERROR:                 ^
 320
 321 //----------------------------------------------------------------------
 322 // Scalar Integer Add and Sub
 323 //----------------------------------------------------------------------
 324
 325       // Mismatched registers
 326          add d0, s1, d2
 327          sub s1, d1, d2
 328
 329 // CHECK-ERROR: error: invalid operand for instruction
 330 // CHECK-ERROR:         add d0, s1, d2
 331 // CHECK-ERROR:                 ^
 332 // CHECK-ERROR: error: invalid operand for instruction
 333 // CHECK-ERROR:         sub s1, d1, d2
 334 // CHECK-ERROR:             ^
 335
 336 //----------------------------------------------------------------------
 337 // Vector Reciprocal Step (Floating Point)
 338 //----------------------------------------------------------------------
 339
 340         // Mismatched and invalid vector types
 341          frecps v0.4s, v1.2d, v2.4s
 342          frecps v0.8h, v1.8h, v2.8h
 343
 344 // CHECK-ERROR: error: invalid operand for instruction
 345 // CHECK-ERROR:        frecps v0.4s, v1.2d, v2.4s
 346 // CHECK-ERROR:                         ^
 347 // CHECK-ERROR: error: invalid operand for instruction
 348 // CHECK-ERROR:        frecps v0.8h, v1.8h, v2.8h
 349 // CHECK-ERROR:                  ^
 350
 351 //----------------------------------------------------------------------
 352 // Vector Reciprocal Square Root Step (Floating Point)
 353 //----------------------------------------------------------------------
 354
 355         // Mismatched and invalid vector types
 356          frsqrts v0.2d, v1.2d, v2.2s
 357          frsqrts v0.4h, v1.4h, v2.4h
 358
 359 // CHECK-ERROR: error: invalid operand for instruction
 360 // CHECK-ERROR:        frsqrts v0.2d, v1.2d, v2.2s
 361 // CHECK-ERROR:                                 ^
 362 // CHECK-ERROR: error: invalid operand for instruction
 363 // CHECK-ERROR:        frsqrts v0.4h, v1.4h, v2.4h
 364 // CHECK-ERROR:                   ^
 365
 366
 367 //----------------------------------------------------------------------
 368 // Vector Absolute Compare Mask Less Than Or Equal (Floating Point)
 369 //----------------------------------------------------------------------
 370
 371         // Mismatched and invalid vector types
 372         facge v0.2d, v1.2s, v2.2d
 373         facge v0.4h, v1.4h, v2.4h
 374         facle v0.8h, v1.4h, v2.4h
 375
 376 // CHECK-ERROR: error: invalid operand for instruction
 377 // CHECK-ERROR:        facge v0.2d, v1.2s, v2.2d
 378 // CHECK-ERROR:                        ^
 379 // CHECK-ERROR: error: invalid operand for instruction
 380 // CHECK-ERROR:        facge v0.4h, v1.4h, v2.4h
 381 // CHECK-ERROR:                 ^
 382 // CHECK-ERROR: error: invalid operand for instruction
 383 // CHECK-ERROR:        facle v0.8h, v1.4h, v2.4h
 384 // CHECK-ERROR:                 ^
 385 //----------------------------------------------------------------------
 386 // Vector Absolute Compare Mask Less Than (Floating Point)
 387 //----------------------------------------------------------------------
 388
 389         // Mismatched and invalid vector types
 390         facgt v0.2d, v1.2d, v2.4s
 391         facgt v0.8h, v1.8h, v2.8h
 392         faclt v0.8b, v1.8b, v2.8b
 393
 394 // CHECK-ERROR: error: invalid operand for instruction
 395 // CHECK-ERROR:        facgt v0.2d, v1.2d, v2.4s
 396 // CHECK-ERROR:                               ^
 397 // CHECK-ERROR: error: invalid operand for instruction
 398 // CHECK-ERROR:        facgt v0.8h, v1.8h, v2.8h
 399 // CHECK-ERROR:                 ^
 400 // CHECK-ERROR: error: invalid operand for instruction
 401 // CHECK-ERROR:        faclt v0.8b, v1.8b, v2.8b
 402 // CHECK-ERROR:                 ^
 403
 404
 405 //----------------------------------------------------------------------
 406 // Vector Compare Mask Equal (Integer)
 407 //----------------------------------------------------------------------
 408
 409          // Mismatched vector types
 410          cmeq c0.2d, v1.2d, v2.2s
 411
 412 // CHECK-ERROR: error: invalid operand for instruction
 413 // CHECK-ERROR:        cmeq c0.2d, v1.2d, v2.2s
 414 // CHECK-ERROR:                              ^
 415
 416 //----------------------------------------------------------------------
 417 // Vector Compare Mask Higher or Same (Unsigned Integer)
 418 // Vector Compare Mask Less or Same (Unsigned Integer)
 419 // CMLS is alias for CMHS with operands reversed.
 420 //----------------------------------------------------------------------
 421
 422          // Mismatched vector types
 423          cmhs c0.4h, v1.8b, v2.8b
 424          cmls c0.16b, v1.16b, v2.2d
 425
 426 // CHECK-ERROR: error: invalid operand for instruction
 427 // CHECK-ERROR:        cmhs c0.4h, v1.8b, v2.8b
 428 // CHECK-ERROR:                       ^
 429 // CHECK-ERROR: error: invalid operand for instruction
 430 // CHECK-ERROR:        cmls c0.16b, v1.16b, v2.2d
 431 // CHECK-ERROR:                                ^
 432
 433 //----------------------------------------------------------------------
 434 // Vector Compare Mask Greater Than or Equal (Integer)
 435 // Vector Compare Mask Less Than or Equal (Integer)
 436 // CMLE is alias for CMGE with operands reversed.
 437 //----------------------------------------------------------------------
 438
 439          // Mismatched vector types
 440          cmge c0.8h, v1.8b, v2.8b
 441          cmle c0.4h, v1.2s, v2.2s
 442
 443 // CHECK-ERROR: error: invalid operand for instruction
 444 // CHECK-ERROR:        cmge c0.8h, v1.8b, v2.8b
 445 // CHECK-ERROR:                       ^
 446 // CHECK-ERROR: error: invalid operand for instruction
 447 // CHECK-ERROR:         cmle c0.4h, v1.2s, v2.2s
 448 // CHECK-ERROR:                        ^
 449
 450 //----------------------------------------------------------------------
 451 // Vector Compare Mask Higher (Unsigned Integer)
 452 // Vector Compare Mask Lower (Unsigned Integer)
 453 // CMLO is alias for CMHI with operands reversed.
 454 //----------------------------------------------------------------------
 455
 456          // Mismatched vector types
 457          cmhi c0.4s, v1.4s, v2.16b
 458          cmlo c0.8b, v1.8b, v2.2s
 459
 460 // CHECK-ERROR: error: invalid operand for instruction
 461 // CHECK-ERROR:        cmhi c0.4s, v1.4s, v2.16b
 462 // CHECK-ERROR:                              ^
 463 // CHECK-ERROR: error: invalid operand for instruction
 464 // CHECK-ERROR:         cmlo c0.8b, v1.8b, v2.2s
 465 // CHECK-ERROR:                               ^
 466
 467 //----------------------------------------------------------------------
 468 // Vector Compare Mask Greater Than (Integer)
 469 // Vector Compare Mask Less Than (Integer)
 470 // CMLT is alias for CMGT with operands reversed.
 471 //----------------------------------------------------------------------
 472
 473          // Mismatched vector types
 474          cmgt c0.8b, v1.4s, v2.16b
 475          cmlt c0.8h, v1.16b, v2.4s
 476
 477 // CHECK-ERROR: error: invalid operand for instruction
 478 // CHECK-ERROR:         cmgt c0.8b, v1.4s, v2.16b
 479 // CHECK-ERROR:                        ^
 480 // CHECK-ERROR: error: invalid operand for instruction
 481 // CHECK-ERROR:         cmlt c0.8h, v1.16b, v2.4s
 482 // CHECK-ERROR:                        ^
 483
 484 //----------------------------------------------------------------------
 485 // Vector Compare Mask Bitwise Test (Integer)
 486 //----------------------------------------------------------------------
 487
 488          // Mismatched vector types
 489          cmtst c0.16b, v1.16b, v2.4s
 490
 491 // CHECK-ERROR: error: invalid operand for instruction
 492 // CHECK-ERROR:         cmtst c0.16b, v1.16b, v2.4s
 493 // CHECK-ERROR:                                  ^
 494
 495 //----------------------------------------------------------------------
 496 // Vector Compare Mask Equal (Floating Point)
 497 //----------------------------------------------------------------------
 498
 499         // Mismatched and invalid vector types
 500         fcmeq v0.2d, v1.2s, v2.2d
 501         fcmeq v0.16b, v1.16b, v2.16b
 502         fcmeq v0.8b, v1.4h, v2.4h
 503
 504 // CHECK-ERROR: error: invalid operand for instruction
 505 // CHECK-ERROR:        fcmeq v0.2d, v1.2s, v2.2d
 506 // CHECK-ERROR:                        ^
 507 // CHECK-ERROR: error: invalid operand for instruction
 508 // CHECK-ERROR:        fcmeq v0.16b, v1.16b, v2.16b
 509 // CHECK-ERROR:                 ^
 510 // CHECK-ERROR: error: invalid operand for instruction
 511 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, v2.4h
 512 // CHECK-ERROR:                 ^
 513
 514 //----------------------------------------------------------------------
 515 // Vector Compare Mask Greater Than Or Equal (Floating Point)
 516 // Vector Compare Mask Less Than Or Equal (Floating Point)
 517 // FCMLE is alias for FCMGE with operands reversed.
 518 //----------------------------------------------------------------------
 519
 520         // Mismatched and invalid vector types
 521          fcmge v31.4s, v29.2s, v28.4s
 522          fcmge v3.8b, v8.2s, v12.2s
 523          fcmle v17.8h, v15.2d, v13.2d
 524
 525 // CHECK-ERROR: error: invalid operand for instruction
 526 // CHECK-ERROR:        fcmge v31.4s, v29.2s, v28.4s
 527 // CHECK-ERROR:                          ^
 528 // CHECK-ERROR: error: invalid operand for instruction
 529 // CHECK-ERROR:        fcmge v3.8b, v8.2s, v12.2s
 530 // CHECK-ERROR:                 ^
 531 // CHECK-ERROR: error: invalid operand for instruction
 532 // CHECK-ERROR:        fcmle v17.8h, v15.2d, v13.2d
 533 // CHECK-ERROR:                 ^
 534
 535 //----------------------------------------------------------------------
 536 // Vector Compare Mask Greater Than (Floating Point)
 537 // Vector Compare Mask Less Than (Floating Point)
 538 // FCMLT is alias for FCMGT with operands reversed.
 539 //----------------------------------------------------------------------
 540
 541         // Mismatched and invalid vector types
 542          fcmgt v0.2d, v31.2s, v16.2s
 543          fcmgt v4.4s, v7.4s, v15.4h
 544          fcmlt v29.2d, v5.2d, v2.16b
 545
 546 // CHECK-ERROR: error: invalid operand for instruction
 547 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, v16.2s
 548 // CHECK-ERROR:                         ^
 549 // CHECK-ERROR: error: expected floating-point constant #0.0 or invalid register type
 550 // CHECK-ERROR:        fcmgt v4.4s, v7.4s, v15.4h
 551 // CHECK-ERROR:                                ^
 552 // CHECK-ERROR: error: expected floating-point constant #0.0 or invalid register type
 553 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, v2.16b
 554 // CHECK-ERROR:                                ^
 555
 556 //----------------------------------------------------------------------
 557 // Vector Compare Mask Equal to Zero (Integer)
 558 //----------------------------------------------------------------------
 559         // Mismatched vector types and invalid imm
 560          // Mismatched vector types
 561          cmeq c0.2d, v1.2s, #0
 562          cmeq c0.2d, v1.2d, #1
 563
 564 // CHECK-ERROR: error: invalid operand for instruction
 565 // CHECK-ERROR:        cmeq c0.2d, v1.2s, #0
 566 // CHECK-ERROR:                       ^
 567 // CHECK-ERROR: error: invalid operand for instruction
 568 // CHECK-ERROR:        cmeq c0.2d, v1.2d, #1
 569 // CHECK-ERROR:                            ^
 570
 571 //----------------------------------------------------------------------
 572 // Vector Compare Mask Greater Than or Equal to Zero (Signed Integer)
 573 //----------------------------------------------------------------------
 574         // Mismatched vector types and invalid imm
 575          cmge c0.8h, v1.8b, #0
 576          cmge c0.4s, v1.4s, #-1
 577
 578 // CHECK-ERROR: error: invalid operand for instruction
 579 // CHECK-ERROR:        cmge c0.8h, v1.8b, #0
 580 // CHECK-ERROR:                       ^
 581 // CHECK-ERROR: error: invalid operand for instruction
 582 // CHECK-ERROR:         cmge c0.4s, v1.4s, #-1
 583 // CHECK-ERROR:                             ^
 584
 585 //----------------------------------------------------------------------
 586 // Vector Compare Mask Greater Than Zero (Signed Integer)
 587 //----------------------------------------------------------------------
 588         // Mismatched vector types and invalid imm
 589          cmgt c0.8b, v1.4s, #0
 590          cmgt c0.8b, v1.8b, #-255
 591
 592 // CHECK-ERROR: error: invalid operand for instruction
 593 // CHECK-ERROR:         cmgt c0.8b, v1.4s, #0
 594 // CHECK-ERROR:                        ^
 595 // CHECK-ERROR: error: invalid operand for instruction
 596 // CHECK-ERROR:         cmgt c0.8b, v1.8b, #-255
 597 // CHECK-ERROR:                             ^
 598
 599 //----------------------------------------------------------------------
 600 // Vector Compare Mask Less Than or Equal To Zero (Signed Integer)
 601 //----------------------------------------------------------------------
 602         // Mismatched vector types and invalid imm
 603          cmle c0.4h, v1.2s, #0
 604          cmle c0.16b, v1.16b, #16
 605
 606 // CHECK-ERROR: error: invalid operand for instruction
 607 // CHECK-ERROR:        cmle c0.4h, v1.2s, #0
 608 // CHECK-ERROR:                       ^
 609 // CHECK-ERROR: error: invalid operand for instruction
 610 // CHECK-ERROR:         cmle c0.16b, v1.16b, #16
 611 // CHECK-ERROR:                               ^
 612 //----------------------------------------------------------------------
 613 // Vector Compare Mask Less Than Zero (Signed Integer)
 614 //----------------------------------------------------------------------
 615         // Mismatched vector types and invalid imm
 616          cmlt c0.8h, v1.16b, #0
 617          cmlt c0.8h, v1.8h, #-15
 618
 619 // CHECK-ERROR: error: invalid operand for instruction
 620 // CHECK-ERROR:         cmlt c0.8h, v1.16b, #0
 621 // CHECK-ERROR:                        ^
 622 // CHECK-ERROR: error: invalid operand for instruction
 623 // CHECK-ERROR:         cmlt c0.8h, v1.8h, #-15
 624 // CHECK-ERROR:                             ^
 625
 626 //----------------------------------------------------------------------
 627 // Vector Compare Mask Equal to Zero (Floating Point)
 628 //----------------------------------------------------------------------
 629
 630         // Mismatched and invalid vector types, invalid imm
 631         fcmeq v0.2d, v1.2s, #0.0
 632         fcmeq v0.16b, v1.16b, #0.0
 633         fcmeq v0.8b, v1.4h, #1.0
 634         fcmeq v0.8b, v1.4h, #1
 635
 636 // CHECK-ERROR: error: invalid operand for instruction
 637 // CHECK-ERROR:        fcmeq v0.2d, v1.2s, #0.0
 638 // CHECK-ERROR:                        ^
 639 // CHECK-ERROR: error: invalid operand for instruction
 640 // CHECK-ERROR:        fcmeq v0.16b, v1.16b, #0.0
 641 // CHECK-ERROR:                 ^
 642 // CHECK-ERROR: error: invalid operand for instruction
 643 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1.0
 644 // CHECK-ERROR:                             ^
 645 // CHECK-ERROR: error:  Expected floating-point immediate
 646 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1
 647 // CHECK-ERROR:                             ^
 648 //----------------------------------------------------------------------
 649 // Vector Compare Mask Greater Than or Equal to Zero (Floating Point)
 650 //----------------------------------------------------------------------
 651
 652         // Mismatched and invalid vector types, invalid imm
 653          fcmge v31.4s, v29.2s, #0.0
 654          fcmge v3.8b, v8.2s, #0.0
 655          fcmle v17.8h, v15.2d, #-1.0
 656          fcmle v17.8h, v15.2d, #0
 657
 658 // CHECK-ERROR: error: invalid operand for instruction
 659 // CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
 660 // CHECK-ERROR:                          ^
 661 // CHECK-ERROR: error: invalid operand for instruction
 662 // CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
 663 // CHECK-ERROR:                 ^
 664 // CHECK-ERROR: error: invalid operand for instruction
 665 // CHECK-ERROR:        fcmle v17.8h, v15.2d, #-1.0
 666 // CHECK-ERROR:                               ^
 667 // CHECK-ERROR: error:  Expected floating-point immediate
 668 // CHECK-ERROR:        fcmle v17.8h, v15.2d, #0
 669 // CHECK-ERROR:                               ^
 670 //----------------------------------------------------------------------
 671 // Vector Compare Mask Greater Than Zero (Floating Point)
 672 //----------------------------------------------------------------------
 673         // Mismatched and invalid vector types, invalid imm
 674          fcmgt v0.2d, v31.2s, #0.0
 675          fcmgt v4.4s, v7.4h, #0.0
 676          fcmlt v29.2d, v5.2d, #255.0
 677          fcmlt v29.2d, v5.2d, #255
 678
 679 // CHECK-ERROR: error: invalid operand for instruction
 680 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
 681 // CHECK-ERROR:                         ^
 682 // CHECK-ERROR: error: invalid operand for instruction
 683 // CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
 684 // CHECK-ERROR:                        ^
 685 // CHECK-ERROR: error: expected floating-point constant #0.0 or invalid register type
 686 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255.0
 687 // CHECK-ERROR:                              ^
 688 // CHECK-ERROR: error:  Expected floating-point immediate
 689 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255
 690 // CHECK-ERROR:                              ^
 691
 692 //----------------------------------------------------------------------
 693 // Vector Compare Mask Less Than or Equal To Zero (Floating Point)
 694 //----------------------------------------------------------------------
 695         // Mismatched and invalid vector types, invalid imm
 696          fcmge v31.4s, v29.2s, #0.0
 697          fcmge v3.8b, v8.2s, #0.0
 698          fcmle v17.2d, v15.2d, #15.0
 699          fcmle v17.2d, v15.2d, #15
 700
 701 // CHECK-ERROR: error: invalid operand for instruction
 702 // CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
 703 // CHECK-ERROR:                          ^
 704 // CHECK-ERROR: error: invalid operand for instruction
 705 // CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
 706 // CHECK-ERROR:                 ^
 707 // CHECK-ERROR: error: expected floating-point constant #0.0 or invalid register type
 708 // CHECK-ERROR:        fcmle v17.2d, v15.2d, #15.0
 709 // CHECK-ERROR:                               ^
 710 // CHECK-ERROR: error:  Expected floating-point immediate
 711 // CHECK-ERROR:        fcmle v17.2d, v15.2d, #15
 712 // CHECK-ERROR:                              ^
 713
 714 //----------------------------------------------------------------------
 715 // Vector Compare Mask Less Than Zero (Floating Point)
 716 //----------------------------------------------------------------------
 717         // Mismatched and invalid vector types, invalid imm
 718          fcmgt v0.2d, v31.2s, #0.0
 719          fcmgt v4.4s, v7.4h, #0.0
 720          fcmlt v29.2d, v5.2d, #16.0
 721          fcmlt v29.2d, v5.2d, #2
 722
 723 // CHECK-ERROR: error: invalid operand for instruction
 724 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
 725 // CHECK-ERROR:                         ^
 726 // CHECK-ERROR: error: invalid operand for instruction
 727 // CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
 728 // CHECK-ERROR:                        ^
 729 // CHECK-ERROR: error: expected floating-point constant #0.0 or invalid register type
 730 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #16.0
 731 // CHECK-ERROR:                              ^
 732 // CHECK-ERROR: error:  Expected floating-point immediate
 733 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #2
 734 // CHECK-ERROR:                              ^
 735
 736 /-----------------------------------------------------------------------
 737 // Vector Integer Halving Add (Signed)
 738 // Vector Integer Halving Add (Unsigned)
 739 // Vector Integer Halving Sub (Signed)
 740 // Vector Integer Halving Sub (Unsigned)
 741 //----------------------------------------------------------------------
 742         // Mismatched and invalid vector types (2d)
 743         shadd v0.2d, v1.2d, v2.2d
 744         uhadd v4.2s, v5.2s, v5.4h
 745         shsub v11.4h, v12.8h, v13.4h
 746         uhsub v31.16b, v29.8b, v28.8b
 747
 748 // CHECK-ERROR: error: invalid operand for instruction
 749 // CHECK-ERROR:        shadd v0.2d, v1.2d, v2.2d
 750 // CHECK-ERROR:                 ^
 751 // CHECK-ERROR: error: invalid operand for instruction
 752 // CHECK-ERROR:        uhadd v4.2s, v5.2s, v5.4h
 753 // CHECK-ERROR:                               ^
 754 // CHECK-ERROR: error: invalid operand for instruction
 755 // CHECK-ERROR:        shsub v11.4h, v12.8h, v13.4h
 756 // CHECK-ERROR:                          ^
 757 // CHECK-ERROR: error: invalid operand for instruction
 758 // CHECK-ERROR:        uhsub v31.16b, v29.8b, v28.8b
 759 // CHECK-ERROR:                          ^
 760
 761 //----------------------------------------------------------------------
 762 // Vector Integer Rouding Halving Add (Signed)
 763 // Vector Integer Rouding Halving Add (Unsigned)
 764 //----------------------------------------------------------------------
 765
 766         // Mismatched and invalid vector types (2d)
 767         srhadd v0.2s, v1.2s, v2.2d
 768         urhadd v0.16b, v1.16b, v2.8h
 769
 770 // CHECK-ERROR: error: invalid operand for instruction
 771 // CHECK-ERROR:        srhadd v0.2s, v1.2s, v2.2d
 772 // CHECK-ERROR:                                ^
 773 // CHECK-ERROR: error: invalid operand for instruction
 774 // CHECK-ERROR:        urhadd v0.16b, v1.16b, v2.8h
 775 // CHECK-ERROR:                                  ^
 776
 777 //----------------------------------------------------------------------
 778 // Vector Integer Saturating Add (Signed)
 779 // Vector Integer Saturating Add (Unsigned)
 780 // Vector Integer Saturating Sub (Signed)
 781 // Vector Integer Saturating Sub (Unsigned)
 782 //----------------------------------------------------------------------
 783
 784         // Mismatched vector types
 785         sqadd v0.2s, v1.2s, v2.2d
 786         uqadd v31.8h, v1.4h, v2.4h
 787         sqsub v10.8h, v1.16b, v2.16b
 788         uqsub v31.8b, v1.8b, v2.4s
 789
 790 // CHECK-ERROR: error: invalid operand for instruction
 791 // CHECK-ERROR:        sqadd v0.2s, v1.2s, v2.2d
 792 // CHECK-ERROR:                               ^
 793 // CHECK-ERROR: error: invalid operand for instruction
 794 // CHECK-ERROR:        uqadd v31.8h, v1.4h, v2.4h
 795 // CHECK-ERROR:                         ^
 796 // CHECK-ERROR: error: invalid operand for instruction
 797 // CHECK-ERROR:        sqsub v10.8h, v1.16b, v2.16b
 798 // CHECK-ERROR:                         ^
 799 // CHECK-ERROR: error: invalid operand for instruction
 800 // CHECK-ERROR:        uqsub v31.8b, v1.8b, v2.4s
 801 // CHECK-ERROR:                                ^
 802
 803 //----------------------------------------------------------------------
 804 // Scalar Integer Saturating Add (Signed)
 805 // Scalar Integer Saturating Add (Unsigned)
 806 // Scalar Integer Saturating Sub (Signed)
 807 // Scalar Integer Saturating Sub (Unsigned)
 808 //----------------------------------------------------------------------
 809
 810       // Mismatched registers
 811          sqadd d0, s31, d2
 812          uqadd s0, s1, d2
 813          sqsub b0, b2, s18
 814          uqsub h1, h2, d2
 815
 816 // CHECK-ERROR: error: invalid operand for instruction
 817 // CHECK-ERROR:        sqadd d0, s31, d2
 818 // CHECK-ERROR:                  ^
 819 // CHECK-ERROR: error: invalid operand for instruction
 820 // CHECK-ERROR:        uqadd s0, s1, d2
 821 // CHECK-ERROR:                      ^
 822 // CHECK-ERROR: error: invalid operand for instruction
 823 // CHECK-ERROR:        sqsub b0, b2, s18
 824 // CHECK-ERROR:                      ^
 825 // CHECK-ERROR: error: invalid operand for instruction
 826 // CHECK-ERROR:        uqsub h1, h2, d2
 827 // CHECK-ERROR:                      ^
 828
 829
 830 //----------------------------------------------------------------------
 831 // Vector Shift Left (Signed and Unsigned Integer)
 832 //----------------------------------------------------------------------
 833         // Mismatched vector types
 834         sshl v0.4s, v15.2s, v16.2s
 835         ushl v1.16b, v25.16b, v6.8h
 836
 837 // CHECK-ERROR: error: invalid operand for instruction
 838 // CHECK-ERROR:        sshl v0.4s, v15.2s, v16.2s
 839 // CHECK-ERROR:                        ^
 840 // CHECK-ERROR: error: invalid operand for instruction
 841 // CHECK-ERROR:        ushl v1.16b, v25.16b, v6.8h
 842 // CHECK-ERROR:                                 ^
 843
 844 //----------------------------------------------------------------------
 845 // Vector Saturating Shift Left (Signed and Unsigned Integer)
 846 //----------------------------------------------------------------------
 847         // Mismatched vector types
 848         sqshl v0.2s, v15.4s, v16.2d
 849         uqshl v1.8b, v25.4h, v6.8h
 850
 851 // CHECK-ERROR: error: invalid operand for instruction
 852 // CHECK-ERROR:        sqshl v0.2s, v15.4s, v16.2d
 853 // CHECK-ERROR:                         ^
 854 // CHECK-ERROR: error: invalid operand for instruction
 855 // CHECK-ERROR:        uqshl v1.8b, v25.4h, v6.8h
 856 // CHECK-ERROR:                         ^
 857
 858 //----------------------------------------------------------------------
 859 // Vector Rouding Shift Left (Signed and Unsigned Integer)
 860 //----------------------------------------------------------------------
 861         // Mismatched vector types
 862         srshl v0.8h, v15.8h, v16.16b
 863         urshl v1.2d, v25.2d, v6.4s
 864
 865 // CHECK-ERROR: error: invalid operand for instruction
 866 // CHECK-ERROR:        srshl v0.8h, v15.8h, v16.16b
 867 // CHECK-ERROR:                                 ^
 868 // CHECK-ERROR: error: invalid operand for instruction
 869 // CHECK-ERROR:        urshl v1.2d, v25.2d, v6.4s
 870 // CHECK-ERROR:                                ^
 871
 872 //----------------------------------------------------------------------
 873 // Vector Saturating Rouding Shift Left (Signed and Unsigned Integer)
 874 //----------------------------------------------------------------------
 875         // Mismatched vector types
 876         sqrshl v0.2s, v15.8h, v16.16b
 877         uqrshl v1.4h, v25.4h,  v6.2d
 878
 879 // CHECK-ERROR: error: invalid operand for instruction
 880 // CHECK-ERROR:        sqrshl v0.2s, v15.8h, v16.16b
 881 // CHECK-ERROR:                          ^
 882 // CHECK-ERROR: error: invalid operand for instruction
 883 // CHECK-ERROR:        uqrshl v1.4h, v25.4h,  v6.2d
 884 // CHECK-ERROR:                                  ^
 885
 886 //----------------------------------------------------------------------
 887 // Scalar Integer Shift Left (Signed, Unsigned)
 888 //----------------------------------------------------------------------
 889         // Mismatched and invalid vector types
 890         sshl d0, d1, s2
 891         ushl b2, b0, b1
 892
 893 // CHECK-ERROR: error: invalid operand for instruction
 894 // CHECK-ERROR:        sshl d0, d1, s2
 895 // CHECK-ERROR:                     ^
 896 // CHECK-ERROR: error: invalid operand for instruction
 897 // CHECK-ERROR:        ushl b2, b0, b1
 898 // CHECK-ERROR:             ^
 899
 900 //----------------------------------------------------------------------
 901 // Scalar Integer Saturating Shift Left (Signed, Unsigned)
 902 //----------------------------------------------------------------------
 903
 904         // Mismatched vector types
 905         sqshl b0, b1, s0
 906         uqshl h0, h1, b0
 907         sqshl s0, s1, h0
 908         uqshl d0, d1, b0
 909
 910 // CHECK-ERROR: error: invalid operand for instruction
 911 // CHECK-ERROR:        sqshl b0, b1, s0
 912 // CHECK-ERROR:                      ^
 913 // CHECK-ERROR: error: invalid operand for instruction
 914 // CHECK-ERROR:        uqshl h0, h1, b0
 915 // CHECK-ERROR:                      ^
 916 // CHECK-ERROR: error: invalid operand for instruction
 917 // CHECK-ERROR:        sqshl s0, s1, h0
 918 // CHECK-ERROR:                      ^
 919 // CHECK-ERROR: error: invalid operand for instruction
 920 // CHECK-ERROR:        uqshl d0, d1, b0
 921 // CHECK-ERROR:                      ^
 922
 923 //----------------------------------------------------------------------
 924 // Scalar Integer Rouding Shift Left (Signed, Unsigned)
 925 //----------------------------------------------------------------------
 926         // Mismatched and invalid vector types
 927         srshl h0, h1, h2
 928         urshl s0, s1, s2
 929
 930 // CHECK-ERROR: error: invalid operand for instruction
 931 // CHECK-ERROR:        srshl h0, h1, h2
 932 // CHECK-ERROR:              ^
 933 // CHECK-ERROR: error: invalid operand for instruction
 934 // CHECK-ERROR:        urshl s0, s1, s2
 935 // CHECK-ERROR:              ^
 936
 937
 938 //----------------------------------------------------------------------
 939 // Scalar Integer Saturating Rounding Shift Left (Signed, Unsigned)
 940 //----------------------------------------------------------------------
 941
 942         // Mismatched vector types
 943         sqrshl b0, b1, s0
 944         uqrshl h0, h1, b0
 945         sqrshl s0, s1, h0
 946         uqrshl d0, d1, b0
 947
 948 // CHECK-ERROR: error: invalid operand for instruction
 949 // CHECK-ERROR:        sqrshl b0, b1, s0
 950 // CHECK-ERROR:                       ^
 951 // CHECK-ERROR: error: invalid operand for instruction
 952 // CHECK-ERROR:        uqrshl h0, h1, b0
 953 // CHECK-ERROR:                       ^
 954 // CHECK-ERROR: error: invalid operand for instruction
 955 // CHECK-ERROR:        sqrshl s0, s1, h0
 956 // CHECK-ERROR:                       ^
 957 // CHECK-ERROR: error: invalid operand for instruction
 958 // CHECK-ERROR:        uqrshl d0, d1, b0
 959 // CHECK-ERROR:                       ^
 960
 961
 962 //----------------------------------------------------------------------
 963 // Vector Maximum (Signed, Unsigned)
 964 //----------------------------------------------------------------------
 965         // Mismatched and invalid vector types
 966         smax v0.2d, v1.2d, v2.2d
 967         umax v0.4h, v1.4h, v2.2s
 968
 969 // CHECK-ERROR: error: invalid operand for instruction
 970 // CHECK-ERROR:        smax v0.2d, v1.2d, v2.2d
 971 // CHECK-ERROR:                ^
 972 // CHECK-ERROR: error: invalid operand for instruction
 973 // CHECK-ERROR:        umax v0.4h, v1.4h, v2.2s
 974 // CHECK-ERROR:                              ^
 975
 976 //----------------------------------------------------------------------
 977 // Vector Minimum (Signed, Unsigned)
 978 //----------------------------------------------------------------------
 979         // Mismatched and invalid vector types
 980         smin v0.2d, v1.2d, v2.2d
 981         umin v0.2s, v1.2s, v2.8b
 982
 983 // CHECK-ERROR: error: invalid operand for instruction
 984 // CHECK-ERROR:        smin v0.2d, v1.2d, v2.2d
 985 // CHECK-ERROR:                ^
 986 // CHECK-ERROR: error: invalid operand for instruction
 987 // CHECK-ERROR:        umin v0.2s, v1.2s, v2.8b
 988 // CHECK-ERROR:                             ^
 989
 990
 991 //----------------------------------------------------------------------
 992 // Vector Maximum (Floating Point)
 993 //----------------------------------------------------------------------
 994         // Mismatched and invalid vector types
 995         fmax v0.2s, v1.2s, v2.4s
 996         fmax v0.8b, v1.8b, v2.8b
 997
 998 // CHECK-ERROR: error: invalid operand for instruction
 999 // CHECK-ERROR:        fmax v0.2s, v1.2s, v2.4s
1000 // CHECK-ERROR:                              ^
1001 // CHECK-ERROR: error: invalid operand for instruction
1002 // CHECK-ERROR:        fmax v0.8b, v1.8b, v2.8b
1003 // CHECK-ERROR:                ^
1004 //----------------------------------------------------------------------
1005 // Vector Minimum (Floating Point)
1006 //----------------------------------------------------------------------
1007         // Mismatched and invalid vector types
1008         fmin v0.4s, v1.4s, v2.2d
1009         fmin v0.8h, v1.8h, v2.8h
1010
1011 // CHECK-ERROR: error: invalid operand for instruction
1012 // CHECK-ERROR:        fmin v0.4s, v1.4s, v2.2d
1013 // CHECK-ERROR:                              ^
1014 // CHECK-ERROR: error: invalid operand for instruction
1015 // CHECK-ERROR:        fmin v0.8h, v1.8h, v2.8h
1016 // CHECK-ERROR:                ^
1017
1018 //----------------------------------------------------------------------
1019 // Vector maxNum (Floating Point)
1020 //----------------------------------------------------------------------
1021         // Mismatched and invalid vector types
1022         fmaxnm v0.2s, v1.2s, v2.2d
1023         fmaxnm v0.4h, v1.8h, v2.4h
1024
1025 // CHECK-ERROR: error: invalid operand for instruction
1026 // CHECK-ERROR:        fmaxnm v0.2s, v1.2s, v2.2d
1027 // CHECK-ERROR:                                ^
1028 // CHECK-ERROR: error: invalid operand for instruction
1029 // CHECK-ERROR:        fmaxnm v0.4h, v1.8h, v2.4h
1030 // CHECK-ERROR:                  ^
1031
1032 //----------------------------------------------------------------------
1033 // Vector minNum (Floating Point)
1034 //----------------------------------------------------------------------
1035         // Mismatched and invalid vector types
1036         fminnm v0.4s, v1.2s, v2.4s
1037         fminnm v0.16b, v0.16b, v0.16b
1038
1039 // CHECK-ERROR: error: invalid operand for instruction
1040 // CHECK-ERROR:        fminnm v0.4s, v1.2s, v2.4s
1041 // CHECK-ERROR:                         ^
1042 // CHECK-ERROR: error: invalid operand for instruction
1043 // CHECK-ERROR:        fminnm v0.16b, v0.16b, v0.16b
1044 // CHECK-ERROR:                  ^
1045
1046
1047 //----------------------------------------------------------------------
1048 // Vector Maximum Pairwise (Signed, Unsigned)
1049 //----------------------------------------------------------------------
1050         // Mismatched and invalid vector types
1051         smaxp v0.2d, v1.2d, v2.2d
1052         umaxp v0.4h, v1.4h, v2.2s
1053
1054 // CHECK-ERROR: error: invalid operand for instruction
1055 // CHECK-ERROR:        smaxp v0.2d, v1.2d, v2.2d
1056 // CHECK-ERROR:                 ^
1057 // CHECK-ERROR: error: invalid operand for instruction
1058 // CHECK-ERROR:        umaxp v0.4h, v1.4h, v2.2s
1059 // CHECK-ERROR:                               ^
1060
1061 //----------------------------------------------------------------------
1062 // Vector Minimum Pairwise (Signed, Unsigned)
1063 //----------------------------------------------------------------------
1064         // Mismatched and invalid vector types
1065         sminp v0.2d, v1.2d, v2.2d
1066         uminp v0.2s, v1.2s, v2.8b
1067
1068 // CHECK-ERROR: error: invalid operand for instruction
1069 // CHECK-ERROR:        sminp v0.2d, v1.2d, v2.2d
1070 // CHECK-ERROR:                 ^
1071 // CHECK-ERROR: error: invalid operand for instruction
1072 // CHECK-ERROR:        uminp v0.2s, v1.2s, v2.8b
1073 // CHECK-ERROR:                               ^
1074
1075
1076 //----------------------------------------------------------------------
1077 // Vector Maximum Pairwise (Floating Point)
1078 //----------------------------------------------------------------------
1079         // Mismatched and invalid vector types
1080         fmaxp v0.2s, v1.2s, v2.4s
1081         fmaxp v0.8b, v1.8b, v2.8b
1082
1083 // CHECK-ERROR: error: invalid operand for instruction
1084 // CHECK-ERROR:        fmaxp v0.2s, v1.2s, v2.4s
1085 // CHECK-ERROR:                               ^
1086 // CHECK-ERROR: error: invalid operand for instruction
1087 // CHECK-ERROR:        fmaxp v0.8b, v1.8b, v2.8b
1088 // CHECK-ERROR:                 ^
1089 //----------------------------------------------------------------------
1090 // Vector Minimum Pairwise (Floating Point)
1091 //----------------------------------------------------------------------
1092         // Mismatched and invalid vector types
1093         fminp v0.4s, v1.4s, v2.2d
1094         fminp v0.8h, v1.8h, v2.8h
1095
1096 // CHECK-ERROR: error: invalid operand for instruction
1097 // CHECK-ERROR:        fminp v0.4s, v1.4s, v2.2d
1098 // CHECK-ERROR:                               ^
1099 // CHECK-ERROR: error: invalid operand for instruction
1100 // CHECK-ERROR:        fminp v0.8h, v1.8h, v2.8h
1101 // CHECK-ERROR:                 ^
1102
1103 //----------------------------------------------------------------------
1104 // Vector maxNum Pairwise (Floating Point)
1105 //----------------------------------------------------------------------
1106         // Mismatched and invalid vector types
1107         fmaxnmp v0.2s, v1.2s, v2.2d
1108         fmaxnmp v0.4h, v1.8h, v2.4h
1109
1110 // CHECK-ERROR: error: invalid operand for instruction
1111 // CHECK-ERROR:        fmaxnmp v0.2s, v1.2s, v2.2d
1112 // CHECK-ERROR:                                 ^
1113 // CHECK-ERROR: error: invalid operand for instruction
1114 // CHECK-ERROR:        fmaxnmp v0.4h, v1.8h, v2.4h
1115 // CHECK-ERROR:                   ^
1116
1117 //----------------------------------------------------------------------
1118 // Vector minNum Pairwise (Floating Point)
1119 //----------------------------------------------------------------------
1120         // Mismatched and invalid vector types
1121         fminnmp v0.4s, v1.2s, v2.4s
1122         fminnmp v0.16b, v0.16b, v0.16b
1123
1124 // CHECK-ERROR: error: invalid operand for instruction
1125 // CHECK-ERROR:        fminnmp v0.4s, v1.2s, v2.4s
1126 // CHECK-ERROR:                          ^
1127 // CHECK-ERROR: error: invalid operand for instruction
1128 // CHECK-ERROR:        fminnmp v0.16b, v0.16b, v0.16b
1129 // CHECK-ERROR:                   ^
1130
1131
1132 //----------------------------------------------------------------------
1133 // Vector Add Pairwise (Integer)
1134 //----------------------------------------------------------------------
1135
1136         // Mismatched vector types
1137         addp v0.16b, v1.8b, v2.8b
1138
1139 // CHECK-ERROR: error: invalid operand for instruction
1140 // CHECK-ERROR:         addp v0.16b, v1.8b, v2.8b
1141 // CHECK-ERROR:                         ^
1142
1143 //----------------------------------------------------------------------
1144 // Vector Add Pairwise (Floating Point)
1145 //----------------------------------------------------------------------
1146         // Mismatched and invalid vector types
1147         faddp v0.16b, v1.8b, v2.8b
1148         faddp v0.2d, v1.2d, v2.8h
1149
1150 // CHECK-ERROR: error: invalid operand for instruction
1151 // CHECK-ERROR:         faddp v0.16b, v1.8b, v2.8b
1152 // CHECK-ERROR:                  ^
1153 // CHECK-ERROR: error: invalid operand for instruction
1154 // CHECK-ERROR:         faddp v0.2d, v1.2d, v2.8h
1155 // CHECK-ERROR:                                ^
1156
1157
1158 //----------------------------------------------------------------------
1159 // Vector Saturating Doubling Multiply High
1160 //----------------------------------------------------------------------
1161          // Mismatched and invalid vector types
1162          sqdmulh v2.4h, v25.8h, v3.4h
1163          sqdmulh v12.2d, v5.2d, v13.2d
1164          sqdmulh v3.8b, v1.8b, v30.8b
1165
1166 // CHECK-ERROR: error: invalid operand for instruction
1167 // CHECK-ERROR:         sqdmulh v2.4h, v25.8h, v3.4h
1168 // CHECK-ERROR:                            ^
1169 // CHECK-ERROR: error: invalid operand for instruction
1170 // CHECK-ERROR:         sqdmulh v12.2d, v5.2d, v13.2d
1171 // CHECK-ERROR:                     ^
1172 // CHECK-ERROR: error: invalid operand for instruction
1173 // CHECK-ERROR:         sqdmulh v3.8b, v1.8b, v30.8b
1174 // CHECK-ERROR:                    ^
1175
1176 //----------------------------------------------------------------------
1177 // Vector Saturating Rouding Doubling Multiply High
1178 //----------------------------------------------------------------------
1179          // Mismatched and invalid vector types
1180          sqrdmulh v2.2s, v25.4s, v3.4s
1181          sqrdmulh v12.16b, v5.16b, v13.16b
1182          sqrdmulh v3.4h, v1.4h, v30.2d
1183
1184
1185 // CHECK-ERROR: error: invalid operand for instruction
1186 // CHECK-ERROR:         sqrdmulh v2.2s, v25.4s, v3.4s
1187 // CHECK-ERROR:                             ^
1188 // CHECK-ERROR: error: invalid operand for instruction
1189 // CHECK-ERROR:         sqrdmulh v12.16b, v5.16b, v13.16b
1190 // CHECK-ERROR:                       ^
1191 // CHECK-ERROR: error: invalid operand for instruction
1192 // CHECK-ERROR:         sqrdmulh v3.4h, v1.4h, v30.2d
1193 // CHECK-ERROR:                                    ^
1194
1195 //----------------------------------------------------------------------
1196 // Vector Multiply Extended
1197 //----------------------------------------------------------------------
1198          // Mismatched and invalid vector types
1199       fmulx v21.2s, v5.2s, v13.2d
1200       fmulx v1.4h, v25.4h, v3.4h
1201
1202 // CHECK-ERROR: error: invalid operand for instruction
1203 // CHECK-ERROR:         fmulx v21.2s, v5.2s, v13.2d
1204 // CHECK-ERROR:                                  ^
1205 // CHECK-ERROR: error: invalid operand for instruction
1206 // CHECK-ERROR:         fmulx v1.4h, v25.4h, v3.4h
1207 // CHECK-ERROR:                  ^
1208
1209 //------------------------------------------------------------------------------
1210 // Vector Shift Left by Immediate
1211 //------------------------------------------------------------------------------
1212          // Mismatched vector types and out of range
1213          shl v0.4s, v15,2s, #3
1214          shl v0.2d, v17.4s, #3
1215          shl v0.8b, v31.8b, #-1
1216          shl v0.8b, v31.8b, #8
1217          shl v0.4s, v21.4s, #32
1218          shl v0.2d, v1.2d, #64
1219
1220 // CHECK-ERROR: error: expected comma before next operand
1221 // CHECK-ERROR:         shl v0.4s, v15,2s, #3
1222 // CHECK-ERROR:                         ^
1223 // CHECK-ERROR: error: invalid operand for instruction
1224 // CHECK-ERROR:         shl v0.2d, v17.4s, #3
1225 // CHECK-ERROR:                        ^
1226 // CHECK-ERROR: error: expected integer in range [0, 7]
1227 // CHECK-ERROR:         shl v0.8b, v31.8b, #-1
1228 // CHECK-ERROR:                            ^
1229 // CHECK-ERROR: error: expected integer in range [0, 7]
1230 // CHECK-ERROR:         shl v0.8b, v31.8b, #8
1231 // CHECK-ERROR:                            ^
1232 // CHECK-ERROR: error: expected integer in range [0, 31]
1233 // CHECK-ERROR:         shl v0.4s, v21.4s, #32
1234 // CHECK-ERROR:                            ^
1235 // CHECK-ERROR: error: expected integer in range [0, 63]
1236 // CHECK-ERROR:         shl v0.2d, v1.2d, #64
1237 // CHECK-ERROR:                           ^
1238
1239 //----------------------------------------------------------------------
1240 // Vector Shift Left Long by Immediate
1241 //----------------------------------------------------------------------
1242         // Mismatched vector types
1243         sshll v0.4s, v15.2s, #3
1244         ushll v1.16b, v25.16b, #6
1245         sshll2 v0.2d, v3.8s, #15
1246         ushll2 v1.4s, v25.4s, #7
1247
1248         // Out of range
1249         sshll v0.8h, v1.8b, #-1
1250         sshll v0.8h, v1.8b, #9
1251         ushll v0.4s, v1.4h, #17
1252         ushll v0.2d, v1.2s, #33
1253         sshll2 v0.8h, v1.16b, #9
1254         sshll2 v0.4s, v1.8h, #17
1255         ushll2 v0.2d, v1.4s, #33
1256
1257 // CHECK-ERROR: error: invalid operand for instruction
1258 // CHECK-ERROR:        sshll v0.4s, v15.2s, #3
1259 // CHECK-ERROR:                         ^
1260 // CHECK-ERROR: error: invalid operand for instruction
1261 // CHECK-ERROR:        ushll v1.16b, v25.16b, #6
1262 // CHECK-ERROR:                 ^
1263 // CHECK-ERROR: error: invalid operand for instruction
1264 // CHECK-ERROR:        sshll2 v0.2d, v3.8s, #15
1265 // CHECK-ERROR:                      ^
1266 // CHECK-ERROR: error: invalid operand for instruction
1267 // CHECK-ERROR:        ushll2 v1.4s, v25.4s, #7
1268 // CHECK-ERROR:                          ^
1269 // CHECK-ERROR: error: expected integer in range [0, 7]
1270 // CHECK-ERROR:        sshll v0.8h, v1.8b, #-1
1271 // CHECK-ERROR:                            ^
1272 // CHECK-ERROR: error: expected integer in range [0, 7]
1273 // CHECK-ERROR:        sshll v0.8h, v1.8b, #9
1274 // CHECK-ERROR:                            ^
1275 // CHECK-ERROR: error: expected integer in range [0, 15]
1276 // CHECK-ERROR:        ushll v0.4s, v1.4h, #17
1277 // CHECK-ERROR:                            ^
1278 // CHECK-ERROR: error: expected integer in range [0, 31]
1279 // CHECK-ERROR:        ushll v0.2d, v1.2s, #33
1280 // CHECK-ERROR:                            ^
1281 // CHECK-ERROR: error: expected integer in range [0, 7]
1282 // CHECK-ERROR:        sshll2 v0.8h, v1.16b, #9
1283 // CHECK-ERROR:                              ^
1284 // CHECK-ERROR: error: expected integer in range [0, 15]
1285 // CHECK-ERROR:        sshll2 v0.4s, v1.8h, #17
1286 // CHECK-ERROR:                             ^
1287 // CHECK-ERROR: error: expected integer in range [0, 31]
1288 // CHECK-ERROR:        ushll2 v0.2d, v1.4s, #33
1289 // CHECK-ERROR:                             ^
1290
1291
1292 //------------------------------------------------------------------------------
1293 // Vector shift right by immediate
1294 //------------------------------------------------------------------------------
1295          sshr v0.8b, v1.8h, #3
1296          sshr v0.4h, v1.4s, #3
1297          sshr v0.2s, v1.2d, #3
1298          sshr v0.16b, v1.16b, #9
1299          sshr v0.8h, v1.8h, #17
1300          sshr v0.4s, v1.4s, #33
1301          sshr v0.2d, v1.2d, #65
1302
1303 // CHECK-ERROR: error: invalid operand for instruction
1304 // CHECK-ERROR:         sshr v0.8b, v1.8h, #3
1305 // CHECK-ERROR:                        ^
1306 // CHECK-ERROR: error: invalid operand for instruction
1307 // CHECK-ERROR:         sshr v0.4h, v1.4s, #3
1308 // CHECK-ERROR:                        ^
1309 // CHECK-ERROR: error: invalid operand for instruction
1310 // CHECK-ERROR:         sshr v0.2s, v1.2d, #3
1311 // CHECK-ERROR:                        ^
1312 // CHECK-ERROR: error: expected integer in range [1, 8]
1313 // CHECK-ERROR:         sshr v0.16b, v1.16b, #9
1314 // CHECK-ERROR:                              ^
1315 // CHECK-ERROR: error: expected integer in range [1, 16]
1316 // CHECK-ERROR:         sshr v0.8h, v1.8h, #17
1317 // CHECK-ERROR:                            ^
1318 // CHECK-ERROR: error: expected integer in range [1, 32]
1319 // CHECK-ERROR:         sshr v0.4s, v1.4s, #33
1320 // CHECK-ERROR:                            ^
1321 // CHECK-ERROR: error: expected integer in range [1, 64]
1322 // CHECK-ERROR:         sshr v0.2d, v1.2d, #65
1323 // CHECK-ERROR:                            ^
1324
1325 //------------------------------------------------------------------------------
1326 // Vector  shift right by immediate
1327 //------------------------------------------------------------------------------
1328          ushr v0.8b, v1.8h, #3
1329          ushr v0.4h, v1.4s, #3
1330          ushr v0.2s, v1.2d, #3
1331          ushr v0.16b, v1.16b, #9
1332          ushr v0.8h, v1.8h, #17
1333          ushr v0.4s, v1.4s, #33
1334          ushr v0.2d, v1.2d, #65
1335
1336 // CHECK-ERROR: error: invalid operand for instruction
1337 // CHECK-ERROR:         ushr v0.8b, v1.8h, #3
1338 // CHECK-ERROR:                        ^
1339 // CHECK-ERROR: error: invalid operand for instruction
1340 // CHECK-ERROR:         ushr v0.4h, v1.4s, #3
1341 // CHECK-ERROR:                        ^
1342 // CHECK-ERROR: error: invalid operand for instruction
1343 // CHECK-ERROR:         ushr v0.2s, v1.2d, #3
1344 // CHECK-ERROR:                        ^
1345 // CHECK-ERROR: error: expected integer in range [1, 8]
1346 // CHECK-ERROR:         ushr v0.16b, v1.16b, #9
1347 // CHECK-ERROR:                              ^
1348 // CHECK-ERROR: error: expected integer in range [1, 16]
1349 // CHECK-ERROR:         ushr v0.8h, v1.8h, #17
1350 // CHECK-ERROR:                            ^
1351 // CHECK-ERROR: error: expected integer in range [1, 32]
1352 // CHECK-ERROR:         ushr v0.4s, v1.4s, #33
1353 // CHECK-ERROR:                            ^
1354 // CHECK-ERROR: error: expected integer in range [1, 64]
1355 // CHECK-ERROR:         ushr v0.2d, v1.2d, #65
1356 // CHECK-ERROR:                            ^
1357
1358 //------------------------------------------------------------------------------
1359 // Vector shift right and accumulate by immediate
1360 //------------------------------------------------------------------------------
1361          ssra v0.8b, v1.8h, #3
1362          ssra v0.4h, v1.4s, #3
1363          ssra v0.2s, v1.2d, #3
1364          ssra v0.16b, v1.16b, #9
1365          ssra v0.8h, v1.8h, #17
1366          ssra v0.4s, v1.4s, #33
1367          ssra v0.2d, v1.2d, #65
1368
1369 // CHECK-ERROR: error: invalid operand for instruction
1370 // CHECK-ERROR:         ssra v0.8b, v1.8h, #3
1371 // CHECK-ERROR:                        ^
1372 // CHECK-ERROR: error: invalid operand for instruction
1373 // CHECK-ERROR:         ssra v0.4h, v1.4s, #3
1374 // CHECK-ERROR:                        ^
1375 // CHECK-ERROR: error: invalid operand for instruction
1376 // CHECK-ERROR:         ssra v0.2s, v1.2d, #3
1377 // CHECK-ERROR:                        ^
1378 // CHECK-ERROR: error: expected integer in range [1, 8]
1379 // CHECK-ERROR:         ssra v0.16b, v1.16b, #9
1380 // CHECK-ERROR:                              ^
1381 // CHECK-ERROR: error: expected integer in range [1, 16]
1382 // CHECK-ERROR:         ssra v0.8h, v1.8h, #17
1383 // CHECK-ERROR:                            ^
1384 // CHECK-ERROR: error: expected integer in range [1, 32]
1385 // CHECK-ERROR:         ssra v0.4s, v1.4s, #33
1386 // CHECK-ERROR:                            ^
1387 // CHECK-ERROR: error: expected integer in range [1, 64]
1388 // CHECK-ERROR:         ssra v0.2d, v1.2d, #65
1389 // CHECK-ERROR:                            ^
1390
1391 //------------------------------------------------------------------------------
1392 // Vector  shift right and accumulate by immediate
1393 //------------------------------------------------------------------------------
1394          usra v0.8b, v1.8h, #3
1395          usra v0.4h, v1.4s, #3
1396          usra v0.2s, v1.2d, #3
1397          usra v0.16b, v1.16b, #9
1398          usra v0.8h, v1.8h, #17
1399          usra v0.4s, v1.4s, #33
1400          usra v0.2d, v1.2d, #65
1401
1402 // CHECK-ERROR: error: invalid operand for instruction
1403 // CHECK-ERROR:         usra v0.8b, v1.8h, #3
1404 // CHECK-ERROR:                        ^
1405 // CHECK-ERROR: error: invalid operand for instruction
1406 // CHECK-ERROR:         usra v0.4h, v1.4s, #3
1407 // CHECK-ERROR:                        ^
1408 // CHECK-ERROR: error: invalid operand for instruction
1409 // CHECK-ERROR:         usra v0.2s, v1.2d, #3
1410 // CHECK-ERROR:                        ^
1411 // CHECK-ERROR: error: expected integer in range [1, 8]
1412 // CHECK-ERROR:         usra v0.16b, v1.16b, #9
1413 // CHECK-ERROR:                              ^
1414 // CHECK-ERROR: error: expected integer in range [1, 16]
1415 // CHECK-ERROR:         usra v0.8h, v1.8h, #17
1416 // CHECK-ERROR:                            ^
1417 // CHECK-ERROR: error: expected integer in range [1, 32]
1418 // CHECK-ERROR:         usra v0.4s, v1.4s, #33
1419 // CHECK-ERROR:                            ^
1420 // CHECK-ERROR: error: expected integer in range [1, 64]
1421 // CHECK-ERROR:         usra v0.2d, v1.2d, #65
1422 // CHECK-ERROR:                            ^
1423
1424 //------------------------------------------------------------------------------
1425 // Vector rounding shift right by immediate
1426 //------------------------------------------------------------------------------
1427          srshr v0.8b, v1.8h, #3
1428          srshr v0.4h, v1.4s, #3
1429          srshr v0.2s, v1.2d, #3
1430          srshr v0.16b, v1.16b, #9
1431          srshr v0.8h, v1.8h, #17
1432          srshr v0.4s, v1.4s, #33
1433          srshr v0.2d, v1.2d, #65
1434
1435 // CHECK-ERROR: error: invalid operand for instruction
1436 // CHECK-ERROR:         srshr v0.8b, v1.8h, #3
1437 // CHECK-ERROR:                         ^
1438 // CHECK-ERROR: error: invalid operand for instruction
1439 // CHECK-ERROR:         srshr v0.4h, v1.4s, #3
1440 // CHECK-ERROR:                         ^
1441 // CHECK-ERROR: error: invalid operand for instruction
1442 // CHECK-ERROR:         srshr v0.2s, v1.2d, #3
1443 // CHECK-ERROR:                         ^
1444 // CHECK-ERROR: error: expected integer in range [1, 8]
1445 // CHECK-ERROR:         srshr v0.16b, v1.16b, #9
1446 // CHECK-ERROR:                               ^
1447 // CHECK-ERROR: error: expected integer in range [1, 16]
1448 // CHECK-ERROR:         srshr v0.8h, v1.8h, #17
1449 // CHECK-ERROR:                             ^
1450 // CHECK-ERROR: error: expected integer in range [1, 32]
1451 // CHECK-ERROR:         srshr v0.4s, v1.4s, #33
1452 // CHECK-ERROR:                             ^
1453 // CHECK-ERROR: error: expected integer in range [1, 64]
1454 // CHECK-ERROR:         srshr v0.2d, v1.2d, #65
1455 // CHECK-ERROR:                             ^
1456
1457 //------------------------------------------------------------------------------
1458 // Vecotr rounding shift right by immediate
1459 //------------------------------------------------------------------------------
1460          urshr v0.8b, v1.8h, #3
1461          urshr v0.4h, v1.4s, #3
1462          urshr v0.2s, v1.2d, #3
1463          urshr v0.16b, v1.16b, #9
1464          urshr v0.8h, v1.8h, #17
1465          urshr v0.4s, v1.4s, #33
1466          urshr v0.2d, v1.2d, #65
1467
1468 // CHECK-ERROR: error: invalid operand for instruction
1469 // CHECK-ERROR:         urshr v0.8b, v1.8h, #3
1470 // CHECK-ERROR:                         ^
1471 // CHECK-ERROR: error: invalid operand for instruction
1472 // CHECK-ERROR:         urshr v0.4h, v1.4s, #3
1473 // CHECK-ERROR:                         ^
1474 // CHECK-ERROR: error: invalid operand for instruction
1475 // CHECK-ERROR:         urshr v0.2s, v1.2d, #3
1476 // CHECK-ERROR:                         ^
1477 // CHECK-ERROR: error: expected integer in range [1, 8]
1478 // CHECK-ERROR:         urshr v0.16b, v1.16b, #9
1479 // CHECK-ERROR:                               ^
1480 // CHECK-ERROR: error: expected integer in range [1, 16]
1481 // CHECK-ERROR:         urshr v0.8h, v1.8h, #17
1482 // CHECK-ERROR:                             ^
1483 // CHECK-ERROR: error: expected integer in range [1, 32]
1484 // CHECK-ERROR:         urshr v0.4s, v1.4s, #33
1485 // CHECK-ERROR:                             ^
1486 // CHECK-ERROR: error: expected integer in range [1, 64]
1487 // CHECK-ERROR:         urshr v0.2d, v1.2d, #65
1488 // CHECK-ERROR:                             ^
1489
1490 //------------------------------------------------------------------------------
1491 // Vector rounding shift right and accumulate by immediate
1492 //------------------------------------------------------------------------------
1493          srsra v0.8b, v1.8h, #3
1494          srsra v0.4h, v1.4s, #3
1495          srsra v0.2s, v1.2d, #3
1496          srsra v0.16b, v1.16b, #9
1497          srsra v0.8h, v1.8h, #17
1498          srsra v0.4s, v1.4s, #33
1499          srsra v0.2d, v1.2d, #65
1500
1501 // CHECK-ERROR: error: invalid operand for instruction
1502 // CHECK-ERROR:         srsra v0.8b, v1.8h, #3
1503 // CHECK-ERROR:                         ^
1504 // CHECK-ERROR: error: invalid operand for instruction
1505 // CHECK-ERROR:         srsra v0.4h, v1.4s, #3
1506 // CHECK-ERROR:                         ^
1507 // CHECK-ERROR: error: invalid operand for instruction
1508 // CHECK-ERROR:         srsra v0.2s, v1.2d, #3
1509 // CHECK-ERROR:                         ^
1510 // CHECK-ERROR: error: expected integer in range [1, 8]
1511 // CHECK-ERROR:         srsra v0.16b, v1.16b, #9
1512 // CHECK-ERROR:                               ^
1513 // CHECK-ERROR: error: expected integer in range [1, 16]
1514 // CHECK-ERROR:         srsra v0.8h, v1.8h, #17
1515 // CHECK-ERROR:                             ^
1516 // CHECK-ERROR: error: expected integer in range [1, 32]
1517 // CHECK-ERROR:         srsra v0.4s, v1.4s, #33
1518 // CHECK-ERROR:                             ^
1519 // CHECK-ERROR: error: expected integer in range [1, 64]
1520 // CHECK-ERROR:         srsra v0.2d, v1.2d, #65
1521 // CHECK-ERROR:                             ^
1522
1523 //------------------------------------------------------------------------------
1524 // Vector rounding shift right and accumulate by immediate
1525 //------------------------------------------------------------------------------
1526          ursra v0.8b, v1.8h, #3
1527          ursra v0.4h, v1.4s, #3
1528          ursra v0.2s, v1.2d, #3
1529          ursra v0.16b, v1.16b, #9
1530          ursra v0.8h, v1.8h, #17
1531          ursra v0.4s, v1.4s, #33
1532          ursra v0.2d, v1.2d, #65
1533
1534 // CHECK-ERROR: error: invalid operand for instruction
1535 // CHECK-ERROR:         ursra v0.8b, v1.8h, #3
1536 // CHECK-ERROR:                         ^
1537 // CHECK-ERROR: error: invalid operand for instruction
1538 // CHECK-ERROR:         ursra v0.4h, v1.4s, #3
1539 // CHECK-ERROR:                         ^
1540 // CHECK-ERROR: error: invalid operand for instruction
1541 // CHECK-ERROR:         ursra v0.2s, v1.2d, #3
1542 // CHECK-ERROR:                         ^
1543 // CHECK-ERROR: error: expected integer in range [1, 8]
1544 // CHECK-ERROR:         ursra v0.16b, v1.16b, #9
1545 // CHECK-ERROR:                               ^
1546 // CHECK-ERROR: error: expected integer in range [1, 16]
1547 // CHECK-ERROR:         ursra v0.8h, v1.8h, #17
1548 // CHECK-ERROR:                             ^
1549 // CHECK-ERROR: error: expected integer in range [1, 32]
1550 // CHECK-ERROR:         ursra v0.4s, v1.4s, #33
1551 // CHECK-ERROR:                             ^
1552 // CHECK-ERROR: error: expected integer in range [1, 64]
1553 // CHECK-ERROR:         ursra v0.2d, v1.2d, #65
1554 // CHECK-ERROR:                             ^
1555
1556 //------------------------------------------------------------------------------
1557 // Vector shift right and insert by immediate
1558 //------------------------------------------------------------------------------
1559          sri v0.8b, v1.8h, #3
1560          sri v0.4h, v1.4s, #3
1561          sri v0.2s, v1.2d, #3
1562          sri v0.16b, v1.16b, #9
1563          sri v0.8h, v1.8h, #17
1564          sri v0.4s, v1.4s, #33
1565          sri v0.2d, v1.2d, #65
1566
1567 // CHECK-ERROR: error: invalid operand for instruction
1568 // CHECK-ERROR:         sri v0.8b, v1.8h, #3
1569 // CHECK-ERROR:                       ^
1570 // CHECK-ERROR: error: invalid operand for instruction
1571 // CHECK-ERROR:         sri v0.4h, v1.4s, #3
1572 // CHECK-ERROR:                       ^
1573 // CHECK-ERROR: error: invalid operand for instruction
1574 // CHECK-ERROR:         sri v0.2s, v1.2d, #3
1575 // CHECK-ERROR:                       ^
1576 // CHECK-ERROR: error: expected integer in range [1, 8]
1577 // CHECK-ERROR:         sri v0.16b, v1.16b, #9
1578 // CHECK-ERROR:                             ^
1579 // CHECK-ERROR: error: expected integer in range [1, 16]
1580 // CHECK-ERROR:         sri v0.8h, v1.8h, #17
1581 // CHECK-ERROR:                           ^
1582 // CHECK-ERROR: error: expected integer in range [1, 32]
1583 // CHECK-ERROR:         sri v0.4s, v1.4s, #33
1584 // CHECK-ERROR:                           ^
1585 // CHECK-ERROR: error: expected integer in range [1, 64]
1586 // CHECK-ERROR:         sri v0.2d, v1.2d, #65
1587 // CHECK-ERROR:                           ^
1588
1589 //------------------------------------------------------------------------------
1590 // Vector shift left and insert by immediate
1591 //------------------------------------------------------------------------------
1592          sli v0.8b, v1.8h, #3
1593          sli v0.4h, v1.4s, #3
1594          sli v0.2s, v1.2d, #3
1595          sli v0.16b, v1.16b, #8
1596          sli v0.8h, v1.8h, #16
1597          sli v0.4s, v1.4s, #32
1598          sli v0.2d, v1.2d, #64
1599
1600 // CHECK-ERROR: error: invalid operand for instruction
1601 // CHECK-ERROR:         sli v0.8b, v1.8h, #3
1602 // CHECK-ERROR:                       ^
1603 // CHECK-ERROR: error: invalid operand for instruction
1604 // CHECK-ERROR:         sli v0.4h, v1.4s, #3
1605 // CHECK-ERROR:                       ^
1606 // CHECK-ERROR: error: invalid operand for instruction
1607 // CHECK-ERROR:         sli v0.2s, v1.2d, #3
1608 // CHECK-ERROR:                       ^
1609 // CHECK-ERROR: error: expected integer in range [0, 7]
1610 // CHECK-ERROR:         sli v0.16b, v1.16b, #8
1611 // CHECK-ERROR:                             ^
1612 // CHECK-ERROR: error: expected integer in range [0, 15]
1613 // CHECK-ERROR:         sli v0.8h, v1.8h, #16
1614 // CHECK-ERROR:                           ^
1615 // CHECK-ERROR: error: expected integer in range [0, 31]
1616 // CHECK-ERROR:         sli v0.4s, v1.4s, #32
1617 // CHECK-ERROR:                           ^
1618 // CHECK-ERROR: error: expected integer in range [0, 63]
1619 // CHECK-ERROR:         sli v0.2d, v1.2d, #64
1620 // CHECK-ERROR:                           ^
1621
1622 //------------------------------------------------------------------------------
1623 // Vector saturating shift left unsigned by immediate
1624 //------------------------------------------------------------------------------
1625          sqshlu v0.8b, v1.8h, #3
1626          sqshlu v0.4h, v1.4s, #3
1627          sqshlu v0.2s, v1.2d, #3
1628          sqshlu v0.16b, v1.16b, #8
1629          sqshlu v0.8h, v1.8h, #16
1630          sqshlu v0.4s, v1.4s, #32
1631          sqshlu v0.2d, v1.2d, #64
1632
1633 // CHECK-ERROR: error: invalid operand for instruction
1634 // CHECK-ERROR:         sqshlu v0.8b, v1.8h, #3
1635 // CHECK-ERROR:                          ^
1636 // CHECK-ERROR: error: invalid operand for instruction
1637 // CHECK-ERROR:         sqshlu v0.4h, v1.4s, #3
1638 // CHECK-ERROR:                          ^
1639 // CHECK-ERROR: error: invalid operand for instruction
1640 // CHECK-ERROR:         sqshlu v0.2s, v1.2d, #3
1641 // CHECK-ERROR:                          ^
1642 // CHECK-ERROR: error: expected integer in range [0, 7]
1643 // CHECK-ERROR:         sqshlu v0.16b, v1.16b, #8
1644 // CHECK-ERROR:                                ^
1645 // CHECK-ERROR: error: expected integer in range [0, 15]
1646 // CHECK-ERROR:         sqshlu v0.8h, v1.8h, #16
1647 // CHECK-ERROR:                              ^
1648 // CHECK-ERROR: error: expected integer in range [0, 31]
1649 // CHECK-ERROR:         sqshlu v0.4s, v1.4s, #32
1650 // CHECK-ERROR:                              ^
1651 // CHECK-ERROR: error: expected integer in range [0, 63]
1652 // CHECK-ERROR:         sqshlu v0.2d, v1.2d, #64
1653 // CHECK-ERROR:                              ^
1654
1655 //------------------------------------------------------------------------------
1656 // Vector saturating shift left by immediate
1657 //------------------------------------------------------------------------------
1658          sqshl v0.8b, v1.8h, #3
1659          sqshl v0.4h, v1.4s, #3
1660          sqshl v0.2s, v1.2d, #3
1661          sqshl v0.16b, v1.16b, #8
1662          sqshl v0.8h, v1.8h, #16
1663          sqshl v0.4s, v1.4s, #32
1664          sqshl v0.2d, v1.2d, #64
1665
1666 // CHECK-ERROR: error: invalid operand for instruction
1667 // CHECK-ERROR:         sqshl v0.8b, v1.8h, #3
1668 // CHECK-ERROR:                         ^
1669 // CHECK-ERROR: error: invalid operand for instruction
1670 // CHECK-ERROR:         sqshl v0.4h, v1.4s, #3
1671 // CHECK-ERROR:                         ^
1672 // CHECK-ERROR: error: invalid operand for instruction
1673 // CHECK-ERROR:         sqshl v0.2s, v1.2d, #3
1674 // CHECK-ERROR:                         ^
1675 // CHECK-ERROR: error: expected integer in range [0, 7]
1676 // CHECK-ERROR:         sqshl v0.16b, v1.16b, #8
1677 // CHECK-ERROR:                               ^
1678 // CHECK-ERROR: error: expected integer in range [0, 15]
1679 // CHECK-ERROR:         sqshl v0.8h, v1.8h, #16
1680 // CHECK-ERROR:                             ^
1681 // CHECK-ERROR: error: expected integer in range [0, 31]
1682 // CHECK-ERROR:         sqshl v0.4s, v1.4s, #32
1683 // CHECK-ERROR:                             ^
1684 // CHECK-ERROR: error: expected integer in range [0, 63]
1685 // CHECK-ERROR:         sqshl v0.2d, v1.2d, #64
1686 // CHECK-ERROR:                             ^
1687
1688 //------------------------------------------------------------------------------
1689 // Vector saturating shift left by immediate
1690 //------------------------------------------------------------------------------
1691          uqshl v0.8b, v1.8h, #3
1692          uqshl v0.4h, v1.4s, #3
1693          uqshl v0.2s, v1.2d, #3
1694          uqshl v0.16b, v1.16b, #8
1695          uqshl v0.8h, v1.8h, #16
1696          uqshl v0.4s, v1.4s, #32
1697          uqshl v0.2d, v1.2d, #64
1698
1699 // CHECK-ERROR: error: invalid operand for instruction
1700 // CHECK-ERROR:         uqshl v0.8b, v1.8h, #3
1701 // CHECK-ERROR:                         ^
1702 // CHECK-ERROR: error: invalid operand for instruction
1703 // CHECK-ERROR:         uqshl v0.4h, v1.4s, #3
1704 // CHECK-ERROR:                         ^
1705 // CHECK-ERROR: error: invalid operand for instruction
1706 // CHECK-ERROR:         uqshl v0.2s, v1.2d, #3
1707 // CHECK-ERROR:                         ^
1708 // CHECK-ERROR: error: expected integer in range [0, 7]
1709 // CHECK-ERROR:         uqshl v0.16b, v1.16b, #8
1710 // CHECK-ERROR:                               ^
1711 // CHECK-ERROR: error: expected integer in range [0, 15]
1712 // CHECK-ERROR:         uqshl v0.8h, v1.8h, #16
1713 // CHECK-ERROR:                             ^
1714 // CHECK-ERROR: error: expected integer in range [0, 31]
1715 // CHECK-ERROR:         uqshl v0.4s, v1.4s, #32
1716 // CHECK-ERROR:                             ^
1717 // CHECK-ERROR: error: expected integer in range [0, 63]
1718 // CHECK-ERROR:         uqshl v0.2d, v1.2d, #64
1719 // CHECK-ERROR:                             ^
1720
1721 //------------------------------------------------------------------------------
1722 // Vector shift right narrow by immediate
1723 //------------------------------------------------------------------------------
1724          shrn v0.8b, v1.8b, #3
1725          shrn v0.4h, v1.4h, #3
1726          shrn v0.2s, v1.2s, #3
1727          shrn2 v0.16b, v1.8h, #17
1728          shrn2 v0.8h, v1.4s, #33
1729          shrn2 v0.4s, v1.2d, #65
1730
1731 // CHECK-ERROR: error: invalid operand for instruction
1732 // CHECK-ERROR:         shrn v0.8b, v1.8b, #3
1733 // CHECK-ERROR:                        ^
1734 // CHECK-ERROR: error: invalid operand for instruction
1735 // CHECK-ERROR:         shrn v0.4h, v1.4h, #3
1736 // CHECK-ERROR:                        ^
1737 // CHECK-ERROR: error: invalid operand for instruction
1738 // CHECK-ERROR:         shrn v0.2s, v1.2s, #3
1739 // CHECK-ERROR:                        ^
1740 // CHECK-ERROR: error: expected integer in range [1, 8]
1741 // CHECK-ERROR:         shrn2 v0.16b, v1.8h, #17
1742 // CHECK-ERROR:                              ^
1743 // CHECK-ERROR: error: expected integer in range [1, 16]
1744 // CHECK-ERROR:         shrn2 v0.8h, v1.4s, #33
1745 // CHECK-ERROR:                             ^
1746 // CHECK-ERROR: error: expected integer in range [1, 32]
1747 // CHECK-ERROR:         shrn2 v0.4s, v1.2d, #65
1748 // CHECK-ERROR:                             ^
1749
1750 //------------------------------------------------------------------------------
1751 // Vector saturating shift right unsigned narrow by immediate
1752 //------------------------------------------------------------------------------
1753          sqshrun v0.8b, v1.8b, #3
1754          sqshrun v0.4h, v1.4h, #3
1755          sqshrun v0.2s, v1.2s, #3
1756          sqshrun2 v0.16b, v1.8h, #17
1757          sqshrun2 v0.8h, v1.4s, #33
1758          sqshrun2 v0.4s, v1.2d, #65
1759
1760 // CHECK-ERROR: error: invalid operand for instruction
1761 // CHECK-ERROR:         sqshrun v0.8b, v1.8b, #3
1762 // CHECK-ERROR:                           ^
1763 // CHECK-ERROR: error: invalid operand for instruction
1764 // CHECK-ERROR:         sqshrun v0.4h, v1.4h, #3
1765 // CHECK-ERROR:                           ^
1766 // CHECK-ERROR: error: invalid operand for instruction
1767 // CHECK-ERROR:         sqshrun v0.2s, v1.2s, #3
1768 // CHECK-ERROR:                           ^
1769 // CHECK-ERROR: error: expected integer in range [1, 8]
1770 // CHECK-ERROR:         sqshrun2 v0.16b, v1.8h, #17
1771 // CHECK-ERROR:                                 ^
1772 // CHECK-ERROR: error: expected integer in range [1, 16]
1773 // CHECK-ERROR:         sqshrun2 v0.8h, v1.4s, #33
1774 // CHECK-ERROR:                                ^
1775 // CHECK-ERROR: error: expected integer in range [1, 32]
1776 // CHECK-ERROR:         sqshrun2 v0.4s, v1.2d, #65
1777 // CHECK-ERROR:                                ^
1778
1779 //------------------------------------------------------------------------------
1780 // Vector rounding shift right narrow by immediate
1781 //------------------------------------------------------------------------------
1782          rshrn v0.8b, v1.8b, #3
1783          rshrn v0.4h, v1.4h, #3
1784          rshrn v0.2s, v1.2s, #3
1785          rshrn2 v0.16b, v1.8h, #17
1786          rshrn2 v0.8h, v1.4s, #33
1787          rshrn2 v0.4s, v1.2d, #65
1788
1789 // CHECK-ERROR: error: invalid operand for instruction
1790 // CHECK-ERROR:         rshrn v0.8b, v1.8b, #3
1791 // CHECK-ERROR:                         ^
1792 // CHECK-ERROR: error: invalid operand for instruction
1793 // CHECK-ERROR:         rshrn v0.4h, v1.4h, #3
1794 // CHECK-ERROR:                         ^
1795 // CHECK-ERROR: error: invalid operand for instruction
1796 // CHECK-ERROR:         rshrn v0.2s, v1.2s, #3
1797 // CHECK-ERROR:                         ^
1798 // CHECK-ERROR: error: expected integer in range [1, 8]
1799 // CHECK-ERROR:         rshrn2 v0.16b, v1.8h, #17
1800 // CHECK-ERROR:                               ^
1801 // CHECK-ERROR: error: expected integer in range [1, 16]
1802 // CHECK-ERROR:         rshrn2 v0.8h, v1.4s, #33
1803 // CHECK-ERROR:                              ^
1804 // CHECK-ERROR: error: expected integer in range [1, 32]
1805 // CHECK-ERROR:         rshrn2 v0.4s, v1.2d, #65
1806 // CHECK-ERROR:                              ^
1807
1808 //------------------------------------------------------------------------------
1809 // Vector saturating shift right rounded unsigned narrow by immediate
1810 //------------------------------------------------------------------------------
1811          sqrshrun v0.8b, v1.8b, #3
1812          sqrshrun v0.4h, v1.4h, #3
1813          sqrshrun v0.2s, v1.2s, #3
1814          sqrshrun2 v0.16b, v1.8h, #17
1815          sqrshrun2 v0.8h, v1.4s, #33
1816          sqrshrun2 v0.4s, v1.2d, #65
1817
1818 // CHECK-ERROR: error: invalid operand for instruction
1819 // CHECK-ERROR:         sqrshrun v0.8b, v1.8b, #3
1820 // CHECK-ERROR:                            ^
1821 // CHECK-ERROR: error: invalid operand for instruction
1822 // CHECK-ERROR:         sqrshrun v0.4h, v1.4h, #3
1823 // CHECK-ERROR:                            ^
1824 // CHECK-ERROR: error: invalid operand for instruction
1825 // CHECK-ERROR:         sqrshrun v0.2s, v1.2s, #3
1826 // CHECK-ERROR:                            ^
1827 // CHECK-ERROR: error: expected integer in range [1, 8]
1828 // CHECK-ERROR:         sqrshrun2 v0.16b, v1.8h, #17
1829 // CHECK-ERROR:                                  ^
1830 // CHECK-ERROR: error: expected integer in range [1, 16]
1831 // CHECK-ERROR:         sqrshrun2 v0.8h, v1.4s, #33
1832 // CHECK-ERROR:                                 ^
1833 // CHECK-ERROR: error: expected integer in range [1, 32]
1834 // CHECK-ERROR:         sqrshrun2 v0.4s, v1.2d, #65
1835 // CHECK-ERROR:                                 ^
1836
1837 //------------------------------------------------------------------------------
1838 // Vector saturating shift right narrow by immediate
1839 //------------------------------------------------------------------------------
1840          sqshrn v0.8b, v1.8b, #3
1841          sqshrn v0.4h, v1.4h, #3
1842          sqshrn v0.2s, v1.2s, #3
1843          sqshrn2 v0.16b, v1.8h, #17
1844          sqshrn2 v0.8h, v1.4s, #33
1845          sqshrn2 v0.4s, v1.2d, #65
1846
1847 // CHECK-ERROR: error: invalid operand for instruction
1848 // CHECK-ERROR:         sqshrn v0.8b, v1.8b, #3
1849 // CHECK-ERROR:                          ^
1850 // CHECK-ERROR: error: invalid operand for instruction
1851 // CHECK-ERROR:         sqshrn v0.4h, v1.4h, #3
1852 // CHECK-ERROR:                          ^
1853 // CHECK-ERROR: error: invalid operand for instruction
1854 // CHECK-ERROR:         sqshrn v0.2s, v1.2s, #3
1855 // CHECK-ERROR:                          ^
1856 // CHECK-ERROR: error: expected integer in range [1, 8]
1857 // CHECK-ERROR:         sqshrn2 v0.16b, v1.8h, #17
1858 // CHECK-ERROR:                                ^
1859 // CHECK-ERROR: error: expected integer in range [1, 16]
1860 // CHECK-ERROR:         sqshrn2 v0.8h, v1.4s, #33
1861 // CHECK-ERROR:                               ^
1862 // CHECK-ERROR: error: expected integer in range [1, 32]
1863 // CHECK-ERROR:         sqshrn2 v0.4s, v1.2d, #65
1864 // CHECK-ERROR:                               ^
1865
1866 //------------------------------------------------------------------------------
1867 // Vector saturating shift right narrow by immediate
1868 //------------------------------------------------------------------------------
1869          uqshrn v0.8b, v1.8b, #3
1870          uqshrn v0.4h, v1.4h, #3
1871          uqshrn v0.2s, v1.2s, #3
1872          uqshrn2 v0.16b, v1.8h, #17
1873          uqshrn2 v0.8h, v1.4s, #33
1874          uqshrn2 v0.4s, v1.2d, #65
1875
1876 // CHECK-ERROR: error: invalid operand for instruction
1877 // CHECK-ERROR:         uqshrn v0.8b, v1.8b, #3
1878 // CHECK-ERROR:                          ^
1879 // CHECK-ERROR: error: invalid operand for instruction
1880 // CHECK-ERROR:         uqshrn v0.4h, v1.4h, #3
1881 // CHECK-ERROR:                          ^
1882 // CHECK-ERROR: error: invalid operand for instruction
1883 // CHECK-ERROR:         uqshrn v0.2s, v1.2s, #3
1884 // CHECK-ERROR:                          ^
1885 // CHECK-ERROR: error: expected integer in range [1, 8]
1886 // CHECK-ERROR:         uqshrn2 v0.16b, v1.8h, #17
1887 // CHECK-ERROR:                                ^
1888 // CHECK-ERROR: error: expected integer in range [1, 16]
1889 // CHECK-ERROR:         uqshrn2 v0.8h, v1.4s, #33
1890 // CHECK-ERROR:                               ^
1891 // CHECK-ERROR: error: expected integer in range [1, 32]
1892 // CHECK-ERROR:         uqshrn2 v0.4s, v1.2d, #65
1893 // CHECK-ERROR:                               ^
1894
1895 //------------------------------------------------------------------------------
1896 // Vector saturating shift right rounded narrow by immediate
1897 //------------------------------------------------------------------------------
1898          sqrshrn v0.8b, v1.8b, #3
1899          sqrshrn v0.4h, v1.4h, #3
1900          sqrshrn v0.2s, v1.2s, #3
1901          sqrshrn2 v0.16b, v1.8h, #17
1902          sqrshrn2 v0.8h, v1.4s, #33
1903          sqrshrn2 v0.4s, v1.2d, #65
1904
1905 // CHECK-ERROR: error: invalid operand for instruction
1906 // CHECK-ERROR:         sqrshrn v0.8b, v1.8b, #3
1907 // CHECK-ERROR:                           ^
1908 // CHECK-ERROR: error: invalid operand for instruction
1909 // CHECK-ERROR:         sqrshrn v0.4h, v1.4h, #3
1910 // CHECK-ERROR:                           ^
1911 // CHECK-ERROR: error: invalid operand for instruction
1912 // CHECK-ERROR:         sqrshrn v0.2s, v1.2s, #3
1913 // CHECK-ERROR:                           ^
1914 // CHECK-ERROR: error: expected integer in range [1, 8]
1915 // CHECK-ERROR:         sqrshrn2 v0.16b, v1.8h, #17
1916 // CHECK-ERROR:                                 ^
1917 // CHECK-ERROR: error: expected integer in range [1, 16]
1918 // CHECK-ERROR:         sqrshrn2 v0.8h, v1.4s, #33
1919 // CHECK-ERROR:                                ^
1920 // CHECK-ERROR: error: expected integer in range [1, 32]
1921 // CHECK-ERROR:         sqrshrn2 v0.4s, v1.2d, #65
1922 // CHECK-ERROR:                                ^
1923
1924 //------------------------------------------------------------------------------
1925 // Vector saturating shift right rounded narrow by immediate
1926 //------------------------------------------------------------------------------
1927          uqrshrn v0.8b, v1.8b, #3
1928          uqrshrn v0.4h, v1.4h, #3
1929          uqrshrn v0.2s, v1.2s, #3
1930          uqrshrn2 v0.16b, v1.8h, #17
1931          uqrshrn2 v0.8h, v1.4s, #33
1932          uqrshrn2 v0.4s, v1.2d, #65
1933
1934 // CHECK-ERROR: error: invalid operand for instruction
1935 // CHECK-ERROR:         uqrshrn v0.8b, v1.8b, #3
1936 // CHECK-ERROR:                           ^
1937 // CHECK-ERROR: error: invalid operand for instruction
1938 // CHECK-ERROR:         uqrshrn v0.4h, v1.4h, #3
1939 // CHECK-ERROR:                           ^
1940 // CHECK-ERROR: error: invalid operand for instruction
1941 // CHECK-ERROR:         uqrshrn v0.2s, v1.2s, #3
1942 // CHECK-ERROR:                           ^
1943 // CHECK-ERROR: error: expected integer in range [1, 8]
1944 // CHECK-ERROR:         uqrshrn2 v0.16b, v1.8h, #17
1945 // CHECK-ERROR:                                 ^
1946 // CHECK-ERROR: error: expected integer in range [1, 16]
1947 // CHECK-ERROR:         uqrshrn2 v0.8h, v1.4s, #33
1948 // CHECK-ERROR:                                ^
1949 // CHECK-ERROR: error: expected integer in range [1, 32]
1950 // CHECK-ERROR:         uqrshrn2 v0.4s, v1.2d, #65
1951 // CHECK-ERROR:                                ^
1952
1953 //------------------------------------------------------------------------------
1954 // Fixed-point convert to floating-point
1955 //------------------------------------------------------------------------------
1956          scvtf v0.2s, v1.2d, #3
1957          scvtf v0.4s, v1.4h, #3
1958          scvtf v0.2d, v1.2s, #3
1959          ucvtf v0.2s, v1.2s, #33
1960          ucvtf v0.4s, v1.4s, #33
1961          ucvtf v0.2d, v1.2d, #65
1962
1963 // CHECK-ERROR: error: invalid operand for instruction
1964 // CHECK-ERROR:         scvtf v0.2s, v1.2d, #3
1965 // CHECK-ERROR:                         ^
1966 // CHECK-ERROR: error: invalid operand for instruction
1967 // CHECK-ERROR:         scvtf v0.4s, v1.4h, #3
1968 // CHECK-ERROR:                         ^
1969 // CHECK-ERROR: error: invalid operand for instruction
1970 // CHECK-ERROR:         scvtf v0.2d, v1.2s, #3
1971 // CHECK-ERROR:                         ^
1972 // CHECK-ERROR: error: expected integer in range [1, 32]
1973 // CHECK-ERROR:         ucvtf v0.2s, v1.2s, #33
1974 // CHECK-ERROR:                             ^
1975 // CHECK-ERROR: error: expected integer in range [1, 32]
1976 // CHECK-ERROR:         ucvtf v0.4s, v1.4s, #33
1977 // CHECK-ERROR:                             ^
1978 // CHECK-ERROR: error: expected integer in range [1, 64]
1979 // CHECK-ERROR:         ucvtf v0.2d, v1.2d, #65
1980 // CHECK-ERROR:                             ^
1981
1982 //------------------------------------------------------------------------------
1983 // Floating-point convert to fixed-point
1984 //------------------------------------------------------------------------------
1985          fcvtzs v0.2s, v1.2d, #3
1986          fcvtzs v0.4s, v1.4h, #3
1987          fcvtzs v0.2d, v1.2s, #3
1988          fcvtzu v0.2s, v1.2s, #33
1989          fcvtzu v0.4s, v1.4s, #33
1990          fcvtzu v0.2d, v1.2d, #65
1991
1992 // CHECK-ERROR: error: invalid operand for instruction
1993 // CHECK-ERROR:         fcvtzs v0.2s, v1.2d, #3
1994 // CHECK-ERROR:                          ^
1995 // CHECK-ERROR: error: invalid operand for instruction
1996 // CHECK-ERROR:         fcvtzs v0.4s, v1.4h, #3
1997 // CHECK-ERROR:                          ^
1998 // CHECK-ERROR: error: invalid operand for instruction
1999 // CHECK-ERROR:         fcvtzs v0.2d, v1.2s, #3
2000 // CHECK-ERROR:                          ^
2001 // CHECK-ERROR: error: expected integer in range [1, 32]
2002 // CHECK-ERROR:         fcvtzu v0.2s, v1.2s, #33
2003 // CHECK-ERROR:                              ^
2004 // CHECK-ERROR: error: expected integer in range [1, 32]
2005 // CHECK-ERROR:         fcvtzu v0.4s, v1.4s, #33
2006 // CHECK-ERROR:                              ^
2007 // CHECK-ERROR: error: expected integer in range [1, 64]
2008 // CHECK-ERROR:         fcvtzu v0.2d, v1.2d, #65
2009 // CHECK-ERROR:                              ^
2010
2011 //----------------------------------------------------------------------
2012 // Vector operation on 3 operands with different types
2013 //----------------------------------------------------------------------
2014
2015         // Mismatched and invalid vector types
2016         saddl v0.8h, v1.8h, v2.8b
2017         saddl v0.4s, v1.4s, v2.4h
2018         saddl v0.2d, v1.2d, v2.2s
2019
2020 // CHECK-ERROR: error: invalid operand for instruction
2021 // CHECK-ERROR:        saddl v0.8h, v1.8h, v2.8b
2022 // CHECK-ERROR:                        ^
2023 // CHECK-ERROR: error: invalid operand for instruction
2024 // CHECK-ERROR:        saddl v0.4s, v1.4s, v2.4h
2025 // CHECK-ERROR:                        ^
2026 // CHECK-ERROR: error: invalid operand for instruction
2027 // CHECK-ERROR:        saddl v0.2d, v1.2d, v2.2s
2028 // CHECK-ERROR:                        ^
2029
2030         saddl2 v0.4s, v1.8s, v2.8h
2031         saddl2 v0.8h, v1.16h, v2.16b
2032         saddl2 v0.2d, v1.4d, v2.4s
2033
2034 // CHECK-ERROR: error: invalid operand for instruction
2035 // CHECK-ERROR:        saddl2 v0.4s, v1.8s, v2.8h
2036 // CHECK-ERROR:                      ^
2037 // CHECK-ERROR: error: invalid operand for instruction
2038 // CHECK-ERROR:        saddl2 v0.8h, v1.16h, v2.16b
2039 // CHECK-ERROR:                      ^
2040 // CHECK-ERROR: error: invalid operand for instruction
2041 // CHECK-ERROR:        saddl2 v0.2d, v1.4d, v2.4s
2042 // CHECK-ERROR:                      ^
2043
2044         uaddl v0.8h, v1.8h, v2.8b
2045         uaddl v0.4s, v1.4s, v2.4h
2046         uaddl v0.2d, v1.2d, v2.2s
2047
2048 // CHECK-ERROR: error: invalid operand for instruction
2049 // CHECK-ERROR:        uaddl v0.8h, v1.8h, v2.8b
2050 // CHECK-ERROR:                        ^
2051 // CHECK-ERROR: error: invalid operand for instruction
2052 // CHECK-ERROR:        uaddl v0.4s, v1.4s, v2.4h
2053 // CHECK-ERROR:                        ^
2054 // CHECK-ERROR: error: invalid operand for instruction
2055 // CHECK-ERROR:        uaddl v0.2d, v1.2d, v2.2s
2056 // CHECK-ERROR:                        ^
2057
2058         uaddl2 v0.8h, v1.16h, v2.16b
2059         uaddl2 v0.4s, v1.8s, v2.8h
2060         uaddl2 v0.2d, v1.4d, v2.4s
2061
2062 // CHECK-ERROR: error: invalid operand for instruction
2063 // CHECK-ERROR:        uaddl2 v0.8h, v1.16h, v2.16b
2064 // CHECK-ERROR:                      ^
2065 // CHECK-ERROR: error: invalid operand for instruction
2066 // CHECK-ERROR:        uaddl2 v0.4s, v1.8s, v2.8h
2067 // CHECK-ERROR:                      ^
2068 // CHECK-ERROR: error: invalid operand for instruction
2069 // CHECK-ERROR:        uaddl2 v0.2d, v1.4d, v2.4s
2070 // CHECK-ERROR:                      ^
2071
2072         ssubl v0.8h, v1.8h, v2.8b
2073         ssubl v0.4s, v1.4s, v2.4h
2074         ssubl v0.2d, v1.2d, v2.2s
2075
2076 // CHECK-ERROR: error: invalid operand for instruction
2077 // CHECK-ERROR:        ssubl v0.8h, v1.8h, v2.8b
2078 // CHECK-ERROR:                        ^
2079 // CHECK-ERROR: error: invalid operand for instruction
2080 // CHECK-ERROR:        ssubl v0.4s, v1.4s, v2.4h
2081 // CHECK-ERROR:                        ^
2082 // CHECK-ERROR: error: invalid operand for instruction
2083 // CHECK-ERROR:        ssubl v0.2d, v1.2d, v2.2s
2084 // CHECK-ERROR:                        ^
2085
2086         ssubl2 v0.8h, v1.16h, v2.16b
2087         ssubl2 v0.4s, v1.8s, v2.8h
2088         ssubl2 v0.2d, v1.4d, v2.4s
2089
2090 // CHECK-ERROR: error: invalid operand for instruction
2091 // CHECK-ERROR:        ssubl2 v0.8h, v1.16h, v2.16b
2092 // CHECK-ERROR:                      ^
2093 // CHECK-ERROR: error: invalid operand for instruction
2094 // CHECK-ERROR:        ssubl2 v0.4s, v1.8s, v2.8h
2095 // CHECK-ERROR:                      ^
2096 // CHECK-ERROR: error: invalid operand for instruction
2097 // CHECK-ERROR:        ssubl2 v0.2d, v1.4d, v2.4s
2098 // CHECK-ERROR:                      ^
2099
2100         usubl v0.8h, v1.8h, v2.8b
2101         usubl v0.4s, v1.4s, v2.4h
2102         usubl v0.2d, v1.2d, v2.2s
2103
2104 // CHECK-ERROR: error: invalid operand for instruction
2105 // CHECK-ERROR:        usubl v0.8h, v1.8h, v2.8b
2106 // CHECK-ERROR:                        ^
2107 // CHECK-ERROR: error: invalid operand for instruction
2108 // CHECK-ERROR:        usubl v0.4s, v1.4s, v2.4h
2109 // CHECK-ERROR:                        ^
2110 // CHECK-ERROR: error: invalid operand for instruction
2111 // CHECK-ERROR:        usubl v0.2d, v1.2d, v2.2s
2112 // CHECK-ERROR:                        ^
2113
2114         usubl2 v0.8h, v1.16h, v2.16b
2115         usubl2 v0.4s, v1.8s, v2.8h
2116         usubl2 v0.2d, v1.4d, v2.4s
2117
2118 // CHECK-ERROR: error: invalid operand for instruction
2119 // CHECK-ERROR:        usubl2 v0.8h, v1.16h, v2.16b
2120 // CHECK-ERROR:                      ^
2121 // CHECK-ERROR: error: invalid operand for instruction
2122 // CHECK-ERROR:        usubl2 v0.4s, v1.8s, v2.8h
2123 // CHECK-ERROR:                      ^
2124 // CHECK-ERROR: error: invalid operand for instruction
2125 // CHECK-ERROR:        usubl2 v0.2d, v1.4d, v2.4s
2126 // CHECK-ERROR:                      ^
2127
2128         sabal v0.8h, v1.8h, v2.8b
2129         sabal v0.4s, v1.4s, v2.4h
2130         sabal v0.2d, v1.2d, v2.2s
2131
2132 // CHECK-ERROR: error: invalid operand for instruction
2133 // CHECK-ERROR:        sabal v0.8h, v1.8h, v2.8b
2134 // CHECK-ERROR:                        ^
2135 // CHECK-ERROR: error: invalid operand for instruction
2136 // CHECK-ERROR:        sabal v0.4s, v1.4s, v2.4h
2137 // CHECK-ERROR:                        ^
2138 // CHECK-ERROR: error: invalid operand for instruction
2139 // CHECK-ERROR:        sabal v0.2d, v1.2d, v2.2s
2140 // CHECK-ERROR:                        ^
2141
2142         sabal2 v0.8h, v1.16h, v2.16b
2143         sabal2 v0.4s, v1.8s, v2.8h
2144         sabal2 v0.2d, v1.4d, v2.4s
2145
2146 // CHECK-ERROR: error: invalid operand for instruction
2147 // CHECK-ERROR:        sabal2 v0.8h, v1.16h, v2.16b
2148 // CHECK-ERROR:                      ^
2149 // CHECK-ERROR: error: invalid operand for instruction
2150 // CHECK-ERROR:        sabal2 v0.4s, v1.8s, v2.8h
2151 // CHECK-ERROR:                      ^
2152 // CHECK-ERROR: error: invalid operand for instruction
2153 // CHECK-ERROR:        sabal2 v0.2d, v1.4d, v2.4s
2154 // CHECK-ERROR:                      ^
2155
2156         uabal v0.8h, v1.8h, v2.8b
2157         uabal v0.4s, v1.4s, v2.4h
2158         uabal v0.2d, v1.2d, v2.2s
2159
2160 // CHECK-ERROR: error: invalid operand for instruction
2161 // CHECK-ERROR:        uabal v0.8h, v1.8h, v2.8b
2162 // CHECK-ERROR:                        ^
2163 // CHECK-ERROR: error: invalid operand for instruction
2164 // CHECK-ERROR:        uabal v0.4s, v1.4s, v2.4h
2165 // CHECK-ERROR:                        ^
2166 // CHECK-ERROR: error: invalid operand for instruction
2167 // CHECK-ERROR:        uabal v0.2d, v1.2d, v2.2s
2168 // CHECK-ERROR:                        ^
2169
2170         uabal2 v0.8h, v1.16h, v2.16b
2171         uabal2 v0.4s, v1.8s, v2.8h
2172         uabal2 v0.2d, v1.4d, v2.4s
2173
2174 // CHECK-ERROR: error: invalid operand for instruction
2175 // CHECK-ERROR:        uabal2 v0.8h, v1.16h, v2.16b
2176 // CHECK-ERROR:                      ^
2177 // CHECK-ERROR: error: invalid operand for instruction
2178 // CHECK-ERROR:        uabal2 v0.4s, v1.8s, v2.8h
2179 // CHECK-ERROR:                      ^
2180 // CHECK-ERROR: error: invalid operand for instruction
2181 // CHECK-ERROR:        uabal2 v0.2d, v1.4d, v2.4s
2182 // CHECK-ERROR:                      ^
2183
2184         sabdl v0.8h, v1.8h, v2.8b
2185         sabdl v0.4s, v1.4s, v2.4h
2186         sabdl v0.2d, v1.2d, v2.2s
2187
2188 // CHECK-ERROR: error: invalid operand for instruction
2189 // CHECK-ERROR:        sabdl v0.8h, v1.8h, v2.8b
2190 // CHECK-ERROR:                        ^
2191 // CHECK-ERROR: error: invalid operand for instruction
2192 // CHECK-ERROR:        sabdl v0.4s, v1.4s, v2.4h
2193 // CHECK-ERROR:                        ^
2194 // CHECK-ERROR: error: invalid operand for instruction
2195 // CHECK-ERROR:        sabdl v0.2d, v1.2d, v2.2s
2196 // CHECK-ERROR:                        ^
2197
2198         sabdl2 v0.8h, v1.16h, v2.16b
2199         sabdl2 v0.4s, v1.8s, v2.8h
2200         sabdl2 v0.2d, v1.4d, v2.4s
2201
2202 // CHECK-ERROR: error: invalid operand for instruction
2203 // CHECK-ERROR:        sabdl2 v0.8h, v1.16h, v2.16b
2204 // CHECK-ERROR:                      ^
2205 // CHECK-ERROR: error: invalid operand for instruction
2206 // CHECK-ERROR:        sabdl2 v0.4s, v1.8s, v2.8h
2207 // CHECK-ERROR:                      ^
2208 // CHECK-ERROR: error: invalid operand for instruction
2209 // CHECK-ERROR:        sabdl2 v0.2d, v1.4d, v2.4s
2210 // CHECK-ERROR:                      ^
2211
2212         uabdl v0.8h, v1.8h, v2.8b
2213         uabdl v0.4s, v1.4s, v2.4h
2214         uabdl v0.2d, v1.2d, v2.2s
2215
2216 // CHECK-ERROR: error: invalid operand for instruction
2217 // CHECK-ERROR:        uabdl v0.8h, v1.8h, v2.8b
2218 // CHECK-ERROR:                        ^
2219 // CHECK-ERROR: error: invalid operand for instruction
2220 // CHECK-ERROR:        uabdl v0.4s, v1.4s, v2.4h
2221 // CHECK-ERROR:                        ^
2222 // CHECK-ERROR: error: invalid operand for instruction
2223 // CHECK-ERROR:        uabdl v0.2d, v1.2d, v2.2s
2224 // CHECK-ERROR:                        ^
2225
2226         uabdl2 v0.8h, v1.16h, v2.16b
2227         uabdl2 v0.4s, v1.8s, v2.8h
2228         uabdl2 v0.2d, v1.4d, v2.4s
2229
2230 // CHECK-ERROR: error: invalid operand for instruction
2231 // CHECK-ERROR:        uabdl2 v0.8h, v1.16h, v2.16b
2232 // CHECK-ERROR:                      ^
2233 // CHECK-ERROR: error: invalid operand for instruction
2234 // CHECK-ERROR:        uabdl2 v0.4s, v1.8s, v2.8h
2235 // CHECK-ERROR:                      ^
2236 // CHECK-ERROR: error: invalid operand for instruction
2237 // CHECK-ERROR:        uabdl2 v0.2d, v1.4d, v2.4s
2238 // CHECK-ERROR:                      ^
2239
2240         smlal v0.8h, v1.8h, v2.8b
2241         smlal v0.4s, v1.4s, v2.4h
2242         smlal v0.2d, v1.2d, v2.2s
2243
2244 // CHECK-ERROR: error: invalid operand for instruction
2245 // CHECK-ERROR:        smlal v0.8h, v1.8h, v2.8b
2246 // CHECK-ERROR:                        ^
2247 // CHECK-ERROR: error: invalid operand for instruction
2248 // CHECK-ERROR:        smlal v0.4s, v1.4s, v2.4h
2249 // CHECK-ERROR:                        ^
2250 // CHECK-ERROR: error: invalid operand for instruction
2251 // CHECK-ERROR:        smlal v0.2d, v1.2d, v2.2s
2252 // CHECK-ERROR:                        ^
2253
2254         smlal2 v0.8h, v1.16h, v2.16b
2255         smlal2 v0.4s, v1.8s, v2.8h
2256         smlal2 v0.2d, v1.4d, v2.4s
2257
2258 // CHECK-ERROR: error: invalid operand for instruction
2259 // CHECK-ERROR:        smlal2 v0.8h, v1.16h, v2.16b
2260 // CHECK-ERROR:                      ^
2261 // CHECK-ERROR: error: invalid operand for instruction
2262 // CHECK-ERROR:        smlal2 v0.4s, v1.8s, v2.8h
2263 // CHECK-ERROR:                      ^
2264 // CHECK-ERROR: error: invalid operand for instruction
2265 // CHECK-ERROR:        smlal2 v0.2d, v1.4d, v2.4s
2266 // CHECK-ERROR:                      ^
2267
2268         umlal v0.8h, v1.8h, v2.8b
2269         umlal v0.4s, v1.4s, v2.4h
2270         umlal v0.2d, v1.2d, v2.2s
2271
2272 // CHECK-ERROR: error: invalid operand for instruction
2273 // CHECK-ERROR:        umlal v0.8h, v1.8h, v2.8b
2274 // CHECK-ERROR:                        ^
2275 // CHECK-ERROR: error: invalid operand for instruction
2276 // CHECK-ERROR:        umlal v0.4s, v1.4s, v2.4h
2277 // CHECK-ERROR:                        ^
2278 // CHECK-ERROR: error: invalid operand for instruction
2279 // CHECK-ERROR:        umlal v0.2d, v1.2d, v2.2s
2280 // CHECK-ERROR:                        ^
2281
2282         umlal2 v0.8h, v1.16h, v2.16b
2283         umlal2 v0.4s, v1.8s, v2.8h
2284         umlal2 v0.2d, v1.4d, v2.4s
2285
2286 // CHECK-ERROR: error: invalid operand for instruction
2287 // CHECK-ERROR:        umlal2 v0.8h, v1.16h, v2.16b
2288 // CHECK-ERROR:                      ^
2289 // CHECK-ERROR: error: invalid operand for instruction
2290 // CHECK-ERROR:        umlal2 v0.4s, v1.8s, v2.8h
2291 // CHECK-ERROR:                      ^
2292 // CHECK-ERROR: error: invalid operand for instruction
2293 // CHECK-ERROR:        umlal2 v0.2d, v1.4d, v2.4s
2294 // CHECK-ERROR:                      ^
2295
2296         smlsl v0.8h, v1.8h, v2.8b
2297         smlsl v0.4s, v1.4s, v2.4h
2298         smlsl v0.2d, v1.2d, v2.2s
2299
2300 // CHECK-ERROR: error: invalid operand for instruction
2301 // CHECK-ERROR:        smlsl v0.8h, v1.8h, v2.8b
2302 // CHECK-ERROR:                        ^
2303 // CHECK-ERROR: error: invalid operand for instruction
2304 // CHECK-ERROR:        smlsl v0.4s, v1.4s, v2.4h
2305 // CHECK-ERROR:                        ^
2306 // CHECK-ERROR: error: invalid operand for instruction
2307 // CHECK-ERROR:        smlsl v0.2d, v1.2d, v2.2s
2308 // CHECK-ERROR:                        ^
2309
2310         smlsl2 v0.8h, v1.16h, v2.16b
2311         smlsl2 v0.4s, v1.8s, v2.8h
2312         smlsl2 v0.2d, v1.4d, v2.4s
2313
2314 // CHECK-ERROR: error: invalid operand for instruction
2315 // CHECK-ERROR:        smlsl2 v0.8h, v1.16h, v2.16b
2316 // CHECK-ERROR:                      ^
2317 // CHECK-ERROR: error: invalid operand for instruction
2318 // CHECK-ERROR:        smlsl2 v0.4s, v1.8s, v2.8h
2319 // CHECK-ERROR:                      ^
2320 // CHECK-ERROR: error: invalid operand for instruction
2321 // CHECK-ERROR:        smlsl2 v0.2d, v1.4d, v2.4s
2322 // CHECK-ERROR:                      ^
2323
2324         umlsl v0.8h, v1.8h, v2.8b
2325         umlsl v0.4s, v1.4s, v2.4h
2326         umlsl v0.2d, v1.2d, v2.2s
2327
2328 // CHECK-ERROR: error: invalid operand for instruction
2329 // CHECK-ERROR:        umlsl v0.8h, v1.8h, v2.8b
2330 // CHECK-ERROR:                        ^
2331 // CHECK-ERROR: error: invalid operand for instruction
2332 // CHECK-ERROR:        umlsl v0.4s, v1.4s, v2.4h
2333 // CHECK-ERROR:                        ^
2334 // CHECK-ERROR: error: invalid operand for instruction
2335 // CHECK-ERROR:        umlsl v0.2d, v1.2d, v2.2s
2336 // CHECK-ERROR:                        ^
2337
2338         umlsl2 v0.8h, v1.16h, v2.16b
2339         umlsl2 v0.4s, v1.8s, v2.8h
2340         umlsl2 v0.2d, v1.4d, v2.4s
2341
2342 // CHECK-ERROR: error: invalid operand for instruction
2343 // CHECK-ERROR:        umlsl2 v0.8h, v1.16h, v2.16b
2344 // CHECK-ERROR:                      ^
2345 // CHECK-ERROR: error: invalid operand for instruction
2346 // CHECK-ERROR:        umlsl2 v0.4s, v1.8s, v2.8h
2347 // CHECK-ERROR:                      ^
2348 // CHECK-ERROR: error: invalid operand for instruction
2349 // CHECK-ERROR:        umlsl2 v0.2d, v1.4d, v2.4s
2350 // CHECK-ERROR:                      ^
2351
2352         smull v0.8h, v1.8h, v2.8b
2353         smull v0.4s, v1.4s, v2.4h
2354         smull v0.2d, v1.2d, v2.2s
2355
2356 // CHECK-ERROR: error: invalid operand for instruction
2357 // CHECK-ERROR:        smull v0.8h, v1.8h, v2.8b
2358 // CHECK-ERROR:                        ^
2359 // CHECK-ERROR: error: invalid operand for instruction
2360 // CHECK-ERROR:        smull v0.4s, v1.4s, v2.4h
2361 // CHECK-ERROR:                        ^
2362 // CHECK-ERROR: error: invalid operand for instruction
2363 // CHECK-ERROR:        smull v0.2d, v1.2d, v2.2s
2364 // CHECK-ERROR:                        ^
2365
2366         smull2 v0.8h, v1.16h, v2.16b
2367         smull2 v0.4s, v1.8s, v2.8h
2368         smull2 v0.2d, v1.4d, v2.4s
2369
2370 // CHECK-ERROR: error: invalid operand for instruction
2371 // CHECK-ERROR:        smull2 v0.8h, v1.16h, v2.16b
2372 // CHECK-ERROR:                      ^
2373 // CHECK-ERROR: error: invalid operand for instruction
2374 // CHECK-ERROR:        smull2 v0.4s, v1.8s, v2.8h
2375 // CHECK-ERROR:                      ^
2376 // CHECK-ERROR: error: invalid operand for instruction
2377 // CHECK-ERROR:        smull2 v0.2d, v1.4d, v2.4s
2378 // CHECK-ERROR:                      ^
2379
2380         umull v0.8h, v1.8h, v2.8b
2381         umull v0.4s, v1.4s, v2.4h
2382         umull v0.2d, v1.2d, v2.2s
2383
2384 // CHECK-ERROR: error: invalid operand for instruction
2385 // CHECK-ERROR:        umull v0.8h, v1.8h, v2.8b
2386 // CHECK-ERROR:                        ^
2387 // CHECK-ERROR: error: invalid operand for instruction
2388 // CHECK-ERROR:        umull v0.4s, v1.4s, v2.4h
2389 // CHECK-ERROR:                        ^
2390 // CHECK-ERROR: error: invalid operand for instruction
2391 // CHECK-ERROR:        umull v0.2d, v1.2d, v2.2s
2392 // CHECK-ERROR:                        ^
2393
2394         umull2 v0.8h, v1.16h, v2.16b
2395         umull2 v0.4s, v1.8s, v2.8h
2396         umull2 v0.2d, v1.4d, v2.4s
2397
2398 // CHECK-ERROR: error: invalid operand for instruction
2399 // CHECK-ERROR:        umull2 v0.8h, v1.16h, v2.16b
2400 // CHECK-ERROR:                      ^
2401 // CHECK-ERROR: error: invalid operand for instruction
2402 // CHECK-ERROR:        umull2 v0.4s, v1.8s, v2.8h
2403 // CHECK-ERROR:                      ^
2404 // CHECK-ERROR: error: invalid operand for instruction
2405 // CHECK-ERROR:        umull2 v0.2d, v1.4d, v2.4s
2406 // CHECK-ERROR:                      ^
2407
2408 //------------------------------------------------------------------------------
2409 // Long - Variant 2
2410 //------------------------------------------------------------------------------
2411
2412         sqdmlal v0.4s, v1.4s, v2.4h
2413         sqdmlal v0.2d, v1.2d, v2.2s
2414
2415 // CHECK-ERROR: error: invalid operand for instruction
2416 // CHECK-ERROR:        sqdmlal v0.4s, v1.4s, v2.4h
2417 // CHECK-ERROR:                          ^
2418 // CHECK-ERROR: error: invalid operand for instruction
2419 // CHECK-ERROR:        sqdmlal v0.2d, v1.2d, v2.2s
2420 // CHECK-ERROR:                          ^
2421
2422         sqdmlal2 v0.4s, v1.8s, v2.8h
2423         sqdmlal2 v0.2d, v1.4d, v2.4s
2424
2425 // CHECK-ERROR: error: invalid operand for instruction
2426 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8s, v2.8h
2427 // CHECK-ERROR:                        ^
2428 // CHECK-ERROR: error: invalid operand for instruction
2429 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4d, v2.4s
2430 // CHECK-ERROR:                        ^
2431
2432         // Mismatched vector types
2433         sqdmlal v0.8h, v1.8b, v2.8b
2434         sqdmlal2 v0.8h, v1.16b, v2.16b
2435
2436 // CHECK-ERROR: error: invalid operand for instruction
2437 // CHECK-ERROR:        sqdmlal v0.8h, v1.8b, v2.8b
2438 // CHECK-ERROR:                   ^
2439 // CHECK-ERROR: error: invalid operand for instruction
2440 // CHECK-ERROR:        sqdmlal2 v0.8h, v1.16b, v2.16b
2441 // CHECK-ERROR:                    ^
2442
2443         sqdmlsl v0.4s, v1.4s, v2.4h
2444         sqdmlsl v0.2d, v1.2d, v2.2s
2445
2446 // CHECK-ERROR: error: invalid operand for instruction
2447 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4s, v2.4h
2448 // CHECK-ERROR:                          ^
2449 // CHECK-ERROR: error: invalid operand for instruction
2450 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2d, v2.2s
2451 // CHECK-ERROR:                          ^
2452
2453         sqdmlsl2 v0.4s, v1.8s, v2.8h
2454         sqdmlsl2 v0.2d, v1.4d, v2.4s
2455
2456 // CHECK-ERROR: error: invalid operand for instruction
2457 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8s, v2.8h
2458 // CHECK-ERROR:                        ^
2459 // CHECK-ERROR: error: invalid operand for instruction
2460 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4d, v2.4s
2461 // CHECK-ERROR:                        ^
2462
2463         // Mismatched vector types
2464         sqdmlsl v0.8h, v1.8b, v2.8b
2465         sqdmlsl2 v0.8h, v1.16b, v2.16b
2466
2467 // CHECK-ERROR: error: invalid operand for instruction
2468 // CHECK-ERROR:        sqdmlsl v0.8h, v1.8b, v2.8b
2469 // CHECK-ERROR:                   ^
2470 // CHECK-ERROR: error: invalid operand for instruction
2471 // CHECK-ERROR:        sqdmlsl2 v0.8h, v1.16b, v2.16b
2472 // CHECK-ERROR:                    ^
2473
2474
2475         sqdmull v0.4s, v1.4s, v2.4h
2476         sqdmull v0.2d, v1.2d, v2.2s
2477
2478 // CHECK-ERROR: error: invalid operand for instruction
2479 // CHECK-ERROR:        sqdmull v0.4s, v1.4s, v2.4h
2480 // CHECK-ERROR:                          ^
2481 // CHECK-ERROR: error: invalid operand for instruction
2482 // CHECK-ERROR:        sqdmull v0.2d, v1.2d, v2.2s
2483 // CHECK-ERROR:                          ^
2484
2485         sqdmull2 v0.4s, v1.8s, v2.8h
2486         sqdmull2 v0.2d, v1.4d, v2.4s
2487
2488 // CHECK-ERROR: error: invalid operand for instruction
2489 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8s, v2.8h
2490 // CHECK-ERROR:                        ^
2491 // CHECK-ERROR: error: invalid operand for instruction
2492 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4d, v2.4s
2493 // CHECK-ERROR:                        ^
2494
2495         // Mismatched vector types
2496         sqdmull v0.8h, v1.8b, v2.8b
2497         sqdmull2 v0.8h, v1.16b, v2.16b
2498
2499 // CHECK-ERROR: error: invalid operand for instruction
2500 // CHECK-ERROR:        sqdmull v0.8h, v1.8b, v2.8b
2501 // CHECK-ERROR:                   ^
2502 // CHECK-ERROR: error: invalid operand for instruction
2503 // CHECK-ERROR:        sqdmull2 v0.8h, v1.16b, v2.16b
2504 // CHECK-ERROR:                    ^
2505
2506
2507 //------------------------------------------------------------------------------
2508 // Long - Variant 3
2509 //------------------------------------------------------------------------------
2510
2511         pmull v0.8h, v1.8h, v2.8b
2512
2513 // CHECK-ERROR: error: invalid operand for instruction
2514 // CHECK-ERROR:        pmull v0.8h, v1.8h, v2.8b
2515 // CHECK-ERROR:                        ^
2516
2517         // Mismatched vector types
2518         pmull v0.4s, v1.4h, v2.4h
2519         pmull v0.2d, v1.2s, v2.2s
2520
2521 // CHECK-ERROR: error: invalid operand for instruction
2522 // CHECK-ERROR:        pmull v0.4s, v1.4h, v2.4h
2523 // CHECK-ERROR:                 ^
2524 // CHECK-ERROR: error: invalid operand for instruction
2525 // CHECK-ERROR:        pmull v0.2d, v1.2s, v2.2s
2526 // CHECK-ERROR:                 ^
2527
2528
2529         pmull2 v0.8h, v1.16h, v2.16b
2530
2531 // CHECK-ERROR: error: invalid operand for instruction
2532 // CHECK-ERROR:        pmull2 v0.8h, v1.16h, v2.16b
2533 // CHECK-ERROR:                      ^
2534
2535         // Mismatched vector types
2536         pmull2 v0.4s, v1.8h v2.8h
2537         pmull2 v0.2d, v1.4s, v2.4s
2538
2539 // CHECK-ERROR: error: expected comma before next operand
2540 // CHECK-ERROR:        pmull2 v0.4s, v1.8h v2.8h
2541 // CHECK-ERROR:                            ^
2542 // CHECK-ERROR: error: invalid operand for instruction
2543 // CHECK-ERROR:        pmull2 v0.2d, v1.4s, v2.4s
2544 // CHECK-ERROR:                  ^
2545
2546 //------------------------------------------------------------------------------
2547 // Widen
2548 //------------------------------------------------------------------------------
2549
2550         saddw v0.8h, v1.8h, v2.8h
2551         saddw v0.4s, v1.4s, v2.4s
2552         saddw v0.2d, v1.2d, v2.2d
2553
2554 // CHECK-ERROR: error: invalid operand for instruction
2555 // CHECK-ERROR:        saddw v0.8h, v1.8h, v2.8h
2556 // CHECK-ERROR:                               ^
2557 // CHECK-ERROR: error: invalid operand for instruction
2558 // CHECK-ERROR:        saddw v0.4s, v1.4s, v2.4s
2559 // CHECK-ERROR:                               ^
2560 // CHECK-ERROR: error: invalid operand for instruction
2561 // CHECK-ERROR:        saddw v0.2d, v1.2d, v2.2d
2562 // CHECK-ERROR:                               ^
2563
2564         saddw2 v0.8h, v1.8h, v2.16h
2565         saddw2 v0.4s, v1.4s, v2.8s
2566         saddw2 v0.2d, v1.2d, v2.4d
2567
2568 // CHECK-ERROR: error: invalid operand for instruction
2569 // CHECK-ERROR:        saddw2 v0.8h, v1.8h, v2.16h
2570 // CHECK-ERROR:                             ^
2571 // CHECK-ERROR: error: invalid operand for instruction
2572 // CHECK-ERROR:        saddw2 v0.4s, v1.4s, v2.8s
2573 // CHECK-ERROR:                             ^
2574 // CHECK-ERROR: error: invalid operand for instruction
2575 // CHECK-ERROR:        saddw2 v0.2d, v1.2d, v2.4d
2576 // CHECK-ERROR:                             ^
2577
2578         uaddw v0.8h, v1.8h, v2.8h
2579         uaddw v0.4s, v1.4s, v2.4s
2580         uaddw v0.2d, v1.2d, v2.2d
2581
2582 // CHECK-ERROR: error: invalid operand for instruction
2583 // CHECK-ERROR:        uaddw v0.8h, v1.8h, v2.8h
2584 // CHECK-ERROR:                               ^
2585 // CHECK-ERROR: error: invalid operand for instruction
2586 // CHECK-ERROR:        uaddw v0.4s, v1.4s, v2.4s
2587 // CHECK-ERROR:                               ^
2588 // CHECK-ERROR: error: invalid operand for instruction
2589 // CHECK-ERROR:        uaddw v0.2d, v1.2d, v2.2d
2590 // CHECK-ERROR:                               ^
2591
2592         uaddw2 v0.8h, v1.8h, v2.16h
2593         uaddw2 v0.4s, v1.4s, v2.8s
2594         uaddw2 v0.2d, v1.2d, v2.4d
2595
2596 // CHECK-ERROR: error: invalid operand for instruction
2597 // CHECK-ERROR:        uaddw2 v0.8h, v1.8h, v2.16h
2598 // CHECK-ERROR:                             ^
2599 // CHECK-ERROR: error: invalid operand for instruction
2600 // CHECK-ERROR:        uaddw2 v0.4s, v1.4s, v2.8s
2601 // CHECK-ERROR:                             ^
2602 // CHECK-ERROR: error: invalid operand for instruction
2603 // CHECK-ERROR:        uaddw2 v0.2d, v1.2d, v2.4d
2604 // CHECK-ERROR:                             ^
2605
2606         ssubw v0.8h, v1.8h, v2.8h
2607         ssubw v0.4s, v1.4s, v2.4s
2608         ssubw v0.2d, v1.2d, v2.2d
2609
2610 // CHECK-ERROR: error: invalid operand for instruction
2611 // CHECK-ERROR:        ssubw v0.8h, v1.8h, v2.8h
2612 // CHECK-ERROR:                               ^
2613 // CHECK-ERROR: error: invalid operand for instruction
2614 // CHECK-ERROR:        ssubw v0.4s, v1.4s, v2.4s
2615 // CHECK-ERROR:                               ^
2616 // CHECK-ERROR: error: invalid operand for instruction
2617 // CHECK-ERROR:        ssubw v0.2d, v1.2d, v2.2d
2618 // CHECK-ERROR:                               ^
2619
2620         ssubw2 v0.8h, v1.8h, v2.16h
2621         ssubw2 v0.4s, v1.4s, v2.8s
2622         ssubw2 v0.2d, v1.2d, v2.4d
2623
2624 // CHECK-ERROR: error: invalid operand for instruction
2625 // CHECK-ERROR:        ssubw2 v0.8h, v1.8h, v2.16h
2626 // CHECK-ERROR:                             ^
2627 // CHECK-ERROR: error: invalid operand for instruction
2628 // CHECK-ERROR:        ssubw2 v0.4s, v1.4s, v2.8s
2629 // CHECK-ERROR:                             ^
2630 // CHECK-ERROR: error: invalid operand for instruction
2631 // CHECK-ERROR:        ssubw2 v0.2d, v1.2d, v2.4d
2632 // CHECK-ERROR:                             ^
2633
2634         usubw v0.8h, v1.8h, v2.8h
2635         usubw v0.4s, v1.4s, v2.4s
2636         usubw v0.2d, v1.2d, v2.2d
2637
2638 // CHECK-ERROR: error: invalid operand for instruction
2639 // CHECK-ERROR:        usubw v0.8h, v1.8h, v2.8h
2640 // CHECK-ERROR:                               ^
2641 // CHECK-ERROR: error: invalid operand for instruction
2642 // CHECK-ERROR:        usubw v0.4s, v1.4s, v2.4s
2643 // CHECK-ERROR:                               ^
2644 // CHECK-ERROR: error: invalid operand for instruction
2645 // CHECK-ERROR:        usubw v0.2d, v1.2d, v2.2d
2646 // CHECK-ERROR:                               ^
2647
2648         usubw2 v0.8h, v1.8h, v2.16h
2649         usubw2 v0.4s, v1.4s, v2.8s
2650         usubw2 v0.2d, v1.2d, v2.4d
2651
2652 // CHECK-ERROR: error: invalid operand for instruction
2653 // CHECK-ERROR:        usubw2 v0.8h, v1.8h, v2.16h
2654 // CHECK-ERROR:                             ^
2655 // CHECK-ERROR: error: invalid operand for instruction
2656 // CHECK-ERROR:        usubw2 v0.4s, v1.4s, v2.8s
2657 // CHECK-ERROR:                             ^
2658 // CHECK-ERROR: error: invalid operand for instruction
2659 // CHECK-ERROR:        usubw2 v0.2d, v1.2d, v2.4d
2660 // CHECK-ERROR:                             ^
2661
2662 //------------------------------------------------------------------------------
2663 // Narrow
2664 //------------------------------------------------------------------------------
2665
2666         addhn v0.8b, v1.8h, v2.8d
2667         addhn v0.4h, v1.4s, v2.4h
2668         addhn v0.2s, v1.2d, v2.2s
2669
2670 // CHECK-ERROR: error: invalid operand for instruction
2671 // CHECK-ERROR:        addhn v0.8b, v1.8h, v2.8d
2672 // CHECK-ERROR:                            ^
2673 // CHECK-ERROR: error: invalid operand for instruction
2674 // CHECK-ERROR:        addhn v0.4h, v1.4s, v2.4h
2675 // CHECK-ERROR:                               ^
2676 // CHECK-ERROR: error: invalid operand for instruction
2677 // CHECK-ERROR:        addhn v0.2s, v1.2d, v2.2s
2678 // CHECK-ERROR:                               ^
2679
2680         addhn2 v0.16b, v1.8h, v2.8b
2681         addhn2 v0.8h, v1.4s, v2.4h
2682         addhn2 v0.4s, v1.2d, v2.2s
2683
2684 // CHECK-ERROR: error: invalid operand for instruction
2685 // CHECK-ERROR:        addhn2 v0.16b, v1.8h, v2.8b
2686 // CHECK-ERROR:                                 ^
2687 // CHECK-ERROR: error: invalid operand for instruction
2688 // CHECK-ERROR:        addhn2 v0.8h, v1.4s, v2.4h
2689 // CHECK-ERROR:                                ^
2690 // CHECK-ERROR: error: invalid operand for instruction
2691 // CHECK-ERROR:        addhn2 v0.4s, v1.2d, v2.2s
2692 // CHECK-ERROR:                                ^
2693
2694         raddhn v0.8b, v1.8h, v2.8b
2695         raddhn v0.4h, v1.4s, v2.4h
2696         raddhn v0.2s, v1.2d, v2.2s
2697
2698 // CHECK-ERROR: error: invalid operand for instruction
2699 // CHECK-ERROR:        raddhn v0.8b, v1.8h, v2.8b
2700 // CHECK-ERROR:                                ^
2701 // CHECK-ERROR: error: invalid operand for instruction
2702 // CHECK-ERROR:        raddhn v0.4h, v1.4s, v2.4h
2703 // CHECK-ERROR:                                ^
2704 // CHECK-ERROR: error: invalid operand for instruction
2705 // CHECK-ERROR:        raddhn v0.2s, v1.2d, v2.2s
2706 // CHECK-ERROR:                                ^
2707
2708         raddhn2 v0.16b, v1.8h, v2.8b
2709         raddhn2 v0.8h, v1.4s, v2.4h
2710         raddhn2 v0.4s, v1.2d, v2.2s
2711
2712 // CHECK-ERROR: error: invalid operand for instruction
2713 // CHECK-ERROR:        raddhn2 v0.16b, v1.8h, v2.8b
2714 // CHECK-ERROR:                                  ^
2715 // CHECK-ERROR: error: invalid operand for instruction
2716 // CHECK-ERROR:        raddhn2 v0.8h, v1.4s, v2.4h
2717 // CHECK-ERROR:                                 ^
2718 // CHECK-ERROR: error: invalid operand for instruction
2719 // CHECK-ERROR:        raddhn2 v0.4s, v1.2d, v2.2s
2720 // CHECK-ERROR:                                 ^
2721
2722         rsubhn v0.8b, v1.8h, v2.8b
2723         rsubhn v0.4h, v1.4s, v2.4h
2724         rsubhn v0.2s, v1.2d, v2.2s
2725
2726 // CHECK-ERROR: error: invalid operand for instruction
2727 // CHECK-ERROR:        rsubhn v0.8b, v1.8h, v2.8b
2728 // CHECK-ERROR:                                ^
2729 // CHECK-ERROR: error: invalid operand for instruction
2730 // CHECK-ERROR:        rsubhn v0.4h, v1.4s, v2.4h
2731 // CHECK-ERROR:                                ^
2732 // CHECK-ERROR: error: invalid operand for instruction
2733 // CHECK-ERROR:        rsubhn v0.2s, v1.2d, v2.2s
2734 // CHECK-ERROR:                                ^
2735
2736         rsubhn2 v0.16b, v1.8h, v2.8b
2737         rsubhn2 v0.8h, v1.4s, v2.4h
2738         rsubhn2 v0.4s, v1.2d, v2.2s
2739
2740 // CHECK-ERROR: error: invalid operand for instruction
2741 // CHECK-ERROR:        rsubhn2 v0.16b, v1.8h, v2.8b
2742 // CHECK-ERROR:                                  ^
2743 // CHECK-ERROR: error: invalid operand for instruction
2744 // CHECK-ERROR:        rsubhn2 v0.8h, v1.4s, v2.4h
2745 // CHECK-ERROR:                                 ^
2746 // CHECK-ERROR: error: invalid operand for instruction
2747 // CHECK-ERROR:        rsubhn2 v0.4s, v1.2d, v2.2s
2748 // CHECK-ERROR:                                 ^
2749
2750 //----------------------------------------------------------------------
2751 // Scalar Reduce Add Pairwise (Integer)
2752 //----------------------------------------------------------------------
2753          // invalid vector types
2754       addp s0, d1.2d
2755       addp d0, d1.2s
2756
2757 // CHECK-ERROR: error: invalid operand for instruction
2758 // CHECK-ERROR:          addp s0, d1.2d
2759 // CHECK-ERROR:               ^
2760 // CHECK-ERROR: error: invalid operand for instruction
2761 // CHECK-ERROR:          addp d0, d1.2s
2762 // CHECK-ERROR:                      ^
2763
2764 //----------------------------------------------------------------------
2765 // Scalar Reduce Add Pairwise (Floating Point)
2766 //----------------------------------------------------------------------
2767          // invalid vector types
2768       faddp s0, d1.2d
2769       faddp d0, d1.2s
2770
2771 // CHECK-ERROR: error: invalid operand for instruction
2772 // CHECK-ERROR:          faddp s0, d1.2d
2773 // CHECK-ERROR:                    ^
2774 // CHECK-ERROR: error: invalid operand for instruction
2775 // CHECK-ERROR:          faddp d0, d1.2s
2776 // CHECK-ERROR:                    ^
2777
2778 //----------------------------------------------------------------------
2779 // Scalar Reduce Maximum Pairwise (Floating Point)
2780 //----------------------------------------------------------------------
2781          // mismatched and invalid vector types
2782       fmaxp s0, v1.2d
2783       fmaxp d31, v2.2s
2784       fmaxp h3, v2.2s
2785
2786 // CHECK-ERROR: error: invalid operand for instruction
2787 // CHECK-ERROR:          fmaxp s0, v1.2d
2788 // CHECK-ERROR:                       ^
2789 // CHECK-ERROR: error: invalid operand for instruction
2790 // CHECK-ERROR:          fmaxp d31, v2.2s
2791 // CHECK-ERROR:                        ^
2792 // CHECK-ERROR: error: invalid operand for instruction
2793 // CHECK-ERROR:          fmaxp h3, v2.2s
2794 // CHECK-ERROR:                ^
2795
2796
2797 //----------------------------------------------------------------------
2798 // Scalar Reduce Minimum Pairwise (Floating Point)
2799 //----------------------------------------------------------------------
2800          // mismatched and invalid vector types
2801       fminp s0, v1.4h
2802       fminp d31, v2.8h
2803       fminp b3, v2.2s
2804
2805 // CHECK-ERROR: error: invalid operand for instruction
2806 // CHECK-ERROR:          fminp s0, v1.4h
2807 // CHECK-ERROR:                       ^
2808 // CHECK-ERROR: error: invalid operand for instruction
2809 // CHECK-ERROR:          fminp d31, v2.8h
2810 // CHECK-ERROR:                        ^
2811 // CHECK-ERROR: error: invalid operand for instruction
2812 // CHECK-ERROR:          fminp b3, v2.2s
2813 // CHECK-ERROR:                ^
2814
2815
2816 //----------------------------------------------------------------------
2817 // Scalar Reduce maxNum Pairwise (Floating Point)
2818 //----------------------------------------------------------------------
2819          // mismatched and invalid vector types
2820       fmaxnmp s0, v1.8b
2821       fmaxnmp d31, v2.16b
2822       fmaxnmp v1.2s, v2.2s
2823
2824 // CHECK-ERROR: error: invalid operand for instruction
2825 // CHECK-ERROR:          fmaxnmp s0, v1.8b
2826 // CHECK-ERROR:                         ^
2827 // CHECK-ERROR: error: invalid operand for instruction
2828 // CHECK-ERROR:          fmaxnmp d31, v2.16b
2829 // CHECK-ERROR:                          ^
2830 // CHECK-ERROR: error: too few operands for instruction
2831 // CHECK-ERROR:          fmaxnmp v1.2s, v2.2s
2832 // CHECK-ERROR:          ^
2833
2834 //----------------------------------------------------------------------
2835 // Scalar Reduce minNum Pairwise (Floating Point)
2836 //----------------------------------------------------------------------
2837          // mismatched and invalid vector types
2838       fminnmp s0, v1.2d
2839       fminnmp d31, v2.4s
2840       fminnmp v1.4s, v2.2d
2841
2842 // CHECK-ERROR: error: invalid operand for instruction
2843 // CHECK-ERROR:          fminnmp s0, v1.2d
2844 // CHECK-ERROR:                         ^
2845 // CHECK-ERROR: error: invalid operand for instruction
2846 // CHECK-ERROR:          fminnmp d31, v2.4s
2847 // CHECK-ERROR:                          ^
2848 // CHECK-ERROR: error: invalid operand for instruction
2849 // CHECK-ERROR:          fminnmp v1.4s, v2.2d
2850 // CHECK-ERROR:          ^
2851
2852       mla v0.2d, v1.2d, v16.d[1]
2853       mla v0.2s, v1.2s, v2.s[4]
2854       mla v0.4s, v1.4s, v2.s[4]
2855       mla v0.2h, v1.2h, v2.h[1]
2856       mla v0.4h, v1.4h, v2.h[8]
2857       mla v0.8h, v1.8h, v2.h[8]
2858       mla v0.4h, v1.4h, v16.h[2]
2859       mla v0.8h, v1.8h, v16.h[2]
2860
2861 // CHECK-ERROR: error: invalid operand for instruction
2862 // CHECK-ERROR:        mla v0.2d, v1.2d, v16.d[1]
2863 // CHECK-ERROR:               ^
2864 // CHECK-ERROR: error: lane number incompatible with layout
2865 // CHECK-ERROR:        mla v0.2s, v1.2s, v2.s[4]
2866 // CHECK-ERROR:                               ^
2867 // CHECK-ERROR: error: lane number incompatible with layout
2868 // CHECK-ERROR:        mla v0.4s, v1.4s, v2.s[4]
2869 // CHECK-ERROR:                               ^
2870 // CHECK-ERROR: error: invalid operand for instruction
2871 // CHECK-ERROR:        mla v0.2h, v1.2h, v2.h[1]
2872 // CHECK-ERROR:            ^
2873 // CHECK-ERROR: error: lane number incompatible with layout
2874 // CHECK-ERROR:        mla v0.4h, v1.4h, v2.h[8]
2875 // CHECK-ERROR:                               ^
2876 // CHECK-ERROR: error: lane number incompatible with layout
2877 // CHECK-ERROR:        mla v0.8h, v1.8h, v2.h[8]
2878 // CHECK-ERROR:                               ^
2879 // CHECK-ERROR: error: invalid operand for instruction
2880 // CHECK-ERROR:        mla v0.4h, v1.4h, v16.h[2]
2881 // CHECK-ERROR:                          ^
2882 // CHECK-ERROR: error: invalid operand for instruction
2883 // CHECK-ERROR:        mla v0.8h, v1.8h, v16.h[2]
2884 // CHECK-ERROR:                              ^
2885
2886       mls v0.2d, v1.2d, v16.d[1]
2887       mls v0.2s, v1.2s, v2.s[4]
2888       mls v0.4s, v1.4s, v2.s[4]
2889       mls v0.2h, v1.2h, v2.h[1]
2890       mls v0.4h, v1.4h, v2.h[8]
2891       mls v0.8h, v1.8h, v2.h[8]
2892       mls v0.4h, v1.4h, v16.h[2]
2893       mls v0.8h, v1.8h, v16.h[2]
2894
2895 // CHECK-ERROR: error: invalid operand for instruction
2896 // CHECK-ERROR:        mls v0.2d, v1.2d, v16.d[1]
2897 // CHECK-ERROR:               ^
2898 // CHECK-ERROR: error: lane number incompatible with layout
2899 // CHECK-ERROR:        mls v0.2s, v1.2s, v2.s[4]
2900 // CHECK-ERROR:                               ^
2901 // CHECK-ERROR: error: lane number incompatible with layout
2902 // CHECK-ERROR:        mls v0.4s, v1.4s, v2.s[4]
2903 // CHECK-ERROR:                               ^
2904 // CHECK-ERROR: error: invalid operand for instruction
2905 // CHECK-ERROR:        mls v0.2h, v1.2h, v2.h[1]
2906 // CHECK-ERROR:            ^
2907 // CHECK-ERROR: error: lane number incompatible with layout
2908 // CHECK-ERROR:        mls v0.4h, v1.4h, v2.h[8]
2909 // CHECK-ERROR:                               ^
2910 // CHECK-ERROR: error: lane number incompatible with layout
2911 // CHECK-ERROR:        mls v0.8h, v1.8h, v2.h[8]
2912 // CHECK-ERROR:                               ^
2913 // CHECK-ERROR: error: invalid operand for instruction
2914 // CHECK-ERROR:        mls v0.4h, v1.4h, v16.h[2]
2915 // CHECK-ERROR:                          ^
2916 // CHECK-ERROR: error: invalid operand for instruction
2917 // CHECK-ERROR:        mls v0.8h, v1.8h, v16.h[2]
2918 // CHECK-ERROR:                              ^
2919
2920       fmla v0.4h, v1.4h, v2.h[2]
2921       fmla v0.8h, v1.8h, v2.h[2]
2922       fmla v0.2s, v1.2s, v2.s[4]
2923       fmla v0.2s, v1.2s, v22.s[4]
2924       fmla v3.4s, v8.4s, v2.s[4]
2925       fmla v3.4s, v8.4s, v22.s[4]
2926       fmla v0.2d, v1.2d, v2.d[2]
2927       fmla v0.2d, v1.2d, v22.d[2]
2928
2929 // CHECK-ERROR: error: invalid operand for instruction
2930 // CHECK-ERROR:        fmla v0.4h, v1.4h, v2.h[2]
2931 // CHECK-ERROR:                ^
2932 // CHECK-ERROR: error: invalid operand for instruction
2933 // CHECK-ERROR:        fmla v0.8h, v1.8h, v2.h[2]
2934 // CHECK-ERROR:                ^
2935 // CHECK-ERROR: error: lane number incompatible with layout
2936 // CHECK-ERROR:        fmla v0.2s, v1.2s, v2.s[4]
2937 // CHECK-ERROR:                                ^
2938 // CHECK-ERROR: error: lane number incompatible with layout
2939 // CHECK-ERROR:        fmla v0.2s, v1.2s, v22.s[4]
2940 // CHECK-ERROR:                                 ^
2941 // CHECK-ERROR: error: lane number incompatible with layout
2942 // CHECK-ERROR:        fmla v3.4s, v8.4s, v2.s[4]
2943 // CHECK-ERROR:                                ^
2944 // CHECK-ERROR: error: lane number incompatible with layout
2945 // CHECK-ERROR:        fmla v3.4s, v8.4s, v22.s[4]
2946 // CHECK-ERROR:                                 ^
2947 // CHECK-ERROR: error: lane number incompatible with layout
2948 // CHECK-ERROR:        fmla v0.2d, v1.2d, v2.d[2]
2949 // CHECK-ERROR:                                ^
2950 // CHECK-ERROR: error: lane number incompatible with layout
2951 // CHECK-ERROR:        fmla v0.2d, v1.2d, v22.d[2]
2952 // CHECK-ERROR:                                 ^
2953
2954       fmls v0.4h, v1.4h, v2.h[2]
2955       fmls v0.8h, v1.8h, v2.h[2]
2956       fmls v0.2s, v1.2s, v2.s[4]
2957       fmls v0.2s, v1.2s, v22.s[4]
2958       fmls v3.4s, v8.4s, v2.s[4]
2959       fmls v3.4s, v8.4s, v22.s[4]
2960       fmls v0.2d, v1.2d, v2.d[2]
2961       fmls v0.2d, v1.2d, v22.d[2]
2962
2963 // CHECK-ERROR: error: invalid operand for instruction
2964 // CHECK-ERROR:        fmls v0.4h, v1.4h, v2.h[2]
2965 // CHECK-ERROR:                ^
2966 // CHECK-ERROR: error: invalid operand for instruction
2967 // CHECK-ERROR:        fmls v0.8h, v1.8h, v2.h[2]
2968 // CHECK-ERROR:                ^
2969 // CHECK-ERROR: error: lane number incompatible with layout
2970 // CHECK-ERROR:        fmls v0.2s, v1.2s, v2.s[4]
2971 // CHECK-ERROR:                                ^
2972 // CHECK-ERROR: error: lane number incompatible with layout
2973 // CHECK-ERROR:        fmls v0.2s, v1.2s, v22.s[4]
2974 // CHECK-ERROR:                                 ^
2975 // CHECK-ERROR: error: lane number incompatible with layout
2976 // CHECK-ERROR:        fmls v3.4s, v8.4s, v2.s[4]
2977 // CHECK-ERROR:                                ^
2978 // CHECK-ERROR: error: lane number incompatible with layout
2979 // CHECK-ERROR:        fmls v3.4s, v8.4s, v22.s[4]
2980 // CHECK-ERROR:                                 ^
2981 // CHECK-ERROR: error: lane number incompatible with layout
2982 // CHECK-ERROR:        fmls v0.2d, v1.2d, v2.d[2]
2983 // CHECK-ERROR:                                ^
2984 // CHECK-ERROR: error: lane number incompatible with layout
2985 // CHECK-ERROR:        fmls v0.2d, v1.2d, v22.d[2]
2986 // CHECK-ERROR:                                 ^
2987
2988       smlal v0.4h, v1.4h, v2.h[2]
2989       smlal v0.4s, v1.4h, v2.h[8]
2990       smlal v0.4s, v1.4h, v16.h[2]
2991       smlal v0.2s, v1.2s, v2.s[4]
2992       smlal v0.2d, v1.2s, v2.s[4]
2993       smlal v0.2d, v1.2s, v22.s[4]
2994       smlal2 v0.4h, v1.8h, v1.h[2]
2995       smlal2 v0.4s, v1.8h, v1.h[8]
2996       smlal2 v0.4s, v1.8h, v16.h[2]
2997       smlal2 v0.2s, v1.4s, v1.s[2]
2998       smlal2 v0.2d, v1.4s, v1.s[4]
2999       smlal2 v0.2d, v1.4s, v22.s[4]
3000
3001 // CHECK-ERROR: error: invalid operand for instruction
3002 // CHECK-ERROR:        smlal v0.4h, v1.4h, v2.h[2]
3003 // CHECK-ERROR:              ^
3004 // CHECK-ERROR: error: lane number incompatible with layout
3005 // CHECK-ERROR:        smlal v0.4s, v1.4h, v2.h[8]
3006 // CHECK-ERROR:                                 ^
3007 // CHECK-ERROR: error: invalid operand for instruction
3008 // CHECK-ERROR:        smlal v0.4s, v1.4h, v16.h[2]
3009 // CHECK-ERROR:                            ^
3010 // CHECK-ERROR: error: lane number incompatible with layout
3011 // CHECK-ERROR:        smlal v0.2s, v1.2s, v2.s[4]
3012 // CHECK-ERROR:                                 ^
3013 // CHECK-ERROR: error: lane number incompatible with layout
3014 // CHECK-ERROR:        smlal v0.2d, v1.2s, v2.s[4]
3015 // CHECK-ERROR:                                 ^
3016 // CHECK-ERROR: error: lane number incompatible with layout
3017 // CHECK-ERROR:        smlal v0.2d, v1.2s, v22.s[4]
3018 // CHECK-ERROR:                                  ^
3019 // CHECK-ERROR: error: invalid operand for instruction
3020 // CHECK-ERROR:        smlal2 v0.4h, v1.8h, v1.h[2]
3021 // CHECK-ERROR:               ^
3022 // CHECK-ERROR: error: lane number incompatible with layout
3023 // CHECK-ERROR:        smlal2 v0.4s, v1.8h, v1.h[8]
3024 // CHECK-ERROR:                                  ^
3025 // CHECK-ERROR: error: invalid operand for instruction
3026 // CHECK-ERROR:        smlal2 v0.4s, v1.8h, v16.h[2]
3027 // CHECK-ERROR:                                 ^
3028 // CHECK-ERROR: error: invalid operand for instruction
3029 // CHECK-ERROR:        smlal2 v0.2s, v1.4s, v1.s[2]
3030 // CHECK-ERROR:               ^
3031 // CHECK-ERROR: error: lane number incompatible with layout
3032 // CHECK-ERROR:        smlal2 v0.2d, v1.4s, v1.s[4]
3033 // CHECK-ERROR:                                  ^
3034 // CHECK-ERROR: error: lane number incompatible with layout
3035 // CHECK-ERROR:        smlal2 v0.2d, v1.4s, v22.s[4]
3036 // CHECK-ERROR:                                   ^
3037
3038       smlsl v0.4h, v1.4h, v2.h[2]
3039       smlsl v0.4s, v1.4h, v2.h[8]
3040       smlsl v0.4s, v1.4h, v16.h[2]
3041       smlsl v0.2s, v1.2s, v2.s[4]
3042       smlsl v0.2d, v1.2s, v2.s[4]
3043       smlsl v0.2d, v1.2s, v22.s[4]
3044       smlsl2 v0.4h, v1.8h, v1.h[2]
3045       smlsl2 v0.4s, v1.8h, v1.h[8]
3046       smlsl2 v0.4s, v1.8h, v16.h[2]
3047       smlsl2 v0.2s, v1.4s, v1.s[2]
3048       smlsl2 v0.2d, v1.4s, v1.s[4]
3049       smlsl2 v0.2d, v1.4s, v22.s[4]
3050
3051 // CHECK-ERROR: error: invalid operand for instruction
3052 // CHECK-ERROR:        smlsl v0.4h, v1.4h, v2.h[2]
3053 // CHECK-ERROR:              ^
3054 // CHECK-ERROR: error: lane number incompatible with layout
3055 // CHECK-ERROR:        smlsl v0.4s, v1.4h, v2.h[8]
3056 // CHECK-ERROR:                                 ^
3057 // CHECK-ERROR: error: invalid operand for instruction
3058 // CHECK-ERROR:        smlsl v0.4s, v1.4h, v16.h[2]
3059 // CHECK-ERROR:                            ^
3060 // CHECK-ERROR: error: lane number incompatible with layout
3061 // CHECK-ERROR:        smlsl v0.2s, v1.2s, v2.s[4]
3062 // CHECK-ERROR:                                 ^
3063 // CHECK-ERROR: error: lane number incompatible with layout
3064 // CHECK-ERROR:        smlsl v0.2d, v1.2s, v2.s[4]
3065 // CHECK-ERROR:                                 ^
3066 // CHECK-ERROR: error: lane number incompatible with layout
3067 // CHECK-ERROR:        smlsl v0.2d, v1.2s, v22.s[4]
3068 // CHECK-ERROR:                                  ^
3069 // CHECK-ERROR: error: invalid operand for instruction
3070 // CHECK-ERROR:        smlsl2 v0.4h, v1.8h, v1.h[2]
3071 // CHECK-ERROR:               ^
3072 // CHECK-ERROR: error: lane number incompatible with layout
3073 // CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v1.h[8]
3074 // CHECK-ERROR:                                  ^
3075 // CHECK-ERROR: error: invalid operand for instruction
3076 // CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v16.h[2]
3077 // CHECK-ERROR:                                 ^
3078 // CHECK-ERROR: error: invalid operand for instruction
3079 // CHECK-ERROR:        smlsl2 v0.2s, v1.4s, v1.s[2]
3080 // CHECK-ERROR:               ^
3081 // CHECK-ERROR: error: lane number incompatible with layout
3082 // CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v1.s[4]
3083 // CHECK-ERROR:                                  ^
3084 // CHECK-ERROR: error: lane number incompatible with layout
3085 // CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v22.s[4]
3086 // CHECK-ERROR:                                   ^
3087
3088       umlal v0.4h, v1.4h, v2.h[2]
3089       umlal v0.4s, v1.4h, v2.h[8]
3090       umlal v0.4s, v1.4h, v16.h[2]
3091       umlal v0.2s, v1.2s, v2.s[4]
3092       umlal v0.2d, v1.2s, v2.s[4]
3093       umlal v0.2d, v1.2s, v22.s[4]
3094       umlal2 v0.4h, v1.8h, v1.h[2]
3095       umlal2 v0.4s, v1.8h, v1.h[8]
3096       umlal2 v0.4s, v1.8h, v16.h[2]
3097       umlal2 v0.2s, v1.4s, v1.s[2]
3098       umlal2 v0.2d, v1.4s, v1.s[4]
3099       umlal2 v0.2d, v1.4s, v22.s[4]
3100
3101 // CHECK-ERROR: error: invalid operand for instruction
3102 // CHECK-ERROR:        umlal v0.4h, v1.4h, v2.h[2]
3103 // CHECK-ERROR:              ^
3104 // CHECK-ERROR: error: lane number incompatible with layout
3105 // CHECK-ERROR:        umlal v0.4s, v1.4h, v2.h[8]
3106 // CHECK-ERROR:                                 ^
3107 // CHECK-ERROR: error: invalid operand for instruction
3108 // CHECK-ERROR:        umlal v0.4s, v1.4h, v16.h[2]
3109 // CHECK-ERROR:                            ^
3110 // CHECK-ERROR: error: lane number incompatible with layout
3111 // CHECK-ERROR:        umlal v0.2s, v1.2s, v2.s[4]
3112 // CHECK-ERROR:                                 ^
3113 // CHECK-ERROR: error: lane number incompatible with layout
3114 // CHECK-ERROR:        umlal v0.2d, v1.2s, v2.s[4]
3115 // CHECK-ERROR:                                 ^
3116 // CHECK-ERROR: error: lane number incompatible with layout
3117 // CHECK-ERROR:        umlal v0.2d, v1.2s, v22.s[4]
3118 // CHECK-ERROR:                                  ^
3119 // CHECK-ERROR: error: invalid operand for instruction
3120 // CHECK-ERROR:        umlal2 v0.4h, v1.8h, v1.h[2]
3121 // CHECK-ERROR:               ^
3122 // CHECK-ERROR: error: lane number incompatible with layout
3123 // CHECK-ERROR:        umlal2 v0.4s, v1.8h, v1.h[8]
3124 // CHECK-ERROR:                                  ^
3125 // CHECK-ERROR: error: invalid operand for instruction
3126 // CHECK-ERROR:        umlal2 v0.4s, v1.8h, v16.h[2]
3127 // CHECK-ERROR:                                 ^
3128 // CHECK-ERROR: error: invalid operand for instruction
3129 // CHECK-ERROR:        umlal2 v0.2s, v1.4s, v1.s[2]
3130 // CHECK-ERROR:               ^
3131 // CHECK-ERROR: error: lane number incompatible with layout
3132 // CHECK-ERROR:        umlal2 v0.2d, v1.4s, v1.s[4]
3133 // CHECK-ERROR:                                  ^
3134 // CHECK-ERROR: error: lane number incompatible with layout
3135 // CHECK-ERROR:        umlal2 v0.2d, v1.4s, v22.s[4]
3136 // CHECK-ERROR:                                   ^
3137
3138       umlsl v0.4h, v1.4h, v2.h[2]
3139       umlsl v0.4s, v1.4h, v2.h[8]
3140       umlsl v0.4s, v1.4h, v16.h[2]
3141       umlsl v0.2s, v1.2s, v2.s[4]
3142       umlsl v0.2d, v1.2s, v2.s[4]
3143       umlsl v0.2d, v1.2s, v22.s[4]
3144       umlsl2 v0.4h, v1.8h, v1.h[2]
3145       umlsl2 v0.4s, v1.8h, v1.h[8]
3146       umlsl2 v0.4s, v1.8h, v16.h[2]
3147       umlsl2 v0.2s, v1.4s, v1.s[2]
3148       umlsl2 v0.2d, v1.4s, v1.s[4]
3149       umlsl2 v0.2d, v1.4s, v22.s[4]
3150
3151 // CHECK-ERROR: error: invalid operand for instruction
3152 // CHECK-ERROR:        umlsl v0.4h, v1.4h, v2.h[2]
3153 // CHECK-ERROR:              ^
3154 // CHECK-ERROR: error: lane number incompatible with layout
3155 // CHECK-ERROR:        umlsl v0.4s, v1.4h, v2.h[8]
3156 // CHECK-ERROR:                                 ^
3157 // CHECK-ERROR: error: invalid operand for instruction
3158 // CHECK-ERROR:        umlsl v0.4s, v1.4h, v16.h[2]
3159 // CHECK-ERROR:                            ^
3160 // CHECK-ERROR: error: lane number incompatible with layout
3161 // CHECK-ERROR:        umlsl v0.2s, v1.2s, v2.s[4]
3162 // CHECK-ERROR:                                 ^
3163 // CHECK-ERROR: error: lane number incompatible with layout
3164 // CHECK-ERROR:        umlsl v0.2d, v1.2s, v2.s[4]
3165 // CHECK-ERROR:                                 ^
3166 // CHECK-ERROR: error: lane number incompatible with layout
3167 // CHECK-ERROR:        umlsl v0.2d, v1.2s, v22.s[4]
3168 // CHECK-ERROR:                                  ^
3169 // CHECK-ERROR: error: invalid operand for instruction
3170 // CHECK-ERROR:        umlsl2 v0.4h, v1.8h, v1.h[2]
3171 // CHECK-ERROR:               ^
3172 // CHECK-ERROR: error: lane number incompatible with layout
3173 // CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v1.h[8]
3174 // CHECK-ERROR:                                  ^
3175 // CHECK-ERROR: error: invalid operand for instruction
3176 // CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v16.h[2]
3177 // CHECK-ERROR:                                 ^
3178 // CHECK-ERROR: error: invalid operand for instruction
3179 // CHECK-ERROR:        umlsl2 v0.2s, v1.4s, v1.s[2]
3180 // CHECK-ERROR:               ^
3181 // CHECK-ERROR: error: lane number incompatible with layout
3182 // CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v1.s[4]
3183 // CHECK-ERROR:                                  ^
3184 // CHECK-ERROR: error: lane number incompatible with layout
3185 // CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v22.s[4]
3186 // CHECK-ERROR:                                   ^
3187
3188       sqdmlal v0.4h, v1.4h, v2.h[2]
3189       sqdmlal v0.4s, v1.4h, v2.h[8]
3190       sqdmlal v0.4s, v1.4h, v16.h[2]
3191       sqdmlal v0.2s, v1.2s, v2.s[4]
3192       sqdmlal v0.2d, v1.2s, v2.s[4]
3193       sqdmlal v0.2d, v1.2s, v22.s[4]
3194       sqdmlal2 v0.4h, v1.8h, v1.h[2]
3195       sqdmlal2 v0.4s, v1.8h, v1.h[8]
3196       sqdmlal2 v0.4s, v1.8h, v16.h[2]
3197       sqdmlal2 v0.2s, v1.4s, v1.s[2]
3198       sqdmlal2 v0.2d, v1.4s, v1.s[4]
3199       sqdmlal2 v0.2d, v1.4s, v22.s[4]
3200
3201 // CHECK-ERROR: error: invalid operand for instruction
3202 // CHECK-ERROR:        sqdmlal v0.4h, v1.4h, v2.h[2]
3203 // CHECK-ERROR:                ^
3204 // CHECK-ERROR: error: lane number incompatible with layout
3205 // CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v2.h[8]
3206 // CHECK-ERROR:                                   ^
3207 // CHECK-ERROR: error: invalid operand for instruction
3208 // CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v16.h[2]
3209 // CHECK-ERROR:                              ^
3210 // CHECK-ERROR: error: lane number incompatible with layout
3211 // CHECK-ERROR:        sqdmlal v0.2s, v1.2s, v2.s[4]
3212 // CHECK-ERROR:                                   ^
3213 // CHECK-ERROR: error: lane number incompatible with layout
3214 // CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v2.s[4]
3215 // CHECK-ERROR:                                   ^
3216 // CHECK-ERROR: error: lane number incompatible with layout
3217 // CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v22.s[4]
3218 // CHECK-ERROR:                                    ^
3219 // CHECK-ERROR: error: invalid operand for instruction
3220 // CHECK-ERROR:        sqdmlal2 v0.4h, v1.8h, v1.h[2]
3221 // CHECK-ERROR:                 ^
3222 // CHECK-ERROR: error: lane number incompatible with layout
3223 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v1.h[8]
3224 // CHECK-ERROR:                                    ^
3225 // CHECK-ERROR: error: invalid operand for instruction
3226 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v16.h[2]
3227 // CHECK-ERROR:                                   ^
3228 // CHECK-ERROR: error: invalid operand for instruction
3229 // CHECK-ERROR:        sqdmlal2 v0.2s, v1.4s, v1.s[2]
3230 // CHECK-ERROR:                 ^
3231 // CHECK-ERROR: error: lane number incompatible with layout
3232 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v1.s[4]
3233 // CHECK-ERROR:                                    ^
3234 // CHECK-ERROR: error: lane number incompatible with layout
3235 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v22.s[4]
3236 // CHECK-ERROR:                                     ^
3237
3238       sqdmlsl v0.4h, v1.4h, v2.h[2]
3239       sqdmlsl v0.4s, v1.4h, v2.h[8]
3240       sqdmlsl v0.4s, v1.4h, v16.h[2]
3241       sqdmlsl v0.2s, v1.2s, v2.s[4]
3242       sqdmlsl v0.2d, v1.2s, v2.s[4]
3243       sqdmlsl v0.2d, v1.2s, v22.s[4]
3244       sqdmlsl2 v0.4h, v1.8h, v1.h[2]
3245       sqdmlsl2 v0.4s, v1.8h, v1.h[8]
3246       sqdmlsl2 v0.4s, v1.8h, v16.h[2]
3247       sqdmlsl2 v0.2s, v1.4s, v1.s[2]
3248       sqdmlsl2 v0.2d, v1.4s, v1.s[4]
3249       sqdmlsl2 v0.2d, v1.4s, v22.s[4]
3250
3251 // CHECK-ERROR: error: invalid operand for instruction
3252 // CHECK-ERROR:        sqdmlsl v0.4h, v1.4h, v2.h[2]
3253 // CHECK-ERROR:                ^
3254 // CHECK-ERROR: error: lane number incompatible with layout
3255 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v2.h[8]
3256 // CHECK-ERROR:                                   ^
3257 // CHECK-ERROR: error: invalid operand for instruction
3258 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v16.h[2]
3259 // CHECK-ERROR:                              ^
3260 // CHECK-ERROR: error: lane number incompatible with layout
3261 // CHECK-ERROR:        sqdmlsl v0.2s, v1.2s, v2.s[4]
3262 // CHECK-ERROR:                                   ^
3263 // CHECK-ERROR: error: lane number incompatible with layout
3264 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v2.s[4]
3265 // CHECK-ERROR:                                   ^
3266 // CHECK-ERROR: error: lane number incompatible with layout
3267 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v22.s[4]
3268 // CHECK-ERROR:                                    ^
3269 // CHECK-ERROR: error: invalid operand for instruction
3270 // CHECK-ERROR:        sqdmlsl2 v0.4h, v1.8h, v1.h[2]
3271 // CHECK-ERROR:                 ^
3272 // CHECK-ERROR: error: lane number incompatible with layout
3273 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v1.h[8]
3274 // CHECK-ERROR:                                    ^
3275 // CHECK-ERROR: error: invalid operand for instruction
3276 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v16.h[2]
3277 // CHECK-ERROR:                                   ^
3278 // CHECK-ERROR: error: invalid operand for instruction
3279 // CHECK-ERROR:        sqdmlsl2 v0.2s, v1.4s, v1.s[2]
3280 // CHECK-ERROR:                 ^
3281 // CHECK-ERROR: error: lane number incompatible with layout
3282 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v1.s[4]
3283 // CHECK-ERROR:                                    ^
3284 // CHECK-ERROR: error: lane number incompatible with layout
3285 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v22.s[4]
3286 // CHECK-ERROR:                                     ^
3287
3288       mul v0.4h, v1.4h, v2.h[8]
3289       mul v0.4h, v1.4h, v16.h[8]
3290       mul v0.8h, v1.8h, v2.h[8]
3291       mul v0.8h, v1.8h, v16.h[8]
3292       mul v0.2s, v1.2s, v2.s[4]
3293       mul v0.2s, v1.2s, v22.s[4]
3294       mul v0.4s, v1.4s, v2.s[4]
3295       mul v0.4s, v1.4s, v22.s[4]
3296       mul v0.2d, v1.2d, v2.d[1]
3297
3298 // CHECK-ERROR: error: lane number incompatible with layout
3299 // CHECK-ERROR:        mul v0.4h, v1.4h, v2.h[8]
3300 // CHECK-ERROR:                               ^
3301 // CHECK-ERROR: error: lane number incompatible with layout
3302 // CHECK-ERROR:        mul v0.4h, v1.4h, v16.h[8]
3303 // CHECK-ERROR:                                ^
3304 // CHECK-ERROR: error: lane number incompatible with layout
3305 // CHECK-ERROR:        mul v0.8h, v1.8h, v2.h[8]
3306 // CHECK-ERROR:                               ^
3307 // CHECK-ERROR: error: lane number incompatible with layout
3308 // CHECK-ERROR:        mul v0.8h, v1.8h, v16.h[8]
3309 // CHECK-ERROR:                                ^
3310 // CHECK-ERROR: error: lane number incompatible with layout
3311 // CHECK-ERROR:        mul v0.2s, v1.2s, v2.s[4]
3312 // CHECK-ERROR:                               ^
3313 // CHECK-ERROR: error: lane number incompatible with layout
3314 // CHECK-ERROR:        mul v0.2s, v1.2s, v22.s[4]
3315 // CHECK-ERROR:                                ^
3316 // CHECK-ERROR: error: lane number incompatible with layout
3317 // CHECK-ERROR:        mul v0.4s, v1.4s, v2.s[4]
3318 // CHECK-ERROR:                               ^
3319 // CHECK-ERROR: error: lane number incompatible with layout
3320 // CHECK-ERROR:        mul v0.4s, v1.4s, v22.s[4]
3321 // CHECK-ERROR:                                ^
3322
3323       fmul v0.4h, v1.4h, v2.h[4]
3324       fmul v0.2s, v1.2s, v2.s[4]
3325       fmul v0.2s, v1.2s, v22.s[4]
3326       fmul v0.4s, v1.4s, v2.s[4]
3327       fmul v0.4s, v1.4s, v22.s[4]
3328       fmul v0.2d, v1.2d, v2.d[2]
3329       fmul v0.2d, v1.2d, v22.d[2]
3330
3331 // CHECK-ERROR: error: invalid operand for instruction
3332 // CHECK-ERROR:        mul v0.2d, v1.2d, v2.d[1]
3333 // CHECK-ERROR:               ^
3334 // CHECK-ERROR: error: invalid operand for instruction
3335 // CHECK-ERROR:        fmul v0.4h, v1.4h, v2.h[4]
3336 // CHECK-ERROR:                ^
3337 // CHECK-ERROR: error: lane number incompatible with layout
3338 // CHECK-ERROR:        fmul v0.2s, v1.2s, v2.s[4]
3339 // CHECK-ERROR:                                ^
3340 // CHECK-ERROR: error: lane number incompatible with layout
3341 // CHECK-ERROR:        fmul v0.2s, v1.2s, v22.s[4]
3342 // CHECK-ERROR:                                 ^
3343 // CHECK-ERROR: error: lane number incompatible with layout
3344 // CHECK-ERROR:        fmul v0.4s, v1.4s, v2.s[4]
3345 // CHECK-ERROR:                                ^
3346 // CHECK-ERROR: error: lane number incompatible with layout
3347 // CHECK-ERROR:        fmul v0.4s, v1.4s, v22.s[4]
3348 // CHECK-ERROR:                                 ^
3349 // CHECK-ERROR: error: lane number incompatible with layout
3350 // CHECK-ERROR:        fmul v0.2d, v1.2d, v2.d[2]
3351 // CHECK-ERROR:                                ^
3352 // CHECK-ERROR: error: lane number incompatible with layout
3353 // CHECK-ERROR:        fmul v0.2d, v1.2d, v22.d[2]
3354 // CHECK-ERROR:                                 ^
3355
3356       fmulx v0.4h, v1.4h, v2.h[4]
3357       fmulx v0.2s, v1.2s, v2.s[4]
3358       fmulx v0.2s, v1.2s, v22.s[4]
3359       fmulx v0.4s, v1.4s, v2.s[4]
3360       fmulx v0.4s, v1.4s, v22.s[4]
3361       fmulx v0.2d, v1.2d, v2.d[2]
3362       fmulx v0.2d, v1.2d, v22.d[2]
3363
3364 // CHECK-ERROR: error: invalid operand for instruction
3365 // CHECK-ERROR:        fmulx v0.4h, v1.4h, v2.h[4]
3366 // CHECK-ERROR:                 ^
3367 // CHECK-ERROR: error: lane number incompatible with layout
3368 // CHECK-ERROR:        fmulx v0.2s, v1.2s, v2.s[4]
3369 // CHECK-ERROR:                                 ^
3370 // CHECK-ERROR: error: lane number incompatible with layout
3371 // CHECK-ERROR:        fmulx v0.2s, v1.2s, v22.s[4]
3372 // CHECK-ERROR:                                  ^
3373 // CHECK-ERROR: error: lane number incompatible with layout
3374 // CHECK-ERROR:        fmulx v0.4s, v1.4s, v2.s[4]
3375 // CHECK-ERROR:                                 ^
3376 // CHECK-ERROR: error: lane number incompatible with layout
3377 // CHECK-ERROR:        fmulx v0.4s, v1.4s, v22.s[4]
3378 // CHECK-ERROR:                                  ^
3379 // CHECK-ERROR: error: lane number incompatible with layout
3380 // CHECK-ERROR:        fmulx v0.2d, v1.2d, v2.d[2]
3381 // CHECK-ERROR:                                 ^
3382 // CHECK-ERROR: error: lane number incompatible with layout
3383 // CHECK-ERROR:        fmulx v0.2d, v1.2d, v22.d[2]
3384 // CHECK-ERROR:                                  ^
3385
3386       smull v0.4h, v1.4h, v2.h[2]
3387       smull v0.4s, v1.4h, v2.h[8]
3388       smull v0.4s, v1.4h, v16.h[4]
3389       smull v0.2s, v1.2s, v2.s[2]
3390       smull v0.2d, v1.2s, v2.s[4]
3391       smull v0.2d, v1.2s, v22.s[4]
3392       smull2 v0.4h, v1.8h, v2.h[2]
3393       smull2 v0.4s, v1.8h, v2.h[8]
3394       smull2 v0.4s, v1.8h, v16.h[4]
3395       smull2 v0.2s, v1.4s, v2.s[2]
3396       smull2 v0.2d, v1.4s, v2.s[4]
3397       smull2 v0.2d, v1.4s, v22.s[4]
3398
3399 // CHECK-ERROR: error: invalid operand for instruction
3400 // CHECK-ERROR:        smull v0.4h, v1.4h, v2.h[2]
3401 // CHECK-ERROR:              ^
3402 // CHECK-ERROR: error: lane number incompatible with layout
3403 // CHECK-ERROR:        smull v0.4s, v1.4h, v2.h[8]
3404 // CHECK-ERROR:                                 ^
3405 // CHECK-ERROR: error: invalid operand for instruction
3406 // CHECK-ERROR:        smull v0.4s, v1.4h, v16.h[4]
3407 // CHECK-ERROR:                            ^
3408 // CHECK-ERROR: error: invalid operand for instruction
3409 // CHECK-ERROR:        smull v0.2s, v1.2s, v2.s[2]
3410 // CHECK-ERROR:              ^
3411 // CHECK-ERROR: error: lane number incompatible with layout
3412 // CHECK-ERROR:        smull v0.2d, v1.2s, v2.s[4]
3413 // CHECK-ERROR:                                 ^
3414 // CHECK-ERROR: error: lane number incompatible with layout
3415 // CHECK-ERROR:        smull v0.2d, v1.2s, v22.s[4]
3416 // CHECK-ERROR:                                  ^
3417 // CHECK-ERROR: error: invalid operand for instruction
3418 // CHECK-ERROR:        smull2 v0.4h, v1.8h, v2.h[2]
3419 // CHECK-ERROR:               ^
3420 // CHECK-ERROR: error: lane number incompatible with layout
3421 // CHECK-ERROR:        smull2 v0.4s, v1.8h, v2.h[8]
3422 // CHECK-ERROR:                                  ^
3423 // CHECK-ERROR: error: invalid operand for instruction
3424 // CHECK-ERROR:        smull2 v0.4s, v1.8h, v16.h[4]
3425 // CHECK-ERROR:                                 ^
3426 // CHECK-ERROR: error: invalid operand for instruction
3427 // CHECK-ERROR:        smull2 v0.2s, v1.4s, v2.s[2]
3428 // CHECK-ERROR:               ^
3429 // CHECK-ERROR: error: lane number incompatible with layout
3430 // CHECK-ERROR:        smull2 v0.2d, v1.4s, v2.s[4]
3431 // CHECK-ERROR:                                  ^
3432 // CHECK-ERROR: error: lane number incompatible with layout
3433 // CHECK-ERROR:        smull2 v0.2d, v1.4s, v22.s[4]
3434 // CHECK-ERROR:                                   ^
3435
3436       umull v0.4h, v1.4h, v2.h[2]
3437       umull v0.4s, v1.4h, v2.h[8]
3438       umull v0.4s, v1.4h, v16.h[4]
3439       umull v0.2s, v1.2s, v2.s[2]
3440       umull v0.2d, v1.2s, v2.s[4]
3441       umull v0.2d, v1.2s, v22.s[4]
3442       umull2 v0.4h, v1.8h, v2.h[2]
3443       umull2 v0.4s, v1.8h, v2.h[8]
3444       umull2 v0.4s, v1.8h, v16.h[4]
3445       umull2 v0.2s, v1.4s, v2.s[2]
3446       umull2 v0.2d, v1.4s, v2.s[4]
3447       umull2 v0.2d, v1.4s, v22.s[4]
3448
3449 // CHECK-ERROR: error: invalid operand for instruction
3450 // CHECK-ERROR:        umull v0.4h, v1.4h, v2.h[2]
3451 // CHECK-ERROR:              ^
3452 // CHECK-ERROR: error: lane number incompatible with layout
3453 // CHECK-ERROR:        umull v0.4s, v1.4h, v2.h[8]
3454 // CHECK-ERROR:                                 ^
3455 // CHECK-ERROR: error: invalid operand for instruction
3456 // CHECK-ERROR:        umull v0.4s, v1.4h, v16.h[4]
3457 // CHECK-ERROR:                            ^
3458 // CHECK-ERROR: error: invalid operand for instruction
3459 // CHECK-ERROR:        umull v0.2s, v1.2s, v2.s[2]
3460 // CHECK-ERROR:              ^
3461 // CHECK-ERROR: error: lane number incompatible with layout
3462 // CHECK-ERROR:        umull v0.2d, v1.2s, v2.s[4]
3463 // CHECK-ERROR:                                 ^
3464 // CHECK-ERROR: error: lane number incompatible with layout
3465 // CHECK-ERROR:        umull v0.2d, v1.2s, v22.s[4]
3466 // CHECK-ERROR:                                  ^
3467 // CHECK-ERROR: error: invalid operand for instruction
3468 // CHECK-ERROR:        umull2 v0.4h, v1.8h, v2.h[2]
3469 // CHECK-ERROR:               ^
3470 // CHECK-ERROR: error: lane number incompatible with layout
3471 // CHECK-ERROR:        umull2 v0.4s, v1.8h, v2.h[8]
3472 // CHECK-ERROR:                                  ^
3473 // CHECK-ERROR: error: invalid operand for instruction
3474 // CHECK-ERROR:        umull2 v0.4s, v1.8h, v16.h[4]
3475 // CHECK-ERROR:                                 ^
3476 // CHECK-ERROR: error: invalid operand for instruction
3477 // CHECK-ERROR:        umull2 v0.2s, v1.4s, v2.s[2]
3478 // CHECK-ERROR:               ^
3479 // CHECK-ERROR: error: lane number incompatible with layout
3480 // CHECK-ERROR:        umull2 v0.2d, v1.4s, v2.s[4]
3481 // CHECK-ERROR:                                  ^
3482 // CHECK-ERROR: error: lane number incompatible with layout
3483 // CHECK-ERROR:        umull2 v0.2d, v1.4s, v22.s[4]
3484 // CHECK-ERROR:                                   ^
3485
3486       sqdmull v0.4h, v1.4h, v2.h[2]
3487       sqdmull v0.4s, v1.4h, v2.h[8]
3488       sqdmull v0.4s, v1.4h, v16.h[4]
3489       sqdmull v0.2s, v1.2s, v2.s[2]
3490       sqdmull v0.2d, v1.2s, v2.s[4]
3491       sqdmull v0.2d, v1.2s, v22.s[4]
3492       sqdmull2 v0.4h, v1.8h, v2.h[2]
3493       sqdmull2 v0.4s, v1.8h, v2.h[8]
3494       sqdmull2 v0.4s, v1.8h, v16.h[4]
3495       sqdmull2 v0.2s, v1.4s, v2.s[2]
3496       sqdmull2 v0.2d, v1.4s, v2.s[4]
3497       sqdmull2 v0.2d, v1.4s, v22.s[4]
3498
3499 // CHECK-ERROR: error: invalid operand for instruction
3500 // CHECK-ERROR:        sqdmull v0.4h, v1.4h, v2.h[2]
3501 // CHECK-ERROR:                ^
3502 // CHECK-ERROR: error: lane number incompatible with layout
3503 // CHECK-ERROR:        sqdmull v0.4s, v1.4h, v2.h[8]
3504 // CHECK-ERROR:                                   ^
3505 // CHECK-ERROR: error: invalid operand for instruction
3506 // CHECK-ERROR:        sqdmull v0.4s, v1.4h, v16.h[4]
3507 // CHECK-ERROR:                              ^
3508 // CHECK-ERROR: error: invalid operand for instruction
3509 // CHECK-ERROR:        sqdmull v0.2s, v1.2s, v2.s[2]
3510 // CHECK-ERROR:                ^
3511 // CHECK-ERROR: error: lane number incompatible with layout
3512 // CHECK-ERROR:        sqdmull v0.2d, v1.2s, v2.s[4]
3513 // CHECK-ERROR:                                   ^
3514 // CHECK-ERROR: error: lane number incompatible with layout
3515 // CHECK-ERROR:        sqdmull v0.2d, v1.2s, v22.s[4]
3516 // CHECK-ERROR:                                    ^
3517 // CHECK-ERROR: error: invalid operand for instruction
3518 // CHECK-ERROR:        sqdmull2 v0.4h, v1.8h, v2.h[2]
3519 // CHECK-ERROR:                 ^
3520 // CHECK-ERROR: error: lane number incompatible with layout
3521 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v2.h[8]
3522 // CHECK-ERROR:                                    ^
3523 // CHECK-ERROR: error: invalid operand for instruction
3524 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v16.h[4]
3525 // CHECK-ERROR:                                   ^
3526 // CHECK-ERROR: error: invalid operand for instruction
3527 // CHECK-ERROR:        sqdmull2 v0.2s, v1.4s, v2.s[2]
3528 // CHECK-ERROR:                 ^
3529 // CHECK-ERROR: error: lane number incompatible with layout
3530 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v2.s[4]
3531 // CHECK-ERROR:                                    ^
3532 // CHECK-ERROR: error: lane number incompatible with layout
3533 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v22.s[4]
3534 // CHECK-ERROR:                                     ^
3535
3536       sqdmulh v0.4h, v1.4h, v2.h[8]
3537       sqdmulh v0.4h, v1.4h, v16.h[2]
3538       sqdmulh v0.8h, v1.8h, v2.h[8]
3539       sqdmulh v0.8h, v1.8h, v16.h[2]
3540       sqdmulh v0.2s, v1.2s, v2.s[4]
3541       sqdmulh v0.2s, v1.2s, v22.s[4]
3542       sqdmulh v0.4s, v1.4s, v2.s[4]
3543       sqdmulh v0.4s, v1.4s, v22.s[4]
3544       sqdmulh v0.2d, v1.2d, v22.d[1]
3545
3546 // CHECK-ERROR: error: lane number incompatible with layout
3547 // CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v2.h[8]
3548 // CHECK-ERROR:                                   ^
3549 // CHECK-ERROR: error: invalid operand for instruction
3550 // CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v16.h[2]
3551 // CHECK-ERROR:                              ^
3552 // CHECK-ERROR: error: lane number incompatible with layout
3553 // CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v2.h[8]
3554 // CHECK-ERROR:                                   ^
3555 // CHECK-ERROR: error: invalid operand for instruction
3556 // CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v16.h[2]
3557 // CHECK-ERROR:                                  ^
3558 // CHECK-ERROR: error: lane number incompatible with layout
3559 // CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v2.s[4]
3560 // CHECK-ERROR:                                   ^
3561 // CHECK-ERROR: error: lane number incompatible with layout
3562 // CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v22.s[4]
3563 // CHECK-ERROR:                                    ^
3564 // CHECK-ERROR: error: lane number incompatible with layout
3565 // CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v2.s[4]
3566 // CHECK-ERROR:                                   ^
3567 // CHECK-ERROR: error: lane number incompatible with layout
3568 // CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v22.s[4]
3569 // CHECK-ERROR:                                    ^
3570 // CHECK-ERROR: error: invalid operand for instruction
3571 // CHECK-ERROR:        sqdmulh v0.2d, v1.2d, v22.d[1]
3572 // CHECK-ERROR:                   ^
3573
3574       sqrdmulh v0.4h, v1.4h, v2.h[8]
3575       sqrdmulh v0.4h, v1.4h, v16.h[2]
3576       sqrdmulh v0.8h, v1.8h, v2.h[8]
3577       sqrdmulh v0.8h, v1.8h, v16.h[2]
3578       sqrdmulh v0.2s, v1.2s, v2.s[4]
3579       sqrdmulh v0.2s, v1.2s, v22.s[4]
3580       sqrdmulh v0.4s, v1.4s, v2.s[4]
3581       sqrdmulh v0.4s, v1.4s, v22.s[4]
3582       sqrdmulh v0.2d, v1.2d, v22.d[1]
3583
3584 // CHECK-ERROR: error: lane number incompatible with layout
3585 // CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v2.h[8]
3586 // CHECK-ERROR:                                    ^
3587 // CHECK-ERROR: error: invalid operand for instruction
3588 // CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v16.h[2]
3589 // CHECK-ERROR:                               ^
3590 // CHECK-ERROR: error: lane number incompatible with layout
3591 // CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v2.h[8]
3592 // CHECK-ERROR:                                    ^
3593 // CHECK-ERROR: error: invalid operand for instruction
3594 // CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v16.h[2]
3595 // CHECK-ERROR:                                   ^
3596 // CHECK-ERROR: error: lane number incompatible with layout
3597 // CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v2.s[4]
3598 // CHECK-ERROR:                                    ^
3599 // CHECK-ERROR: error: lane number incompatible with layout
3600 // CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v22.s[4]
3601 // CHECK-ERROR:                                     ^
3602 // CHECK-ERROR: error: lane number incompatible with layout
3603 // CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v2.s[4]
3604 // CHECK-ERROR:                                    ^
3605 // CHECK-ERROR: error: lane number incompatible with layout
3606 // CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v22.s[4]
3607 // CHECK-ERROR:                                     ^
3608 // CHECK-ERROR: error: invalid operand for instruction
3609 // CHECK-ERROR:        sqrdmulh v0.2d, v1.2d, v22.d[1]
3610 // CHECK-ERROR:                    ^
3611
3612 //----------------------------------------------------------------------
3613 // Across vectors
3614 //----------------------------------------------------------------------
3615
3616         saddlv b0, v1.8b
3617         saddlv b0, v1.16b
3618         saddlv h0, v1.4h
3619         saddlv h0, v1.8h
3620         saddlv s0, v1.2s
3621         saddlv s0, v1.4s
3622         saddlv d0, v1.2s
3623
3624 // CHECK-ERROR: error: invalid operand for instruction
3625 // CHECK-ERROR:        saddlv b0, v1.8b
3626 // CHECK-ERROR:               ^
3627 // CHECK-ERROR: error: invalid operand for instruction
3628 // CHECK-ERROR:        saddlv b0, v1.16b
3629 // CHECK-ERROR:               ^
3630 // CHECK-ERROR: error: invalid operand for instruction
3631 // CHECK-ERROR:        saddlv h0, v1.4h
3632 // CHECK-ERROR:                      ^
3633 // CHECK-ERROR: error: invalid operand for instruction
3634 // CHECK-ERROR:        saddlv h0, v1.8h
3635 // CHECK-ERROR:                      ^
3636 // CHECK-ERROR: error: invalid operand for instruction
3637 // CHECK-ERROR:        saddlv s0, v1.2s
3638 // CHECK-ERROR:                      ^
3639 // CHECK-ERROR: error: invalid operand for instruction
3640 // CHECK-ERROR:        saddlv s0, v1.4s
3641 // CHECK-ERROR:                      ^
3642 // CHECK-ERROR: error: invalid operand for instruction
3643 // CHECK-ERROR:        saddlv d0, v1.2s
3644 // CHECK-ERROR:                   ^
3645
3646         uaddlv b0, v1.8b
3647         uaddlv b0, v1.16b
3648         uaddlv h0, v1.4h
3649         uaddlv h0, v1.8h
3650         uaddlv s0, v1.2s
3651         uaddlv s0, v1.4s
3652         uaddlv d0, v1.2s
3653
3654 // CHECK-ERROR: error: invalid operand for instruction
3655 // CHECK-ERROR:        uaddlv b0, v1.8b
3656 // CHECK-ERROR:               ^
3657 // CHECK-ERROR: error: invalid operand for instruction
3658 // CHECK-ERROR:        uaddlv b0, v1.16b
3659 // CHECK-ERROR:               ^
3660 // CHECK-ERROR: error: invalid operand for instruction
3661 // CHECK-ERROR:        uaddlv h0, v1.4h
3662 // CHECK-ERROR:                      ^
3663 // CHECK-ERROR: error: invalid operand for instruction
3664 // CHECK-ERROR:        uaddlv h0, v1.8h
3665 // CHECK-ERROR:                      ^
3666 // CHECK-ERROR: error: invalid operand for instruction
3667 // CHECK-ERROR:        uaddlv s0, v1.2s
3668 // CHECK-ERROR:                      ^
3669 // CHECK-ERROR: error: invalid operand for instruction
3670 // CHECK-ERROR:        uaddlv s0, v1.4s
3671 // CHECK-ERROR:                      ^
3672 // CHECK-ERROR: error: invalid operand for instruction
3673 // CHECK-ERROR:        uaddlv d0, v1.2s
3674 // CHECK-ERROR:                   ^
3675
3676         smaxv s0, v1.2s
3677         sminv s0, v1.2s
3678         umaxv s0, v1.2s
3679         uminv s0, v1.2s
3680         addv s0, v1.2s
3681
3682 // CHECK-ERROR: error: invalid operand for instruction
3683 // CHECK-ERROR:        smaxv s0, v1.2s
3684 // CHECK-ERROR:                  ^
3685 // CHECK-ERROR: error: invalid operand for instruction
3686 // CHECK-ERROR:        sminv s0, v1.2s
3687 // CHECK-ERROR:                  ^
3688 // CHECK-ERROR: error: invalid operand for instruction
3689 // CHECK-ERROR:        umaxv s0, v1.2s
3690 // CHECK-ERROR:                  ^
3691 // CHECK-ERROR: error: invalid operand for instruction
3692 // CHECK-ERROR:        uminv s0, v1.2s
3693 // CHECK-ERROR:                  ^
3694 // CHECK-ERROR: error: invalid operand for instruction
3695 // CHECK-ERROR:        addv s0, v1.2s
3696 // CHECK-ERROR:                 ^
3697
3698         smaxv d0, v1.2d
3699         sminv d0, v1.2d
3700         umaxv d0, v1.2d
3701         uminv d0, v1.2d
3702         addv d0, v1.2d
3703
3704 // CHECK-ERROR: error: invalid operand for instruction
3705 // CHECK-ERROR:        smaxv d0, v1.2d
3706 // CHECK-ERROR:              ^
3707 // CHECK-ERROR: error: invalid operand for instruction
3708 // CHECK-ERROR:        sminv d0, v1.2d
3709 // CHECK-ERROR:              ^
3710 // CHECK-ERROR: error: invalid operand for instruction
3711 // CHECK-ERROR:        umaxv d0, v1.2d
3712 // CHECK-ERROR:              ^
3713 // CHECK-ERROR: error: invalid operand for instruction
3714 // CHECK-ERROR:        uminv d0, v1.2d
3715 // CHECK-ERROR:              ^
3716 // CHECK-ERROR: error: invalid operand for instruction
3717 // CHECK-ERROR:        addv d0, v1.2d
3718 // CHECK-ERROR:             ^
3719
3720         fmaxnmv b0, v1.16b
3721         fminnmv b0, v1.16b
3722         fmaxv b0, v1.16b
3723         fminv b0, v1.16b
3724
3725 // CHECK-ERROR: error: invalid operand for instruction
3726 // CHECK-ERROR:        fmaxnmv b0, v1.16b
3727 // CHECK-ERROR:                ^
3728 // CHECK-ERROR: error: invalid operand for instruction
3729 // CHECK-ERROR:        fminnmv b0, v1.16b
3730 // CHECK-ERROR:                ^
3731 // CHECK-ERROR: error: invalid operand for instruction
3732 // CHECK-ERROR:        fmaxv b0, v1.16b
3733 // CHECK-ERROR:              ^
3734 // CHECK-ERROR: error: invalid operand for instruction
3735 // CHECK-ERROR:        fminv b0, v1.16b
3736 // CHECK-ERROR:              ^
3737
3738         fmaxnmv h0, v1.8h
3739         fminnmv h0, v1.8h
3740         fmaxv h0, v1.8h
3741         fminv h0, v1.8h
3742
3743 // CHECK-ERROR: error: invalid operand for instruction
3744 // CHECK-ERROR:        fmaxnmv h0, v1.8h
3745 // CHECK-ERROR:                ^
3746 // CHECK-ERROR: error: invalid operand for instruction
3747 // CHECK-ERROR:        fminnmv h0, v1.8h
3748 // CHECK-ERROR:                ^
3749 // CHECK-ERROR: error: invalid operand for instruction
3750 // CHECK-ERROR:        fmaxv h0, v1.8h
3751 // CHECK-ERROR:              ^
3752 // CHECK-ERROR: error: invalid operand for instruction
3753 // CHECK-ERROR:        fminv h0, v1.8h
3754 // CHECK-ERROR:              ^
3755
3756         fmaxnmv d0, v1.2d
3757         fminnmv d0, v1.2d
3758         fmaxv d0, v1.2d
3759         fminv d0, v1.2d
3760
3761 // CHECK-ERROR: error: invalid operand for instruction
3762 // CHECK-ERROR:        fmaxnmv d0, v1.2d
3763 // CHECK-ERROR:                ^
3764 // CHECK-ERROR: error: invalid operand for instruction
3765 // CHECK-ERROR:        fminnmv d0, v1.2d
3766 // CHECK-ERROR:                ^
3767 // CHECK-ERROR: error: invalid operand for instruction
3768 // CHECK-ERROR:        fmaxv d0, v1.2d
3769 // CHECK-ERROR:              ^
3770 // CHECK-ERROR: error: invalid operand for instruction
3771 // CHECK-ERROR:        fminv d0, v1.2d
3772 // CHECK-ERROR:              ^
3773