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 // Scalar Floating-point Reciprocal Estimate
 218 //----------------------------------------------------------------------
 219
 220     frecpe s19, h14
 221     frecpe d13, s13
 222
 223 // CHECK-ERROR: error: invalid operand for instruction
 224 // CHECK-ERROR:        frecpe s19, h14
 225 // CHECK-ERROR:                    ^
 226 // CHECK-ERROR: error: invalid operand for instruction
 227 // CHECK-ERROR:        frecpe d13, s13
 228 // CHECK-ERROR:                    ^
 229
 230 //----------------------------------------------------------------------
 231 // Scalar Floating-point Reciprocal Exponent
 232 //----------------------------------------------------------------------
 233
 234     frecpx s18, h10
 235     frecpx d16, s19
 236
 237 // CHECK-ERROR: error: invalid operand for instruction
 238 // CHECK-ERROR:        frecpx s18, h10
 239 // CHECK-ERROR:                    ^
 240 // CHECK-ERROR: error: invalid operand for instruction
 241 // CHECK-ERROR:        frecpx d16, s19
 242 // CHECK-ERROR:                    ^
 243
 244 //----------------------------------------------------------------------
 245 // Scalar Floating-point Reciprocal Square Root Estimate
 246 //----------------------------------------------------------------------
 247
 248     frsqrte s22, h13
 249     frsqrte d21, s12
 250
 251 // CHECK-ERROR: error: invalid operand for instruction
 252 // CHECK-ERROR:        frsqrte s22, h13
 253 // CHECK-ERROR:                     ^
 254 // CHECK-ERROR: error: invalid operand for instruction
 255 // CHECK-ERROR:        frsqrte d21, s12
 256 // CHECK-ERROR:                     ^
 257
 258 //----------------------------------------------------------------------
 259 // Vector Move Immediate - bytemask, per doubleword
 260 //---------------------------------------------------------------------
 261         // invalid bytemask (0x00 or 0xff)
 262         movi v0.2d, #0x10ff00ff00ff00ff
 263
 264 // CHECK:ERROR: error: invalid operand for instruction
 265 // CHECK:ERROR:         movi v0.2d, #0x10ff00ff00ff00ff
 266 // CHECK:ERROR:                     ^
 267
 268 //----------------------------------------------------------------------
 269 // Vector Move Immediate - bytemask, one doubleword
 270 //----------------------------------------------------------------------
 271         // invalid bytemask (0x00 or 0xff)
 272         movi v0.2d, #0xffff00ff001f00ff
 273
 274 // CHECK:ERROR: error: invalid operand for instruction
 275 // CHECK:ERROR:         movi v0.2d, #0xffff00ff001f00ff
 276 // CHECK:ERROR:                     ^
 277 //----------------------------------------------------------------------
 278 // Vector Floating Point Move Immediate
 279 //----------------------------------------------------------------------
 280         // invalid vector type (2s, 4s, 2d)
 281          fmov v0.4h, #1.0
 282
 283 // CHECK:ERROR: error: invalid operand for instruction
 284 // CHECK:ERROR:         fmov v0.4h, #1.0
 285 // CHECK:ERROR:              ^
 286
 287 //----------------------------------------------------------------------
 288 // Vector Move -  register
 289 //----------------------------------------------------------------------
 290       // invalid vector type (8b, 16b)
 291       mov v0.2s, v31.8b
 292 // CHECK:ERROR: error: invalid operand for instruction
 293 // CHECK:ERROR:         mov v0.2s, v31.8b
 294 // CHECK:ERROR:                ^
 295
 296 //----------------------------------------------------------------------
 297 // Vector Absolute Difference and Accumulate (Signed, Unsigned)
 298 //----------------------------------------------------------------------
 299
 300         // Mismatched and invalid vector types (2d)
 301         saba v0.16b, v1.8b, v2.8b
 302         uaba v0.2d, v1.2d, v2.2d
 303
 304 // CHECK-ERROR: error: invalid operand for instruction
 305 // CHECK-ERROR:         saba v0.16b, v1.8b, v2.8b
 306 // CHECK-ERROR:                        ^
 307 // CHECK-ERROR: error: invalid operand for instruction
 308 // CHECK-ERROR:         uaba v0.2d, v1.2d, v2.2d
 309 // CHECK-ERROR:                ^
 310
 311 //----------------------------------------------------------------------
 312 // Vector Absolute Difference and Accumulate (Signed, Unsigned)
 313 // Vector Absolute Difference (Signed, Unsigned)
 314
 315         // Mismatched and invalid vector types (2d)
 316         uaba v0.16b, v1.8b, v2.8b
 317         saba v0.2d, v1.2d, v2.2d
 318         uabd v0.4s, v1.2s, v2.2s
 319         sabd v0.4h, v1.8h, v8.8h
 320
 321 // CHECK-ERROR: error: invalid operand for instruction
 322 // CHECK-ERROR:         uaba v0.16b, v1.8b, v2.8b
 323 // CHECK-ERROR:                        ^
 324 // CHECK-ERROR: error: invalid operand for instruction
 325 // CHECK-ERROR:         saba v0.2d, v1.2d, v2.2d
 326 // CHECK-ERROR:                ^
 327 // CHECK-ERROR: error: invalid operand for instruction
 328 // CHECK-ERROR:         uabd v0.4s, v1.2s, v2.2s
 329 // CHECK-ERROR:                        ^
 330 // CHECK-ERROR: error: invalid operand for instruction
 331 // CHECK-ERROR:         sabd v0.4h, v1.8h, v8.8h
 332 // CHECK-ERROR:                        ^
 333
 334 //----------------------------------------------------------------------
 335 // Vector Absolute Difference (Floating Point)
 336 //----------------------------------------------------------------------
 337         // Mismatched and invalid vector types
 338         fabd v0.2s, v1.4s, v2.2d
 339         fabd v0.4h, v1.4h, v2.4h
 340
 341 // CHECK-ERROR: error: invalid operand for instruction
 342 // CHECK-ERROR:         fabd v0.2s, v1.4s, v2.2d
 343 // CHECK-ERROR:                        ^
 344 // CHECK-ERROR: error: instruction requires: fullfp16
 345 // CHECK-ERROR:         fabd v0.4h, v1.4h, v2.4h
 346 // CHECK-ERROR:                 ^
 347 //----------------------------------------------------------------------
 348 // Vector Multiply (Polynomial)
 349 //----------------------------------------------------------------------
 350
 351         // Mismatched and invalid vector types
 352          pmul v0.8b, v1.8b, v2.16b
 353          pmul v0.2s, v1.2s, v2.2s
 354
 355 // CHECK-ERROR: error: invalid operand for instruction
 356 // CHECK-ERROR:         pmul v0.8b, v1.8b, v2.16b
 357 // CHECK-ERROR:                               ^
 358 // CHECK-ERROR: error: invalid operand for instruction
 359 // CHECK-ERROR:         pmul v0.2s, v1.2s, v2.2s
 360 // CHECK-ERROR:                 ^
 361
 362 //----------------------------------------------------------------------
 363 // Scalar Integer Add and Sub
 364 //----------------------------------------------------------------------
 365
 366       // Mismatched registers
 367          add d0, s1, d2
 368          sub s1, d1, d2
 369
 370 // CHECK-ERROR: error: invalid operand for instruction
 371 // CHECK-ERROR:         add d0, s1, d2
 372 // CHECK-ERROR:                 ^
 373 // CHECK-ERROR: error: invalid operand for instruction
 374 // CHECK-ERROR:         sub s1, d1, d2
 375 // CHECK-ERROR:             ^
 376
 377 //----------------------------------------------------------------------
 378 // Vector Reciprocal Step (Floating Point)
 379 //----------------------------------------------------------------------
 380
 381         // Mismatched and invalid vector types
 382          frecps v0.4s, v1.2d, v2.4s
 383          frecps v0.8h, v1.8h, v2.8h
 384
 385 // CHECK-ERROR: error: invalid operand for instruction
 386 // CHECK-ERROR:        frecps v0.4s, v1.2d, v2.4s
 387 // CHECK-ERROR:                         ^
 388 // CHECK-ERROR: error: instruction requires: fullfp16
 389 // CHECK-ERROR:        frecps v0.8h, v1.8h, v2.8h
 390 // CHECK-ERROR:                  ^
 391
 392 //----------------------------------------------------------------------
 393 // Vector Reciprocal Square Root Step (Floating Point)
 394 //----------------------------------------------------------------------
 395
 396         // Mismatched and invalid vector types
 397          frsqrts v0.2d, v1.2d, v2.2s
 398          frsqrts v0.4h, v1.4h, v2.4h
 399
 400 // CHECK-ERROR: error: invalid operand for instruction
 401 // CHECK-ERROR:        frsqrts v0.2d, v1.2d, v2.2s
 402 // CHECK-ERROR:                                 ^
 403 // CHECK-ERROR: error: instruction requires: fullfp16
 404 // CHECK-ERROR:        frsqrts v0.4h, v1.4h, v2.4h
 405 // CHECK-ERROR:                   ^
 406
 407
 408 //----------------------------------------------------------------------
 409 // Vector Absolute Compare Mask Less Than Or Equal (Floating Point)
 410 //----------------------------------------------------------------------
 411
 412         // Mismatched and invalid vector types
 413         facge v0.2d, v1.2s, v2.2d
 414         facge v0.4h, v1.4h, v2.4h
 415         facle v0.8h, v1.4h, v2.4h
 416
 417 // CHECK-ERROR: error: invalid operand for instruction
 418 // CHECK-ERROR:        facge v0.2d, v1.2s, v2.2d
 419 // CHECK-ERROR:                        ^
 420 // CHECK-ERROR: error: instruction requires: fullfp16
 421 // CHECK-ERROR:        facge v0.4h, v1.4h, v2.4h
 422 // CHECK-ERROR:                 ^
 423 // CHECK-ERROR: error: invalid operand for instruction
 424 // CHECK-ERROR:        facle v0.8h, v1.4h, v2.4h
 425 // CHECK-ERROR:                 ^
 426 //----------------------------------------------------------------------
 427 // Vector Absolute Compare Mask Less Than (Floating Point)
 428 //----------------------------------------------------------------------
 429
 430         // Mismatched and invalid vector types
 431         facgt v0.2d, v1.2d, v2.4s
 432         facgt v0.8h, v1.8h, v2.8h
 433         faclt v0.8b, v1.8b, v2.8b
 434
 435 // CHECK-ERROR: error: invalid operand for instruction
 436 // CHECK-ERROR:        facgt v0.2d, v1.2d, v2.4s
 437 // CHECK-ERROR:                               ^
 438 // CHECK-ERROR: error: instruction requires: fullfp16
 439 // CHECK-ERROR:        facgt v0.8h, v1.8h, v2.8h
 440 // CHECK-ERROR:                 ^
 441 // CHECK-ERROR: error: invalid operand for instruction
 442 // CHECK-ERROR:        faclt v0.8b, v1.8b, v2.8b
 443 // CHECK-ERROR:                 ^
 444
 445
 446 //----------------------------------------------------------------------
 447 // Vector Compare Mask Equal (Integer)
 448 //----------------------------------------------------------------------
 449
 450          // Mismatched vector types
 451          cmeq c0.2d, v1.2d, v2.2s
 452
 453 // CHECK-ERROR: error: invalid operand for instruction
 454 // CHECK-ERROR:        cmeq c0.2d, v1.2d, v2.2s
 455 // CHECK-ERROR:                              ^
 456
 457 //----------------------------------------------------------------------
 458 // Vector Compare Mask Higher or Same (Unsigned Integer)
 459 // Vector Compare Mask Less or Same (Unsigned Integer)
 460 // CMLS is alias for CMHS with operands reversed.
 461 //----------------------------------------------------------------------
 462
 463          // Mismatched vector types
 464          cmhs c0.4h, v1.8b, v2.8b
 465          cmls c0.16b, v1.16b, v2.2d
 466
 467 // CHECK-ERROR: error: invalid operand for instruction
 468 // CHECK-ERROR:        cmhs c0.4h, v1.8b, v2.8b
 469 // CHECK-ERROR:                       ^
 470 // CHECK-ERROR: error: invalid operand for instruction
 471 // CHECK-ERROR:        cmls c0.16b, v1.16b, v2.2d
 472 // CHECK-ERROR:                                ^
 473
 474 //----------------------------------------------------------------------
 475 // Vector Compare Mask Greater Than or Equal (Integer)
 476 // Vector Compare Mask Less Than or Equal (Integer)
 477 // CMLE is alias for CMGE with operands reversed.
 478 //----------------------------------------------------------------------
 479
 480          // Mismatched vector types
 481          cmge c0.8h, v1.8b, v2.8b
 482          cmle c0.4h, v1.2s, v2.2s
 483
 484 // CHECK-ERROR: error: invalid operand for instruction
 485 // CHECK-ERROR:        cmge c0.8h, v1.8b, v2.8b
 486 // CHECK-ERROR:                       ^
 487 // CHECK-ERROR: error: invalid operand for instruction
 488 // CHECK-ERROR:         cmle c0.4h, v1.2s, v2.2s
 489 // CHECK-ERROR:                        ^
 490
 491 //----------------------------------------------------------------------
 492 // Vector Compare Mask Higher (Unsigned Integer)
 493 // Vector Compare Mask Lower (Unsigned Integer)
 494 // CMLO is alias for CMHI with operands reversed.
 495 //----------------------------------------------------------------------
 496
 497          // Mismatched vector types
 498          cmhi c0.4s, v1.4s, v2.16b
 499          cmlo c0.8b, v1.8b, v2.2s
 500
 501 // CHECK-ERROR: error: invalid operand for instruction
 502 // CHECK-ERROR:        cmhi c0.4s, v1.4s, v2.16b
 503 // CHECK-ERROR:                              ^
 504 // CHECK-ERROR: error: invalid operand for instruction
 505 // CHECK-ERROR:         cmlo c0.8b, v1.8b, v2.2s
 506 // CHECK-ERROR:                               ^
 507
 508 //----------------------------------------------------------------------
 509 // Vector Compare Mask Greater Than (Integer)
 510 // Vector Compare Mask Less Than (Integer)
 511 // CMLT is alias for CMGT with operands reversed.
 512 //----------------------------------------------------------------------
 513
 514          // Mismatched vector types
 515          cmgt c0.8b, v1.4s, v2.16b
 516          cmlt c0.8h, v1.16b, v2.4s
 517
 518 // CHECK-ERROR: error: invalid operand for instruction
 519 // CHECK-ERROR:         cmgt c0.8b, v1.4s, v2.16b
 520 // CHECK-ERROR:                        ^
 521 // CHECK-ERROR: error: invalid operand for instruction
 522 // CHECK-ERROR:         cmlt c0.8h, v1.16b, v2.4s
 523 // CHECK-ERROR:                        ^
 524
 525 //----------------------------------------------------------------------
 526 // Vector Compare Mask Bitwise Test (Integer)
 527 //----------------------------------------------------------------------
 528
 529          // Mismatched vector types
 530          cmtst c0.16b, v1.16b, v2.4s
 531
 532 // CHECK-ERROR: error: invalid operand for instruction
 533 // CHECK-ERROR:         cmtst c0.16b, v1.16b, v2.4s
 534 // CHECK-ERROR:                                  ^
 535
 536 //----------------------------------------------------------------------
 537 // Vector Compare Mask Equal (Floating Point)
 538 //----------------------------------------------------------------------
 539
 540         // Mismatched and invalid vector types
 541         fcmeq v0.2d, v1.2s, v2.2d
 542         fcmeq v0.16b, v1.16b, v2.16b
 543         fcmeq v0.8b, v1.4h, v2.4h
 544
 545 // CHECK-ERROR: error: invalid operand for instruction
 546 // CHECK-ERROR:        fcmeq v0.2d, v1.2s, v2.2d
 547 // CHECK-ERROR:                        ^
 548 // CHECK-ERROR: error: invalid operand for instruction
 549 // CHECK-ERROR:        fcmeq v0.16b, v1.16b, v2.16b
 550 // CHECK-ERROR:                 ^
 551 // CHECK-ERROR: error: invalid operand for instruction
 552 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, v2.4h
 553 // CHECK-ERROR:                 ^
 554
 555 //----------------------------------------------------------------------
 556 // Vector Compare Mask Greater Than Or Equal (Floating Point)
 557 // Vector Compare Mask Less Than Or Equal (Floating Point)
 558 // FCMLE is alias for FCMGE with operands reversed.
 559 //----------------------------------------------------------------------
 560
 561         // Mismatched and invalid vector types
 562          fcmge v31.4s, v29.2s, v28.4s
 563          fcmge v3.8b, v8.2s, v12.2s
 564          fcmle v17.8h, v15.2d, v13.2d
 565
 566 // CHECK-ERROR: error: invalid operand for instruction
 567 // CHECK-ERROR:        fcmge v31.4s, v29.2s, v28.4s
 568 // CHECK-ERROR:                          ^
 569 // CHECK-ERROR: error: invalid operand for instruction
 570 // CHECK-ERROR:        fcmge v3.8b, v8.2s, v12.2s
 571 // CHECK-ERROR:                 ^
 572 // CHECK-ERROR: error: invalid operand for instruction
 573 // CHECK-ERROR:        fcmle v17.8h, v15.2d, v13.2d
 574 // CHECK-ERROR:                 ^
 575
 576 //----------------------------------------------------------------------
 577 // Vector Compare Mask Greater Than (Floating Point)
 578 // Vector Compare Mask Less Than (Floating Point)
 579 // FCMLT is alias for FCMGT with operands reversed.
 580 //----------------------------------------------------------------------
 581
 582         // Mismatched and invalid vector types
 583          fcmgt v0.2d, v31.2s, v16.2s
 584          fcmgt v4.4s, v7.4s, v15.4h
 585          fcmlt v29.2d, v5.2d, v2.16b
 586
 587 // CHECK-ERROR: error: invalid operand for instruction
 588 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, v16.2s
 589 // CHECK-ERROR:                         ^
 590
 591 // CHECK-ERROR: error: invalid operand for instruction
 592 // CHECK-ERROR:        fcmgt v4.4s, v7.4s, v15.4h
 593 // CHECK-ERROR:                                ^
 594 // CHECK-ERROR: error: invalid operand for instruction
 595 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, v2.16b
 596 // CHECK-ERROR:                                ^
 597
 598 //----------------------------------------------------------------------
 599 // Vector Compare Mask Equal to Zero (Integer)
 600 //----------------------------------------------------------------------
 601         // Mismatched vector types and invalid imm
 602          // Mismatched vector types
 603          cmeq c0.2d, v1.2s, #0
 604          cmeq c0.2d, v1.2d, #1
 605
 606 // CHECK-ERROR: error: invalid operand for instruction
 607 // CHECK-ERROR:        cmeq c0.2d, v1.2s, #0
 608 // CHECK-ERROR:                       ^
 609 // CHECK-ERROR: error: invalid operand for instruction
 610 // CHECK-ERROR:        cmeq c0.2d, v1.2d, #1
 611 // CHECK-ERROR:                            ^
 612
 613 //----------------------------------------------------------------------
 614 // Vector Compare Mask Greater Than or Equal to Zero (Signed Integer)
 615 //----------------------------------------------------------------------
 616         // Mismatched vector types and invalid imm
 617          cmge c0.8h, v1.8b, #0
 618          cmge c0.4s, v1.4s, #-1
 619
 620 // CHECK-ERROR: error: invalid operand for instruction
 621 // CHECK-ERROR:        cmge c0.8h, v1.8b, #0
 622 // CHECK-ERROR:                       ^
 623 // CHECK-ERROR: error: invalid operand for instruction
 624 // CHECK-ERROR:         cmge c0.4s, v1.4s, #-1
 625 // CHECK-ERROR:                             ^
 626
 627 //----------------------------------------------------------------------
 628 // Vector Compare Mask Greater Than Zero (Signed Integer)
 629 //----------------------------------------------------------------------
 630         // Mismatched vector types and invalid imm
 631          cmgt c0.8b, v1.4s, #0
 632          cmgt c0.8b, v1.8b, #-255
 633
 634 // CHECK-ERROR: error: invalid operand for instruction
 635 // CHECK-ERROR:         cmgt c0.8b, v1.4s, #0
 636 // CHECK-ERROR:                        ^
 637 // CHECK-ERROR: error: invalid operand for instruction
 638 // CHECK-ERROR:         cmgt c0.8b, v1.8b, #-255
 639 // CHECK-ERROR:                             ^
 640
 641 //----------------------------------------------------------------------
 642 // Vector Compare Mask Less Than or Equal To Zero (Signed Integer)
 643 //----------------------------------------------------------------------
 644         // Mismatched vector types and invalid imm
 645          cmle c0.4h, v1.2s, #0
 646          cmle c0.16b, v1.16b, #16
 647
 648 // CHECK-ERROR: error: invalid operand for instruction
 649 // CHECK-ERROR:        cmle c0.4h, v1.2s, #0
 650 // CHECK-ERROR:                       ^
 651 // CHECK-ERROR: error: invalid operand for instruction
 652 // CHECK-ERROR:         cmle c0.16b, v1.16b, #16
 653 // CHECK-ERROR:                               ^
 654 //----------------------------------------------------------------------
 655 // Vector Compare Mask Less Than Zero (Signed Integer)
 656 //----------------------------------------------------------------------
 657         // Mismatched vector types and invalid imm
 658          cmlt c0.8h, v1.16b, #0
 659          cmlt c0.8h, v1.8h, #-15
 660
 661 // CHECK-ERROR: error: invalid operand for instruction
 662 // CHECK-ERROR:         cmlt c0.8h, v1.16b, #0
 663 // CHECK-ERROR:                        ^
 664 // CHECK-ERROR: error: invalid operand for instruction
 665 // CHECK-ERROR:         cmlt c0.8h, v1.8h, #-15
 666 // CHECK-ERROR:                             ^
 667
 668 //----------------------------------------------------------------------
 669 // Vector Compare Mask Equal to Zero (Floating Point)
 670 //----------------------------------------------------------------------
 671
 672         // Mismatched and invalid vector types, invalid imm
 673         fcmeq v0.2d, v1.2s, #0.0
 674         fcmeq v0.16b, v1.16b, #0.0
 675         fcmeq v0.8b, v1.4h, #1.0
 676         fcmeq v0.8b, v1.4h, #1
 677
 678 // CHECK-ERROR: error: invalid operand for instruction
 679 // CHECK-ERROR:        fcmeq v0.2d, v1.2s, #0.0
 680 // CHECK-ERROR:                        ^
 681 // CHECK-ERROR: error: invalid operand for instruction
 682 // CHECK-ERROR:        fcmeq v0.16b, v1.16b, #0.0
 683 // CHECK-ERROR:                 ^
 684
 685
 686 // CHECK-ERROR: error: expected floating-point constant #0.0
 687 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1.0
 688 // CHECK-ERROR:                             ^
 689 // CHECK-ERROR: error: invalid operand for instruction
 690 // CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1
 691 // CHECK-ERROR:                             ^
 692
 693 //----------------------------------------------------------------------
 694 // Vector Compare Mask Greater Than or Equal to Zero (Floating Point)
 695 //----------------------------------------------------------------------
 696
 697         // Mismatched and invalid vector types, invalid imm
 698          fcmge v31.4s, v29.2s, #0.0
 699          fcmge v3.8b, v8.2s, #0.0
 700          fcmle v17.8h, v15.2d, #-1.0
 701          fcmle v17.8h, v15.2d, #2
 702
 703 // CHECK-ERROR: error: invalid operand for instruction
 704 // CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
 705 // CHECK-ERROR:                          ^
 706 // CHECK-ERROR: error: invalid operand for instruction
 707 // CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
 708 // CHECK-ERROR:                 ^
 709
 710
 711 // CHECK-ERROR: error: expected floating-point constant #0.0
 712 // CHECK-ERROR:        fcmle v17.8h, v15.2d, #-1.0
 713 // CHECK-ERROR:                               ^
 714 // CHECK-ERROR: error: invalid operand for instruction
 715 // CHECK-ERROR:        fcmle v17.8h, v15.2d, #2
 716 // CHECK-ERROR:                               ^
 717
 718 //----------------------------------------------------------------------
 719 // Vector Compare Mask Greater Than Zero (Floating Point)
 720 //----------------------------------------------------------------------
 721         // Mismatched and invalid vector types, invalid imm
 722          fcmgt v0.2d, v31.2s, #0.0
 723          fcmgt v4.4s, v7.4h, #0.0
 724          fcmlt v29.2d, v5.2d, #255.0
 725          fcmlt v29.2d, v5.2d, #255
 726
 727 // CHECK-ERROR: error: invalid operand for instruction
 728 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
 729 // CHECK-ERROR:                         ^
 730 // CHECK-ERROR: error: invalid operand for instruction
 731 // CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
 732 // CHECK-ERROR:                        ^
 733
 734
 735 // CHECK-ERROR: error: expected floating-point constant #0.0
 736 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255.0
 737 // CHECK-ERROR:                              ^
 738 // CHECK-ERROR: error: invalid operand for instruction
 739 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255
 740 // CHECK-ERROR:                              ^
 741
 742 //----------------------------------------------------------------------
 743 // Vector Compare Mask Less Than or Equal To Zero (Floating Point)
 744 //----------------------------------------------------------------------
 745         // Mismatched and invalid vector types, invalid imm
 746          fcmge v31.4s, v29.2s, #0.0
 747          fcmge v3.8b, v8.2s, #0.0
 748          fcmle v17.2d, v15.2d, #15.0
 749          fcmle v17.2d, v15.2d, #15
 750
 751 // CHECK-ERROR: error: invalid operand for instruction
 752 // CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
 753 // CHECK-ERROR:                          ^
 754 // CHECK-ERROR: error: invalid operand for instruction
 755 // CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
 756 // CHECK-ERROR:                 ^
 757
 758
 759 // CHECK-ERROR: error: expected floating-point constant #0.0
 760 // CHECK-ERROR:        fcmle v17.2d, v15.2d, #15.0
 761 // CHECK-ERROR:                               ^
 762 // CHECK-ERROR: error: invalid operand for instruction
 763 // CHECK-ERROR:        fcmle v17.2d, v15.2d, #15
 764 // CHECK-ERROR:                              ^
 765
 766 //----------------------------------------------------------------------
 767 // Vector Compare Mask Less Than Zero (Floating Point)
 768 //----------------------------------------------------------------------
 769         // Mismatched and invalid vector types, invalid imm
 770          fcmgt v0.2d, v31.2s, #0.0
 771          fcmgt v4.4s, v7.4h, #0.0
 772          fcmlt v29.2d, v5.2d, #16.0
 773          fcmlt v29.2d, v5.2d, #2
 774
 775 // CHECK-ERROR: error: invalid operand for instruction
 776 // CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
 777 // CHECK-ERROR:                         ^
 778 // CHECK-ERROR: error: invalid operand for instruction
 779 // CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
 780 // CHECK-ERROR:                        ^
 781
 782
 783 // CHECK-ERROR: error: expected floating-point constant #0.0
 784 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #16.0
 785 // CHECK-ERROR:                              ^
 786 // CHECK-ERROR: error: invalid operand for instruction
 787 // CHECK-ERROR:        fcmlt v29.2d, v5.2d, #2
 788 // CHECK-ERROR:                              ^
 789
 790 /-----------------------------------------------------------------------
 791 // Vector Integer Halving Add (Signed)
 792 // Vector Integer Halving Add (Unsigned)
 793 // Vector Integer Halving Sub (Signed)
 794 // Vector Integer Halving Sub (Unsigned)
 795 //----------------------------------------------------------------------
 796         // Mismatched and invalid vector types (2d)
 797         shadd v0.2d, v1.2d, v2.2d
 798         uhadd v4.2s, v5.2s, v5.4h
 799         shsub v11.4h, v12.8h, v13.4h
 800         uhsub v31.16b, v29.8b, v28.8b
 801
 802 // CHECK-ERROR: error: invalid operand for instruction
 803 // CHECK-ERROR:        shadd v0.2d, v1.2d, v2.2d
 804 // CHECK-ERROR:                 ^
 805 // CHECK-ERROR: error: invalid operand for instruction
 806 // CHECK-ERROR:        uhadd v4.2s, v5.2s, v5.4h
 807 // CHECK-ERROR:                               ^
 808 // CHECK-ERROR: error: invalid operand for instruction
 809 // CHECK-ERROR:        shsub v11.4h, v12.8h, v13.4h
 810 // CHECK-ERROR:                          ^
 811 // CHECK-ERROR: error: invalid operand for instruction
 812 // CHECK-ERROR:        uhsub v31.16b, v29.8b, v28.8b
 813 // CHECK-ERROR:                          ^
 814
 815 //----------------------------------------------------------------------
 816 // Vector Integer Rouding Halving Add (Signed)
 817 // Vector Integer Rouding Halving Add (Unsigned)
 818 //----------------------------------------------------------------------
 819
 820         // Mismatched and invalid vector types (2d)
 821         srhadd v0.2s, v1.2s, v2.2d
 822         urhadd v0.16b, v1.16b, v2.8h
 823
 824 // CHECK-ERROR: error: invalid operand for instruction
 825 // CHECK-ERROR:        srhadd v0.2s, v1.2s, v2.2d
 826 // CHECK-ERROR:                                ^
 827 // CHECK-ERROR: error: invalid operand for instruction
 828 // CHECK-ERROR:        urhadd v0.16b, v1.16b, v2.8h
 829 // CHECK-ERROR:                                  ^
 830
 831 //----------------------------------------------------------------------
 832 // Vector Integer Saturating Add (Signed)
 833 // Vector Integer Saturating Add (Unsigned)
 834 // Vector Integer Saturating Sub (Signed)
 835 // Vector Integer Saturating Sub (Unsigned)
 836 //----------------------------------------------------------------------
 837
 838         // Mismatched vector types
 839         sqadd v0.2s, v1.2s, v2.2d
 840         uqadd v31.8h, v1.4h, v2.4h
 841         sqsub v10.8h, v1.16b, v2.16b
 842         uqsub v31.8b, v1.8b, v2.4s
 843
 844 // CHECK-ERROR: error: invalid operand for instruction
 845 // CHECK-ERROR:        sqadd v0.2s, v1.2s, v2.2d
 846 // CHECK-ERROR:                               ^
 847 // CHECK-ERROR: error: invalid operand for instruction
 848 // CHECK-ERROR:        uqadd v31.8h, v1.4h, v2.4h
 849 // CHECK-ERROR:                         ^
 850 // CHECK-ERROR: error: invalid operand for instruction
 851 // CHECK-ERROR:        sqsub v10.8h, v1.16b, v2.16b
 852 // CHECK-ERROR:                         ^
 853 // CHECK-ERROR: error: invalid operand for instruction
 854 // CHECK-ERROR:        uqsub v31.8b, v1.8b, v2.4s
 855 // CHECK-ERROR:                                ^
 856
 857 //----------------------------------------------------------------------
 858 // Scalar Integer Saturating Add (Signed)
 859 // Scalar Integer Saturating Add (Unsigned)
 860 // Scalar Integer Saturating Sub (Signed)
 861 // Scalar Integer Saturating Sub (Unsigned)
 862 //----------------------------------------------------------------------
 863
 864       // Mismatched registers
 865          sqadd d0, s31, d2
 866          uqadd s0, s1, d2
 867          sqsub b0, b2, s18
 868          uqsub h1, h2, d2
 869
 870 // CHECK-ERROR: error: invalid operand for instruction
 871 // CHECK-ERROR:        sqadd d0, s31, d2
 872 // CHECK-ERROR:                  ^
 873 // CHECK-ERROR: error: invalid operand for instruction
 874 // CHECK-ERROR:        uqadd s0, s1, d2
 875 // CHECK-ERROR:                      ^
 876 // CHECK-ERROR: error: invalid operand for instruction
 877 // CHECK-ERROR:        sqsub b0, b2, s18
 878 // CHECK-ERROR:                      ^
 879 // CHECK-ERROR: error: invalid operand for instruction
 880 // CHECK-ERROR:        uqsub h1, h2, d2
 881 // CHECK-ERROR:                      ^
 882
 883 //----------------------------------------------------------------------
 884 // Scalar Integer Saturating Doubling Multiply Half High (Signed)
 885 //----------------------------------------------------------------------
 886
 887     sqdmulh h10, s11, h12
 888     sqdmulh s20, h21, s2
 889
 890 // CHECK-ERROR: error: invalid operand for instruction
 891 // CHECK-ERROR:        sqdmulh h10, s11, h12
 892 // CHECK-ERROR:                     ^
 893 // CHECK-ERROR: error: invalid operand for instruction
 894 // CHECK-ERROR:        sqdmulh s20, h21, s2
 895 // CHECK-ERROR:                     ^
 896
 897 //------------------------------------------------------------------------
 898 // Scalar Integer Saturating Rounding Doubling Multiply Half High (Signed)
 899 //------------------------------------------------------------------------
 900
 901     sqrdmulh h10, s11, h12
 902     sqrdmulh s20, h21, s2
 903
 904 // CHECK-ERROR: error: invalid operand for instruction
 905 // CHECK-ERROR:        sqrdmulh h10, s11, h12
 906 // CHECK-ERROR:                      ^
 907 // CHECK-ERROR: error: invalid operand for instruction
 908 // CHECK-ERROR:        sqrdmulh s20, h21, s2
 909 // CHECK-ERROR:                      ^
 910
 911 //----------------------------------------------------------------------
 912 // Vector Shift Left (Signed and Unsigned Integer)
 913 //----------------------------------------------------------------------
 914         // Mismatched vector types
 915         sshl v0.4s, v15.2s, v16.2s
 916         ushl v1.16b, v25.16b, v6.8h
 917
 918 // CHECK-ERROR: error: invalid operand for instruction
 919 // CHECK-ERROR:        sshl v0.4s, v15.2s, v16.2s
 920 // CHECK-ERROR:                        ^
 921 // CHECK-ERROR: error: invalid operand for instruction
 922 // CHECK-ERROR:        ushl v1.16b, v25.16b, v6.8h
 923 // CHECK-ERROR:                                 ^
 924
 925 //----------------------------------------------------------------------
 926 // Vector Saturating Shift Left (Signed and Unsigned Integer)
 927 //----------------------------------------------------------------------
 928         // Mismatched vector types
 929         sqshl v0.2s, v15.4s, v16.2d
 930         uqshl v1.8b, v25.4h, v6.8h
 931
 932 // CHECK-ERROR: error: invalid operand for instruction
 933 // CHECK-ERROR:        sqshl v0.2s, v15.4s, v16.2d
 934 // CHECK-ERROR:                         ^
 935 // CHECK-ERROR: error: invalid operand for instruction
 936 // CHECK-ERROR:        uqshl v1.8b, v25.4h, v6.8h
 937 // CHECK-ERROR:                         ^
 938
 939 //----------------------------------------------------------------------
 940 // Vector Rouding Shift Left (Signed and Unsigned Integer)
 941 //----------------------------------------------------------------------
 942         // Mismatched vector types
 943         srshl v0.8h, v15.8h, v16.16b
 944         urshl v1.2d, v25.2d, v6.4s
 945
 946 // CHECK-ERROR: error: invalid operand for instruction
 947 // CHECK-ERROR:        srshl v0.8h, v15.8h, v16.16b
 948 // CHECK-ERROR:                                 ^
 949 // CHECK-ERROR: error: invalid operand for instruction
 950 // CHECK-ERROR:        urshl v1.2d, v25.2d, v6.4s
 951 // CHECK-ERROR:                                ^
 952
 953 //----------------------------------------------------------------------
 954 // Vector Saturating Rouding Shift Left (Signed and Unsigned Integer)
 955 //----------------------------------------------------------------------
 956         // Mismatched vector types
 957         sqrshl v0.2s, v15.8h, v16.16b
 958         uqrshl v1.4h, v25.4h,  v6.2d
 959
 960 // CHECK-ERROR: error: invalid operand for instruction
 961 // CHECK-ERROR:        sqrshl v0.2s, v15.8h, v16.16b
 962 // CHECK-ERROR:                          ^
 963 // CHECK-ERROR: error: invalid operand for instruction
 964 // CHECK-ERROR:        uqrshl v1.4h, v25.4h,  v6.2d
 965 // CHECK-ERROR:                                  ^
 966
 967 //----------------------------------------------------------------------
 968 // Scalar Integer Shift Left (Signed, Unsigned)
 969 //----------------------------------------------------------------------
 970         // Mismatched and invalid vector types
 971         sshl d0, d1, s2
 972         ushl b2, b0, b1
 973
 974 // CHECK-ERROR: error: invalid operand for instruction
 975 // CHECK-ERROR:        sshl d0, d1, s2
 976 // CHECK-ERROR:                     ^
 977 // CHECK-ERROR: error: invalid operand for instruction
 978 // CHECK-ERROR:        ushl b2, b0, b1
 979 // CHECK-ERROR:             ^
 980
 981 //----------------------------------------------------------------------
 982 // Scalar Integer Saturating Shift Left (Signed, Unsigned)
 983 //----------------------------------------------------------------------
 984
 985         // Mismatched vector types
 986         sqshl b0, s1, b0
 987         uqshl h0, b1, h0
 988         sqshl s0, h1, s0
 989         uqshl d0, b1, d0
 990
 991 // CHECK-ERROR: error: invalid operand for instruction
 992 // CHECK-ERROR:        sqshl b0, s1, b0
 993 // CHECK-ERROR:                  ^
 994 // CHECK-ERROR: error: invalid operand for instruction
 995 // CHECK-ERROR:        uqshl h0, b1, h0
 996 // CHECK-ERROR:                  ^
 997 // CHECK-ERROR: error: invalid operand for instruction
 998 // CHECK-ERROR:        sqshl s0, h1, s0
 999 // CHECK-ERROR:                  ^
1000 // CHECK-ERROR: error: invalid operand for instruction
1001 // CHECK-ERROR:        uqshl d0, b1, d0
1002 // CHECK-ERROR:                  ^
1003
1004 //----------------------------------------------------------------------
1005 // Scalar Integer Rouding Shift Left (Signed, Unsigned)
1006 //----------------------------------------------------------------------
1007         // Mismatched and invalid vector types
1008         srshl h0, h1, h2
1009         urshl s0, s1, s2
1010
1011 // CHECK-ERROR: error: invalid operand for instruction
1012 // CHECK-ERROR:        srshl h0, h1, h2
1013 // CHECK-ERROR:              ^
1014 // CHECK-ERROR: error: invalid operand for instruction
1015 // CHECK-ERROR:        urshl s0, s1, s2
1016 // CHECK-ERROR:              ^
1017
1018
1019 //----------------------------------------------------------------------
1020 // Scalar Integer Saturating Rounding Shift Left (Signed, Unsigned)
1021 //----------------------------------------------------------------------
1022
1023         // Mismatched vector types
1024         sqrshl b0, b1, s0
1025         uqrshl h0, h1, b0
1026         sqrshl s0, s1, h0
1027         uqrshl d0, d1, b0
1028
1029 // CHECK-ERROR: error: invalid operand for instruction
1030 // CHECK-ERROR:        sqrshl b0, b1, s0
1031 // CHECK-ERROR:                       ^
1032 // CHECK-ERROR: error: invalid operand for instruction
1033 // CHECK-ERROR:        uqrshl h0, h1, b0
1034 // CHECK-ERROR:                       ^
1035 // CHECK-ERROR: error: invalid operand for instruction
1036 // CHECK-ERROR:        sqrshl s0, s1, h0
1037 // CHECK-ERROR:                       ^
1038 // CHECK-ERROR: error: invalid operand for instruction
1039 // CHECK-ERROR:        uqrshl d0, d1, b0
1040 // CHECK-ERROR:                       ^
1041
1042
1043 //----------------------------------------------------------------------
1044 // Vector Maximum (Signed, Unsigned)
1045 //----------------------------------------------------------------------
1046         // Mismatched and invalid vector types
1047         smax v0.2d, v1.2d, v2.2d
1048         umax v0.4h, v1.4h, v2.2s
1049
1050 // CHECK-ERROR: error: invalid operand for instruction
1051 // CHECK-ERROR:        smax v0.2d, v1.2d, v2.2d
1052 // CHECK-ERROR:                ^
1053 // CHECK-ERROR: error: invalid operand for instruction
1054 // CHECK-ERROR:        umax v0.4h, v1.4h, v2.2s
1055 // CHECK-ERROR:                              ^
1056
1057 //----------------------------------------------------------------------
1058 // Vector Minimum (Signed, Unsigned)
1059 //----------------------------------------------------------------------
1060         // Mismatched and invalid vector types
1061         smin v0.2d, v1.2d, v2.2d
1062         umin v0.2s, v1.2s, v2.8b
1063
1064 // CHECK-ERROR: error: invalid operand for instruction
1065 // CHECK-ERROR:        smin v0.2d, v1.2d, v2.2d
1066 // CHECK-ERROR:                ^
1067 // CHECK-ERROR: error: invalid operand for instruction
1068 // CHECK-ERROR:        umin v0.2s, v1.2s, v2.8b
1069 // CHECK-ERROR:                             ^
1070
1071
1072 //----------------------------------------------------------------------
1073 // Vector Maximum (Floating Point)
1074 //----------------------------------------------------------------------
1075         // Mismatched and invalid vector types
1076         fmax v0.2s, v1.2s, v2.4s
1077         fmax v0.8b, v1.8b, v2.8b
1078
1079 // CHECK-ERROR: error: invalid operand for instruction
1080 // CHECK-ERROR:        fmax v0.2s, v1.2s, v2.4s
1081 // CHECK-ERROR:                              ^
1082 // CHECK-ERROR: error: invalid operand for instruction
1083 // CHECK-ERROR:        fmax v0.8b, v1.8b, v2.8b
1084 // CHECK-ERROR:                ^
1085 //----------------------------------------------------------------------
1086 // Vector Minimum (Floating Point)
1087 //----------------------------------------------------------------------
1088         // Mismatched and invalid vector types
1089         fmin v0.4s, v1.4s, v2.2d
1090         fmin v0.8h, v1.8h, v2.8h
1091
1092 // CHECK-ERROR: error: invalid operand for instruction
1093 // CHECK-ERROR:        fmin v0.4s, v1.4s, v2.2d
1094 // CHECK-ERROR:                              ^
1095 // CHECK-ERROR: error: instruction requires: fullfp16
1096 // CHECK-ERROR:        fmin v0.8h, v1.8h, v2.8h
1097 // CHECK-ERROR:                ^
1098
1099 //----------------------------------------------------------------------
1100 // Vector maxNum (Floating Point)
1101 //----------------------------------------------------------------------
1102         // Mismatched and invalid vector types
1103         fmaxnm v0.2s, v1.2s, v2.2d
1104         fmaxnm v0.4h, v1.8h, v2.4h
1105
1106 // CHECK-ERROR: error: invalid operand for instruction
1107 // CHECK-ERROR:        fmaxnm v0.2s, v1.2s, v2.2d
1108 // CHECK-ERROR:                                ^
1109 // CHECK-ERROR: error: invalid operand for instruction
1110 // CHECK-ERROR:        fmaxnm v0.4h, v1.8h, v2.4h
1111 // CHECK-ERROR:                  ^
1112
1113 //----------------------------------------------------------------------
1114 // Vector minNum (Floating Point)
1115 //----------------------------------------------------------------------
1116         // Mismatched and invalid vector types
1117         fminnm v0.4s, v1.2s, v2.4s
1118         fminnm v0.16b, v0.16b, v0.16b
1119
1120 // CHECK-ERROR: error: invalid operand for instruction
1121 // CHECK-ERROR:        fminnm v0.4s, v1.2s, v2.4s
1122 // CHECK-ERROR:                         ^
1123 // CHECK-ERROR: error: invalid operand for instruction
1124 // CHECK-ERROR:        fminnm v0.16b, v0.16b, v0.16b
1125 // CHECK-ERROR:                  ^
1126
1127
1128 //----------------------------------------------------------------------
1129 // Vector Maximum Pairwise (Signed, Unsigned)
1130 //----------------------------------------------------------------------
1131         // Mismatched and invalid vector types
1132         smaxp v0.2d, v1.2d, v2.2d
1133         umaxp v0.4h, v1.4h, v2.2s
1134
1135 // CHECK-ERROR: error: invalid operand for instruction
1136 // CHECK-ERROR:        smaxp v0.2d, v1.2d, v2.2d
1137 // CHECK-ERROR:                 ^
1138 // CHECK-ERROR: error: invalid operand for instruction
1139 // CHECK-ERROR:        umaxp v0.4h, v1.4h, v2.2s
1140 // CHECK-ERROR:                               ^
1141
1142 //----------------------------------------------------------------------
1143 // Vector Minimum Pairwise (Signed, Unsigned)
1144 //----------------------------------------------------------------------
1145         // Mismatched and invalid vector types
1146         sminp v0.2d, v1.2d, v2.2d
1147         uminp v0.2s, v1.2s, v2.8b
1148
1149 // CHECK-ERROR: error: invalid operand for instruction
1150 // CHECK-ERROR:        sminp v0.2d, v1.2d, v2.2d
1151 // CHECK-ERROR:                 ^
1152 // CHECK-ERROR: error: invalid operand for instruction
1153 // CHECK-ERROR:        uminp v0.2s, v1.2s, v2.8b
1154 // CHECK-ERROR:                               ^
1155
1156
1157 //----------------------------------------------------------------------
1158 // Vector Maximum Pairwise (Floating Point)
1159 //----------------------------------------------------------------------
1160         // Mismatched and invalid vector types
1161         fmaxp v0.2s, v1.2s, v2.4s
1162         fmaxp v0.8b, v1.8b, v2.8b
1163
1164 // CHECK-ERROR: error: invalid operand for instruction
1165 // CHECK-ERROR:        fmaxp v0.2s, v1.2s, v2.4s
1166 // CHECK-ERROR:                               ^
1167 // CHECK-ERROR: error: invalid operand for instruction
1168 // CHECK-ERROR:        fmaxp v0.8b, v1.8b, v2.8b
1169 // CHECK-ERROR:                 ^
1170 //----------------------------------------------------------------------
1171 // Vector Minimum Pairwise (Floating Point)
1172 //----------------------------------------------------------------------
1173         // Mismatched and invalid vector types
1174         fminp v0.4s, v1.4s, v2.2d
1175         fminp v0.8h, v1.8h, v2.8h
1176
1177 // CHECK-ERROR: error: invalid operand for instruction
1178 // CHECK-ERROR:        fminp v0.4s, v1.4s, v2.2d
1179 // CHECK-ERROR:                               ^
1180 // CHECK-ERROR: error: instruction requires: fullfp16
1181 // CHECK-ERROR:        fminp v0.8h, v1.8h, v2.8h
1182 // CHECK-ERROR:                 ^
1183
1184 //----------------------------------------------------------------------
1185 // Vector maxNum Pairwise (Floating Point)
1186 //----------------------------------------------------------------------
1187         // Mismatched and invalid vector types
1188         fmaxnmp v0.2s, v1.2s, v2.2d
1189         fmaxnmp v0.4h, v1.8h, v2.4h
1190
1191 // CHECK-ERROR: error: invalid operand for instruction
1192 // CHECK-ERROR:        fmaxnmp v0.2s, v1.2s, v2.2d
1193 // CHECK-ERROR:                                 ^
1194 // CHECK-ERROR: error: invalid operand for instruction
1195 // CHECK-ERROR:        fmaxnmp v0.4h, v1.8h, v2.4h
1196 // CHECK-ERROR:                   ^
1197
1198 //----------------------------------------------------------------------
1199 // Vector minNum Pairwise (Floating Point)
1200 //----------------------------------------------------------------------
1201         // Mismatched and invalid vector types
1202         fminnmp v0.4s, v1.2s, v2.4s
1203         fminnmp v0.16b, v0.16b, v0.16b
1204
1205 // CHECK-ERROR: error: invalid operand for instruction
1206 // CHECK-ERROR:        fminnmp v0.4s, v1.2s, v2.4s
1207 // CHECK-ERROR:                          ^
1208 // CHECK-ERROR: error: invalid operand for instruction
1209 // CHECK-ERROR:        fminnmp v0.16b, v0.16b, v0.16b
1210 // CHECK-ERROR:                   ^
1211
1212
1213 //----------------------------------------------------------------------
1214 // Vector Add Pairwise (Integer)
1215 //----------------------------------------------------------------------
1216
1217         // Mismatched vector types
1218         addp v0.16b, v1.8b, v2.8b
1219
1220 // CHECK-ERROR: error: invalid operand for instruction
1221 // CHECK-ERROR:         addp v0.16b, v1.8b, v2.8b
1222 // CHECK-ERROR:                         ^
1223
1224 //----------------------------------------------------------------------
1225 // Vector Add Pairwise (Floating Point)
1226 //----------------------------------------------------------------------
1227         // Mismatched and invalid vector types
1228         faddp v0.16b, v1.8b, v2.8b
1229         faddp v0.2d, v1.2d, v2.8h
1230
1231 // CHECK-ERROR: error: invalid operand for instruction
1232 // CHECK-ERROR:         faddp v0.16b, v1.8b, v2.8b
1233 // CHECK-ERROR:                  ^
1234 // CHECK-ERROR: error: invalid operand for instruction
1235 // CHECK-ERROR:         faddp v0.2d, v1.2d, v2.8h
1236 // CHECK-ERROR:                                ^
1237
1238
1239 //----------------------------------------------------------------------
1240 // Vector Saturating Doubling Multiply High
1241 //----------------------------------------------------------------------
1242          // Mismatched and invalid vector types
1243          sqdmulh v2.4h, v25.8h, v3.4h
1244          sqdmulh v12.2d, v5.2d, v13.2d
1245          sqdmulh v3.8b, v1.8b, v30.8b
1246
1247 // CHECK-ERROR: error: invalid operand for instruction
1248 // CHECK-ERROR:         sqdmulh v2.4h, v25.8h, v3.4h
1249 // CHECK-ERROR:                            ^
1250 // CHECK-ERROR: error: invalid operand for instruction
1251 // CHECK-ERROR:         sqdmulh v12.2d, v5.2d, v13.2d
1252 // CHECK-ERROR:                     ^
1253 // CHECK-ERROR: error: invalid operand for instruction
1254 // CHECK-ERROR:         sqdmulh v3.8b, v1.8b, v30.8b
1255 // CHECK-ERROR:                    ^
1256
1257 //----------------------------------------------------------------------
1258 // Vector Saturating Rouding Doubling Multiply High
1259 //----------------------------------------------------------------------
1260          // Mismatched and invalid vector types
1261          sqrdmulh v2.2s, v25.4s, v3.4s
1262          sqrdmulh v12.16b, v5.16b, v13.16b
1263          sqrdmulh v3.4h, v1.4h, v30.2d
1264
1265
1266 // CHECK-ERROR: error: invalid operand for instruction
1267 // CHECK-ERROR:         sqrdmulh v2.2s, v25.4s, v3.4s
1268 // CHECK-ERROR:                             ^
1269 // CHECK-ERROR: error: invalid operand for instruction
1270 // CHECK-ERROR:         sqrdmulh v12.16b, v5.16b, v13.16b
1271 // CHECK-ERROR:                       ^
1272 // CHECK-ERROR: error: invalid operand for instruction
1273 // CHECK-ERROR:         sqrdmulh v3.4h, v1.4h, v30.2d
1274 // CHECK-ERROR:                                    ^
1275
1276 //----------------------------------------------------------------------
1277 // Vector Multiply Extended
1278 //----------------------------------------------------------------------
1279          // Mismatched and invalid vector types
1280       fmulx v21.2s, v5.2s, v13.2d
1281       fmulx v1.4h, v25.4h, v3.4h
1282
1283 // CHECK-ERROR: error: invalid operand for instruction
1284 // CHECK-ERROR:         fmulx v21.2s, v5.2s, v13.2d
1285 // CHECK-ERROR:                                  ^
1286 // CHECK-ERROR: error: instruction requires: fullfp16
1287 // CHECK-ERROR:         fmulx v1.4h, v25.4h, v3.4h
1288 // CHECK-ERROR:                  ^
1289
1290 //------------------------------------------------------------------------------
1291 // Vector Shift Left by Immediate
1292 //------------------------------------------------------------------------------
1293          // Mismatched vector types and out of range
1294          shl v0.4s, v15,2s, #3
1295          shl v0.2d, v17.4s, #3
1296          shl v0.8b, v31.8b, #-1
1297          shl v0.8b, v31.8b, #8
1298          shl v0.4s, v21.4s, #32
1299          shl v0.2d, v1.2d, #64
1300
1301
1302 // CHECK-ERROR: error: unexpected token in argument list
1303 // CHECK-ERROR:         shl v0.4s, v15,2s, #3
1304 // CHECK-ERROR:                         ^
1305
1306 // CHECK-ERROR: error: invalid operand for instruction
1307 // CHECK-ERROR:         shl v0.2d, v17.4s, #3
1308 // CHECK-ERROR:                        ^
1309 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1310 // CHECK-ERROR:         shl v0.8b, v31.8b, #-1
1311 // CHECK-ERROR:                            ^
1312 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1313 // CHECK-ERROR:         shl v0.8b, v31.8b, #8
1314 // CHECK-ERROR:                            ^
1315 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1316 // CHECK-ERROR:         shl v0.4s, v21.4s, #32
1317 // CHECK-ERROR:                            ^
1318 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1319 // CHECK-ERROR:         shl v0.2d, v1.2d, #64
1320 // CHECK-ERROR:                           ^
1321
1322 //----------------------------------------------------------------------
1323 // Vector Shift Left Long by Immediate
1324 //----------------------------------------------------------------------
1325         // Mismatched vector types
1326         sshll v0.4s, v15.2s, #3
1327         ushll v1.16b, v25.16b, #6
1328         sshll2 v0.2d, v3.8s, #15
1329         ushll2 v1.4s, v25.4s, #7
1330
1331         // Out of range
1332         sshll v0.8h, v1.8b, #-1
1333         sshll v0.8h, v1.8b, #9
1334         ushll v0.4s, v1.4h, #17
1335         ushll v0.2d, v1.2s, #33
1336         sshll2 v0.8h, v1.16b, #9
1337         sshll2 v0.4s, v1.8h, #17
1338         ushll2 v0.2d, v1.4s, #33
1339
1340 // CHECK-ERROR: error: invalid operand for instruction
1341 // CHECK-ERROR:        sshll v0.4s, v15.2s, #3
1342 // CHECK-ERROR:                         ^
1343 // CHECK-ERROR: error: invalid operand for instruction
1344 // CHECK-ERROR:        ushll v1.16b, v25.16b, #6
1345 // CHECK-ERROR:                 ^
1346 // CHECK-ERROR: error: invalid operand for instruction
1347 // CHECK-ERROR:        sshll2 v0.2d, v3.8s, #15
1348 // CHECK-ERROR:                      ^
1349 // CHECK-ERROR: error: invalid operand for instruction
1350 // CHECK-ERROR:        ushll2 v1.4s, v25.4s, #7
1351 // CHECK-ERROR:                          ^
1352 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1353 // CHECK-ERROR:        sshll v0.8h, v1.8b, #-1
1354 // CHECK-ERROR:                            ^
1355 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1356 // CHECK-ERROR:        sshll v0.8h, v1.8b, #9
1357 // CHECK-ERROR:                            ^
1358 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1359 // CHECK-ERROR:        ushll v0.4s, v1.4h, #17
1360 // CHECK-ERROR:                            ^
1361 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1362 // CHECK-ERROR:        ushll v0.2d, v1.2s, #33
1363 // CHECK-ERROR:                            ^
1364 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1365 // CHECK-ERROR:        sshll2 v0.8h, v1.16b, #9
1366 // CHECK-ERROR:                              ^
1367 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1368 // CHECK-ERROR:        sshll2 v0.4s, v1.8h, #17
1369 // CHECK-ERROR:                             ^
1370 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1371 // CHECK-ERROR:        ushll2 v0.2d, v1.4s, #33
1372 // CHECK-ERROR:                             ^
1373
1374
1375 //------------------------------------------------------------------------------
1376 // Vector shift right by immediate
1377 //------------------------------------------------------------------------------
1378          sshr v0.8b, v1.8h, #3
1379          sshr v0.4h, v1.4s, #3
1380          sshr v0.2s, v1.2d, #3
1381          sshr v0.16b, v1.16b, #9
1382          sshr v0.8h, v1.8h, #17
1383          sshr v0.4s, v1.4s, #33
1384          sshr v0.2d, v1.2d, #65
1385
1386 // CHECK-ERROR: error: invalid operand for instruction
1387 // CHECK-ERROR:         sshr v0.8b, v1.8h, #3
1388 // CHECK-ERROR:                        ^
1389 // CHECK-ERROR: error: invalid operand for instruction
1390 // CHECK-ERROR:         sshr v0.4h, v1.4s, #3
1391 // CHECK-ERROR:                        ^
1392 // CHECK-ERROR: error: invalid operand for instruction
1393 // CHECK-ERROR:         sshr v0.2s, v1.2d, #3
1394 // CHECK-ERROR:                        ^
1395 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1396 // CHECK-ERROR:         sshr v0.16b, v1.16b, #9
1397 // CHECK-ERROR:                              ^
1398 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1399 // CHECK-ERROR:         sshr v0.8h, v1.8h, #17
1400 // CHECK-ERROR:                            ^
1401 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1402 // CHECK-ERROR:         sshr v0.4s, v1.4s, #33
1403 // CHECK-ERROR:                            ^
1404 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1405 // CHECK-ERROR:         sshr v0.2d, v1.2d, #65
1406 // CHECK-ERROR:                            ^
1407
1408 //------------------------------------------------------------------------------
1409 // Vector  shift right by immediate
1410 //------------------------------------------------------------------------------
1411          ushr v0.8b, v1.8h, #3
1412          ushr v0.4h, v1.4s, #3
1413          ushr v0.2s, v1.2d, #3
1414          ushr v0.16b, v1.16b, #9
1415          ushr v0.8h, v1.8h, #17
1416          ushr v0.4s, v1.4s, #33
1417          ushr v0.2d, v1.2d, #65
1418
1419 // CHECK-ERROR: error: invalid operand for instruction
1420 // CHECK-ERROR:         ushr v0.8b, v1.8h, #3
1421 // CHECK-ERROR:                        ^
1422 // CHECK-ERROR: error: invalid operand for instruction
1423 // CHECK-ERROR:         ushr v0.4h, v1.4s, #3
1424 // CHECK-ERROR:                        ^
1425 // CHECK-ERROR: error: invalid operand for instruction
1426 // CHECK-ERROR:         ushr v0.2s, v1.2d, #3
1427 // CHECK-ERROR:                        ^
1428 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1429 // CHECK-ERROR:         ushr v0.16b, v1.16b, #9
1430 // CHECK-ERROR:                              ^
1431 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1432 // CHECK-ERROR:         ushr v0.8h, v1.8h, #17
1433 // CHECK-ERROR:                            ^
1434 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1435 // CHECK-ERROR:         ushr v0.4s, v1.4s, #33
1436 // CHECK-ERROR:                            ^
1437 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1438 // CHECK-ERROR:         ushr v0.2d, v1.2d, #65
1439 // CHECK-ERROR:                            ^
1440
1441 //------------------------------------------------------------------------------
1442 // Vector shift right and accumulate by immediate
1443 //------------------------------------------------------------------------------
1444          ssra v0.8b, v1.8h, #3
1445          ssra v0.4h, v1.4s, #3
1446          ssra v0.2s, v1.2d, #3
1447          ssra v0.16b, v1.16b, #9
1448          ssra v0.8h, v1.8h, #17
1449          ssra v0.4s, v1.4s, #33
1450          ssra v0.2d, v1.2d, #65
1451
1452 // CHECK-ERROR: error: invalid operand for instruction
1453 // CHECK-ERROR:         ssra v0.8b, v1.8h, #3
1454 // CHECK-ERROR:                        ^
1455 // CHECK-ERROR: error: invalid operand for instruction
1456 // CHECK-ERROR:         ssra v0.4h, v1.4s, #3
1457 // CHECK-ERROR:                        ^
1458 // CHECK-ERROR: error: invalid operand for instruction
1459 // CHECK-ERROR:         ssra v0.2s, v1.2d, #3
1460 // CHECK-ERROR:                        ^
1461 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1462 // CHECK-ERROR:         ssra v0.16b, v1.16b, #9
1463 // CHECK-ERROR:                              ^
1464 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1465 // CHECK-ERROR:         ssra v0.8h, v1.8h, #17
1466 // CHECK-ERROR:                            ^
1467 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1468 // CHECK-ERROR:         ssra v0.4s, v1.4s, #33
1469 // CHECK-ERROR:                            ^
1470 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1471 // CHECK-ERROR:         ssra v0.2d, v1.2d, #65
1472 // CHECK-ERROR:                            ^
1473
1474 //------------------------------------------------------------------------------
1475 // Vector  shift right and accumulate by immediate
1476 //------------------------------------------------------------------------------
1477          usra v0.8b, v1.8h, #3
1478          usra v0.4h, v1.4s, #3
1479          usra v0.2s, v1.2d, #3
1480          usra v0.16b, v1.16b, #9
1481          usra v0.8h, v1.8h, #17
1482          usra v0.4s, v1.4s, #33
1483          usra v0.2d, v1.2d, #65
1484
1485 // CHECK-ERROR: error: invalid operand for instruction
1486 // CHECK-ERROR:         usra v0.8b, v1.8h, #3
1487 // CHECK-ERROR:                        ^
1488 // CHECK-ERROR: error: invalid operand for instruction
1489 // CHECK-ERROR:         usra v0.4h, v1.4s, #3
1490 // CHECK-ERROR:                        ^
1491 // CHECK-ERROR: error: invalid operand for instruction
1492 // CHECK-ERROR:         usra v0.2s, v1.2d, #3
1493 // CHECK-ERROR:                        ^
1494 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1495 // CHECK-ERROR:         usra v0.16b, v1.16b, #9
1496 // CHECK-ERROR:                              ^
1497 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1498 // CHECK-ERROR:         usra v0.8h, v1.8h, #17
1499 // CHECK-ERROR:                            ^
1500 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1501 // CHECK-ERROR:         usra v0.4s, v1.4s, #33
1502 // CHECK-ERROR:                            ^
1503 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1504 // CHECK-ERROR:         usra v0.2d, v1.2d, #65
1505 // CHECK-ERROR:                            ^
1506
1507 //------------------------------------------------------------------------------
1508 // Vector rounding shift right by immediate
1509 //------------------------------------------------------------------------------
1510          srshr v0.8b, v1.8h, #3
1511          srshr v0.4h, v1.4s, #3
1512          srshr v0.2s, v1.2d, #3
1513          srshr v0.16b, v1.16b, #9
1514          srshr v0.8h, v1.8h, #17
1515          srshr v0.4s, v1.4s, #33
1516          srshr v0.2d, v1.2d, #65
1517
1518 // CHECK-ERROR: error: invalid operand for instruction
1519 // CHECK-ERROR:         srshr v0.8b, v1.8h, #3
1520 // CHECK-ERROR:                         ^
1521 // CHECK-ERROR: error: invalid operand for instruction
1522 // CHECK-ERROR:         srshr v0.4h, v1.4s, #3
1523 // CHECK-ERROR:                         ^
1524 // CHECK-ERROR: error: invalid operand for instruction
1525 // CHECK-ERROR:         srshr v0.2s, v1.2d, #3
1526 // CHECK-ERROR:                         ^
1527 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1528 // CHECK-ERROR:         srshr v0.16b, v1.16b, #9
1529 // CHECK-ERROR:                               ^
1530 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1531 // CHECK-ERROR:         srshr v0.8h, v1.8h, #17
1532 // CHECK-ERROR:                             ^
1533 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1534 // CHECK-ERROR:         srshr v0.4s, v1.4s, #33
1535 // CHECK-ERROR:                             ^
1536 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1537 // CHECK-ERROR:         srshr v0.2d, v1.2d, #65
1538 // CHECK-ERROR:                             ^
1539
1540 //------------------------------------------------------------------------------
1541 // Vecotr rounding shift right by immediate
1542 //------------------------------------------------------------------------------
1543          urshr v0.8b, v1.8h, #3
1544          urshr v0.4h, v1.4s, #3
1545          urshr v0.2s, v1.2d, #3
1546          urshr v0.16b, v1.16b, #9
1547          urshr v0.8h, v1.8h, #17
1548          urshr v0.4s, v1.4s, #33
1549          urshr v0.2d, v1.2d, #65
1550
1551 // CHECK-ERROR: error: invalid operand for instruction
1552 // CHECK-ERROR:         urshr v0.8b, v1.8h, #3
1553 // CHECK-ERROR:                         ^
1554 // CHECK-ERROR: error: invalid operand for instruction
1555 // CHECK-ERROR:         urshr v0.4h, v1.4s, #3
1556 // CHECK-ERROR:                         ^
1557 // CHECK-ERROR: error: invalid operand for instruction
1558 // CHECK-ERROR:         urshr v0.2s, v1.2d, #3
1559 // CHECK-ERROR:                         ^
1560 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1561 // CHECK-ERROR:         urshr v0.16b, v1.16b, #9
1562 // CHECK-ERROR:                               ^
1563 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1564 // CHECK-ERROR:         urshr v0.8h, v1.8h, #17
1565 // CHECK-ERROR:                             ^
1566 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1567 // CHECK-ERROR:         urshr v0.4s, v1.4s, #33
1568 // CHECK-ERROR:                             ^
1569 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1570 // CHECK-ERROR:         urshr v0.2d, v1.2d, #65
1571 // CHECK-ERROR:                             ^
1572
1573 //------------------------------------------------------------------------------
1574 // Vector rounding shift right and accumulate by immediate
1575 //------------------------------------------------------------------------------
1576          srsra v0.8b, v1.8h, #3
1577          srsra v0.4h, v1.4s, #3
1578          srsra v0.2s, v1.2d, #3
1579          srsra v0.16b, v1.16b, #9
1580          srsra v0.8h, v1.8h, #17
1581          srsra v0.4s, v1.4s, #33
1582          srsra v0.2d, v1.2d, #65
1583
1584 // CHECK-ERROR: error: invalid operand for instruction
1585 // CHECK-ERROR:         srsra v0.8b, v1.8h, #3
1586 // CHECK-ERROR:                         ^
1587 // CHECK-ERROR: error: invalid operand for instruction
1588 // CHECK-ERROR:         srsra v0.4h, v1.4s, #3
1589 // CHECK-ERROR:                         ^
1590 // CHECK-ERROR: error: invalid operand for instruction
1591 // CHECK-ERROR:         srsra v0.2s, v1.2d, #3
1592 // CHECK-ERROR:                         ^
1593 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1594 // CHECK-ERROR:         srsra v0.16b, v1.16b, #9
1595 // CHECK-ERROR:                               ^
1596 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1597 // CHECK-ERROR:         srsra v0.8h, v1.8h, #17
1598 // CHECK-ERROR:                             ^
1599 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1600 // CHECK-ERROR:         srsra v0.4s, v1.4s, #33
1601 // CHECK-ERROR:                             ^
1602 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1603 // CHECK-ERROR:         srsra v0.2d, v1.2d, #65
1604 // CHECK-ERROR:                             ^
1605
1606 //------------------------------------------------------------------------------
1607 // Vector rounding shift right and accumulate by immediate
1608 //------------------------------------------------------------------------------
1609          ursra v0.8b, v1.8h, #3
1610          ursra v0.4h, v1.4s, #3
1611          ursra v0.2s, v1.2d, #3
1612          ursra v0.16b, v1.16b, #9
1613          ursra v0.8h, v1.8h, #17
1614          ursra v0.4s, v1.4s, #33
1615          ursra v0.2d, v1.2d, #65
1616
1617 // CHECK-ERROR: error: invalid operand for instruction
1618 // CHECK-ERROR:         ursra v0.8b, v1.8h, #3
1619 // CHECK-ERROR:                         ^
1620 // CHECK-ERROR: error: invalid operand for instruction
1621 // CHECK-ERROR:         ursra v0.4h, v1.4s, #3
1622 // CHECK-ERROR:                         ^
1623 // CHECK-ERROR: error: invalid operand for instruction
1624 // CHECK-ERROR:         ursra v0.2s, v1.2d, #3
1625 // CHECK-ERROR:                         ^
1626 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1627 // CHECK-ERROR:         ursra v0.16b, v1.16b, #9
1628 // CHECK-ERROR:                               ^
1629 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1630 // CHECK-ERROR:         ursra v0.8h, v1.8h, #17
1631 // CHECK-ERROR:                             ^
1632 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1633 // CHECK-ERROR:         ursra v0.4s, v1.4s, #33
1634 // CHECK-ERROR:                             ^
1635 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1636 // CHECK-ERROR:         ursra v0.2d, v1.2d, #65
1637 // CHECK-ERROR:                             ^
1638
1639 //------------------------------------------------------------------------------
1640 // Vector shift right and insert by immediate
1641 //------------------------------------------------------------------------------
1642          sri v0.8b, v1.8h, #3
1643          sri v0.4h, v1.4s, #3
1644          sri v0.2s, v1.2d, #3
1645          sri v0.16b, v1.16b, #9
1646          sri v0.8h, v1.8h, #17
1647          sri v0.4s, v1.4s, #33
1648          sri v0.2d, v1.2d, #65
1649
1650 // CHECK-ERROR: error: invalid operand for instruction
1651 // CHECK-ERROR:         sri v0.8b, v1.8h, #3
1652 // CHECK-ERROR:                       ^
1653 // CHECK-ERROR: error: invalid operand for instruction
1654 // CHECK-ERROR:         sri v0.4h, v1.4s, #3
1655 // CHECK-ERROR:                       ^
1656 // CHECK-ERROR: error: invalid operand for instruction
1657 // CHECK-ERROR:         sri v0.2s, v1.2d, #3
1658 // CHECK-ERROR:                       ^
1659 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1660 // CHECK-ERROR:         sri v0.16b, v1.16b, #9
1661 // CHECK-ERROR:                             ^
1662 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1663 // CHECK-ERROR:         sri v0.8h, v1.8h, #17
1664 // CHECK-ERROR:                           ^
1665 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1666 // CHECK-ERROR:         sri v0.4s, v1.4s, #33
1667 // CHECK-ERROR:                           ^
1668 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
1669 // CHECK-ERROR:         sri v0.2d, v1.2d, #65
1670 // CHECK-ERROR:                           ^
1671
1672 //------------------------------------------------------------------------------
1673 // Vector shift left and insert by immediate
1674 //------------------------------------------------------------------------------
1675          sli v0.8b, v1.8h, #3
1676          sli v0.4h, v1.4s, #3
1677          sli v0.2s, v1.2d, #3
1678          sli v0.16b, v1.16b, #8
1679          sli v0.8h, v1.8h, #16
1680          sli v0.4s, v1.4s, #32
1681          sli v0.2d, v1.2d, #64
1682
1683 // CHECK-ERROR: error: invalid operand for instruction
1684 // CHECK-ERROR:         sli v0.8b, v1.8h, #3
1685 // CHECK-ERROR:                       ^
1686 // CHECK-ERROR: error: invalid operand for instruction
1687 // CHECK-ERROR:         sli v0.4h, v1.4s, #3
1688 // CHECK-ERROR:                       ^
1689 // CHECK-ERROR: error: invalid operand for instruction
1690 // CHECK-ERROR:         sli v0.2s, v1.2d, #3
1691 // CHECK-ERROR:                       ^
1692 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1693 // CHECK-ERROR:         sli v0.16b, v1.16b, #8
1694 // CHECK-ERROR:                             ^
1695 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1696 // CHECK-ERROR:         sli v0.8h, v1.8h, #16
1697 // CHECK-ERROR:                           ^
1698 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1699 // CHECK-ERROR:         sli v0.4s, v1.4s, #32
1700 // CHECK-ERROR:                           ^
1701 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1702 // CHECK-ERROR:         sli v0.2d, v1.2d, #64
1703 // CHECK-ERROR:                           ^
1704
1705 //------------------------------------------------------------------------------
1706 // Vector saturating shift left unsigned by immediate
1707 //------------------------------------------------------------------------------
1708          sqshlu v0.8b, v1.8h, #3
1709          sqshlu v0.4h, v1.4s, #3
1710          sqshlu v0.2s, v1.2d, #3
1711          sqshlu v0.16b, v1.16b, #8
1712          sqshlu v0.8h, v1.8h, #16
1713          sqshlu v0.4s, v1.4s, #32
1714          sqshlu v0.2d, v1.2d, #64
1715
1716 // CHECK-ERROR: error: invalid operand for instruction
1717 // CHECK-ERROR:         sqshlu v0.8b, v1.8h, #3
1718 // CHECK-ERROR:                          ^
1719 // CHECK-ERROR: error: invalid operand for instruction
1720 // CHECK-ERROR:         sqshlu v0.4h, v1.4s, #3
1721 // CHECK-ERROR:                          ^
1722 // CHECK-ERROR: error: invalid operand for instruction
1723 // CHECK-ERROR:         sqshlu v0.2s, v1.2d, #3
1724 // CHECK-ERROR:                          ^
1725 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1726 // CHECK-ERROR:         sqshlu v0.16b, v1.16b, #8
1727 // CHECK-ERROR:                                ^
1728 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1729 // CHECK-ERROR:         sqshlu v0.8h, v1.8h, #16
1730 // CHECK-ERROR:                              ^
1731 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1732 // CHECK-ERROR:         sqshlu v0.4s, v1.4s, #32
1733 // CHECK-ERROR:                              ^
1734 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1735 // CHECK-ERROR:         sqshlu v0.2d, v1.2d, #64
1736 // CHECK-ERROR:                              ^
1737
1738 //------------------------------------------------------------------------------
1739 // Vector saturating shift left by immediate
1740 //------------------------------------------------------------------------------
1741          sqshl v0.8b, v1.8h, #3
1742          sqshl v0.4h, v1.4s, #3
1743          sqshl v0.2s, v1.2d, #3
1744          sqshl v0.16b, v1.16b, #8
1745          sqshl v0.8h, v1.8h, #16
1746          sqshl v0.4s, v1.4s, #32
1747          sqshl v0.2d, v1.2d, #64
1748
1749 // CHECK-ERROR: error: invalid operand for instruction
1750 // CHECK-ERROR:         sqshl v0.8b, v1.8h, #3
1751 // CHECK-ERROR:                         ^
1752 // CHECK-ERROR: error: invalid operand for instruction
1753 // CHECK-ERROR:         sqshl v0.4h, v1.4s, #3
1754 // CHECK-ERROR:                         ^
1755 // CHECK-ERROR: error: invalid operand for instruction
1756 // CHECK-ERROR:         sqshl v0.2s, v1.2d, #3
1757 // CHECK-ERROR:                         ^
1758 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1759 // CHECK-ERROR:         sqshl v0.16b, v1.16b, #8
1760 // CHECK-ERROR:                               ^
1761 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1762 // CHECK-ERROR:         sqshl v0.8h, v1.8h, #16
1763 // CHECK-ERROR:                             ^
1764 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1765 // CHECK-ERROR:         sqshl v0.4s, v1.4s, #32
1766 // CHECK-ERROR:                             ^
1767 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1768 // CHECK-ERROR:         sqshl v0.2d, v1.2d, #64
1769 // CHECK-ERROR:                             ^
1770
1771 //------------------------------------------------------------------------------
1772 // Vector saturating shift left by immediate
1773 //------------------------------------------------------------------------------
1774          uqshl v0.8b, v1.8h, #3
1775          uqshl v0.4h, v1.4s, #3
1776          uqshl v0.2s, v1.2d, #3
1777          uqshl v0.16b, v1.16b, #8
1778          uqshl v0.8h, v1.8h, #16
1779          uqshl v0.4s, v1.4s, #32
1780          uqshl v0.2d, v1.2d, #64
1781
1782 // CHECK-ERROR: error: invalid operand for instruction
1783 // CHECK-ERROR:         uqshl v0.8b, v1.8h, #3
1784 // CHECK-ERROR:                         ^
1785 // CHECK-ERROR: error: invalid operand for instruction
1786 // CHECK-ERROR:         uqshl v0.4h, v1.4s, #3
1787 // CHECK-ERROR:                         ^
1788 // CHECK-ERROR: error: invalid operand for instruction
1789 // CHECK-ERROR:         uqshl v0.2s, v1.2d, #3
1790 // CHECK-ERROR:                         ^
1791 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
1792 // CHECK-ERROR:         uqshl v0.16b, v1.16b, #8
1793 // CHECK-ERROR:                               ^
1794 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
1795 // CHECK-ERROR:         uqshl v0.8h, v1.8h, #16
1796 // CHECK-ERROR:                             ^
1797 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
1798 // CHECK-ERROR:         uqshl v0.4s, v1.4s, #32
1799 // CHECK-ERROR:                             ^
1800 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
1801 // CHECK-ERROR:         uqshl v0.2d, v1.2d, #64
1802 // CHECK-ERROR:                             ^
1803
1804 //------------------------------------------------------------------------------
1805 // Vector shift right narrow by immediate
1806 //------------------------------------------------------------------------------
1807          shrn v0.8b, v1.8b, #3
1808          shrn v0.4h, v1.4h, #3
1809          shrn v0.2s, v1.2s, #3
1810          shrn2 v0.16b, v1.8h, #17
1811          shrn2 v0.8h, v1.4s, #33
1812          shrn2 v0.4s, v1.2d, #65
1813
1814 // CHECK-ERROR: error: invalid operand for instruction
1815 // CHECK-ERROR:         shrn v0.8b, v1.8b, #3
1816 // CHECK-ERROR:                        ^
1817 // CHECK-ERROR: error: invalid operand for instruction
1818 // CHECK-ERROR:         shrn v0.4h, v1.4h, #3
1819 // CHECK-ERROR:                        ^
1820 // CHECK-ERROR: error: invalid operand for instruction
1821 // CHECK-ERROR:         shrn v0.2s, v1.2s, #3
1822 // CHECK-ERROR:                        ^
1823 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1824 // CHECK-ERROR:         shrn2 v0.16b, v1.8h, #17
1825 // CHECK-ERROR:                              ^
1826 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1827 // CHECK-ERROR:         shrn2 v0.8h, v1.4s, #33
1828 // CHECK-ERROR:                             ^
1829 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1830 // CHECK-ERROR:         shrn2 v0.4s, v1.2d, #65
1831 // CHECK-ERROR:                             ^
1832
1833 //------------------------------------------------------------------------------
1834 // Vector saturating shift right unsigned narrow by immediate
1835 //------------------------------------------------------------------------------
1836          sqshrun v0.8b, v1.8b, #3
1837          sqshrun v0.4h, v1.4h, #3
1838          sqshrun v0.2s, v1.2s, #3
1839          sqshrun2 v0.16b, v1.8h, #17
1840          sqshrun2 v0.8h, v1.4s, #33
1841          sqshrun2 v0.4s, v1.2d, #65
1842
1843 // CHECK-ERROR: error: invalid operand for instruction
1844 // CHECK-ERROR:         sqshrun v0.8b, v1.8b, #3
1845 // CHECK-ERROR:                           ^
1846 // CHECK-ERROR: error: invalid operand for instruction
1847 // CHECK-ERROR:         sqshrun v0.4h, v1.4h, #3
1848 // CHECK-ERROR:                           ^
1849 // CHECK-ERROR: error: invalid operand for instruction
1850 // CHECK-ERROR:         sqshrun v0.2s, v1.2s, #3
1851 // CHECK-ERROR:                           ^
1852 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1853 // CHECK-ERROR:         sqshrun2 v0.16b, v1.8h, #17
1854 // CHECK-ERROR:                                 ^
1855 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1856 // CHECK-ERROR:         sqshrun2 v0.8h, v1.4s, #33
1857 // CHECK-ERROR:                                ^
1858 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1859 // CHECK-ERROR:         sqshrun2 v0.4s, v1.2d, #65
1860 // CHECK-ERROR:                                ^
1861
1862 //------------------------------------------------------------------------------
1863 // Vector rounding shift right narrow by immediate
1864 //------------------------------------------------------------------------------
1865          rshrn v0.8b, v1.8b, #3
1866          rshrn v0.4h, v1.4h, #3
1867          rshrn v0.2s, v1.2s, #3
1868          rshrn2 v0.16b, v1.8h, #17
1869          rshrn2 v0.8h, v1.4s, #33
1870          rshrn2 v0.4s, v1.2d, #65
1871
1872 // CHECK-ERROR: error: invalid operand for instruction
1873 // CHECK-ERROR:         rshrn v0.8b, v1.8b, #3
1874 // CHECK-ERROR:                         ^
1875 // CHECK-ERROR: error: invalid operand for instruction
1876 // CHECK-ERROR:         rshrn v0.4h, v1.4h, #3
1877 // CHECK-ERROR:                         ^
1878 // CHECK-ERROR: error: invalid operand for instruction
1879 // CHECK-ERROR:         rshrn v0.2s, v1.2s, #3
1880 // CHECK-ERROR:                         ^
1881 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1882 // CHECK-ERROR:         rshrn2 v0.16b, v1.8h, #17
1883 // CHECK-ERROR:                               ^
1884 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1885 // CHECK-ERROR:         rshrn2 v0.8h, v1.4s, #33
1886 // CHECK-ERROR:                              ^
1887 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1888 // CHECK-ERROR:         rshrn2 v0.4s, v1.2d, #65
1889 // CHECK-ERROR:                              ^
1890
1891 //------------------------------------------------------------------------------
1892 // Vector saturating shift right rounded unsigned narrow by immediate
1893 //------------------------------------------------------------------------------
1894          sqrshrun v0.8b, v1.8b, #3
1895          sqrshrun v0.4h, v1.4h, #3
1896          sqrshrun v0.2s, v1.2s, #3
1897          sqrshrun2 v0.16b, v1.8h, #17
1898          sqrshrun2 v0.8h, v1.4s, #33
1899          sqrshrun2 v0.4s, v1.2d, #65
1900
1901 // CHECK-ERROR: error: invalid operand for instruction
1902 // CHECK-ERROR:         sqrshrun v0.8b, v1.8b, #3
1903 // CHECK-ERROR:                            ^
1904 // CHECK-ERROR: error: invalid operand for instruction
1905 // CHECK-ERROR:         sqrshrun v0.4h, v1.4h, #3
1906 // CHECK-ERROR:                            ^
1907 // CHECK-ERROR: error: invalid operand for instruction
1908 // CHECK-ERROR:         sqrshrun v0.2s, v1.2s, #3
1909 // CHECK-ERROR:                            ^
1910 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1911 // CHECK-ERROR:         sqrshrun2 v0.16b, v1.8h, #17
1912 // CHECK-ERROR:                                  ^
1913 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1914 // CHECK-ERROR:         sqrshrun2 v0.8h, v1.4s, #33
1915 // CHECK-ERROR:                                 ^
1916 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1917 // CHECK-ERROR:         sqrshrun2 v0.4s, v1.2d, #65
1918 // CHECK-ERROR:                                 ^
1919
1920 //------------------------------------------------------------------------------
1921 // Vector saturating shift right narrow by immediate
1922 //------------------------------------------------------------------------------
1923          sqshrn v0.8b, v1.8b, #3
1924          sqshrn v0.4h, v1.4h, #3
1925          sqshrn v0.2s, v1.2s, #3
1926          sqshrn2 v0.16b, v1.8h, #17
1927          sqshrn2 v0.8h, v1.4s, #33
1928          sqshrn2 v0.4s, v1.2d, #65
1929
1930 // CHECK-ERROR: error: invalid operand for instruction
1931 // CHECK-ERROR:         sqshrn v0.8b, v1.8b, #3
1932 // CHECK-ERROR:                          ^
1933 // CHECK-ERROR: error: invalid operand for instruction
1934 // CHECK-ERROR:         sqshrn v0.4h, v1.4h, #3
1935 // CHECK-ERROR:                          ^
1936 // CHECK-ERROR: error: invalid operand for instruction
1937 // CHECK-ERROR:         sqshrn v0.2s, v1.2s, #3
1938 // CHECK-ERROR:                          ^
1939 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1940 // CHECK-ERROR:         sqshrn2 v0.16b, v1.8h, #17
1941 // CHECK-ERROR:                                ^
1942 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1943 // CHECK-ERROR:         sqshrn2 v0.8h, v1.4s, #33
1944 // CHECK-ERROR:                               ^
1945 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1946 // CHECK-ERROR:         sqshrn2 v0.4s, v1.2d, #65
1947 // CHECK-ERROR:                               ^
1948
1949 //------------------------------------------------------------------------------
1950 // Vector saturating shift right narrow by immediate
1951 //------------------------------------------------------------------------------
1952          uqshrn v0.8b, v1.8b, #3
1953          uqshrn v0.4h, v1.4h, #3
1954          uqshrn v0.2s, v1.2s, #3
1955          uqshrn2 v0.16b, v1.8h, #17
1956          uqshrn2 v0.8h, v1.4s, #33
1957          uqshrn2 v0.4s, v1.2d, #65
1958
1959 // CHECK-ERROR: error: invalid operand for instruction
1960 // CHECK-ERROR:         uqshrn v0.8b, v1.8b, #3
1961 // CHECK-ERROR:                          ^
1962 // CHECK-ERROR: error: invalid operand for instruction
1963 // CHECK-ERROR:         uqshrn v0.4h, v1.4h, #3
1964 // CHECK-ERROR:                          ^
1965 // CHECK-ERROR: error: invalid operand for instruction
1966 // CHECK-ERROR:         uqshrn v0.2s, v1.2s, #3
1967 // CHECK-ERROR:                          ^
1968 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1969 // CHECK-ERROR:         uqshrn2 v0.16b, v1.8h, #17
1970 // CHECK-ERROR:                                ^
1971 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
1972 // CHECK-ERROR:         uqshrn2 v0.8h, v1.4s, #33
1973 // CHECK-ERROR:                               ^
1974 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
1975 // CHECK-ERROR:         uqshrn2 v0.4s, v1.2d, #65
1976 // CHECK-ERROR:                               ^
1977
1978 //------------------------------------------------------------------------------
1979 // Vector saturating shift right rounded narrow by immediate
1980 //------------------------------------------------------------------------------
1981          sqrshrn v0.8b, v1.8b, #3
1982          sqrshrn v0.4h, v1.4h, #3
1983          sqrshrn v0.2s, v1.2s, #3
1984          sqrshrn2 v0.16b, v1.8h, #17
1985          sqrshrn2 v0.8h, v1.4s, #33
1986          sqrshrn2 v0.4s, v1.2d, #65
1987
1988 // CHECK-ERROR: error: invalid operand for instruction
1989 // CHECK-ERROR:         sqrshrn v0.8b, v1.8b, #3
1990 // CHECK-ERROR:                           ^
1991 // CHECK-ERROR: error: invalid operand for instruction
1992 // CHECK-ERROR:         sqrshrn v0.4h, v1.4h, #3
1993 // CHECK-ERROR:                           ^
1994 // CHECK-ERROR: error: invalid operand for instruction
1995 // CHECK-ERROR:         sqrshrn v0.2s, v1.2s, #3
1996 // CHECK-ERROR:                           ^
1997 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
1998 // CHECK-ERROR:         sqrshrn2 v0.16b, v1.8h, #17
1999 // CHECK-ERROR:                                 ^
2000 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
2001 // CHECK-ERROR:         sqrshrn2 v0.8h, v1.4s, #33
2002 // CHECK-ERROR:                                ^
2003 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2004 // CHECK-ERROR:         sqrshrn2 v0.4s, v1.2d, #65
2005 // CHECK-ERROR:                                ^
2006
2007 //------------------------------------------------------------------------------
2008 // Vector saturating shift right rounded narrow by immediate
2009 //------------------------------------------------------------------------------
2010          uqrshrn v0.8b, v1.8b, #3
2011          uqrshrn v0.4h, v1.4h, #3
2012          uqrshrn v0.2s, v1.2s, #3
2013          uqrshrn2 v0.16b, v1.8h, #17
2014          uqrshrn2 v0.8h, v1.4s, #33
2015          uqrshrn2 v0.4s, v1.2d, #65
2016
2017 // CHECK-ERROR: error: invalid operand for instruction
2018 // CHECK-ERROR:         uqrshrn v0.8b, v1.8b, #3
2019 // CHECK-ERROR:                           ^
2020 // CHECK-ERROR: error: invalid operand for instruction
2021 // CHECK-ERROR:         uqrshrn v0.4h, v1.4h, #3
2022 // CHECK-ERROR:                           ^
2023 // CHECK-ERROR: error: invalid operand for instruction
2024 // CHECK-ERROR:         uqrshrn v0.2s, v1.2s, #3
2025 // CHECK-ERROR:                           ^
2026 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
2027 // CHECK-ERROR:         uqrshrn2 v0.16b, v1.8h, #17
2028 // CHECK-ERROR:                                 ^
2029 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
2030 // CHECK-ERROR:         uqrshrn2 v0.8h, v1.4s, #33
2031 // CHECK-ERROR:                                ^
2032 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2033 // CHECK-ERROR:         uqrshrn2 v0.4s, v1.2d, #65
2034 // CHECK-ERROR:                                ^
2035
2036 //------------------------------------------------------------------------------
2037 // Fixed-point convert to floating-point
2038 //------------------------------------------------------------------------------
2039          scvtf v0.2s, v1.2d, #3
2040          scvtf v0.4s, v1.4h, #3
2041          scvtf v0.2d, v1.2s, #3
2042          ucvtf v0.2s, v1.2s, #33
2043          ucvtf v0.4s, v1.4s, #33
2044          ucvtf v0.2d, v1.2d, #65
2045
2046 // CHECK-ERROR: error: invalid operand for instruction
2047 // CHECK-ERROR:         scvtf v0.2s, v1.2d, #3
2048 // CHECK-ERROR:                         ^
2049 // CHECK-ERROR: error: invalid operand for instruction
2050 // CHECK-ERROR:         scvtf v0.4s, v1.4h, #3
2051 // CHECK-ERROR:                         ^
2052 // CHECK-ERROR: error: invalid operand for instruction
2053 // CHECK-ERROR:         scvtf v0.2d, v1.2s, #3
2054 // CHECK-ERROR:                         ^
2055 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2056 // CHECK-ERROR:         ucvtf v0.2s, v1.2s, #33
2057 // CHECK-ERROR:                             ^
2058 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2059 // CHECK-ERROR:         ucvtf v0.4s, v1.4s, #33
2060 // CHECK-ERROR:                             ^
2061 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
2062 // CHECK-ERROR:         ucvtf v0.2d, v1.2d, #65
2063 // CHECK-ERROR:                             ^
2064
2065 //------------------------------------------------------------------------------
2066 // Floating-point convert to fixed-point
2067 //------------------------------------------------------------------------------
2068          fcvtzs v0.2s, v1.2d, #3
2069          fcvtzs v0.4s, v1.4h, #3
2070          fcvtzs v0.2d, v1.2s, #3
2071          fcvtzu v0.2s, v1.2s, #33
2072          fcvtzu v0.4s, v1.4s, #33
2073          fcvtzu v0.2d, v1.2d, #65
2074
2075 // CHECK-ERROR: error: invalid operand for instruction
2076 // CHECK-ERROR:         fcvtzs v0.2s, v1.2d, #3
2077 // CHECK-ERROR:                          ^
2078 // CHECK-ERROR: error: invalid operand for instruction
2079 // CHECK-ERROR:         fcvtzs v0.4s, v1.4h, #3
2080 // CHECK-ERROR:                          ^
2081 // CHECK-ERROR: error: invalid operand for instruction
2082 // CHECK-ERROR:         fcvtzs v0.2d, v1.2s, #3
2083 // CHECK-ERROR:                          ^
2084 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2085 // CHECK-ERROR:         fcvtzu v0.2s, v1.2s, #33
2086 // CHECK-ERROR:                              ^
2087 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
2088 // CHECK-ERROR:         fcvtzu v0.4s, v1.4s, #33
2089 // CHECK-ERROR:                              ^
2090 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
2091 // CHECK-ERROR:         fcvtzu v0.2d, v1.2d, #65
2092 // CHECK-ERROR:                              ^
2093
2094 //----------------------------------------------------------------------
2095 // Vector operation on 3 operands with different types
2096 //----------------------------------------------------------------------
2097
2098         // Mismatched and invalid vector types
2099         saddl v0.8h, v1.8h, v2.8b
2100         saddl v0.4s, v1.4s, v2.4h
2101         saddl v0.2d, v1.2d, v2.2s
2102
2103 // CHECK-ERROR: error: invalid operand for instruction
2104 // CHECK-ERROR:        saddl v0.8h, v1.8h, v2.8b
2105 // CHECK-ERROR:                        ^
2106 // CHECK-ERROR: error: invalid operand for instruction
2107 // CHECK-ERROR:        saddl v0.4s, v1.4s, v2.4h
2108 // CHECK-ERROR:                        ^
2109 // CHECK-ERROR: error: invalid operand for instruction
2110 // CHECK-ERROR:        saddl v0.2d, v1.2d, v2.2s
2111 // CHECK-ERROR:                        ^
2112
2113         saddl2 v0.4s, v1.8s, v2.8h
2114         saddl2 v0.8h, v1.16h, v2.16b
2115         saddl2 v0.2d, v1.4d, v2.4s
2116
2117 // CHECK-ERROR: error: invalid operand for instruction
2118 // CHECK-ERROR:        saddl2 v0.4s, v1.8s, v2.8h
2119 // CHECK-ERROR:                      ^
2120 // CHECK-ERROR: error: invalid operand for instruction
2121 // CHECK-ERROR:        saddl2 v0.8h, v1.16h, v2.16b
2122 // CHECK-ERROR:                      ^
2123 // CHECK-ERROR: error: invalid operand for instruction
2124 // CHECK-ERROR:        saddl2 v0.2d, v1.4d, v2.4s
2125 // CHECK-ERROR:                      ^
2126
2127         uaddl v0.8h, v1.8h, v2.8b
2128         uaddl v0.4s, v1.4s, v2.4h
2129         uaddl v0.2d, v1.2d, v2.2s
2130
2131 // CHECK-ERROR: error: invalid operand for instruction
2132 // CHECK-ERROR:        uaddl v0.8h, v1.8h, v2.8b
2133 // CHECK-ERROR:                        ^
2134 // CHECK-ERROR: error: invalid operand for instruction
2135 // CHECK-ERROR:        uaddl v0.4s, v1.4s, v2.4h
2136 // CHECK-ERROR:                        ^
2137 // CHECK-ERROR: error: invalid operand for instruction
2138 // CHECK-ERROR:        uaddl v0.2d, v1.2d, v2.2s
2139 // CHECK-ERROR:                        ^
2140
2141         uaddl2 v0.8h, v1.16h, v2.16b
2142         uaddl2 v0.4s, v1.8s, v2.8h
2143         uaddl2 v0.2d, v1.4d, v2.4s
2144
2145 // CHECK-ERROR: error: invalid operand for instruction
2146 // CHECK-ERROR:        uaddl2 v0.8h, v1.16h, v2.16b
2147 // CHECK-ERROR:                      ^
2148 // CHECK-ERROR: error: invalid operand for instruction
2149 // CHECK-ERROR:        uaddl2 v0.4s, v1.8s, v2.8h
2150 // CHECK-ERROR:                      ^
2151 // CHECK-ERROR: error: invalid operand for instruction
2152 // CHECK-ERROR:        uaddl2 v0.2d, v1.4d, v2.4s
2153 // CHECK-ERROR:                      ^
2154
2155         ssubl v0.8h, v1.8h, v2.8b
2156         ssubl v0.4s, v1.4s, v2.4h
2157         ssubl v0.2d, v1.2d, v2.2s
2158
2159 // CHECK-ERROR: error: invalid operand for instruction
2160 // CHECK-ERROR:        ssubl v0.8h, v1.8h, v2.8b
2161 // CHECK-ERROR:                        ^
2162 // CHECK-ERROR: error: invalid operand for instruction
2163 // CHECK-ERROR:        ssubl v0.4s, v1.4s, v2.4h
2164 // CHECK-ERROR:                        ^
2165 // CHECK-ERROR: error: invalid operand for instruction
2166 // CHECK-ERROR:        ssubl v0.2d, v1.2d, v2.2s
2167 // CHECK-ERROR:                        ^
2168
2169         ssubl2 v0.8h, v1.16h, v2.16b
2170         ssubl2 v0.4s, v1.8s, v2.8h
2171         ssubl2 v0.2d, v1.4d, v2.4s
2172
2173 // CHECK-ERROR: error: invalid operand for instruction
2174 // CHECK-ERROR:        ssubl2 v0.8h, v1.16h, v2.16b
2175 // CHECK-ERROR:                      ^
2176 // CHECK-ERROR: error: invalid operand for instruction
2177 // CHECK-ERROR:        ssubl2 v0.4s, v1.8s, v2.8h
2178 // CHECK-ERROR:                      ^
2179 // CHECK-ERROR: error: invalid operand for instruction
2180 // CHECK-ERROR:        ssubl2 v0.2d, v1.4d, v2.4s
2181 // CHECK-ERROR:                      ^
2182
2183         usubl v0.8h, v1.8h, v2.8b
2184         usubl v0.4s, v1.4s, v2.4h
2185         usubl v0.2d, v1.2d, v2.2s
2186
2187 // CHECK-ERROR: error: invalid operand for instruction
2188 // CHECK-ERROR:        usubl v0.8h, v1.8h, v2.8b
2189 // CHECK-ERROR:                        ^
2190 // CHECK-ERROR: error: invalid operand for instruction
2191 // CHECK-ERROR:        usubl v0.4s, v1.4s, v2.4h
2192 // CHECK-ERROR:                        ^
2193 // CHECK-ERROR: error: invalid operand for instruction
2194 // CHECK-ERROR:        usubl v0.2d, v1.2d, v2.2s
2195 // CHECK-ERROR:                        ^
2196
2197         usubl2 v0.8h, v1.16h, v2.16b
2198         usubl2 v0.4s, v1.8s, v2.8h
2199         usubl2 v0.2d, v1.4d, v2.4s
2200
2201 // CHECK-ERROR: error: invalid operand for instruction
2202 // CHECK-ERROR:        usubl2 v0.8h, v1.16h, v2.16b
2203 // CHECK-ERROR:                      ^
2204 // CHECK-ERROR: error: invalid operand for instruction
2205 // CHECK-ERROR:        usubl2 v0.4s, v1.8s, v2.8h
2206 // CHECK-ERROR:                      ^
2207 // CHECK-ERROR: error: invalid operand for instruction
2208 // CHECK-ERROR:        usubl2 v0.2d, v1.4d, v2.4s
2209 // CHECK-ERROR:                      ^
2210
2211         sabal v0.8h, v1.8h, v2.8b
2212         sabal v0.4s, v1.4s, v2.4h
2213         sabal v0.2d, v1.2d, v2.2s
2214
2215 // CHECK-ERROR: error: invalid operand for instruction
2216 // CHECK-ERROR:        sabal v0.8h, v1.8h, v2.8b
2217 // CHECK-ERROR:                        ^
2218 // CHECK-ERROR: error: invalid operand for instruction
2219 // CHECK-ERROR:        sabal v0.4s, v1.4s, v2.4h
2220 // CHECK-ERROR:                        ^
2221 // CHECK-ERROR: error: invalid operand for instruction
2222 // CHECK-ERROR:        sabal v0.2d, v1.2d, v2.2s
2223 // CHECK-ERROR:                        ^
2224
2225         sabal2 v0.8h, v1.16h, v2.16b
2226         sabal2 v0.4s, v1.8s, v2.8h
2227         sabal2 v0.2d, v1.4d, v2.4s
2228
2229 // CHECK-ERROR: error: invalid operand for instruction
2230 // CHECK-ERROR:        sabal2 v0.8h, v1.16h, v2.16b
2231 // CHECK-ERROR:                      ^
2232 // CHECK-ERROR: error: invalid operand for instruction
2233 // CHECK-ERROR:        sabal2 v0.4s, v1.8s, v2.8h
2234 // CHECK-ERROR:                      ^
2235 // CHECK-ERROR: error: invalid operand for instruction
2236 // CHECK-ERROR:        sabal2 v0.2d, v1.4d, v2.4s
2237 // CHECK-ERROR:                      ^
2238
2239         uabal v0.8h, v1.8h, v2.8b
2240         uabal v0.4s, v1.4s, v2.4h
2241         uabal v0.2d, v1.2d, v2.2s
2242
2243 // CHECK-ERROR: error: invalid operand for instruction
2244 // CHECK-ERROR:        uabal v0.8h, v1.8h, v2.8b
2245 // CHECK-ERROR:                        ^
2246 // CHECK-ERROR: error: invalid operand for instruction
2247 // CHECK-ERROR:        uabal v0.4s, v1.4s, v2.4h
2248 // CHECK-ERROR:                        ^
2249 // CHECK-ERROR: error: invalid operand for instruction
2250 // CHECK-ERROR:        uabal v0.2d, v1.2d, v2.2s
2251 // CHECK-ERROR:                        ^
2252
2253         uabal2 v0.8h, v1.16h, v2.16b
2254         uabal2 v0.4s, v1.8s, v2.8h
2255         uabal2 v0.2d, v1.4d, v2.4s
2256
2257 // CHECK-ERROR: error: invalid operand for instruction
2258 // CHECK-ERROR:        uabal2 v0.8h, v1.16h, v2.16b
2259 // CHECK-ERROR:                      ^
2260 // CHECK-ERROR: error: invalid operand for instruction
2261 // CHECK-ERROR:        uabal2 v0.4s, v1.8s, v2.8h
2262 // CHECK-ERROR:                      ^
2263 // CHECK-ERROR: error: invalid operand for instruction
2264 // CHECK-ERROR:        uabal2 v0.2d, v1.4d, v2.4s
2265 // CHECK-ERROR:                      ^
2266
2267         sabdl v0.8h, v1.8h, v2.8b
2268         sabdl v0.4s, v1.4s, v2.4h
2269         sabdl v0.2d, v1.2d, v2.2s
2270
2271 // CHECK-ERROR: error: invalid operand for instruction
2272 // CHECK-ERROR:        sabdl v0.8h, v1.8h, v2.8b
2273 // CHECK-ERROR:                        ^
2274 // CHECK-ERROR: error: invalid operand for instruction
2275 // CHECK-ERROR:        sabdl v0.4s, v1.4s, v2.4h
2276 // CHECK-ERROR:                        ^
2277 // CHECK-ERROR: error: invalid operand for instruction
2278 // CHECK-ERROR:        sabdl v0.2d, v1.2d, v2.2s
2279 // CHECK-ERROR:                        ^
2280
2281         sabdl2 v0.8h, v1.16h, v2.16b
2282         sabdl2 v0.4s, v1.8s, v2.8h
2283         sabdl2 v0.2d, v1.4d, v2.4s
2284
2285 // CHECK-ERROR: error: invalid operand for instruction
2286 // CHECK-ERROR:        sabdl2 v0.8h, v1.16h, v2.16b
2287 // CHECK-ERROR:                      ^
2288 // CHECK-ERROR: error: invalid operand for instruction
2289 // CHECK-ERROR:        sabdl2 v0.4s, v1.8s, v2.8h
2290 // CHECK-ERROR:                      ^
2291 // CHECK-ERROR: error: invalid operand for instruction
2292 // CHECK-ERROR:        sabdl2 v0.2d, v1.4d, v2.4s
2293 // CHECK-ERROR:                      ^
2294
2295         uabdl v0.8h, v1.8h, v2.8b
2296         uabdl v0.4s, v1.4s, v2.4h
2297         uabdl v0.2d, v1.2d, v2.2s
2298
2299 // CHECK-ERROR: error: invalid operand for instruction
2300 // CHECK-ERROR:        uabdl v0.8h, v1.8h, v2.8b
2301 // CHECK-ERROR:                        ^
2302 // CHECK-ERROR: error: invalid operand for instruction
2303 // CHECK-ERROR:        uabdl v0.4s, v1.4s, v2.4h
2304 // CHECK-ERROR:                        ^
2305 // CHECK-ERROR: error: invalid operand for instruction
2306 // CHECK-ERROR:        uabdl v0.2d, v1.2d, v2.2s
2307 // CHECK-ERROR:                        ^
2308
2309         uabdl2 v0.8h, v1.16h, v2.16b
2310         uabdl2 v0.4s, v1.8s, v2.8h
2311         uabdl2 v0.2d, v1.4d, v2.4s
2312
2313 // CHECK-ERROR: error: invalid operand for instruction
2314 // CHECK-ERROR:        uabdl2 v0.8h, v1.16h, v2.16b
2315 // CHECK-ERROR:                      ^
2316 // CHECK-ERROR: error: invalid operand for instruction
2317 // CHECK-ERROR:        uabdl2 v0.4s, v1.8s, v2.8h
2318 // CHECK-ERROR:                      ^
2319 // CHECK-ERROR: error: invalid operand for instruction
2320 // CHECK-ERROR:        uabdl2 v0.2d, v1.4d, v2.4s
2321 // CHECK-ERROR:                      ^
2322
2323         smlal v0.8h, v1.8h, v2.8b
2324         smlal v0.4s, v1.4s, v2.4h
2325         smlal v0.2d, v1.2d, v2.2s
2326
2327 // CHECK-ERROR: error: invalid operand for instruction
2328 // CHECK-ERROR:        smlal v0.8h, v1.8h, v2.8b
2329 // CHECK-ERROR:                        ^
2330 // CHECK-ERROR: error: invalid operand for instruction
2331 // CHECK-ERROR:        smlal v0.4s, v1.4s, v2.4h
2332 // CHECK-ERROR:                        ^
2333 // CHECK-ERROR: error: invalid operand for instruction
2334 // CHECK-ERROR:        smlal v0.2d, v1.2d, v2.2s
2335 // CHECK-ERROR:                        ^
2336
2337         smlal2 v0.8h, v1.16h, v2.16b
2338         smlal2 v0.4s, v1.8s, v2.8h
2339         smlal2 v0.2d, v1.4d, v2.4s
2340
2341 // CHECK-ERROR: error: invalid operand for instruction
2342 // CHECK-ERROR:        smlal2 v0.8h, v1.16h, v2.16b
2343 // CHECK-ERROR:                      ^
2344 // CHECK-ERROR: error: invalid operand for instruction
2345 // CHECK-ERROR:        smlal2 v0.4s, v1.8s, v2.8h
2346 // CHECK-ERROR:                      ^
2347 // CHECK-ERROR: error: invalid operand for instruction
2348 // CHECK-ERROR:        smlal2 v0.2d, v1.4d, v2.4s
2349 // CHECK-ERROR:                      ^
2350
2351         umlal v0.8h, v1.8h, v2.8b
2352         umlal v0.4s, v1.4s, v2.4h
2353         umlal v0.2d, v1.2d, v2.2s
2354
2355 // CHECK-ERROR: error: invalid operand for instruction
2356 // CHECK-ERROR:        umlal v0.8h, v1.8h, v2.8b
2357 // CHECK-ERROR:                        ^
2358 // CHECK-ERROR: error: invalid operand for instruction
2359 // CHECK-ERROR:        umlal v0.4s, v1.4s, v2.4h
2360 // CHECK-ERROR:                        ^
2361 // CHECK-ERROR: error: invalid operand for instruction
2362 // CHECK-ERROR:        umlal v0.2d, v1.2d, v2.2s
2363 // CHECK-ERROR:                        ^
2364
2365         umlal2 v0.8h, v1.16h, v2.16b
2366         umlal2 v0.4s, v1.8s, v2.8h
2367         umlal2 v0.2d, v1.4d, v2.4s
2368
2369 // CHECK-ERROR: error: invalid operand for instruction
2370 // CHECK-ERROR:        umlal2 v0.8h, v1.16h, v2.16b
2371 // CHECK-ERROR:                      ^
2372 // CHECK-ERROR: error: invalid operand for instruction
2373 // CHECK-ERROR:        umlal2 v0.4s, v1.8s, v2.8h
2374 // CHECK-ERROR:                      ^
2375 // CHECK-ERROR: error: invalid operand for instruction
2376 // CHECK-ERROR:        umlal2 v0.2d, v1.4d, v2.4s
2377 // CHECK-ERROR:                      ^
2378
2379         smlsl v0.8h, v1.8h, v2.8b
2380         smlsl v0.4s, v1.4s, v2.4h
2381         smlsl v0.2d, v1.2d, v2.2s
2382
2383 // CHECK-ERROR: error: invalid operand for instruction
2384 // CHECK-ERROR:        smlsl v0.8h, v1.8h, v2.8b
2385 // CHECK-ERROR:                        ^
2386 // CHECK-ERROR: error: invalid operand for instruction
2387 // CHECK-ERROR:        smlsl v0.4s, v1.4s, v2.4h
2388 // CHECK-ERROR:                        ^
2389 // CHECK-ERROR: error: invalid operand for instruction
2390 // CHECK-ERROR:        smlsl v0.2d, v1.2d, v2.2s
2391 // CHECK-ERROR:                        ^
2392
2393         smlsl2 v0.8h, v1.16h, v2.16b
2394         smlsl2 v0.4s, v1.8s, v2.8h
2395         smlsl2 v0.2d, v1.4d, v2.4s
2396
2397 // CHECK-ERROR: error: invalid operand for instruction
2398 // CHECK-ERROR:        smlsl2 v0.8h, v1.16h, v2.16b
2399 // CHECK-ERROR:                      ^
2400 // CHECK-ERROR: error: invalid operand for instruction
2401 // CHECK-ERROR:        smlsl2 v0.4s, v1.8s, v2.8h
2402 // CHECK-ERROR:                      ^
2403 // CHECK-ERROR: error: invalid operand for instruction
2404 // CHECK-ERROR:        smlsl2 v0.2d, v1.4d, v2.4s
2405 // CHECK-ERROR:                      ^
2406
2407         umlsl v0.8h, v1.8h, v2.8b
2408         umlsl v0.4s, v1.4s, v2.4h
2409         umlsl v0.2d, v1.2d, v2.2s
2410
2411 // CHECK-ERROR: error: invalid operand for instruction
2412 // CHECK-ERROR:        umlsl v0.8h, v1.8h, v2.8b
2413 // CHECK-ERROR:                        ^
2414 // CHECK-ERROR: error: invalid operand for instruction
2415 // CHECK-ERROR:        umlsl v0.4s, v1.4s, v2.4h
2416 // CHECK-ERROR:                        ^
2417 // CHECK-ERROR: error: invalid operand for instruction
2418 // CHECK-ERROR:        umlsl v0.2d, v1.2d, v2.2s
2419 // CHECK-ERROR:                        ^
2420
2421         umlsl2 v0.8h, v1.16h, v2.16b
2422         umlsl2 v0.4s, v1.8s, v2.8h
2423         umlsl2 v0.2d, v1.4d, v2.4s
2424
2425 // CHECK-ERROR: error: invalid operand for instruction
2426 // CHECK-ERROR:        umlsl2 v0.8h, v1.16h, v2.16b
2427 // CHECK-ERROR:                      ^
2428 // CHECK-ERROR: error: invalid operand for instruction
2429 // CHECK-ERROR:        umlsl2 v0.4s, v1.8s, v2.8h
2430 // CHECK-ERROR:                      ^
2431 // CHECK-ERROR: error: invalid operand for instruction
2432 // CHECK-ERROR:        umlsl2 v0.2d, v1.4d, v2.4s
2433 // CHECK-ERROR:                      ^
2434
2435         smull v0.8h, v1.8h, v2.8b
2436         smull v0.4s, v1.4s, v2.4h
2437         smull v0.2d, v1.2d, v2.2s
2438
2439 // CHECK-ERROR: error: invalid operand for instruction
2440 // CHECK-ERROR:        smull v0.8h, v1.8h, v2.8b
2441 // CHECK-ERROR:                        ^
2442 // CHECK-ERROR: error: invalid operand for instruction
2443 // CHECK-ERROR:        smull v0.4s, v1.4s, v2.4h
2444 // CHECK-ERROR:                        ^
2445 // CHECK-ERROR: error: invalid operand for instruction
2446 // CHECK-ERROR:        smull v0.2d, v1.2d, v2.2s
2447 // CHECK-ERROR:                        ^
2448
2449         smull2 v0.8h, v1.16h, v2.16b
2450         smull2 v0.4s, v1.8s, v2.8h
2451         smull2 v0.2d, v1.4d, v2.4s
2452
2453 // CHECK-ERROR: error: invalid operand for instruction
2454 // CHECK-ERROR:        smull2 v0.8h, v1.16h, v2.16b
2455 // CHECK-ERROR:                      ^
2456 // CHECK-ERROR: error: invalid operand for instruction
2457 // CHECK-ERROR:        smull2 v0.4s, v1.8s, v2.8h
2458 // CHECK-ERROR:                      ^
2459 // CHECK-ERROR: error: invalid operand for instruction
2460 // CHECK-ERROR:        smull2 v0.2d, v1.4d, v2.4s
2461 // CHECK-ERROR:                      ^
2462
2463         umull v0.8h, v1.8h, v2.8b
2464         umull v0.4s, v1.4s, v2.4h
2465         umull v0.2d, v1.2d, v2.2s
2466
2467 // CHECK-ERROR: error: invalid operand for instruction
2468 // CHECK-ERROR:        umull v0.8h, v1.8h, v2.8b
2469 // CHECK-ERROR:                        ^
2470 // CHECK-ERROR: error: invalid operand for instruction
2471 // CHECK-ERROR:        umull v0.4s, v1.4s, v2.4h
2472 // CHECK-ERROR:                        ^
2473 // CHECK-ERROR: error: invalid operand for instruction
2474 // CHECK-ERROR:        umull v0.2d, v1.2d, v2.2s
2475 // CHECK-ERROR:                        ^
2476
2477         umull2 v0.8h, v1.16h, v2.16b
2478         umull2 v0.4s, v1.8s, v2.8h
2479         umull2 v0.2d, v1.4d, v2.4s
2480
2481 // CHECK-ERROR: error: invalid operand for instruction
2482 // CHECK-ERROR:        umull2 v0.8h, v1.16h, v2.16b
2483 // CHECK-ERROR:                      ^
2484 // CHECK-ERROR: error: invalid operand for instruction
2485 // CHECK-ERROR:        umull2 v0.4s, v1.8s, v2.8h
2486 // CHECK-ERROR:                      ^
2487 // CHECK-ERROR: error: invalid operand for instruction
2488 // CHECK-ERROR:        umull2 v0.2d, v1.4d, v2.4s
2489 // CHECK-ERROR:                      ^
2490
2491 //------------------------------------------------------------------------------
2492 // Long - Variant 2
2493 //------------------------------------------------------------------------------
2494
2495         sqdmlal v0.4s, v1.4s, v2.4h
2496         sqdmlal v0.2d, v1.2d, v2.2s
2497
2498 // CHECK-ERROR: error: invalid operand for instruction
2499 // CHECK-ERROR:        sqdmlal v0.4s, v1.4s, v2.4h
2500 // CHECK-ERROR:                          ^
2501 // CHECK-ERROR: error: invalid operand for instruction
2502 // CHECK-ERROR:        sqdmlal v0.2d, v1.2d, v2.2s
2503 // CHECK-ERROR:                          ^
2504
2505         sqdmlal2 v0.4s, v1.8s, v2.8h
2506         sqdmlal2 v0.2d, v1.4d, v2.4s
2507
2508 // CHECK-ERROR: error: invalid operand for instruction
2509 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8s, v2.8h
2510 // CHECK-ERROR:                        ^
2511 // CHECK-ERROR: error: invalid operand for instruction
2512 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4d, v2.4s
2513 // CHECK-ERROR:                        ^
2514
2515         // Mismatched vector types
2516         sqdmlal v0.8h, v1.8b, v2.8b
2517         sqdmlal2 v0.8h, v1.16b, v2.16b
2518
2519 // CHECK-ERROR: error: invalid operand for instruction
2520 // CHECK-ERROR:        sqdmlal v0.8h, v1.8b, v2.8b
2521 // CHECK-ERROR:                   ^
2522 // CHECK-ERROR: error: invalid operand for instruction
2523 // CHECK-ERROR:        sqdmlal2 v0.8h, v1.16b, v2.16b
2524 // CHECK-ERROR:                    ^
2525
2526         sqdmlsl v0.4s, v1.4s, v2.4h
2527         sqdmlsl v0.2d, v1.2d, v2.2s
2528
2529 // CHECK-ERROR: error: invalid operand for instruction
2530 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4s, v2.4h
2531 // CHECK-ERROR:                          ^
2532 // CHECK-ERROR: error: invalid operand for instruction
2533 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2d, v2.2s
2534 // CHECK-ERROR:                          ^
2535
2536         sqdmlsl2 v0.4s, v1.8s, v2.8h
2537         sqdmlsl2 v0.2d, v1.4d, v2.4s
2538
2539 // CHECK-ERROR: error: invalid operand for instruction
2540 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8s, v2.8h
2541 // CHECK-ERROR:                        ^
2542 // CHECK-ERROR: error: invalid operand for instruction
2543 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4d, v2.4s
2544 // CHECK-ERROR:                        ^
2545
2546         // Mismatched vector types
2547         sqdmlsl v0.8h, v1.8b, v2.8b
2548         sqdmlsl2 v0.8h, v1.16b, v2.16b
2549
2550 // CHECK-ERROR: error: invalid operand for instruction
2551 // CHECK-ERROR:        sqdmlsl v0.8h, v1.8b, v2.8b
2552 // CHECK-ERROR:                   ^
2553 // CHECK-ERROR: error: invalid operand for instruction
2554 // CHECK-ERROR:        sqdmlsl2 v0.8h, v1.16b, v2.16b
2555 // CHECK-ERROR:                    ^
2556
2557
2558         sqdmull v0.4s, v1.4s, v2.4h
2559         sqdmull v0.2d, v1.2d, v2.2s
2560
2561 // CHECK-ERROR: error: invalid operand for instruction
2562 // CHECK-ERROR:        sqdmull v0.4s, v1.4s, v2.4h
2563 // CHECK-ERROR:                          ^
2564 // CHECK-ERROR: error: invalid operand for instruction
2565 // CHECK-ERROR:        sqdmull v0.2d, v1.2d, v2.2s
2566 // CHECK-ERROR:                          ^
2567
2568         sqdmull2 v0.4s, v1.8s, v2.8h
2569         sqdmull2 v0.2d, v1.4d, v2.4s
2570
2571 // CHECK-ERROR: error: invalid operand for instruction
2572 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8s, v2.8h
2573 // CHECK-ERROR:                        ^
2574 // CHECK-ERROR: error: invalid operand for instruction
2575 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4d, v2.4s
2576 // CHECK-ERROR:                        ^
2577
2578         // Mismatched vector types
2579         sqdmull v0.8h, v1.8b, v2.8b
2580         sqdmull2 v0.8h, v1.16b, v2.16b
2581
2582 // CHECK-ERROR: error: invalid operand for instruction
2583 // CHECK-ERROR:        sqdmull v0.8h, v1.8b, v2.8b
2584 // CHECK-ERROR:                   ^
2585 // CHECK-ERROR: error: invalid operand for instruction
2586 // CHECK-ERROR:        sqdmull2 v0.8h, v1.16b, v2.16b
2587 // CHECK-ERROR:                    ^
2588
2589
2590 //------------------------------------------------------------------------------
2591 // Long - Variant 3
2592 //------------------------------------------------------------------------------
2593
2594         pmull v0.8h, v1.8h, v2.8b
2595
2596 // CHECK-ERROR: error: invalid operand for instruction
2597 // CHECK-ERROR:        pmull v0.8h, v1.8h, v2.8b
2598 // CHECK-ERROR:                        ^
2599
2600         pmull v0.1q, v1.2d, v2.2d
2601
2602 // CHECK-ERROR: error: invalid operand for instruction
2603 // CHECK-ERROR:        pmull v0.1q, v1.2d, v2.2d
2604 // CHECK-ERROR:                     ^
2605
2606         // Mismatched vector types
2607         pmull v0.4s, v1.4h, v2.4h
2608         pmull v0.2d, v1.2s, v2.2s
2609
2610 // CHECK-ERROR: error: invalid operand for instruction
2611 // CHECK-ERROR:        pmull v0.4s, v1.4h, v2.4h
2612 // CHECK-ERROR:                 ^
2613 // CHECK-ERROR: error: invalid operand for instruction
2614 // CHECK-ERROR:        pmull v0.2d, v1.2s, v2.2s
2615 // CHECK-ERROR:                 ^
2616
2617
2618         pmull2 v0.8h, v1.16h, v2.16b
2619
2620 // CHECK-ERROR: error: invalid operand for instruction
2621 // CHECK-ERROR:        pmull2 v0.8h, v1.16h, v2.16b
2622 // CHECK-ERROR:                      ^
2623
2624         pmull2 v0.q, v1.2d, v2.2d
2625
2626 // CHECK-ERROR: error: invalid operand for instruction
2627 // CHECK-ERROR:        pmull2 v0.q, v1.2d, v2.2d
2628 // CHECK-ERROR:                  ^
2629
2630         // Mismatched vector types
2631         pmull2 v0.4s, v1.8h v2.8h
2632         pmull2 v0.2d, v1.4s, v2.4s
2633
2634
2635 // CHECK-ERROR: error: unexpected token in argument list
2636 // CHECK-ERROR:        pmull2 v0.4s, v1.8h v2.8h
2637 // CHECK-ERROR:                            ^
2638
2639 // CHECK-ERROR: error: invalid operand for instruction
2640 // CHECK-ERROR:        pmull2 v0.2d, v1.4s, v2.4s
2641 // CHECK-ERROR:                  ^
2642
2643 //------------------------------------------------------------------------------
2644 // Widen
2645 //------------------------------------------------------------------------------
2646
2647         saddw v0.8h, v1.8h, v2.8h
2648         saddw v0.4s, v1.4s, v2.4s
2649         saddw v0.2d, v1.2d, v2.2d
2650
2651 // CHECK-ERROR: error: invalid operand for instruction
2652 // CHECK-ERROR:        saddw v0.8h, v1.8h, v2.8h
2653 // CHECK-ERROR:                               ^
2654 // CHECK-ERROR: error: invalid operand for instruction
2655 // CHECK-ERROR:        saddw v0.4s, v1.4s, v2.4s
2656 // CHECK-ERROR:                               ^
2657 // CHECK-ERROR: error: invalid operand for instruction
2658 // CHECK-ERROR:        saddw v0.2d, v1.2d, v2.2d
2659 // CHECK-ERROR:                               ^
2660
2661         saddw2 v0.8h, v1.8h, v2.16h
2662         saddw2 v0.4s, v1.4s, v2.8s
2663         saddw2 v0.2d, v1.2d, v2.4d
2664
2665 // CHECK-ERROR: error: invalid operand for instruction
2666 // CHECK-ERROR:        saddw2 v0.8h, v1.8h, v2.16h
2667 // CHECK-ERROR:                             ^
2668 // CHECK-ERROR: error: invalid operand for instruction
2669 // CHECK-ERROR:        saddw2 v0.4s, v1.4s, v2.8s
2670 // CHECK-ERROR:                             ^
2671 // CHECK-ERROR: error: invalid operand for instruction
2672 // CHECK-ERROR:        saddw2 v0.2d, v1.2d, v2.4d
2673 // CHECK-ERROR:                             ^
2674
2675         uaddw v0.8h, v1.8h, v2.8h
2676         uaddw v0.4s, v1.4s, v2.4s
2677         uaddw v0.2d, v1.2d, v2.2d
2678
2679 // CHECK-ERROR: error: invalid operand for instruction
2680 // CHECK-ERROR:        uaddw v0.8h, v1.8h, v2.8h
2681 // CHECK-ERROR:                               ^
2682 // CHECK-ERROR: error: invalid operand for instruction
2683 // CHECK-ERROR:        uaddw v0.4s, v1.4s, v2.4s
2684 // CHECK-ERROR:                               ^
2685 // CHECK-ERROR: error: invalid operand for instruction
2686 // CHECK-ERROR:        uaddw v0.2d, v1.2d, v2.2d
2687 // CHECK-ERROR:                               ^
2688
2689         uaddw2 v0.8h, v1.8h, v2.16h
2690         uaddw2 v0.4s, v1.4s, v2.8s
2691         uaddw2 v0.2d, v1.2d, v2.4d
2692
2693 // CHECK-ERROR: error: invalid operand for instruction
2694 // CHECK-ERROR:        uaddw2 v0.8h, v1.8h, v2.16h
2695 // CHECK-ERROR:                             ^
2696 // CHECK-ERROR: error: invalid operand for instruction
2697 // CHECK-ERROR:        uaddw2 v0.4s, v1.4s, v2.8s
2698 // CHECK-ERROR:                             ^
2699 // CHECK-ERROR: error: invalid operand for instruction
2700 // CHECK-ERROR:        uaddw2 v0.2d, v1.2d, v2.4d
2701 // CHECK-ERROR:                             ^
2702
2703         ssubw v0.8h, v1.8h, v2.8h
2704         ssubw v0.4s, v1.4s, v2.4s
2705         ssubw v0.2d, v1.2d, v2.2d
2706
2707 // CHECK-ERROR: error: invalid operand for instruction
2708 // CHECK-ERROR:        ssubw v0.8h, v1.8h, v2.8h
2709 // CHECK-ERROR:                               ^
2710 // CHECK-ERROR: error: invalid operand for instruction
2711 // CHECK-ERROR:        ssubw v0.4s, v1.4s, v2.4s
2712 // CHECK-ERROR:                               ^
2713 // CHECK-ERROR: error: invalid operand for instruction
2714 // CHECK-ERROR:        ssubw v0.2d, v1.2d, v2.2d
2715 // CHECK-ERROR:                               ^
2716
2717         ssubw2 v0.8h, v1.8h, v2.16h
2718         ssubw2 v0.4s, v1.4s, v2.8s
2719         ssubw2 v0.2d, v1.2d, v2.4d
2720
2721 // CHECK-ERROR: error: invalid operand for instruction
2722 // CHECK-ERROR:        ssubw2 v0.8h, v1.8h, v2.16h
2723 // CHECK-ERROR:                             ^
2724 // CHECK-ERROR: error: invalid operand for instruction
2725 // CHECK-ERROR:        ssubw2 v0.4s, v1.4s, v2.8s
2726 // CHECK-ERROR:                             ^
2727 // CHECK-ERROR: error: invalid operand for instruction
2728 // CHECK-ERROR:        ssubw2 v0.2d, v1.2d, v2.4d
2729 // CHECK-ERROR:                             ^
2730
2731         usubw v0.8h, v1.8h, v2.8h
2732         usubw v0.4s, v1.4s, v2.4s
2733         usubw v0.2d, v1.2d, v2.2d
2734
2735 // CHECK-ERROR: error: invalid operand for instruction
2736 // CHECK-ERROR:        usubw v0.8h, v1.8h, v2.8h
2737 // CHECK-ERROR:                               ^
2738 // CHECK-ERROR: error: invalid operand for instruction
2739 // CHECK-ERROR:        usubw v0.4s, v1.4s, v2.4s
2740 // CHECK-ERROR:                               ^
2741 // CHECK-ERROR: error: invalid operand for instruction
2742 // CHECK-ERROR:        usubw v0.2d, v1.2d, v2.2d
2743 // CHECK-ERROR:                               ^
2744
2745         usubw2 v0.8h, v1.8h, v2.16h
2746         usubw2 v0.4s, v1.4s, v2.8s
2747         usubw2 v0.2d, v1.2d, v2.4d
2748
2749 // CHECK-ERROR: error: invalid operand for instruction
2750 // CHECK-ERROR:        usubw2 v0.8h, v1.8h, v2.16h
2751 // CHECK-ERROR:                             ^
2752 // CHECK-ERROR: error: invalid operand for instruction
2753 // CHECK-ERROR:        usubw2 v0.4s, v1.4s, v2.8s
2754 // CHECK-ERROR:                             ^
2755 // CHECK-ERROR: error: invalid operand for instruction
2756 // CHECK-ERROR:        usubw2 v0.2d, v1.2d, v2.4d
2757 // CHECK-ERROR:                             ^
2758
2759 //------------------------------------------------------------------------------
2760 // Narrow
2761 //------------------------------------------------------------------------------
2762
2763         addhn v0.8b, v1.8h, v2.8d
2764         addhn v0.4h, v1.4s, v2.4h
2765         addhn v0.2s, v1.2d, v2.2s
2766
2767 // CHECK-ERROR: error: invalid operand for instruction
2768 // CHECK-ERROR:        addhn v0.8b, v1.8h, v2.8d
2769 // CHECK-ERROR:                            ^
2770 // CHECK-ERROR: error: invalid operand for instruction
2771 // CHECK-ERROR:        addhn v0.4h, v1.4s, v2.4h
2772 // CHECK-ERROR:                               ^
2773 // CHECK-ERROR: error: invalid operand for instruction
2774 // CHECK-ERROR:        addhn v0.2s, v1.2d, v2.2s
2775 // CHECK-ERROR:                               ^
2776
2777         addhn2 v0.16b, v1.8h, v2.8b
2778         addhn2 v0.8h, v1.4s, v2.4h
2779         addhn2 v0.4s, v1.2d, v2.2s
2780
2781 // CHECK-ERROR: error: invalid operand for instruction
2782 // CHECK-ERROR:        addhn2 v0.16b, v1.8h, v2.8b
2783 // CHECK-ERROR:                                 ^
2784 // CHECK-ERROR: error: invalid operand for instruction
2785 // CHECK-ERROR:        addhn2 v0.8h, v1.4s, v2.4h
2786 // CHECK-ERROR:                                ^
2787 // CHECK-ERROR: error: invalid operand for instruction
2788 // CHECK-ERROR:        addhn2 v0.4s, v1.2d, v2.2s
2789 // CHECK-ERROR:                                ^
2790
2791         raddhn v0.8b, v1.8h, v2.8b
2792         raddhn v0.4h, v1.4s, v2.4h
2793         raddhn v0.2s, v1.2d, v2.2s
2794
2795 // CHECK-ERROR: error: invalid operand for instruction
2796 // CHECK-ERROR:        raddhn v0.8b, v1.8h, v2.8b
2797 // CHECK-ERROR:                                ^
2798 // CHECK-ERROR: error: invalid operand for instruction
2799 // CHECK-ERROR:        raddhn v0.4h, v1.4s, v2.4h
2800 // CHECK-ERROR:                                ^
2801 // CHECK-ERROR: error: invalid operand for instruction
2802 // CHECK-ERROR:        raddhn v0.2s, v1.2d, v2.2s
2803 // CHECK-ERROR:                                ^
2804
2805         raddhn2 v0.16b, v1.8h, v2.8b
2806         raddhn2 v0.8h, v1.4s, v2.4h
2807         raddhn2 v0.4s, v1.2d, v2.2s
2808
2809 // CHECK-ERROR: error: invalid operand for instruction
2810 // CHECK-ERROR:        raddhn2 v0.16b, v1.8h, v2.8b
2811 // CHECK-ERROR:                                  ^
2812 // CHECK-ERROR: error: invalid operand for instruction
2813 // CHECK-ERROR:        raddhn2 v0.8h, v1.4s, v2.4h
2814 // CHECK-ERROR:                                 ^
2815 // CHECK-ERROR: error: invalid operand for instruction
2816 // CHECK-ERROR:        raddhn2 v0.4s, v1.2d, v2.2s
2817 // CHECK-ERROR:                                 ^
2818
2819         rsubhn v0.8b, v1.8h, v2.8b
2820         rsubhn v0.4h, v1.4s, v2.4h
2821         rsubhn v0.2s, v1.2d, v2.2s
2822
2823 // CHECK-ERROR: error: invalid operand for instruction
2824 // CHECK-ERROR:        rsubhn v0.8b, v1.8h, v2.8b
2825 // CHECK-ERROR:                                ^
2826 // CHECK-ERROR: error: invalid operand for instruction
2827 // CHECK-ERROR:        rsubhn v0.4h, v1.4s, v2.4h
2828 // CHECK-ERROR:                                ^
2829 // CHECK-ERROR: error: invalid operand for instruction
2830 // CHECK-ERROR:        rsubhn v0.2s, v1.2d, v2.2s
2831 // CHECK-ERROR:                                ^
2832
2833         rsubhn2 v0.16b, v1.8h, v2.8b
2834         rsubhn2 v0.8h, v1.4s, v2.4h
2835         rsubhn2 v0.4s, v1.2d, v2.2s
2836
2837 // CHECK-ERROR: error: invalid operand for instruction
2838 // CHECK-ERROR:        rsubhn2 v0.16b, v1.8h, v2.8b
2839 // CHECK-ERROR:                                  ^
2840 // CHECK-ERROR: error: invalid operand for instruction
2841 // CHECK-ERROR:        rsubhn2 v0.8h, v1.4s, v2.4h
2842 // CHECK-ERROR:                                 ^
2843 // CHECK-ERROR: error: invalid operand for instruction
2844 // CHECK-ERROR:        rsubhn2 v0.4s, v1.2d, v2.2s
2845 // CHECK-ERROR:                                 ^
2846
2847 //----------------------------------------------------------------------
2848 // Scalar Reduce Add Pairwise (Integer)
2849 //----------------------------------------------------------------------
2850          // invalid vector types
2851       addp s0, d1.2d
2852       addp d0, d1.2s
2853
2854 // CHECK-ERROR: error: invalid operand for instruction
2855 // CHECK-ERROR:          addp s0, d1.2d
2856 // CHECK-ERROR:               ^
2857 // CHECK-ERROR: error: invalid operand for instruction
2858 // CHECK-ERROR:          addp d0, d1.2s
2859 // CHECK-ERROR:                      ^
2860
2861 //----------------------------------------------------------------------
2862 // Scalar Reduce Add Pairwise (Floating Point)
2863 //----------------------------------------------------------------------
2864          // invalid vector types
2865       faddp s0, d1.2d
2866       faddp d0, d1.2s
2867
2868 // CHECK-ERROR: error: invalid operand for instruction
2869 // CHECK-ERROR:          faddp s0, d1.2d
2870 // CHECK-ERROR:                    ^
2871 // CHECK-ERROR: error: invalid operand for instruction
2872 // CHECK-ERROR:          faddp d0, d1.2s
2873 // CHECK-ERROR:                    ^
2874
2875 //----------------------------------------------------------------------
2876 // Scalar Reduce Maximum Pairwise (Floating Point)
2877 //----------------------------------------------------------------------
2878          // mismatched and invalid vector types
2879       fmaxp s0, v1.2d
2880       fmaxp d31, v2.2s
2881       fmaxp h3, v2.2s
2882
2883 // CHECK-ERROR: error: invalid operand for instruction
2884 // CHECK-ERROR:          fmaxp s0, v1.2d
2885 // CHECK-ERROR:                       ^
2886 // CHECK-ERROR: error: invalid operand for instruction
2887 // CHECK-ERROR:          fmaxp d31, v2.2s
2888 // CHECK-ERROR:                        ^
2889 // CHECK-ERROR: error: invalid operand for instruction
2890 // CHECK-ERROR:          fmaxp h3, v2.2s
2891 // CHECK-ERROR:                ^
2892
2893
2894 //----------------------------------------------------------------------
2895 // Scalar Reduce Minimum Pairwise (Floating Point)
2896 //----------------------------------------------------------------------
2897          // mismatched and invalid vector types
2898       fminp s0, v1.4h
2899       fminp d31, v2.8h
2900       fminp b3, v2.2s
2901
2902 // CHECK-ERROR: error: invalid operand for instruction
2903 // CHECK-ERROR:          fminp s0, v1.4h
2904 // CHECK-ERROR:                       ^
2905 // CHECK-ERROR: error: invalid operand for instruction
2906 // CHECK-ERROR:          fminp d31, v2.8h
2907 // CHECK-ERROR:                        ^
2908 // CHECK-ERROR: error: invalid operand for instruction
2909 // CHECK-ERROR:          fminp b3, v2.2s
2910 // CHECK-ERROR:                ^
2911
2912
2913 //----------------------------------------------------------------------
2914 // Scalar Reduce maxNum Pairwise (Floating Point)
2915 //----------------------------------------------------------------------
2916          // mismatched and invalid vector types
2917       fmaxnmp s0, v1.8b
2918       fmaxnmp d31, v2.16b
2919       fmaxnmp v1.2s, v2.2s
2920
2921 // CHECK-ERROR: error: invalid operand for instruction
2922 // CHECK-ERROR:          fmaxnmp s0, v1.8b
2923 // CHECK-ERROR:                         ^
2924 // CHECK-ERROR: error: invalid operand for instruction
2925 // CHECK-ERROR:          fmaxnmp d31, v2.16b
2926 // CHECK-ERROR:                          ^
2927 // CHECK-ERROR: error: too few operands for instruction
2928 // CHECK-ERROR:          fmaxnmp v1.2s, v2.2s
2929 // CHECK-ERROR:          ^
2930
2931 //----------------------------------------------------------------------
2932 // Scalar Reduce minNum Pairwise (Floating Point)
2933 //----------------------------------------------------------------------
2934          // mismatched and invalid vector types
2935       fminnmp s0, v1.2d
2936       fminnmp d31, v2.4s
2937       fminnmp v1.4s, v2.2d
2938
2939 // CHECK-ERROR: error: invalid operand for instruction
2940 // CHECK-ERROR:          fminnmp s0, v1.2d
2941 // CHECK-ERROR:                         ^
2942 // CHECK-ERROR: error: invalid operand for instruction
2943 // CHECK-ERROR:          fminnmp d31, v2.4s
2944 // CHECK-ERROR:                          ^
2945 // CHECK-ERROR: error: invalid operand for instruction
2946 // CHECK-ERROR:          fminnmp v1.4s, v2.2d
2947 // CHECK-ERROR:          ^
2948
2949       mla v0.2d, v1.2d, v16.d[1]
2950       mla v0.2s, v1.2s, v2.s[4]
2951       mla v0.4s, v1.4s, v2.s[4]
2952       mla v0.2h, v1.2h, v2.h[1]
2953       mla v0.4h, v1.4h, v2.h[8]
2954       mla v0.8h, v1.8h, v2.h[8]
2955       mla v0.4h, v1.4h, v16.h[2]
2956       mla v0.8h, v1.8h, v16.h[2]
2957
2958 // CHECK-ERROR: error: invalid operand for instruction
2959 // CHECK-ERROR:        mla v0.2d, v1.2d, v16.d[1]
2960 // CHECK-ERROR:               ^
2961 // CHECK-ERROR: vector lane must be an integer in range
2962 // CHECK-ERROR:        mla v0.2s, v1.2s, v2.s[4]
2963 // CHECK-ERROR:                               ^
2964 // CHECK-ERROR: vector lane must be an integer in range
2965 // CHECK-ERROR:        mla v0.4s, v1.4s, v2.s[4]
2966 // CHECK-ERROR:                               ^
2967 // CHECK-ERROR: error: invalid operand for instruction
2968 // CHECK-ERROR:        mla v0.2h, v1.2h, v2.h[1]
2969 // CHECK-ERROR:            ^
2970 // CHECK-ERROR: vector lane must be an integer in range
2971 // CHECK-ERROR:        mla v0.4h, v1.4h, v2.h[8]
2972 // CHECK-ERROR:                               ^
2973 // CHECK-ERROR: vector lane must be an integer in range
2974 // CHECK-ERROR:        mla v0.8h, v1.8h, v2.h[8]
2975 // CHECK-ERROR:                               ^
2976 // CHECK-ERROR: error: invalid operand for instruction
2977 // CHECK-ERROR:        mla v0.4h, v1.4h, v16.h[2]
2978 // CHECK-ERROR:                          ^
2979 // CHECK-ERROR: error: invalid operand for instruction
2980 // CHECK-ERROR:        mla v0.8h, v1.8h, v16.h[2]
2981 // CHECK-ERROR:                              ^
2982
2983       mls v0.2d, v1.2d, v16.d[1]
2984       mls v0.2s, v1.2s, v2.s[4]
2985       mls v0.4s, v1.4s, v2.s[4]
2986       mls v0.2h, v1.2h, v2.h[1]
2987       mls v0.4h, v1.4h, v2.h[8]
2988       mls v0.8h, v1.8h, v2.h[8]
2989       mls v0.4h, v1.4h, v16.h[2]
2990       mls v0.8h, v1.8h, v16.h[2]
2991
2992 // CHECK-ERROR: error: invalid operand for instruction
2993 // CHECK-ERROR:        mls v0.2d, v1.2d, v16.d[1]
2994 // CHECK-ERROR:               ^
2995 // CHECK-ERROR: vector lane must be an integer in range
2996 // CHECK-ERROR:        mls v0.2s, v1.2s, v2.s[4]
2997 // CHECK-ERROR:                               ^
2998 // CHECK-ERROR: vector lane must be an integer in range
2999 // CHECK-ERROR:        mls v0.4s, v1.4s, v2.s[4]
3000 // CHECK-ERROR:                               ^
3001 // CHECK-ERROR: error: invalid operand for instruction
3002 // CHECK-ERROR:        mls v0.2h, v1.2h, v2.h[1]
3003 // CHECK-ERROR:            ^
3004 // CHECK-ERROR: vector lane must be an integer in range
3005 // CHECK-ERROR:        mls v0.4h, v1.4h, v2.h[8]
3006 // CHECK-ERROR:                               ^
3007 // CHECK-ERROR: vector lane must be an integer in range
3008 // CHECK-ERROR:        mls v0.8h, v1.8h, v2.h[8]
3009 // CHECK-ERROR:                               ^
3010 // CHECK-ERROR: error: invalid operand for instruction
3011 // CHECK-ERROR:        mls v0.4h, v1.4h, v16.h[2]
3012 // CHECK-ERROR:                          ^
3013 // CHECK-ERROR: error: invalid operand for instruction
3014 // CHECK-ERROR:        mls v0.8h, v1.8h, v16.h[2]
3015 // CHECK-ERROR:                              ^
3016
3017       fmla v0.4h, v1.4h, v2.h[2]
3018       fmla v0.8h, v1.8h, v2.h[2]
3019       fmla v0.2s, v1.2s, v2.s[4]
3020       fmla v0.2s, v1.2s, v22.s[4]
3021       fmla v3.4s, v8.4s, v2.s[4]
3022       fmla v3.4s, v8.4s, v22.s[4]
3023       fmla v0.2d, v1.2d, v2.d[2]
3024       fmla v0.2d, v1.2d, v22.d[2]
3025
3026 // CHECK-ERROR: error: instruction requires: fullfp16
3027 // CHECK-ERROR:        fmla v0.4h, v1.4h, v2.h[2]
3028 // CHECK-ERROR:                ^
3029 // CHECK-ERROR: error: instruction requires: fullfp16
3030 // CHECK-ERROR:        fmla v0.8h, v1.8h, v2.h[2]
3031 // CHECK-ERROR:                ^
3032 // CHECK-ERROR: vector lane must be an integer in range
3033 // CHECK-ERROR:        fmla v0.2s, v1.2s, v2.s[4]
3034 // CHECK-ERROR:                                ^
3035 // CHECK-ERROR: vector lane must be an integer in range
3036 // CHECK-ERROR:        fmla v0.2s, v1.2s, v22.s[4]
3037 // CHECK-ERROR:                                 ^
3038 // CHECK-ERROR: vector lane must be an integer in range
3039 // CHECK-ERROR:        fmla v3.4s, v8.4s, v2.s[4]
3040 // CHECK-ERROR:                                ^
3041 // CHECK-ERROR: vector lane must be an integer in range
3042 // CHECK-ERROR:        fmla v3.4s, v8.4s, v22.s[4]
3043 // CHECK-ERROR:                                 ^
3044 // CHECK-ERROR: vector lane must be an integer in range
3045 // CHECK-ERROR:        fmla v0.2d, v1.2d, v2.d[2]
3046 // CHECK-ERROR:                                ^
3047 // CHECK-ERROR: vector lane must be an integer in range
3048 // CHECK-ERROR:        fmla v0.2d, v1.2d, v22.d[2]
3049 // CHECK-ERROR:                                 ^
3050
3051       fmls v0.4h, v1.4h, v2.h[2]
3052       fmls v0.8h, v1.8h, v2.h[2]
3053       fmls v0.2s, v1.2s, v2.s[4]
3054       fmls v0.2s, v1.2s, v22.s[4]
3055       fmls v3.4s, v8.4s, v2.s[4]
3056       fmls v3.4s, v8.4s, v22.s[4]
3057       fmls v0.2d, v1.2d, v2.d[2]
3058       fmls v0.2d, v1.2d, v22.d[2]
3059
3060 // CHECK-ERROR: error: instruction requires: fullfp16
3061 // CHECK-ERROR:        fmls v0.4h, v1.4h, v2.h[2]
3062 // CHECK-ERROR:                ^
3063 // CHECK-ERROR: error: instruction requires: fullfp16
3064 // CHECK-ERROR:        fmls v0.8h, v1.8h, v2.h[2]
3065 // CHECK-ERROR:                ^
3066 // CHECK-ERROR: vector lane must be an integer in range
3067 // CHECK-ERROR:        fmls v0.2s, v1.2s, v2.s[4]
3068 // CHECK-ERROR:                                ^
3069 // CHECK-ERROR: vector lane must be an integer in range
3070 // CHECK-ERROR:        fmls v0.2s, v1.2s, v22.s[4]
3071 // CHECK-ERROR:                                 ^
3072 // CHECK-ERROR: vector lane must be an integer in range
3073 // CHECK-ERROR:        fmls v3.4s, v8.4s, v2.s[4]
3074 // CHECK-ERROR:                                ^
3075 // CHECK-ERROR: vector lane must be an integer in range
3076 // CHECK-ERROR:        fmls v3.4s, v8.4s, v22.s[4]
3077 // CHECK-ERROR:                                 ^
3078 // CHECK-ERROR: vector lane must be an integer in range
3079 // CHECK-ERROR:        fmls v0.2d, v1.2d, v2.d[2]
3080 // CHECK-ERROR:                                ^
3081 // CHECK-ERROR: vector lane must be an integer in range
3082 // CHECK-ERROR:        fmls v0.2d, v1.2d, v22.d[2]
3083 // CHECK-ERROR:                                 ^
3084
3085       smlal v0.4h, v1.4h, v2.h[2]
3086       smlal v0.4s, v1.4h, v2.h[8]
3087       smlal v0.4s, v1.4h, v16.h[2]
3088       smlal v0.2s, v1.2s, v2.s[1]
3089       smlal v0.2d, v1.2s, v2.s[4]
3090       smlal v0.2d, v1.2s, v22.s[4]
3091       smlal2 v0.4h, v1.8h, v1.h[2]
3092       smlal2 v0.4s, v1.8h, v1.h[8]
3093       smlal2 v0.4s, v1.8h, v16.h[2]
3094       smlal2 v0.2s, v1.4s, v1.s[2]
3095       smlal2 v0.2d, v1.4s, v1.s[4]
3096       smlal2 v0.2d, v1.4s, v22.s[4]
3097
3098 // CHECK-ERROR: error: invalid operand for instruction
3099 // CHECK-ERROR:        smlal v0.4h, v1.4h, v2.h[2]
3100 // CHECK-ERROR:              ^
3101 // CHECK-ERROR: vector lane must be an integer in range
3102 // CHECK-ERROR:        smlal v0.4s, v1.4h, v2.h[8]
3103 // CHECK-ERROR:                                 ^
3104 // CHECK-ERROR: error: invalid operand for instruction
3105 // CHECK-ERROR:        smlal v0.4s, v1.4h, v16.h[2]
3106 // CHECK-ERROR:                            ^
3107 // CHECK-ERROR: error: invalid operand for instruction
3108 // CHECK-ERROR:        smlal v0.2s, v1.2s, v2.s[1]
3109 // CHECK-ERROR:                                 ^
3110 // CHECK-ERROR: vector lane must be an integer in range
3111 // CHECK-ERROR:        smlal v0.2d, v1.2s, v2.s[4]
3112 // CHECK-ERROR:                                 ^
3113 // CHECK-ERROR: vector lane must be an integer in range
3114 // CHECK-ERROR:        smlal v0.2d, v1.2s, v22.s[4]
3115 // CHECK-ERROR:                                  ^
3116 // CHECK-ERROR: error: invalid operand for instruction
3117 // CHECK-ERROR:        smlal2 v0.4h, v1.8h, v1.h[2]
3118 // CHECK-ERROR:               ^
3119 // CHECK-ERROR: vector lane must be an integer in range
3120 // CHECK-ERROR:        smlal2 v0.4s, v1.8h, v1.h[8]
3121 // CHECK-ERROR:                                  ^
3122 // CHECK-ERROR: error: invalid operand for instruction
3123 // CHECK-ERROR:        smlal2 v0.4s, v1.8h, v16.h[2]
3124 // CHECK-ERROR:                                 ^
3125 // CHECK-ERROR: error: invalid operand for instruction
3126 // CHECK-ERROR:        smlal2 v0.2s, v1.4s, v1.s[2]
3127 // CHECK-ERROR:               ^
3128 // CHECK-ERROR: vector lane must be an integer in range
3129 // CHECK-ERROR:        smlal2 v0.2d, v1.4s, v1.s[4]
3130 // CHECK-ERROR:                                  ^
3131 // CHECK-ERROR: vector lane must be an integer in range
3132 // CHECK-ERROR:        smlal2 v0.2d, v1.4s, v22.s[4]
3133 // CHECK-ERROR:                                   ^
3134
3135       smlsl v0.4h, v1.4h, v2.h[2]
3136       smlsl v0.4s, v1.4h, v2.h[8]
3137       smlsl v0.4s, v1.4h, v16.h[2]
3138       smlsl v0.2s, v1.2s, v2.s[1]
3139       smlsl v0.2d, v1.2s, v2.s[4]
3140       smlsl v0.2d, v1.2s, v22.s[4]
3141       smlsl2 v0.4h, v1.8h, v1.h[2]
3142       smlsl2 v0.4s, v1.8h, v1.h[8]
3143       smlsl2 v0.4s, v1.8h, v16.h[2]
3144       smlsl2 v0.2s, v1.4s, v1.s[2]
3145       smlsl2 v0.2d, v1.4s, v1.s[4]
3146       smlsl2 v0.2d, v1.4s, v22.s[4]
3147
3148 // CHECK-ERROR: error: invalid operand for instruction
3149 // CHECK-ERROR:        smlsl v0.4h, v1.4h, v2.h[2]
3150 // CHECK-ERROR:              ^
3151 // CHECK-ERROR: vector lane must be an integer in range
3152 // CHECK-ERROR:        smlsl v0.4s, v1.4h, v2.h[8]
3153 // CHECK-ERROR:                                 ^
3154 // CHECK-ERROR: error: invalid operand for instruction
3155 // CHECK-ERROR:        smlsl v0.4s, v1.4h, v16.h[2]
3156 // CHECK-ERROR:                            ^
3157 // CHECK-ERROR: error: invalid operand for instruction
3158 // CHECK-ERROR:        smlsl v0.2s, v1.2s, v2.s[1]
3159 // CHECK-ERROR:                                 ^
3160 // CHECK-ERROR: vector lane must be an integer in range
3161 // CHECK-ERROR:        smlsl v0.2d, v1.2s, v2.s[4]
3162 // CHECK-ERROR:                                 ^
3163 // CHECK-ERROR: vector lane must be an integer in range
3164 // CHECK-ERROR:        smlsl v0.2d, v1.2s, v22.s[4]
3165 // CHECK-ERROR:                                  ^
3166 // CHECK-ERROR: error: invalid operand for instruction
3167 // CHECK-ERROR:        smlsl2 v0.4h, v1.8h, v1.h[2]
3168 // CHECK-ERROR:               ^
3169 // CHECK-ERROR: vector lane must be an integer in range
3170 // CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v1.h[8]
3171 // CHECK-ERROR:                                  ^
3172 // CHECK-ERROR: error: invalid operand for instruction
3173 // CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v16.h[2]
3174 // CHECK-ERROR:                                 ^
3175 // CHECK-ERROR: error: invalid operand for instruction
3176 // CHECK-ERROR:        smlsl2 v0.2s, v1.4s, v1.s[2]
3177 // CHECK-ERROR:               ^
3178 // CHECK-ERROR: vector lane must be an integer in range
3179 // CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v1.s[4]
3180 // CHECK-ERROR:                                  ^
3181 // CHECK-ERROR: vector lane must be an integer in range
3182 // CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v22.s[4]
3183 // CHECK-ERROR:                                   ^
3184
3185       umlal v0.4h, v1.4h, v2.h[2]
3186       umlal v0.4s, v1.4h, v2.h[8]
3187       umlal v0.4s, v1.4h, v16.h[2]
3188       umlal v0.2s, v1.2s, v2.s[1]
3189       umlal v0.2d, v1.2s, v2.s[4]
3190       umlal v0.2d, v1.2s, v22.s[4]
3191       umlal2 v0.4h, v1.8h, v1.h[2]
3192       umlal2 v0.4s, v1.8h, v1.h[8]
3193       umlal2 v0.4s, v1.8h, v16.h[2]
3194       umlal2 v0.2s, v1.4s, v1.s[2]
3195       umlal2 v0.2d, v1.4s, v1.s[4]
3196       umlal2 v0.2d, v1.4s, v22.s[4]
3197
3198 // CHECK-ERROR: error: invalid operand for instruction
3199 // CHECK-ERROR:        umlal v0.4h, v1.4h, v2.h[2]
3200 // CHECK-ERROR:              ^
3201 // CHECK-ERROR: vector lane must be an integer in range
3202 // CHECK-ERROR:        umlal v0.4s, v1.4h, v2.h[8]
3203 // CHECK-ERROR:                                 ^
3204 // CHECK-ERROR: error: invalid operand for instruction
3205 // CHECK-ERROR:        umlal v0.4s, v1.4h, v16.h[2]
3206 // CHECK-ERROR:                            ^
3207 // CHECK-ERROR: error: invalid operand for instruction
3208 // CHECK-ERROR:        umlal v0.2s, v1.2s, v2.s[1]
3209 // CHECK-ERROR:                                 ^
3210 // CHECK-ERROR: vector lane must be an integer in range
3211 // CHECK-ERROR:        umlal v0.2d, v1.2s, v2.s[4]
3212 // CHECK-ERROR:                                 ^
3213 // CHECK-ERROR: vector lane must be an integer in range
3214 // CHECK-ERROR:        umlal v0.2d, v1.2s, v22.s[4]
3215 // CHECK-ERROR:                                  ^
3216 // CHECK-ERROR: error: invalid operand for instruction
3217 // CHECK-ERROR:        umlal2 v0.4h, v1.8h, v1.h[2]
3218 // CHECK-ERROR:               ^
3219 // CHECK-ERROR: vector lane must be an integer in range
3220 // CHECK-ERROR:        umlal2 v0.4s, v1.8h, v1.h[8]
3221 // CHECK-ERROR:                                  ^
3222 // CHECK-ERROR: error: invalid operand for instruction
3223 // CHECK-ERROR:        umlal2 v0.4s, v1.8h, v16.h[2]
3224 // CHECK-ERROR:                                 ^
3225 // CHECK-ERROR: error: invalid operand for instruction
3226 // CHECK-ERROR:        umlal2 v0.2s, v1.4s, v1.s[2]
3227 // CHECK-ERROR:               ^
3228 // CHECK-ERROR: vector lane must be an integer in range
3229 // CHECK-ERROR:        umlal2 v0.2d, v1.4s, v1.s[4]
3230 // CHECK-ERROR:                                  ^
3231 // CHECK-ERROR: vector lane must be an integer in range
3232 // CHECK-ERROR:        umlal2 v0.2d, v1.4s, v22.s[4]
3233 // CHECK-ERROR:                                   ^
3234
3235       umlsl v0.4h, v1.4h, v2.h[2]
3236       umlsl v0.4s, v1.4h, v2.h[8]
3237       umlsl v0.4s, v1.4h, v16.h[2]
3238       umlsl v0.2s, v1.2s, v2.s[3]
3239       umlsl v0.2d, v1.2s, v2.s[4]
3240       umlsl v0.2d, v1.2s, v22.s[4]
3241       umlsl2 v0.4h, v1.8h, v1.h[2]
3242       umlsl2 v0.4s, v1.8h, v1.h[8]
3243       umlsl2 v0.4s, v1.8h, v16.h[2]
3244       umlsl2 v0.2s, v1.4s, v1.s[2]
3245       umlsl2 v0.2d, v1.4s, v1.s[4]
3246       umlsl2 v0.2d, v1.4s, v22.s[4]
3247
3248 // CHECK-ERROR: error: invalid operand for instruction
3249 // CHECK-ERROR:        umlsl v0.4h, v1.4h, v2.h[2]
3250 // CHECK-ERROR:              ^
3251 // CHECK-ERROR: vector lane must be an integer in range
3252 // CHECK-ERROR:        umlsl v0.4s, v1.4h, v2.h[8]
3253 // CHECK-ERROR:                                 ^
3254 // CHECK-ERROR: error: invalid operand for instruction
3255 // CHECK-ERROR:        umlsl v0.4s, v1.4h, v16.h[2]
3256 // CHECK-ERROR:                            ^
3257 // CHECK-ERROR: error: invalid operand for instruction
3258 // CHECK-ERROR:        umlsl v0.2s, v1.2s, v2.s[3]
3259 // CHECK-ERROR:                                 ^
3260 // CHECK-ERROR: vector lane must be an integer in range
3261 // CHECK-ERROR:        umlsl v0.2d, v1.2s, v2.s[4]
3262 // CHECK-ERROR:                                 ^
3263 // CHECK-ERROR: vector lane must be an integer in range
3264 // CHECK-ERROR:        umlsl v0.2d, v1.2s, v22.s[4]
3265 // CHECK-ERROR:                                  ^
3266 // CHECK-ERROR: error: invalid operand for instruction
3267 // CHECK-ERROR:        umlsl2 v0.4h, v1.8h, v1.h[2]
3268 // CHECK-ERROR:               ^
3269 // CHECK-ERROR: vector lane must be an integer in range
3270 // CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v1.h[8]
3271 // CHECK-ERROR:                                  ^
3272 // CHECK-ERROR: error: invalid operand for instruction
3273 // CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v16.h[2]
3274 // CHECK-ERROR:                                 ^
3275 // CHECK-ERROR: error: invalid operand for instruction
3276 // CHECK-ERROR:        umlsl2 v0.2s, v1.4s, v1.s[2]
3277 // CHECK-ERROR:               ^
3278 // CHECK-ERROR: vector lane must be an integer in range
3279 // CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v1.s[4]
3280 // CHECK-ERROR:                                  ^
3281 // CHECK-ERROR: vector lane must be an integer in range
3282 // CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v22.s[4]
3283 // CHECK-ERROR:                                   ^
3284
3285       sqdmlal v0.4h, v1.4h, v2.h[2]
3286       sqdmlal v0.4s, v1.4h, v2.h[8]
3287       sqdmlal v0.4s, v1.4h, v16.h[2]
3288       sqdmlal v0.2s, v1.2s, v2.s[3]
3289       sqdmlal v0.2d, v1.2s, v2.s[4]
3290       sqdmlal v0.2d, v1.2s, v22.s[4]
3291       sqdmlal2 v0.4h, v1.8h, v1.h[2]
3292       sqdmlal2 v0.4s, v1.8h, v1.h[8]
3293       sqdmlal2 v0.4s, v1.8h, v16.h[2]
3294       sqdmlal2 v0.2s, v1.4s, v1.s[2]
3295       sqdmlal2 v0.2d, v1.4s, v1.s[4]
3296       sqdmlal2 v0.2d, v1.4s, v22.s[4]
3297
3298 // CHECK-ERROR: error: invalid operand for instruction
3299 // CHECK-ERROR:        sqdmlal v0.4h, v1.4h, v2.h[2]
3300 // CHECK-ERROR:                ^
3301 // CHECK-ERROR: vector lane must be an integer in range
3302 // CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v2.h[8]
3303 // CHECK-ERROR:                                   ^
3304 // CHECK-ERROR: error: invalid operand for instruction
3305 // CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v16.h[2]
3306 // CHECK-ERROR:                              ^
3307 // CHECK-ERROR: error: invalid operand for instruction
3308 // CHECK-ERROR:        sqdmlal v0.2s, v1.2s, v2.s[3]
3309 // CHECK-ERROR:                                   ^
3310 // CHECK-ERROR: vector lane must be an integer in range
3311 // CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v2.s[4]
3312 // CHECK-ERROR:                                   ^
3313 // CHECK-ERROR: vector lane must be an integer in range
3314 // CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v22.s[4]
3315 // CHECK-ERROR:                                    ^
3316 // CHECK-ERROR: error: invalid operand for instruction
3317 // CHECK-ERROR:        sqdmlal2 v0.4h, v1.8h, v1.h[2]
3318 // CHECK-ERROR:                 ^
3319 // CHECK-ERROR: vector lane must be an integer in range
3320 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v1.h[8]
3321 // CHECK-ERROR:                                    ^
3322 // CHECK-ERROR: error: invalid operand for instruction
3323 // CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v16.h[2]
3324 // CHECK-ERROR:                                   ^
3325 // CHECK-ERROR: error: invalid operand for instruction
3326 // CHECK-ERROR:        sqdmlal2 v0.2s, v1.4s, v1.s[2]
3327 // CHECK-ERROR:                 ^
3328 // CHECK-ERROR: vector lane must be an integer in range
3329 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v1.s[4]
3330 // CHECK-ERROR:                                    ^
3331 // CHECK-ERROR: vector lane must be an integer in range
3332 // CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v22.s[4]
3333 // CHECK-ERROR:                                     ^
3334
3335       sqdmlsl v0.4h, v1.4h, v2.h[2]
3336       sqdmlsl v0.4s, v1.4h, v2.h[8]
3337       sqdmlsl v0.4s, v1.4h, v16.h[2]
3338       sqdmlsl v0.2s, v1.2s, v2.s[3]
3339       sqdmlsl v0.2d, v1.2s, v2.s[4]
3340       sqdmlsl v0.2d, v1.2s, v22.s[4]
3341       sqdmlsl2 v0.4h, v1.8h, v1.h[2]
3342       sqdmlsl2 v0.4s, v1.8h, v1.h[8]
3343       sqdmlsl2 v0.4s, v1.8h, v16.h[2]
3344       sqdmlsl2 v0.2s, v1.4s, v1.s[2]
3345       sqdmlsl2 v0.2d, v1.4s, v1.s[4]
3346       sqdmlsl2 v0.2d, v1.4s, v22.s[4]
3347
3348 // CHECK-ERROR: error: invalid operand for instruction
3349 // CHECK-ERROR:        sqdmlsl v0.4h, v1.4h, v2.h[2]
3350 // CHECK-ERROR:                ^
3351 // CHECK-ERROR: vector lane must be an integer in range
3352 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v2.h[8]
3353 // CHECK-ERROR:                                   ^
3354 // CHECK-ERROR: error: invalid operand for instruction
3355 // CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v16.h[2]
3356 // CHECK-ERROR:                              ^
3357 // CHECK-ERROR: error: invalid operand for instruction
3358 // CHECK-ERROR:        sqdmlsl v0.2s, v1.2s, v2.s[3]
3359 // CHECK-ERROR:                                   ^
3360 // CHECK-ERROR: vector lane must be an integer in range
3361 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v2.s[4]
3362 // CHECK-ERROR:                                   ^
3363 // CHECK-ERROR: vector lane must be an integer in range
3364 // CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v22.s[4]
3365 // CHECK-ERROR:                                    ^
3366 // CHECK-ERROR: error: invalid operand for instruction
3367 // CHECK-ERROR:        sqdmlsl2 v0.4h, v1.8h, v1.h[2]
3368 // CHECK-ERROR:                 ^
3369 // CHECK-ERROR: vector lane must be an integer in range
3370 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v1.h[8]
3371 // CHECK-ERROR:                                    ^
3372 // CHECK-ERROR: error: invalid operand for instruction
3373 // CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v16.h[2]
3374 // CHECK-ERROR:                                   ^
3375 // CHECK-ERROR: error: invalid operand for instruction
3376 // CHECK-ERROR:        sqdmlsl2 v0.2s, v1.4s, v1.s[2]
3377 // CHECK-ERROR:                 ^
3378 // CHECK-ERROR: vector lane must be an integer in range
3379 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v1.s[4]
3380 // CHECK-ERROR:                                    ^
3381 // CHECK-ERROR: vector lane must be an integer in range
3382 // CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v22.s[4]
3383 // CHECK-ERROR:                                     ^
3384
3385       mul v0.4h, v1.4h, v2.h[8]
3386       mul v0.4h, v1.4h, v16.h[8]
3387       mul v0.8h, v1.8h, v2.h[8]
3388       mul v0.8h, v1.8h, v16.h[8]
3389       mul v0.2s, v1.2s, v2.s[4]
3390       mul v0.2s, v1.2s, v22.s[4]
3391       mul v0.4s, v1.4s, v2.s[4]
3392       mul v0.4s, v1.4s, v22.s[4]
3393       mul v0.2d, v1.2d, v2.d[1]
3394
3395 // CHECK-ERROR: vector lane must be an integer in range
3396 // CHECK-ERROR:        mul v0.4h, v1.4h, v2.h[8]
3397 // CHECK-ERROR:                               ^
3398 // CHECK-ERROR: error: invalid operand for instruction
3399 // CHECK-ERROR:        mul v0.4h, v1.4h, v16.h[8]
3400 // CHECK-ERROR:                                ^
3401 // CHECK-ERROR: vector lane must be an integer in range
3402 // CHECK-ERROR:        mul v0.8h, v1.8h, v2.h[8]
3403 // CHECK-ERROR:                               ^
3404 // CHECK-ERROR: invalid operand for instruction
3405 // CHECK-ERROR:        mul v0.8h, v1.8h, v16.h[8]
3406 // CHECK-ERROR:                                ^
3407 // CHECK-ERROR: vector lane must be an integer in range
3408 // CHECK-ERROR:        mul v0.2s, v1.2s, v2.s[4]
3409 // CHECK-ERROR:                               ^
3410 // CHECK-ERROR: vector lane must be an integer in range
3411 // CHECK-ERROR:        mul v0.2s, v1.2s, v22.s[4]
3412 // CHECK-ERROR:                                ^
3413 // CHECK-ERROR: vector lane must be an integer in range
3414 // CHECK-ERROR:        mul v0.4s, v1.4s, v2.s[4]
3415 // CHECK-ERROR:                               ^
3416 // CHECK-ERROR: vector lane must be an integer in range
3417 // CHECK-ERROR:        mul v0.4s, v1.4s, v22.s[4]
3418 // CHECK-ERROR:                                ^
3419
3420       fmul v0.4h, v1.4h, v2.h[4]
3421       fmul v0.2s, v1.2s, v2.s[4]
3422       fmul v0.2s, v1.2s, v22.s[4]
3423       fmul v0.4s, v1.4s, v2.s[4]
3424       fmul v0.4s, v1.4s, v22.s[4]
3425       fmul v0.2d, v1.2d, v2.d[2]
3426       fmul v0.2d, v1.2d, v22.d[2]
3427
3428 // CHECK-ERROR: error: invalid operand for instruction
3429 // CHECK-ERROR:        mul v0.2d, v1.2d, v2.d[1]
3430 // CHECK-ERROR:               ^
3431 // CHECK-ERROR: error: instruction requires: fullfp16
3432 // CHECK-ERROR:        fmul v0.4h, v1.4h, v2.h[4]
3433 // CHECK-ERROR:                ^
3434 // CHECK-ERROR: vector lane must be an integer in range
3435 // CHECK-ERROR:        fmul v0.2s, v1.2s, v2.s[4]
3436 // CHECK-ERROR:                                ^
3437 // CHECK-ERROR: vector lane must be an integer in range
3438 // CHECK-ERROR:        fmul v0.2s, v1.2s, v22.s[4]
3439 // CHECK-ERROR:                                 ^
3440 // CHECK-ERROR: vector lane must be an integer in range
3441 // CHECK-ERROR:        fmul v0.4s, v1.4s, v2.s[4]
3442 // CHECK-ERROR:                                ^
3443 // CHECK-ERROR: vector lane must be an integer in range
3444 // CHECK-ERROR:        fmul v0.4s, v1.4s, v22.s[4]
3445 // CHECK-ERROR:                                 ^
3446 // CHECK-ERROR: vector lane must be an integer in range
3447 // CHECK-ERROR:        fmul v0.2d, v1.2d, v2.d[2]
3448 // CHECK-ERROR:                                ^
3449 // CHECK-ERROR: vector lane must be an integer in range
3450 // CHECK-ERROR:        fmul v0.2d, v1.2d, v22.d[2]
3451 // CHECK-ERROR:                                 ^
3452
3453       fmulx v0.4h, v1.4h, v2.h[4]
3454       fmulx v0.2s, v1.2s, v2.s[4]
3455       fmulx v0.2s, v1.2s, v22.s[4]
3456       fmulx v0.4s, v1.4s, v2.s[4]
3457       fmulx v0.4s, v1.4s, v22.s[4]
3458       fmulx v0.2d, v1.2d, v2.d[2]
3459       fmulx v0.2d, v1.2d, v22.d[2]
3460
3461 // CHECK-ERROR: error: instruction requires: fullfp16
3462 // CHECK-ERROR:        fmulx v0.4h, v1.4h, v2.h[4]
3463 // CHECK-ERROR:                 ^
3464 // CHECK-ERROR: vector lane must be an integer in range
3465 // CHECK-ERROR:        fmulx v0.2s, v1.2s, v2.s[4]
3466 // CHECK-ERROR:                                 ^
3467 // CHECK-ERROR: vector lane must be an integer in range
3468 // CHECK-ERROR:        fmulx v0.2s, v1.2s, v22.s[4]
3469 // CHECK-ERROR:                                  ^
3470 // CHECK-ERROR: vector lane must be an integer in range
3471 // CHECK-ERROR:        fmulx v0.4s, v1.4s, v2.s[4]
3472 // CHECK-ERROR:                                 ^
3473 // CHECK-ERROR: vector lane must be an integer in range
3474 // CHECK-ERROR:        fmulx v0.4s, v1.4s, v22.s[4]
3475 // CHECK-ERROR:                                  ^
3476 // CHECK-ERROR: vector lane must be an integer in range
3477 // CHECK-ERROR:        fmulx v0.2d, v1.2d, v2.d[2]
3478 // CHECK-ERROR:                                 ^
3479 // CHECK-ERROR: vector lane must be an integer in range
3480 // CHECK-ERROR:        fmulx v0.2d, v1.2d, v22.d[2]
3481 // CHECK-ERROR:                                  ^
3482
3483       smull v0.4h, v1.4h, v2.h[2]
3484       smull v0.4s, v1.4h, v2.h[8]
3485       smull v0.4s, v1.4h, v16.h[4]
3486       smull v0.2s, v1.2s, v2.s[2]
3487       smull v0.2d, v1.2s, v2.s[4]
3488       smull v0.2d, v1.2s, v22.s[4]
3489       smull2 v0.4h, v1.8h, v2.h[2]
3490       smull2 v0.4s, v1.8h, v2.h[8]
3491       smull2 v0.4s, v1.8h, v16.h[4]
3492       smull2 v0.2s, v1.4s, v2.s[2]
3493       smull2 v0.2d, v1.4s, v2.s[4]
3494       smull2 v0.2d, v1.4s, v22.s[4]
3495
3496 // CHECK-ERROR: error: invalid operand for instruction
3497 // CHECK-ERROR:        smull v0.4h, v1.4h, v2.h[2]
3498 // CHECK-ERROR:              ^
3499 // CHECK-ERROR: vector lane must be an integer in range
3500 // CHECK-ERROR:        smull v0.4s, v1.4h, v2.h[8]
3501 // CHECK-ERROR:                                 ^
3502 // CHECK-ERROR: error: invalid operand for instruction
3503 // CHECK-ERROR:        smull v0.4s, v1.4h, v16.h[4]
3504 // CHECK-ERROR:                            ^
3505 // CHECK-ERROR: error: invalid operand for instruction
3506 // CHECK-ERROR:        smull v0.2s, v1.2s, v2.s[2]
3507 // CHECK-ERROR:              ^
3508 // CHECK-ERROR: vector lane must be an integer in range
3509 // CHECK-ERROR:        smull v0.2d, v1.2s, v2.s[4]
3510 // CHECK-ERROR:                                 ^
3511 // CHECK-ERROR: vector lane must be an integer in range
3512 // CHECK-ERROR:        smull v0.2d, v1.2s, v22.s[4]
3513 // CHECK-ERROR:                                  ^
3514 // CHECK-ERROR: error: invalid operand for instruction
3515 // CHECK-ERROR:        smull2 v0.4h, v1.8h, v2.h[2]
3516 // CHECK-ERROR:               ^
3517 // CHECK-ERROR: vector lane must be an integer in range
3518 // CHECK-ERROR:        smull2 v0.4s, v1.8h, v2.h[8]
3519 // CHECK-ERROR:                                  ^
3520 // CHECK-ERROR: error: invalid operand for instruction
3521 // CHECK-ERROR:        smull2 v0.4s, v1.8h, v16.h[4]
3522 // CHECK-ERROR:                                 ^
3523 // CHECK-ERROR: error: invalid operand for instruction
3524 // CHECK-ERROR:        smull2 v0.2s, v1.4s, v2.s[2]
3525 // CHECK-ERROR:               ^
3526 // CHECK-ERROR: vector lane must be an integer in range
3527 // CHECK-ERROR:        smull2 v0.2d, v1.4s, v2.s[4]
3528 // CHECK-ERROR:                                  ^
3529 // CHECK-ERROR: vector lane must be an integer in range
3530 // CHECK-ERROR:        smull2 v0.2d, v1.4s, v22.s[4]
3531 // CHECK-ERROR:                                   ^
3532
3533       umull v0.4h, v1.4h, v2.h[2]
3534       umull v0.4s, v1.4h, v2.h[8]
3535       umull v0.4s, v1.4h, v16.h[4]
3536       umull v0.2s, v1.2s, v2.s[2]
3537       umull v0.2d, v1.2s, v2.s[4]
3538       umull v0.2d, v1.2s, v22.s[4]
3539       umull2 v0.4h, v1.8h, v2.h[2]
3540       umull2 v0.4s, v1.8h, v2.h[8]
3541       umull2 v0.4s, v1.8h, v16.h[4]
3542       umull2 v0.2s, v1.4s, v2.s[2]
3543       umull2 v0.2d, v1.4s, v2.s[4]
3544       umull2 v0.2d, v1.4s, v22.s[4]
3545
3546 // CHECK-ERROR: error: invalid operand for instruction
3547 // CHECK-ERROR:        umull v0.4h, v1.4h, v2.h[2]
3548 // CHECK-ERROR:              ^
3549 // CHECK-ERROR: vector lane must be an integer in range
3550 // CHECK-ERROR:        umull v0.4s, v1.4h, v2.h[8]
3551 // CHECK-ERROR:                                 ^
3552 // CHECK-ERROR: error: invalid operand for instruction
3553 // CHECK-ERROR:        umull v0.4s, v1.4h, v16.h[4]
3554 // CHECK-ERROR:                            ^
3555 // CHECK-ERROR: error: invalid operand for instruction
3556 // CHECK-ERROR:        umull v0.2s, v1.2s, v2.s[2]
3557 // CHECK-ERROR:              ^
3558 // CHECK-ERROR: vector lane must be an integer in range
3559 // CHECK-ERROR:        umull v0.2d, v1.2s, v2.s[4]
3560 // CHECK-ERROR:                                 ^
3561 // CHECK-ERROR: vector lane must be an integer in range
3562 // CHECK-ERROR:        umull v0.2d, v1.2s, v22.s[4]
3563 // CHECK-ERROR:                                  ^
3564 // CHECK-ERROR: error: invalid operand for instruction
3565 // CHECK-ERROR:        umull2 v0.4h, v1.8h, v2.h[2]
3566 // CHECK-ERROR:               ^
3567 // CHECK-ERROR: vector lane must be an integer in range
3568 // CHECK-ERROR:        umull2 v0.4s, v1.8h, v2.h[8]
3569 // CHECK-ERROR:                                  ^
3570 // CHECK-ERROR: error: invalid operand for instruction
3571 // CHECK-ERROR:        umull2 v0.4s, v1.8h, v16.h[4]
3572 // CHECK-ERROR:                                 ^
3573 // CHECK-ERROR: error: invalid operand for instruction
3574 // CHECK-ERROR:        umull2 v0.2s, v1.4s, v2.s[2]
3575 // CHECK-ERROR:               ^
3576 // CHECK-ERROR: vector lane must be an integer in range
3577 // CHECK-ERROR:        umull2 v0.2d, v1.4s, v2.s[4]
3578 // CHECK-ERROR:                                  ^
3579 // CHECK-ERROR: vector lane must be an integer in range
3580 // CHECK-ERROR:        umull2 v0.2d, v1.4s, v22.s[4]
3581 // CHECK-ERROR:                                   ^
3582
3583       sqdmull v0.4h, v1.4h, v2.h[2]
3584       sqdmull v0.4s, v1.4h, v2.h[8]
3585       sqdmull v0.4s, v1.4h, v16.h[4]
3586       sqdmull v0.2s, v1.2s, v2.s[2]
3587       sqdmull v0.2d, v1.2s, v2.s[4]
3588       sqdmull v0.2d, v1.2s, v22.s[4]
3589       sqdmull2 v0.4h, v1.8h, v2.h[2]
3590       sqdmull2 v0.4s, v1.8h, v2.h[8]
3591       sqdmull2 v0.4s, v1.8h, v16.h[4]
3592       sqdmull2 v0.2s, v1.4s, v2.s[2]
3593       sqdmull2 v0.2d, v1.4s, v2.s[4]
3594       sqdmull2 v0.2d, v1.4s, v22.s[4]
3595
3596 // CHECK-ERROR: error: invalid operand for instruction
3597 // CHECK-ERROR:        sqdmull v0.4h, v1.4h, v2.h[2]
3598 // CHECK-ERROR:                ^
3599 // CHECK-ERROR: vector lane must be an integer in range
3600 // CHECK-ERROR:        sqdmull v0.4s, v1.4h, v2.h[8]
3601 // CHECK-ERROR:                                   ^
3602 // CHECK-ERROR: error: invalid operand for instruction
3603 // CHECK-ERROR:        sqdmull v0.4s, v1.4h, v16.h[4]
3604 // CHECK-ERROR:                              ^
3605 // CHECK-ERROR: error: invalid operand for instruction
3606 // CHECK-ERROR:        sqdmull v0.2s, v1.2s, v2.s[2]
3607 // CHECK-ERROR:                ^
3608 // CHECK-ERROR: vector lane must be an integer in range
3609 // CHECK-ERROR:        sqdmull v0.2d, v1.2s, v2.s[4]
3610 // CHECK-ERROR:                                   ^
3611 // CHECK-ERROR: vector lane must be an integer in range
3612 // CHECK-ERROR:        sqdmull v0.2d, v1.2s, v22.s[4]
3613 // CHECK-ERROR:                                    ^
3614 // CHECK-ERROR: error: invalid operand for instruction
3615 // CHECK-ERROR:        sqdmull2 v0.4h, v1.8h, v2.h[2]
3616 // CHECK-ERROR:                 ^
3617 // CHECK-ERROR: vector lane must be an integer in range
3618 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v2.h[8]
3619 // CHECK-ERROR:                                    ^
3620 // CHECK-ERROR: error: invalid operand for instruction
3621 // CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v16.h[4]
3622 // CHECK-ERROR:                                   ^
3623 // CHECK-ERROR: error: invalid operand for instruction
3624 // CHECK-ERROR:        sqdmull2 v0.2s, v1.4s, v2.s[2]
3625 // CHECK-ERROR:                 ^
3626 // CHECK-ERROR: vector lane must be an integer in range
3627 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v2.s[4]
3628 // CHECK-ERROR:                                    ^
3629 // CHECK-ERROR: vector lane must be an integer in range
3630 // CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v22.s[4]
3631 // CHECK-ERROR:                                     ^
3632
3633       sqdmulh v0.4h, v1.4h, v2.h[8]
3634       sqdmulh v0.4h, v1.4h, v16.h[2]
3635       sqdmulh v0.8h, v1.8h, v2.h[8]
3636       sqdmulh v0.8h, v1.8h, v16.h[2]
3637       sqdmulh v0.2s, v1.2s, v2.s[4]
3638       sqdmulh v0.2s, v1.2s, v22.s[4]
3639       sqdmulh v0.4s, v1.4s, v2.s[4]
3640       sqdmulh v0.4s, v1.4s, v22.s[4]
3641       sqdmulh v0.2d, v1.2d, v22.d[1]
3642
3643 // CHECK-ERROR: vector lane must be an integer in range
3644 // CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v2.h[8]
3645 // CHECK-ERROR:                                   ^
3646 // CHECK-ERROR: error: invalid operand for instruction
3647 // CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v16.h[2]
3648 // CHECK-ERROR:                              ^
3649 // CHECK-ERROR: vector lane must be an integer in range
3650 // CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v2.h[8]
3651 // CHECK-ERROR:                                   ^
3652 // CHECK-ERROR: error: invalid operand for instruction
3653 // CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v16.h[2]
3654 // CHECK-ERROR:                                  ^
3655 // CHECK-ERROR: vector lane must be an integer in range
3656 // CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v2.s[4]
3657 // CHECK-ERROR:                                   ^
3658 // CHECK-ERROR: vector lane must be an integer in range
3659 // CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v22.s[4]
3660 // CHECK-ERROR:                                    ^
3661 // CHECK-ERROR: vector lane must be an integer in range
3662 // CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v2.s[4]
3663 // CHECK-ERROR:                                   ^
3664 // CHECK-ERROR: vector lane must be an integer in range
3665 // CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v22.s[4]
3666 // CHECK-ERROR:                                    ^
3667 // CHECK-ERROR: error: invalid operand for instruction
3668 // CHECK-ERROR:        sqdmulh v0.2d, v1.2d, v22.d[1]
3669 // CHECK-ERROR:                   ^
3670
3671       sqrdmulh v0.4h, v1.4h, v2.h[8]
3672       sqrdmulh v0.4h, v1.4h, v16.h[2]
3673       sqrdmulh v0.8h, v1.8h, v2.h[8]
3674       sqrdmulh v0.8h, v1.8h, v16.h[2]
3675       sqrdmulh v0.2s, v1.2s, v2.s[4]
3676       sqrdmulh v0.2s, v1.2s, v22.s[4]
3677       sqrdmulh v0.4s, v1.4s, v2.s[4]
3678       sqrdmulh v0.4s, v1.4s, v22.s[4]
3679       sqrdmulh v0.2d, v1.2d, v22.d[1]
3680
3681 // CHECK-ERROR: vector lane must be an integer in range
3682 // CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v2.h[8]
3683 // CHECK-ERROR:                                    ^
3684 // CHECK-ERROR: error: invalid operand for instruction
3685 // CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v16.h[2]
3686 // CHECK-ERROR:                               ^
3687 // CHECK-ERROR: vector lane must be an integer in range
3688 // CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v2.h[8]
3689 // CHECK-ERROR:                                    ^
3690 // CHECK-ERROR: error: invalid operand for instruction
3691 // CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v16.h[2]
3692 // CHECK-ERROR:                                   ^
3693 // CHECK-ERROR: vector lane must be an integer in range
3694 // CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v2.s[4]
3695 // CHECK-ERROR:                                    ^
3696 // CHECK-ERROR: vector lane must be an integer in range
3697 // CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v22.s[4]
3698 // CHECK-ERROR:                                     ^
3699 // CHECK-ERROR: vector lane must be an integer in range
3700 // CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v2.s[4]
3701 // CHECK-ERROR:                                    ^
3702 // CHECK-ERROR: vector lane must be an integer in range
3703 // CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v22.s[4]
3704 // CHECK-ERROR:                                     ^
3705 // CHECK-ERROR: error: invalid operand for instruction
3706 // CHECK-ERROR:        sqrdmulh v0.2d, v1.2d, v22.d[1]
3707 // CHECK-ERROR:                    ^
3708
3709 //----------------------------------------------------------------------
3710 // Across vectors
3711 //----------------------------------------------------------------------
3712
3713         saddlv b0, v1.8b
3714         saddlv b0, v1.16b
3715         saddlv h0, v1.4h
3716         saddlv h0, v1.8h
3717         saddlv s0, v1.2s
3718         saddlv s0, v1.4s
3719         saddlv d0, v1.2s
3720
3721 // CHECK-ERROR: error: invalid operand for instruction
3722 // CHECK-ERROR:        saddlv b0, v1.8b
3723 // CHECK-ERROR:               ^
3724 // CHECK-ERROR: error: invalid operand for instruction
3725 // CHECK-ERROR:        saddlv b0, v1.16b
3726 // CHECK-ERROR:               ^
3727 // CHECK-ERROR: error: invalid operand for instruction
3728 // CHECK-ERROR:        saddlv h0, v1.4h
3729 // CHECK-ERROR:                      ^
3730 // CHECK-ERROR: error: invalid operand for instruction
3731 // CHECK-ERROR:        saddlv h0, v1.8h
3732 // CHECK-ERROR:                      ^
3733 // CHECK-ERROR: error: invalid operand for instruction
3734 // CHECK-ERROR:        saddlv s0, v1.2s
3735 // CHECK-ERROR:                      ^
3736 // CHECK-ERROR: error: invalid operand for instruction
3737 // CHECK-ERROR:        saddlv s0, v1.4s
3738 // CHECK-ERROR:                      ^
3739 // CHECK-ERROR: error: invalid operand for instruction
3740 // CHECK-ERROR:        saddlv d0, v1.2s
3741 // CHECK-ERROR:                   ^
3742
3743         uaddlv b0, v1.8b
3744         uaddlv b0, v1.16b
3745         uaddlv h0, v1.4h
3746         uaddlv h0, v1.8h
3747         uaddlv s0, v1.2s
3748         uaddlv s0, v1.4s
3749         uaddlv d0, v1.2s
3750
3751 // CHECK-ERROR: error: invalid operand for instruction
3752 // CHECK-ERROR:        uaddlv b0, v1.8b
3753 // CHECK-ERROR:               ^
3754 // CHECK-ERROR: error: invalid operand for instruction
3755 // CHECK-ERROR:        uaddlv b0, v1.16b
3756 // CHECK-ERROR:               ^
3757 // CHECK-ERROR: error: invalid operand for instruction
3758 // CHECK-ERROR:        uaddlv h0, v1.4h
3759 // CHECK-ERROR:                      ^
3760 // CHECK-ERROR: error: invalid operand for instruction
3761 // CHECK-ERROR:        uaddlv h0, v1.8h
3762 // CHECK-ERROR:                      ^
3763 // CHECK-ERROR: error: invalid operand for instruction
3764 // CHECK-ERROR:        uaddlv s0, v1.2s
3765 // CHECK-ERROR:                      ^
3766 // CHECK-ERROR: error: invalid operand for instruction
3767 // CHECK-ERROR:        uaddlv s0, v1.4s
3768 // CHECK-ERROR:                      ^
3769 // CHECK-ERROR: error: invalid operand for instruction
3770 // CHECK-ERROR:        uaddlv d0, v1.2s
3771 // CHECK-ERROR:                   ^
3772
3773         smaxv s0, v1.2s
3774         sminv s0, v1.2s
3775         umaxv s0, v1.2s
3776         uminv s0, v1.2s
3777         addv s0, v1.2s
3778
3779 // CHECK-ERROR: error: invalid operand for instruction
3780 // CHECK-ERROR:        smaxv s0, v1.2s
3781 // CHECK-ERROR:                  ^
3782 // CHECK-ERROR: error: invalid operand for instruction
3783 // CHECK-ERROR:        sminv s0, v1.2s
3784 // CHECK-ERROR:                  ^
3785 // CHECK-ERROR: error: invalid operand for instruction
3786 // CHECK-ERROR:        umaxv s0, v1.2s
3787 // CHECK-ERROR:                  ^
3788 // CHECK-ERROR: error: invalid operand for instruction
3789 // CHECK-ERROR:        uminv s0, v1.2s
3790 // CHECK-ERROR:                  ^
3791 // CHECK-ERROR: error: invalid operand for instruction
3792 // CHECK-ERROR:        addv s0, v1.2s
3793 // CHECK-ERROR:                 ^
3794
3795         smaxv d0, v1.2d
3796         sminv d0, v1.2d
3797         umaxv d0, v1.2d
3798         uminv d0, v1.2d
3799         addv d0, v1.2d
3800
3801 // CHECK-ERROR: error: invalid operand for instruction
3802 // CHECK-ERROR:        smaxv d0, v1.2d
3803 // CHECK-ERROR:              ^
3804 // CHECK-ERROR: error: invalid operand for instruction
3805 // CHECK-ERROR:        sminv d0, v1.2d
3806 // CHECK-ERROR:              ^
3807 // CHECK-ERROR: error: invalid operand for instruction
3808 // CHECK-ERROR:        umaxv d0, v1.2d
3809 // CHECK-ERROR:              ^
3810 // CHECK-ERROR: error: invalid operand for instruction
3811 // CHECK-ERROR:        uminv d0, v1.2d
3812 // CHECK-ERROR:              ^
3813 // CHECK-ERROR: error: invalid operand for instruction
3814 // CHECK-ERROR:        addv d0, v1.2d
3815 // CHECK-ERROR:             ^
3816
3817         fmaxnmv b0, v1.16b
3818         fminnmv b0, v1.16b
3819         fmaxv b0, v1.16b
3820         fminv b0, v1.16b
3821
3822 // CHECK-ERROR: error: invalid operand for instruction
3823 // CHECK-ERROR:        fmaxnmv b0, v1.16b
3824 // CHECK-ERROR:                ^
3825 // CHECK-ERROR: error: invalid operand for instruction
3826 // CHECK-ERROR:        fminnmv b0, v1.16b
3827 // CHECK-ERROR:                ^
3828 // CHECK-ERROR: error: invalid operand for instruction
3829 // CHECK-ERROR:        fmaxv b0, v1.16b
3830 // CHECK-ERROR:              ^
3831 // CHECK-ERROR: error: invalid operand for instruction
3832 // CHECK-ERROR:        fminv b0, v1.16b
3833 // CHECK-ERROR:              ^
3834
3835         fmaxnmv h0, v1.8h
3836         fminnmv h0, v1.8h
3837         fmaxv h0, v1.8h
3838         fminv h0, v1.8h
3839
3840 // CHECK-ERROR: error: instruction requires: fullfp16
3841 // CHECK-ERROR:        fmaxnmv h0, v1.8h
3842 // CHECK-ERROR:                ^
3843 // CHECK-ERROR: error: instruction requires: fullfp16
3844 // CHECK-ERROR:        fminnmv h0, v1.8h
3845 // CHECK-ERROR:                ^
3846 // CHECK-ERROR: error: instruction requires: fullfp16
3847 // CHECK-ERROR:        fmaxv h0, v1.8h
3848 // CHECK-ERROR:              ^
3849 // CHECK-ERROR: error: instruction requires: fullfp16
3850 // CHECK-ERROR:        fminv h0, v1.8h
3851 // CHECK-ERROR:              ^
3852
3853         fmaxnmv d0, v1.2d
3854         fminnmv d0, v1.2d
3855         fmaxv d0, v1.2d
3856         fminv d0, v1.2d
3857
3858 // CHECK-ERROR: error: invalid operand for instruction
3859 // CHECK-ERROR:        fmaxnmv d0, v1.2d
3860 // CHECK-ERROR:                ^
3861 // CHECK-ERROR: error: invalid operand for instruction
3862 // CHECK-ERROR:        fminnmv d0, v1.2d
3863 // CHECK-ERROR:                ^
3864 // CHECK-ERROR: error: invalid operand for instruction
3865 // CHECK-ERROR:        fmaxv d0, v1.2d
3866 // CHECK-ERROR:              ^
3867 // CHECK-ERROR: error: invalid operand for instruction
3868 // CHECK-ERROR:        fminv d0, v1.2d
3869 // CHECK-ERROR:              ^
3870
3871 //----------------------------------------------------------------------
3872 // Floating-point Multiply Extended
3873 //----------------------------------------------------------------------
3874
3875     fmulx s20, h22, s15
3876     fmulx d23, d11, s1
3877
3878 // CHECK-ERROR: error: invalid operand for instruction
3879 // CHECK-ERROR:          fmulx s20, h22, s15
3880 // CHECK-ERROR:                     ^
3881 // CHECK-ERROR: error: invalid operand for instruction
3882 // CHECK-ERROR:          fmulx d23, d11, s1
3883 // CHECK-ERROR:                          ^
3884
3885 //----------------------------------------------------------------------
3886 // Floating-point Reciprocal Step
3887 //----------------------------------------------------------------------
3888
3889     frecps s21, s16, h13
3890     frecps d22, s30, d21
3891
3892 // CHECK-ERROR: error: invalid operand for instruction
3893 // CHECK-ERROR:          frecps s21, s16, h13
3894 // CHECK-ERROR:                           ^
3895 // CHECK-ERROR: error: invalid operand for instruction
3896 // CHECK-ERROR:          frecps d22, s30, d21
3897 // CHECK-ERROR:                      ^
3898
3899 //----------------------------------------------------------------------
3900 // Floating-point Reciprocal Square Root Step
3901 //----------------------------------------------------------------------
3902
3903     frsqrts s21, h5, s12
3904     frsqrts d8, s22, d18
3905
3906 // CHECK-ERROR: error: invalid operand for instruction
3907 // CHECK-ERROR:          frsqrts s21, h5, s12
3908 // CHECK-ERROR:                       ^
3909 // CHECK-ERROR: error: invalid operand for instruction
3910 // CHECK-ERROR:          frsqrts d8, s22, d18
3911 // CHECK-ERROR:                      ^
3912
3913 //----------------------------------------------------------------------
3914 // Vector load/store multiple N-element structure (class SIMD lselem)
3915 //----------------------------------------------------------------------
3916          ld1 {x3}, [x2]
3917          ld1 {v4}, [x0]
3918          ld1 {v32.16b}, [x0]
3919          ld1 {v15.8h}, [x32]
3920 // CHECK-ERROR: error: vector register expected
3921 // CHECK-ERROR:        ld1 {x3}, [x2]
3922 // CHECK-ERROR:             ^
3923 // CHECK-ERROR: error: invalid operand for instruction
3924 // CHECK-ERROR:        ld1 {v4}, [x0]
3925 // CHECK-ERROR:             ^
3926 // CHECK-ERROR: error: vector register expected
3927 // CHECK-ERROR:        ld1 {v32.16b}, [x0]
3928 // CHECK-ERROR:             ^
3929 // CHECK-ERROR: error: invalid operand for instruction
3930 // CHECK-ERROR:        ld1 {v15.8h}, [x32]
3931 // CHECK-ERROR:                       ^
3932
3933          ld1 {v0.16b, v2.16b}, [x0]
3934          ld1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
3935          ld1 v0.8b, v1.8b}, [x0]
3936          ld1 {v0.8h-v4.8h}, [x0]
3937          ld1 {v1.8h-v1.8h}, [x0]
3938          ld1 {v15.8h-v17.4h}, [x15]
3939          ld1 {v0.8b-v2.8b, [x0]
3940 // CHECK-ERROR: error: registers must be sequential
3941 // CHECK-ERROR:        ld1 {v0.16b, v2.16b}, [x0]
3942 // CHECK-ERROR:                     ^
3943 // CHECK-ERROR: error: invalid number of vectors
3944 // CHECK-ERROR:        ld1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
3945 // CHECK-ERROR:                                         ^
3946 // CHECK-ERROR: error: unexpected token in argument list
3947 // CHECK-ERROR:        ld1 v0.8b, v1.8b}, [x0]
3948 // CHECK-ERROR:            ^
3949 // CHECK-ERROR: error: invalid number of vectors
3950 // CHECK-ERROR:        ld1 {v0.8h-v4.8h}, [x0]
3951 // CHECK-ERROR:                   ^
3952 // CHECK-ERROR: error: invalid number of vectors
3953 // CHECK-ERROR:        ld1 {v1.8h-v1.8h}, [x0]
3954 // CHECK-ERROR:                   ^
3955 // CHECK-ERROR: error: mismatched register size suffix
3956 // CHECK-ERROR:        ld1 {v15.8h-v17.4h}, [x15]
3957 // CHECK-ERROR:                        ^
3958 // CHECK-ERROR: error: '}' expected
3959 // CHECK-ERROR:        ld1 {v0.8b-v2.8b, [x0]
3960 // CHECK-ERROR:                        ^
3961
3962          ld2 {v15.8h, v16.4h}, [x15]
3963          ld2 {v0.8b, v2.8b}, [x0]
3964          ld2 {v15.4h, v16.4h, v17.4h}, [x32]
3965          ld2 {v15.8h-v16.4h}, [x15]
3966          ld2 {v0.2d-v2.2d}, [x0]
3967 // CHECK-ERROR: error: mismatched register size suffix
3968 // CHECK-ERROR:        ld2 {v15.8h, v16.4h}, [x15]
3969 // CHECK-ERROR:                     ^
3970 // CHECK-ERROR: error: registers must be sequential
3971 // CHECK-ERROR:        ld2 {v0.8b, v2.8b}, [x0]
3972 // CHECK-ERROR:                    ^
3973 // CHECK-ERROR:        ld2 {v15.4h, v16.4h, v17.4h}, [x32]
3974 // CHECK-ERROR:            ^
3975 // CHECK-ERROR: error: mismatched register size suffix
3976 // CHECK-ERROR:        ld2 {v15.8h-v16.4h}, [x15]
3977 // CHECK-ERROR:                        ^
3978 // CHECK-ERROR: error: invalid operand for instruction
3979 // CHECK-ERROR:        ld2 {v0.2d-v2.2d}, [x0]
3980 // CHECK-ERROR:            ^
3981
3982          ld3 {v15.8h, v16.8h, v17.4h}, [x15]
3983          ld3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
3984          ld3 {v0.8b, v2.8b, v3.8b}, [x0]
3985          ld3 {v15.8h-v17.4h}, [x15]
3986          ld3 {v31.4s-v2.4s}, [sp]
3987 // CHECK-ERROR: error: mismatched register size suffix
3988 // CHECK-ERROR:        ld3 {v15.8h, v16.8h, v17.4h}, [x15]
3989 // CHECK-ERROR:                             ^
3990 // CHECK-ERROR: error: mismatched register size suffix
3991 // CHECK-ERROR:        ld3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
3992 // CHECK-ERROR:                    ^
3993 // CHECK-ERROR: error: registers must be sequential
3994 // CHECK-ERROR:        ld3 {v0.8b, v2.8b, v3.8b}, [x0]
3995 // CHECK-ERROR:                    ^
3996 // CHECK-ERROR: error: mismatched register size suffix
3997 // CHECK-ERROR:        ld3 {v15.8h-v17.4h}, [x15]
3998 // CHECK-ERROR:                        ^
3999 // CHECK-ERROR: error: invalid operand for instruction
4000 // CHECK-ERROR:        ld3 {v31.4s-v2.4s}, [sp]
4001 // CHECK-ERROR:            ^
4002
4003          ld4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
4004          ld4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
4005          ld4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
4006          ld4 {v15.8h-v18.4h}, [x15]
4007          ld4 {v31.2s-v1.2s}, [x31]
4008 // CHECK-ERROR: error: mismatched register size suffix
4009 // CHECK-ERROR:        ld4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
4010 // CHECK-ERROR:                             ^
4011 // CHECK-ERROR: error: registers must be sequential
4012 // CHECK-ERROR:        ld4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
4013 // CHECK-ERROR:                    ^
4014 // CHECK-ERROR: error: invalid number of vectors
4015 // CHECK-ERROR:        ld4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
4016 // CHECK-ERROR:                                             ^
4017 // CHECK-ERROR: error: mismatched register size suffix
4018 // CHECK-ERROR:        ld4 {v15.8h-v18.4h}, [x15]
4019 // CHECK-ERROR:                        ^
4020 // CHECK-ERROR: error: invalid operand for instruction
4021 // CHECK-ERROR:        ld4 {v31.2s-v1.2s}, [x31]
4022 // CHECK-ERROR:            ^
4023
4024          st1 {x3}, [x2]
4025          st1 {v4}, [x0]
4026          st1 {v32.16b}, [x0]
4027          st1 {v15.8h}, [x32]
4028 // CHECK-ERROR: error: vector register expected
4029 // CHECK-ERROR:        st1 {x3}, [x2]
4030 // CHECK-ERROR:             ^
4031 // CHECK-ERROR: error: invalid operand for instruction
4032 // CHECK-ERROR:        st1 {v4}, [x0]
4033 // CHECK-ERROR:             ^
4034 // CHECK-ERROR: error: vector register expected
4035 // CHECK-ERROR:        st1 {v32.16b}, [x0]
4036 // CHECK-ERROR:             ^
4037 // CHECK-ERROR: error: invalid operand for instruction
4038 // CHECK-ERROR:        st1 {v15.8h}, [x32]
4039 // CHECK-ERROR:                       ^
4040
4041          st1 {v0.16b, v2.16b}, [x0]
4042          st1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
4043          st1 v0.8b, v1.8b}, [x0]
4044          st1 {v0.8h-v4.8h}, [x0]
4045          st1 {v1.8h-v1.8h}, [x0]
4046          st1 {v15.8h-v17.4h}, [x15]
4047          st1 {v0.8b-v2.8b, [x0]
4048 // CHECK-ERROR: error: registers must be sequential
4049 // CHECK-ERROR:        st1 {v0.16b, v2.16b}, [x0]
4050 // CHECK-ERROR:                     ^
4051 // CHECK-ERROR: error: invalid number of vectors
4052 // CHECK-ERROR:        st1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
4053 // CHECK-ERROR:                                         ^
4054 // CHECK-ERROR: error: unexpected token in argument list
4055 // CHECK-ERROR:        st1 v0.8b, v1.8b}, [x0]
4056 // CHECK-ERROR:            ^
4057 // CHECK-ERROR: error: invalid number of vectors
4058 // CHECK-ERROR:        st1 {v0.8h-v4.8h}, [x0]
4059 // CHECK-ERROR:                   ^
4060 // CHECK-ERROR: error: invalid number of vectors
4061 // CHECK-ERROR:        st1 {v1.8h-v1.8h}, [x0]
4062 // CHECK-ERROR:                   ^
4063 // CHECK-ERROR: error: mismatched register size suffix
4064 // CHECK-ERROR:        st1 {v15.8h-v17.4h}, [x15]
4065 // CHECK-ERROR:                        ^
4066 // CHECK-ERROR: error: '}' expected
4067 // CHECK-ERROR:        st1 {v0.8b-v2.8b, [x0]
4068 // CHECK-ERROR:                        ^
4069
4070          st2 {v15.8h, v16.4h}, [x15]
4071          st2 {v0.8b, v2.8b}, [x0]
4072          st2 {v15.4h, v16.4h, v17.4h}, [x30]
4073          st2 {v15.8h-v16.4h}, [x15]
4074          st2 {v0.2d-v2.2d}, [x0]
4075 // CHECK-ERROR: error: mismatched register size suffix
4076 // CHECK-ERROR:        st2 {v15.8h, v16.4h}, [x15]
4077 // CHECK-ERROR:                     ^
4078 // CHECK-ERROR: error: registers must be sequential
4079 // CHECK-ERROR:        st2 {v0.8b, v2.8b}, [x0]
4080 // CHECK-ERROR:                    ^
4081 // CHECK-ERROR: error: invalid operand for instruction
4082 // CHECK-ERROR:        st2 {v15.4h, v16.4h, v17.4h}, [x30]
4083 // CHECK-ERROR:            ^
4084 // CHECK-ERROR: error: mismatched register size suffix
4085 // CHECK-ERROR:        st2 {v15.8h-v16.4h}, [x15]
4086 // CHECK-ERROR:                        ^
4087 // CHECK-ERROR: error: invalid operand for instruction
4088 // CHECK-ERROR:        st2 {v0.2d-v2.2d}, [x0]
4089 // CHECK-ERROR:            ^
4090
4091          st3 {v15.8h, v16.8h, v17.4h}, [x15]
4092          st3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
4093          st3 {v0.8b, v2.8b, v3.8b}, [x0]
4094          st3 {v15.8h-v17.4h}, [x15]
4095          st3 {v31.4s-v2.4s}, [sp]
4096 // CHECK-ERROR: error: mismatched register size suffix
4097 // CHECK-ERROR:        st3 {v15.8h, v16.8h, v17.4h}, [x15]
4098 // CHECK-ERROR:                             ^
4099 // CHECK-ERROR: error: mismatched register size suffix
4100 // CHECK-ERROR:        st3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
4101 // CHECK-ERROR:                    ^
4102 // CHECK-ERROR: error: registers must be sequential
4103 // CHECK-ERROR:        st3 {v0.8b, v2.8b, v3.8b}, [x0]
4104 // CHECK-ERROR:                    ^
4105 // CHECK-ERROR: error: mismatched register size suffix
4106 // CHECK-ERROR:        st3 {v15.8h-v17.4h}, [x15]
4107 // CHECK-ERROR:                        ^
4108 // CHECK-ERROR: error: invalid operand for instruction
4109 // CHECK-ERROR:        st3 {v31.4s-v2.4s}, [sp]
4110 // CHECK-ERROR:            ^
4111
4112          st4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
4113          st4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
4114          st4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
4115          st4 {v15.8h-v18.4h}, [x15]
4116          st4 {v31.2s-v1.2s}, [x31]
4117 // CHECK-ERROR: error: mismatched register size suffix
4118 // CHECK-ERROR:        st4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
4119 // CHECK-ERROR:                             ^
4120 // CHECK-ERROR: error: registers must be sequential
4121 // CHECK-ERROR:        st4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
4122 // CHECK-ERROR:                    ^
4123 // CHECK-ERROR: error: invalid number of vectors
4124 // CHECK-ERROR:        st4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
4125 // CHECK-ERROR:                                             ^
4126 // CHECK-ERROR: error: mismatched register size suffix
4127 // CHECK-ERROR:        st4 {v15.8h-v18.4h}, [x15]
4128 // CHECK-ERROR:                        ^
4129 // CHECK-ERROR: error: invalid operand for instruction
4130 // CHECK-ERROR:        st4 {v31.2s-v1.2s}, [x31]
4131 // CHECK-ERROR:            ^
4132
4133 //----------------------------------------------------------------------
4134 // Vector post-index load/store multiple N-element structure
4135 // (class SIMD lselem-post)
4136 //----------------------------------------------------------------------
4137          ld1 {v0.16b}, [x0], #8
4138          ld1 {v0.8h, v1.16h}, [x0], x1
4139          ld1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4140 // CHECK-ERROR: error: invalid operand for instruction
4141 // CHECK-ERROR:          ld1 {v0.16b}, [x0], #8
4142 // CHECK-ERROR:                              ^
4143 // CHECK-ERROR: error: invalid vector kind qualifier
4144 // CHECK-ERROR:          ld1 {v0.8h, v1.16h}, [x0], x1
4145 // CHECK-ERROR:                      ^
4146 // CHECK-ERROR:  error: invalid operand for instruction
4147 // CHECK-ERROR:          ld1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4148 // CHECK-ERROR:                                                  ^
4149
4150          ld2 {v0.16b, v1.16b}, [x0], #16
4151          ld3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4152          ld4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4153 // CHECK-ERROR:  error: invalid operand for instruction
4154 // CHECK-ERROR:          ld2 {v0.16b, v1.16b}, [x0], #16
4155 // CHECK-ERROR:                                      ^
4156 // CHECK-ERROR:  error: invalid operand for instruction
4157 // CHECK-ERROR:          ld3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4158 // CHECK-ERROR:                                           ^
4159 // CHECK-ERROR: error: mismatched register size suffix
4160 // CHECK-ERROR:          ld4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4161 // CHECK-ERROR:                                     ^
4162
4163          st1 {v0.16b}, [x0], #8
4164          st1 {v0.8h, v1.16h}, [x0], x1
4165          st1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4166 // CHECK-ERROR:  error: invalid operand for instruction
4167 // CHECK-ERROR:          st1 {v0.16b}, [x0], #8
4168 // CHECK-ERROR:                              ^
4169 // CHECK-ERROR: error: invalid vector kind qualifier
4170 // CHECK-ERROR:          st1 {v0.8h, v1.16h}, [x0], x1
4171 // CHECK-ERROR:                      ^
4172 // CHECK-ERROR:  error: invalid operand for instruction
4173 // CHECK-ERROR:          st1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
4174                                                  ^
4175
4176          st2 {v0.16b, v1.16b}, [x0], #16
4177          st3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4178          st4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4179 // CHECK-ERROR:  error: invalid operand for instruction
4180 // CHECK-ERROR:          st2 {v0.16b, v1.16b}, [x0], #16
4181 // CHECK-ERROR:                                      ^
4182 // CHECK-ERROR:  error: invalid operand for instruction
4183 // CHECK-ERROR:          st3 {v5.2s, v6.2s, v7.2s}, [x1], #48
4184 // CHECK-ERROR:                                           ^
4185 // CHECK-ERROR: error: mismatched register size suffix
4186 // CHECK-ERROR:          st4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
4187 // CHECK-ERROR:                                     ^
4188
4189 //------------------------------------------------------------------------------
4190 // Load single N-element structure to all lanes of N consecutive
4191 // registers (N = 1,2,3,4)
4192 //------------------------------------------------------------------------------
4193          ld1r {x1}, [x0]
4194          ld2r {v31.4s, v0.2s}, [sp]
4195          ld3r {v0.8b, v1.8b, v2.8b, v3.8b}, [x0]
4196          ld4r {v31.2s, v0.2s, v1.2d, v2.2s}, [sp]
4197 // CHECK-ERROR: error: vector register expected
4198 // CHECK-ERROR: ld1r {x1}, [x0]
4199 // CHECK-ERROR:       ^
4200 // CHECK-ERROR: error: mismatched register size suffix
4201 // CHECK-ERROR: ld2r {v31.4s, v0.2s}, [sp]
4202 // CHECK-ERROR:               ^
4203 // CHECK-ERROR: error: invalid operand for instruction
4204 // CHECK-ERROR: ld3r {v0.8b, v1.8b, v2.8b, v3.8b}, [x0]
4205 // CHECK-ERROR:      ^
4206 // CHECK-ERROR: error: mismatched register size suffix
4207 // CHECK-ERROR: ld4r {v31.2s, v0.2s, v1.2d, v2.2s}, [sp]
4208 // CHECK-ERROR:                      ^
4209
4210 //------------------------------------------------------------------------------
4211 // Load/Store single N-element structure to/from one lane of N consecutive
4212 // registers (N = 1, 2,3,4)
4213 //------------------------------------------------------------------------------
4214          ld1 {v0.b}[16], [x0]
4215          ld2 {v15.h, v16.h}[8], [x15]
4216          ld3 {v31.s, v0.s, v1.s}[-1], [sp]
4217          ld4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4218 // CHECK-ERROR: vector lane must be an integer in range
4219 // CHECK-ERROR: ld1 {v0.b}[16], [x0]
4220 // CHECK-ERROR:            ^
4221 // CHECK-ERROR: vector lane must be an integer in range
4222 // CHECK-ERROR: ld2 {v15.h, v16.h}[8], [x15]
4223 // CHECK-ERROR:                    ^
4224 // CHECK-ERROR: error: vector lane must be an integer in range
4225 // CHECK-ERROR: ld3 {v31.s, v0.s, v1.s}[-1], [sp]
4226 // CHECK-ERROR:                         ^
4227 // CHECK-ERROR: vector lane must be an integer in range
4228 // CHECK-ERROR: ld4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4229 // CHECK-ERROR:                              ^
4230
4231          st1 {v0.d}[16], [x0]
4232          st2 {v31.s, v0.s}[3], [8]
4233          st3 {v15.h, v16.h, v17.h}[-1], [x15]
4234          st4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4235 // CHECK-ERROR: vector lane must be an integer in range
4236 // CHECK-ERROR: st1 {v0.d}[16], [x0]
4237 // CHECK-ERROR:            ^
4238 // CHECK-ERROR: error: invalid operand for instruction
4239 // CHECK-ERROR: st2 {v31.s, v0.s}[3], [8]
4240 // CHECK-ERROR:                        ^
4241 // CHECK-ERROR: error: vector lane must be an integer in range
4242 // CHECK-ERROR: st3 {v15.h, v16.h, v17.h}[-1], [x15]
4243 // CHECK-ERROR:                           ^
4244 // CHECK-ERROR: vector lane must be an integer in range
4245 // CHECK-ERROR: st4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
4246 // CHECK-ERROR:                              ^
4247
4248 //------------------------------------------------------------------------------
4249 // Post-index of load single N-element structure to all lanes of N consecutive
4250 // registers (N = 1,2,3,4)
4251 //------------------------------------------------------------------------------
4252          ld1r {v15.8h}, [x15], #5
4253          ld2r {v0.2d, v1.2d}, [x0], #7
4254          ld3r {v15.4h, v16.4h, v17.4h}, [x15], #1
4255          ld4r {v31.1d, v0.1d, v1.1d, v2.1d}, [sp], sp
4256 // CHECK-ERROR: error: invalid operand for instruction
4257 // CHECK-ERROR: ld1r {v15.8h}, [x15], #5
4258 // CHECK-ERROR:                       ^
4259 // CHECK-ERROR: error: invalid operand for instruction
4260 // CHECK-ERROR: ld2r {v0.2d, v1.2d}, [x0], #7
4261 // CHECK-ERROR:                            ^
4262 // CHECK-ERROR: error: invalid operand for instruction
4263 // CHECK-ERROR: ld3r {v15.4h, v16.4h, v17.4h}, [x15], #1
4264 // CHECK-ERROR:                                       ^
4265 // CHECK-ERROR: error: invalid operand for instruction
4266 // CHECK-ERROR: ld4r {v31.1d, v0.1d, v1.1d, v2.1d}, [sp], sp
4267 // CHECK-ERROR:                                           ^
4268
4269 //------------------------------------------------------------------------------
4270 // Post-index of Load/Store single N-element structure to/from one lane of N
4271 // consecutive registers (N = 1, 2,3,4)
4272 //------------------------------------------------------------------------------
4273          ld1 {v0.b}[0], [x0], #2
4274          ld2 {v15.h, v16.h}[0], [x15], #3
4275          ld3 {v31.s, v0.s, v1.d}[0], [sp], x9
4276          ld4 {v0.d, v1.d, v2.d, v3.d}[1], [x0], #24
4277 // CHECK-ERROR: error: invalid operand for instruction
4278 // CHECK-ERROR: ld1 {v0.b}[0], [x0], #2
4279 // CHECK-ERROR:                      ^
4280 // CHECK-ERROR: error: invalid operand for instruction
4281 // CHECK-ERROR: ld2 {v15.h, v16.h}[0], [x15], #3
4282 // CHECK-ERROR:                               ^
4283 // CHECK-ERROR: error: mismatched register size suffix
4284 // CHECK-ERROR: ld3 {v31.s, v0.s, v1.d}[0], [sp], x9
4285 // CHECK-ERROR:                      ^
4286 // CHECK-ERROR: error: invalid operand for instruction
4287 // CHECK-ERROR: ld4 {v0.d, v1.d, v2.d, v3.d}[1], [x0], #24
4288 // CHECK-ERROR:                                        ^
4289
4290          st1 {v0.d}[0], [x0], #7
4291          st2 {v31.s, v0.s}[0], [sp], #6
4292          st3 {v15.h, v16.h, v17.h}[0], [x15], #8
4293          st4 {v0.b, v1.b, v2.b, v3.b}[1], [x0], #1
4294 // CHECK-ERROR: error: invalid operand for instruction
4295 // CHECK-ERROR: st1 {v0.d}[0], [x0], #7
4296 // CHECK-ERROR:                      ^
4297 // CHECK-ERROR: error: invalid operand for instruction
4298 // CHECK-ERROR: st2 {v31.s, v0.s}[0], [sp], #6
4299 // CHECK-ERROR:                             ^
4300 // CHECK-ERROR: error: invalid operand for instruction
4301 // CHECK-ERROR: st3 {v15.h, v16.h, v17.h}[0], [x15], #8
4302 // CHECK-ERROR:                                      ^
4303 // CHECK-ERROR: error: invalid operand for instruction
4304 // CHECK-ERROR: st4 {v0.b, v1.b, v2.b, v3.b}[1], [x0], #1
4305 // CHECK-ERROR:                                        ^
4306
4307
4308          ins v2.b[16], w1
4309          ins v7.h[8], w14
4310          ins v20.s[5], w30
4311          ins v1.d[2], x7
4312          ins v2.b[3], b1
4313          ins v7.h[2], h14
4314          ins v20.s[1], s30
4315          ins v1.d[0], d7
4316
4317 // CHECK-ERROR: vector lane must be an integer in range
4318 // CHECK-ERROR:         ins v2.b[16], w1
4319 // CHECK-ERROR:                  ^
4320 // CHECK-ERROR: vector lane must be an integer in range
4321 // CHECK-ERROR:         ins v7.h[8], w14
4322 // CHECK-ERROR:                  ^
4323 // CHECK-ERROR: vector lane must be an integer in range
4324 // CHECK-ERROR:         ins v20.s[5], w30
4325 // CHECK-ERROR:                   ^
4326 // CHECK-ERROR: vector lane must be an integer in range
4327 // CHECK-ERROR:         ins v1.d[2], x7
4328 // CHECK-ERROR:                  ^
4329 // CHECK-ERROR: error: invalid operand for instruction
4330 // CHECK-ERROR:         ins v2.b[3], b1
4331 // CHECK-ERROR:                      ^
4332 // CHECK-ERROR: error: invalid operand for instruction
4333 // CHECK-ERROR:         ins v7.h[2], h14
4334 // CHECK-ERROR:                      ^
4335 // CHECK-ERROR: error: invalid operand for instruction
4336 // CHECK-ERROR:         ins v20.s[1], s30
4337 // CHECK-ERROR:                       ^
4338 // CHECK-ERROR: error: invalid operand for instruction
4339 // CHECK-ERROR:         ins v1.d[0], d7
4340 // CHECK-ERROR:                      ^
4341
4342          smov w1, v0.b[16]
4343          smov w14, v6.h[8]
4344          smov x1, v0.b[16]
4345          smov x14, v6.h[8]
4346          smov x20, v9.s[5]
4347          smov w1, v0.d[0]
4348          smov w14, v6.d[1]
4349          smov x1, v0.d[0]
4350          smov x14, v6.d[1]
4351          smov x20, v9.d[0]
4352
4353 // CHECK-ERROR: vector lane must be an integer in range
4354 // CHECK-ERROR:         smov w1, v0.b[16]
4355 // CHECK-ERROR:                       ^
4356 // CHECK-ERROR: vector lane must be an integer in range
4357 // CHECK-ERROR:         smov w14, v6.h[8]
4358 // CHECK-ERROR:                        ^
4359 // CHECK-ERROR: vector lane must be an integer in range
4360 // CHECK-ERROR:         smov x1, v0.b[16]
4361 // CHECK-ERROR:                       ^
4362 // CHECK-ERROR: vector lane must be an integer in range
4363 // CHECK-ERROR:         smov x14, v6.h[8]
4364 // CHECK-ERROR:                        ^
4365 // CHECK-ERROR: vector lane must be an integer in range
4366 // CHECK-ERROR:         smov x20, v9.s[5]
4367 // CHECK-ERROR:                        ^
4368 // CHECK-ERROR: error: invalid operand for instruction
4369 // CHECK-ERROR:         smov w1, v0.d[0]
4370 // CHECK-ERROR:                     ^
4371 // CHECK-ERROR: error: invalid operand for instruction
4372 // CHECK-ERROR:         smov w14, v6.d[1]
4373 // CHECK-ERROR:                      ^
4374 // CHECK-ERROR: error: invalid operand for instruction
4375 // CHECK-ERROR:         smov x1, v0.d[0]
4376 // CHECK-ERROR:                     ^
4377 // CHECK-ERROR: error: invalid operand for instruction
4378 // CHECK-ERROR:         smov x14, v6.d[1]
4379 // CHECK-ERROR:                      ^
4380 // CHECK-ERROR: error: invalid operand for instruction
4381 // CHECK-ERROR:         smov x20, v9.d[0]
4382 // CHECK-ERROR:                      ^
4383
4384          umov w1, v0.b[16]
4385          umov w14, v6.h[8]
4386          umov w20, v9.s[5]
4387          umov x7, v18.d[3]
4388          umov w1, v0.d[0]
4389          umov s20, v9.s[2]
4390          umov d7, v18.d[1]
4391
4392 // CHECK-ERROR: vector lane must be an integer in range
4393 // CHECK-ERROR:         umov w1, v0.b[16]
4394 // CHECK-ERROR:                       ^
4395 // CHECK-ERROR: vector lane must be an integer in range
4396 // CHECK-ERROR:         umov w14, v6.h[8]
4397 // CHECK-ERROR:                        ^
4398 // CHECK-ERROR: vector lane must be an integer in range
4399 // CHECK-ERROR:         umov w20, v9.s[5]
4400 // CHECK-ERROR:                        ^
4401 // CHECK-ERROR: vector lane must be an integer in range
4402 // CHECK-ERROR:         umov x7, v18.d[3]
4403 // CHECK-ERROR:                        ^
4404 // CHECK-ERROR: error: invalid operand for instruction
4405 // CHECK-ERROR:         umov w1, v0.d[0]
4406 // CHECK-ERROR:                     ^
4407 // CHECK-ERROR: error: invalid operand for instruction
4408 // CHECK-ERROR:         umov s20, v9.s[2]
4409 // CHECK-ERROR:              ^
4410 // CHECK-ERROR: error: invalid operand for instruction
4411 // CHECK-ERROR:         umov d7, v18.d[1]
4412 // CHECK-ERROR:              ^
4413
4414          Ins v1.h[2], v3.b[6]
4415          Ins v6.h[7], v7.s[2]
4416          Ins v15.d[0], v22.s[2]
4417          Ins v0.d[0], v4.b[1]
4418
4419 // CHECK-ERROR: error: invalid operand for instruction
4420 // CHECK-ERROR:         Ins v1.h[2], v3.b[6]
4421 // CHECK-ERROR:                         ^
4422 // CHECK-ERROR: error: invalid operand for instruction
4423 // CHECK-ERROR:         Ins v6.h[7], v7.s[2]
4424 // CHECK-ERROR:                         ^
4425 // CHECK-ERROR: error: invalid operand for instruction
4426 // CHECK-ERROR:         Ins v15.d[0], v22.s[2]
4427 // CHECK-ERROR:                           ^
4428 // CHECK-ERROR: error: invalid operand for instruction
4429 // CHECK-ERROR:         Ins v0.d[0], v4.b[1]
4430 // CHECK-ERROR:                         ^
4431
4432          dup v1.8h, v2.b[2]
4433          dup v11.4s, v7.h[7]
4434          dup v17.2d, v20.s[0]
4435          dup v1.16b, v2.h[2]
4436          dup v11.8h, v7.s[3]
4437          dup v17.4s, v20.d[0]
4438          dup v5.2d, v1.b[1]
4439
4440 // CHECK-ERROR: error: invalid operand for instruction
4441 // CHECK-ERROR:         dup v1.8h, v2.b[2]
4442 // CHECK-ERROR:                       ^
4443 // CHECK-ERROR: error: invalid operand for instruction
4444 // CHECK-ERROR:         dup v11.4s, v7.h[7]
4445 // CHECK-ERROR:                        ^
4446 // CHECK-ERROR: error: invalid operand for instruction
4447 // CHECK-ERROR:         dup v17.2d, v20.s[0]
4448 // CHECK-ERROR:                         ^
4449 // CHECK-ERROR: error: invalid operand for instruction
4450 // CHECK-ERROR:         dup v1.16b, v2.h[2]
4451 // CHECK-ERROR:                        ^
4452 // CHECK-ERROR: invalid operand for instruction
4453 // CHECK-ERROR:         dup v11.8h, v7.s[3]
4454 // CHECK-ERROR:                        ^
4455 // CHECK-ERROR: invalid operand for instruction
4456 // CHECK-ERROR:         dup v17.4s, v20.d[0]
4457 // CHECK-ERROR:                         ^
4458 // CHECK-ERROR: invalid operand for instruction
4459 // CHECK-ERROR:         dup v5.2d, v1.b[1]
4460 // CHECK-ERROR:                       ^
4461
4462          dup v1.8b, b1
4463          dup v11.4h, h14
4464          dup v17.2s, s30
4465          dup v1.16b, d2
4466          dup v11.8s, w16
4467          dup v17.4d, w28
4468          dup v5.2d, w0
4469
4470 // CHECK-ERROR: error: invalid operand for instruction
4471 // CHECK-ERROR:         dup v1.8b, b1
4472 // CHECK-ERROR:                    ^
4473 // CHECK-ERROR: error: invalid operand for instruction
4474 // CHECK-ERROR:         dup v11.4h, h14
4475 // CHECK-ERROR:                     ^
4476 // CHECK-ERROR: error: invalid operand for instruction
4477 // CHECK-ERROR:         dup v17.2s, s30
4478 // CHECK-ERROR:                     ^
4479 // CHECK-ERROR: error: invalid operand for instruction
4480 // CHECK-ERROR:         dup v1.16b, d2
4481 // CHECK-ERROR:                     ^
4482 // CHECK-ERROR: error: invalid operand for instruction
4483 // CHECK-ERROR:         dup v11.8s, w16
4484 // CHECK-ERROR:             ^
4485 // CHECK-ERROR: error: invalid operand for instruction
4486 // CHECK-ERROR:         dup v17.4d, w28
4487 // CHECK-ERROR:             ^
4488 // CHECK-ERROR: error: invalid operand for instruction
4489 // CHECK-ERROR:         dup v5.2d, w0
4490 // CHECK-ERROR:                    ^
4491
4492 //----------------------------------------------------------------------
4493 // Scalar Compare Bitwise Equal
4494 //----------------------------------------------------------------------
4495
4496          cmeq b20, d21, d22
4497
4498 // CHECK-ERROR: error: invalid operand for instruction
4499 // CHECK-ERROR:          cmeq b20, d21, d22
4500 // CHECK-ERROR:               ^
4501
4502 //----------------------------------------------------------------------
4503 // Scalar Compare Bitwise Equal To Zero
4504 //----------------------------------------------------------------------
4505
4506          cmeq d20, b21, #0
4507
4508 // CHECK-ERROR: error: invalid operand for instruction
4509 // CHECK-ERROR:          cmeq d20, b21, #0
4510 // CHECK-ERROR:                    ^
4511
4512 //----------------------------------------------------------------------
4513 // Scalar Compare Unsigned Higher Or Same
4514 //----------------------------------------------------------------------
4515
4516          cmhs b20, d21, d22
4517
4518 // CHECK-ERROR: error: invalid operand for instruction
4519 // CHECK-ERROR:          cmhs b20, d21, d22
4520 // CHECK-ERROR:               ^
4521
4522
4523 //----------------------------------------------------------------------
4524 // Scalar Compare Signed Greather Than Or Equal
4525 //----------------------------------------------------------------------
4526
4527          cmge b20, d21, d22
4528
4529 // CHECK-ERROR: error: invalid operand for instruction
4530 // CHECK-ERROR:          cmge b20, d21, d22
4531 // CHECK-ERROR:               ^
4532
4533 //----------------------------------------------------------------------
4534 // Scalar Compare Signed Greather Than Or Equal To Zero
4535 //----------------------------------------------------------------------
4536
4537          cmge d20, b21, #0
4538
4539 // CHECK-ERROR: error: invalid operand for instruction
4540 // CHECK-ERROR:          cmge d20, b21, #0
4541 // CHECK-ERROR:                    ^
4542
4543 //----------------------------------------------------------------------
4544 // Scalar Compare Unsigned Higher
4545 //----------------------------------------------------------------------
4546
4547          cmhi b20, d21, d22
4548
4549 // CHECK-ERROR: error: invalid operand for instruction
4550 // CHECK-ERROR:          cmhi b20, d21, d22
4551 // CHECK-ERROR:               ^
4552
4553 //----------------------------------------------------------------------
4554 // Scalar Compare Signed Greater Than
4555 //----------------------------------------------------------------------
4556
4557          cmgt b20, d21, d22
4558
4559 // CHECK-ERROR: error: invalid operand for instruction
4560 // CHECK-ERROR:          cmgt b20, d21, d22
4561 // CHECK-ERROR:               ^
4562
4563 //----------------------------------------------------------------------
4564 // Scalar Compare Signed Greater Than Zero
4565 //----------------------------------------------------------------------
4566
4567          cmgt d20, b21, #0
4568
4569 // CHECK-ERROR: error: invalid operand for instruction
4570 // CHECK-ERROR:          cmgt d20, b21, #0
4571 // CHECK-ERROR:                    ^
4572
4573 //----------------------------------------------------------------------
4574 // Scalar Compare Signed Less Than Or Equal To Zero
4575 //----------------------------------------------------------------------
4576
4577          cmle d20, b21, #0
4578
4579 // CHECK-ERROR: error: invalid operand for instruction
4580 // CHECK-ERROR:          cmle d20, b21, #0
4581 // CHECK-ERROR:                    ^
4582
4583 //----------------------------------------------------------------------
4584 // Scalar Compare Less Than Zero
4585 //----------------------------------------------------------------------
4586
4587          cmlt d20, b21, #0
4588
4589 // CHECK-ERROR: error: invalid operand for instruction
4590 // CHECK-ERROR:          cmlt d20, b21, #0
4591 // CHECK-ERROR:                    ^
4592
4593 //----------------------------------------------------------------------
4594 // Scalar Compare Bitwise Test Bits
4595 //----------------------------------------------------------------------
4596
4597          cmtst b20, d21, d22
4598
4599 // CHECK-ERROR: error: invalid operand for instruction
4600 // CHECK-ERROR:          cmtst b20, d21, d22
4601 // CHECK-ERROR:                ^
4602
4603 //----------------------------------------------------------------------
4604 // Scalar Floating-point Compare Mask Equal
4605 //----------------------------------------------------------------------
4606
4607          fcmeq s10, h11, s12
4608          fcmeq d20, s21, d22
4609
4610 // CHECK-ERROR: error: invalid operand for instruction
4611 // CHECK-ERROR:          fcmeq s10, h11, s12
4612 // CHECK-ERROR:                     ^
4613 // CHECK-ERROR: error: invalid operand for instruction
4614 // CHECK-ERROR:          fcmeq d20, s21, d22
4615 // CHECK-ERROR:                     ^
4616
4617 //----------------------------------------------------------------------
4618 // Scalar Floating-point Compare Mask Equal To Zero
4619 //----------------------------------------------------------------------
4620
4621          fcmeq h10, s11, #0.0
4622          fcmeq d20, s21, #0.0
4623
4624 // CHECK-ERROR: error: invalid operand for instruction
4625 // CHECK-ERROR:          fcmeq h10, s11, #0.0
4626 // CHECK-ERROR:                ^
4627 // CHECK-ERROR: error: invalid operand for instruction
4628 // CHECK-ERROR:          fcmeq d20, s21, #0.0
4629 // CHECK-ERROR:                     ^
4630
4631 //----------------------------------------------------------------------
4632 // Scalar Floating-point Compare Mask Greater Than Or Equal
4633 //----------------------------------------------------------------------
4634
4635          fcmge s10, h11, s12
4636          fcmge d20, s21, d22
4637
4638 // CHECK-ERROR: error: invalid operand for instruction
4639 // CHECK-ERROR:          fcmge s10, h11, s12
4640 // CHECK-ERROR:                     ^
4641 // CHECK-ERROR: error: invalid operand for instruction
4642 // CHECK-ERROR:          fcmge d20, s21, d22
4643 // CHECK-ERROR:                     ^
4644
4645 //----------------------------------------------------------------------
4646 // Scalar Floating-point Compare Mask Greater Than Or Equal To Zero
4647 //----------------------------------------------------------------------
4648
4649          fcmge h10, s11, #0.0
4650          fcmge d20, s21, #0.0
4651
4652 // CHECK-ERROR: error: invalid operand for instruction
4653 // CHECK-ERROR:          fcmge h10, s11, #0.0
4654 // CHECK-ERROR:                ^
4655 // CHECK-ERROR: error: invalid operand for instruction
4656 // CHECK-ERROR:          fcmge d20, s21, #0.0
4657 // CHECK-ERROR:                     ^
4658
4659 //----------------------------------------------------------------------
4660 // Scalar Floating-point Compare Mask Greather Than
4661 //----------------------------------------------------------------------
4662
4663          fcmgt s10, h11, s12
4664          fcmgt d20, s21, d22
4665
4666 // CHECK-ERROR: error: invalid operand for instruction
4667 // CHECK-ERROR:          fcmgt s10, h11, s12
4668 // CHECK-ERROR:                     ^
4669 // CHECK-ERROR: error: invalid operand for instruction
4670 // CHECK-ERROR:          fcmgt d20, s21, d22
4671 // CHECK-ERROR:                     ^
4672
4673 //----------------------------------------------------------------------
4674 // Scalar Floating-point Compare Mask Greather Than Zero
4675 //----------------------------------------------------------------------
4676
4677          fcmgt h10, s11, #0.0
4678          fcmgt d20, s21, #0.0
4679
4680 // CHECK-ERROR: error: invalid operand for instruction
4681 // CHECK-ERROR:          fcmgt h10, s11, #0.0
4682 // CHECK-ERROR:                ^
4683 // CHECK-ERROR: error: invalid operand for instruction
4684 // CHECK-ERROR:          fcmgt d20, s21, #0.0
4685 // CHECK-ERROR:                     ^
4686
4687 //----------------------------------------------------------------------
4688 // Scalar Floating-point Compare Mask Less Than Or Equal To Zero
4689 //----------------------------------------------------------------------
4690
4691          fcmle h10, s11, #0.0
4692          fcmle d20, s21, #0.0
4693
4694 // CHECK-ERROR: error: invalid operand for instruction
4695 // CHECK-ERROR:          fcmle h10, s11, #0.0
4696 // CHECK-ERROR:                ^
4697 // CHECK-ERROR: error: invalid operand for instruction
4698 // CHECK-ERROR:          fcmle d20, s21, #0.0
4699 // CHECK-ERROR:                     ^
4700
4701 //----------------------------------------------------------------------
4702 // Scalar Floating-point Compare Mask Less Than
4703 //----------------------------------------------------------------------
4704
4705          fcmlt h10, s11, #0.0
4706          fcmlt d20, s21, #0.0
4707
4708 // CHECK-ERROR: error: invalid operand for instruction
4709 // CHECK-ERROR:          fcmlt h10, s11, #0.0
4710 // CHECK-ERROR:                     ^
4711 // CHECK-ERROR: error: invalid operand for instruction
4712 // CHECK-ERROR:          fcmlt d20, s21, #0.0
4713 // CHECK-ERROR:                     ^
4714
4715 //----------------------------------------------------------------------
4716 // Scalar Floating-point Absolute Compare Mask Greater Than Or Equal
4717 //----------------------------------------------------------------------
4718
4719          facge s10, h11, s12
4720          facge d20, s21, d22
4721
4722 // CHECK-ERROR: error: invalid operand for instruction
4723 // CHECK-ERROR:          facge s10, h11, s12
4724 // CHECK-ERROR:                     ^
4725 // CHECK-ERROR: error: invalid operand for instruction
4726 // CHECK-ERROR:          facge d20, s21, d22
4727 // CHECK-ERROR:                     ^
4728
4729 //----------------------------------------------------------------------
4730 // Scalar Floating-point Absolute Compare Mask Greater Than
4731 //----------------------------------------------------------------------
4732
4733          facgt s10, h11, s12
4734          facgt d20, d21, s22
4735
4736 // CHECK-ERROR: error: invalid operand for instruction
4737 // CHECK-ERROR:          facgt s10, h11, s12
4738 // CHECK-ERROR:                     ^
4739 // CHECK-ERROR: error: invalid operand for instruction
4740 // CHECK-ERROR:          facgt d20, d21, s22
4741 // CHECK-ERROR:                          ^
4742
4743 //----------------------------------------------------------------------
4744 // Scalar Signed Saturating Accumulated of Unsigned Value
4745 //----------------------------------------------------------------------
4746
4747         suqadd b0, h1
4748         suqadd h0, s1
4749         suqadd s0, d1
4750         suqadd d0, b0
4751
4752 // CHECK-ERROR: error: invalid operand for instruction
4753 // CHECK-ERROR:        suqadd b0, h1
4754 // CHECK-ERROR:                   ^
4755 // CHECK-ERROR: error: invalid operand for instruction
4756 // CHECK-ERROR:        suqadd h0, s1
4757 // CHECK-ERROR:                   ^
4758 // CHECK-ERROR: error: invalid operand for instruction
4759 // CHECK-ERROR:        suqadd s0, d1
4760 // CHECK-ERROR:                   ^
4761 // CHECK-ERROR: error: invalid operand for instruction
4762 // CHECK-ERROR:        suqadd d0, b0
4763 // CHECK-ERROR:                   ^
4764
4765 //----------------------------------------------------------------------
4766 // Scalar Unsigned Saturating Accumulated of Signed Value
4767 //----------------------------------------------------------------------
4768
4769         usqadd b0, h1
4770         usqadd h0, s1
4771         usqadd s0, d1
4772         usqadd d0, b1
4773
4774 // CHECK-ERROR: error: invalid operand for instruction
4775 // CHECK-ERROR:        usqadd b0, h1
4776 // CHECK-ERROR:                   ^
4777 // CHECK-ERROR: error: invalid operand for instruction
4778 // CHECK-ERROR:        usqadd h0, s1
4779 // CHECK-ERROR:                   ^
4780 // CHECK-ERROR: error: invalid operand for instruction
4781 // CHECK-ERROR:        usqadd s0, d1
4782 // CHECK-ERROR:                   ^
4783 // CHECK-ERROR: error: invalid operand for instruction
4784 // CHECK-ERROR:        usqadd d0, b1
4785 // CHECK-ERROR:                   ^
4786
4787 //----------------------------------------------------------------------
4788 // Scalar Absolute Value
4789 //----------------------------------------------------------------------
4790
4791     abs d29, s24
4792
4793 // CHECK-ERROR: error: invalid operand for instruction
4794 // CHECK-ERROR:        abs d29, s24
4795 // CHECK-ERROR:                 ^
4796
4797 //----------------------------------------------------------------------
4798 // Scalar Negate
4799 //----------------------------------------------------------------------
4800
4801     neg d29, s24
4802
4803 // CHECK-ERROR: error: invalid operand for instruction
4804 // CHECK-ERROR:        neg d29, s24
4805 // CHECK-ERROR:                 ^
4806
4807 //----------------------------------------------------------------------
4808 // Signed Saturating Doubling Multiply-Add Long
4809 //----------------------------------------------------------------------
4810
4811     sqdmlal s17, h27, s12
4812     sqdmlal d19, s24, d12
4813
4814 // CHECK-ERROR: error: invalid operand for instruction
4815 // CHECK-ERROR:        sqdmlal s17, h27, s12
4816 // CHECK-ERROR:                          ^
4817 // CHECK-ERROR: error: invalid operand for instruction
4818 // CHECK-ERROR:        sqdmlal d19, s24, d12
4819 // CHECK-ERROR:                          ^
4820
4821 //----------------------------------------------------------------------
4822 // Signed Saturating Doubling Multiply-Subtract Long
4823 //----------------------------------------------------------------------
4824
4825     sqdmlsl s14, h12, s25
4826     sqdmlsl d12, s23, d13
4827
4828 // CHECK-ERROR: error: invalid operand for instruction
4829 // CHECK-ERROR:        sqdmlsl s14, h12, s25
4830 // CHECK-ERROR:                          ^
4831 // CHECK-ERROR: error: invalid operand for instruction
4832 // CHECK-ERROR:        sqdmlsl d12, s23, d13
4833 // CHECK-ERROR:                          ^
4834
4835 //----------------------------------------------------------------------
4836 // Signed Saturating Doubling Multiply Long
4837 //----------------------------------------------------------------------
4838
4839     sqdmull s12, h22, s12
4840     sqdmull d15, s22, d12
4841
4842 // CHECK-ERROR: error: invalid operand for instruction
4843 // CHECK-ERROR:        sqdmull s12, h22, s12
4844 // CHECK-ERROR:                          ^
4845 // CHECK-ERROR: error: invalid operand for instruction
4846 // CHECK-ERROR:        sqdmull d15, s22, d12
4847 // CHECK-ERROR:                          ^
4848
4849 //----------------------------------------------------------------------
4850 // Scalar Signed Saturating Extract Unsigned Narrow
4851 //----------------------------------------------------------------------
4852
4853     sqxtun b19, b14
4854     sqxtun h21, h15
4855     sqxtun s20, s12
4856
4857 // CHECK-ERROR: error: invalid operand for instruction
4858 // CHECK-ERROR:        sqxtun b19, b14
4859 // CHECK-ERROR:                    ^
4860 // CHECK-ERROR: error: invalid operand for instruction
4861 // CHECK-ERROR:        sqxtun h21, h15
4862 // CHECK-ERROR:                    ^
4863 // CHECK-ERROR: error: invalid operand for instruction
4864 // CHECK-ERROR:        sqxtun s20, s12
4865 // CHECK-ERROR:                    ^
4866
4867 //----------------------------------------------------------------------
4868 // Scalar Signed Saturating Extract Signed Narrow
4869 //----------------------------------------------------------------------
4870
4871     sqxtn b18, b18
4872     sqxtn h20, h17
4873     sqxtn s19, s14
4874
4875 // CHECK-ERROR: error: invalid operand for instruction
4876 // CHECK-ERROR:        sqxtn b18, b18
4877 // CHECK-ERROR:                   ^
4878 // CHECK-ERROR: error: invalid operand for instruction
4879 // CHECK-ERROR:        sqxtn h20, h17
4880 // CHECK-ERROR:                   ^
4881 // CHECK-ERROR: error: invalid operand for instruction
4882 // CHECK-ERROR:        sqxtn s19, s14
4883 // CHECK-ERROR:                   ^
4884
4885
4886 //----------------------------------------------------------------------
4887 // Scalar Unsigned Saturating Extract Narrow
4888 //----------------------------------------------------------------------
4889
4890     uqxtn b18, b18
4891     uqxtn h20, h17
4892     uqxtn s19, s14
4893
4894 // CHECK-ERROR: error: invalid operand for instruction
4895 // CHECK-ERROR:        uqxtn b18, b18
4896 // CHECK-ERROR:                   ^
4897 // CHECK-ERROR: error: invalid operand for instruction
4898 // CHECK-ERROR:        uqxtn h20, h17
4899 // CHECK-ERROR:                   ^
4900 // CHECK-ERROR: error: invalid operand for instruction
4901 // CHECK-ERROR:        uqxtn s19, s14
4902 // CHECK-ERROR:                   ^
4903
4904 //----------------------------------------------------------------------
4905 // Scalar Signed Shift Right (Immediate)
4906 //----------------------------------------------------------------------
4907         sshr d15, d16, #99
4908
4909 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4910 // CHECK-ERROR:        sshr d15, d16, #99
4911 // CHECK-ERROR:                       ^
4912
4913         sshr d15, s16, #31
4914
4915 // CHECK-ERROR: error: invalid operand for instruction
4916 // CHECK-ERROR:        sshr d15, s16, #31
4917 // CHECK-ERROR:                  ^
4918
4919 //----------------------------------------------------------------------
4920 // Scalar Unsigned Shift Right (Immediate)
4921 //----------------------------------------------------------------------
4922
4923         ushr d10, d17, #99
4924
4925 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4926 // CHECK-ERROR:        ushr d10, d17, #99
4927 // CHECK-ERROR:                       ^
4928
4929 //----------------------------------------------------------------------
4930 // Scalar Signed Rounding Shift Right (Immediate)
4931 //----------------------------------------------------------------------
4932
4933         srshr d19, d18, #99
4934
4935 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4936 // CHECK-ERROR:        srshr d19, d18, #99
4937 // CHECK-ERROR:                        ^
4938
4939 //----------------------------------------------------------------------
4940 // Scalar Unigned Rounding Shift Right (Immediate)
4941 //----------------------------------------------------------------------
4942
4943         urshr d20, d23, #99
4944
4945 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4946 // CHECK-ERROR:        urshr d20, d23, #99
4947 // CHECK-ERROR:                        ^
4948
4949 //----------------------------------------------------------------------
4950 // Scalar Signed Shift Right and Accumulate (Immediate)
4951 //----------------------------------------------------------------------
4952
4953         ssra d18, d12, #99
4954
4955 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4956 // CHECK-ERROR:        ssra d18, d12, #99
4957 // CHECK-ERROR:                       ^
4958
4959 //----------------------------------------------------------------------
4960 // Scalar Unsigned Shift Right and Accumulate (Immediate)
4961 //----------------------------------------------------------------------
4962
4963         usra d20, d13, #99
4964
4965 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4966 // CHECK-ERROR:        usra d20, d13, #99
4967 // CHECK-ERROR:                       ^
4968
4969 //----------------------------------------------------------------------
4970 // Scalar Signed Rounding Shift Right and Accumulate (Immediate)
4971 //----------------------------------------------------------------------
4972
4973         srsra d15, d11, #99
4974
4975 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4976 // CHECK-ERROR:        srsra d15, d11, #99
4977 // CHECK-ERROR:                        ^
4978
4979 //----------------------------------------------------------------------
4980 // Scalar Unsigned Rounding Shift Right and Accumulate (Immediate)
4981 //----------------------------------------------------------------------
4982
4983         ursra d18, d10, #99
4984
4985 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
4986 // CHECK-ERROR:        ursra d18, d10, #99
4987 // CHECK-ERROR:                        ^
4988
4989 //----------------------------------------------------------------------
4990 // Scalar Shift Left (Immediate)
4991 //----------------------------------------------------------------------
4992
4993         shl d7, d10, #99
4994
4995 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
4996 // CHECK-ERROR:        shl d7, d10, #99
4997 // CHECK-ERROR:                     ^
4998
4999         shl d7, s16, #31
5000
5001 // CHECK-ERROR: error: invalid operand for instruction
5002 // CHECK-ERROR:        shl d7, s16, #31
5003 // CHECK-ERROR:                ^
5004
5005 //----------------------------------------------------------------------
5006 // Signed Saturating Shift Left (Immediate)
5007 //----------------------------------------------------------------------
5008
5009         sqshl b11, b19, #99
5010         sqshl h13, h18, #99
5011         sqshl s14, s17, #99
5012         sqshl d15, d16, #99
5013
5014 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
5015 // CHECK-ERROR:        sqshl b11, b19, #99
5016 // CHECK-ERROR:                        ^
5017 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
5018 // CHECK-ERROR:        sqshl h13, h18, #99
5019 // CHECK-ERROR:                        ^
5020 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
5021 // CHECK-ERROR:        sqshl s14, s17, #99
5022 // CHECK-ERROR:                        ^
5023 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
5024 // CHECK-ERROR:        sqshl d15, d16, #99
5025 // CHECK-ERROR:                        ^
5026
5027 //----------------------------------------------------------------------
5028 // Unsigned Saturating Shift Left (Immediate)
5029 //----------------------------------------------------------------------
5030
5031         uqshl b18, b15, #99
5032         uqshl h11, h18, #99
5033         uqshl s14, s19, #99
5034         uqshl d15, d12, #99
5035
5036 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
5037 // CHECK-ERROR:        uqshl b18, b15, #99
5038 // CHECK-ERROR:                        ^
5039 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
5040 // CHECK-ERROR:        uqshl h11, h18, #99
5041 // CHECK-ERROR:                        ^
5042 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
5043 // CHECK-ERROR:        uqshl s14, s19, #99
5044 // CHECK-ERROR:                        ^
5045 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
5046 // CHECK-ERROR:        uqshl d15, d12, #99
5047 // CHECK-ERROR:                        ^
5048
5049 //----------------------------------------------------------------------
5050 // Signed Saturating Shift Left Unsigned (Immediate)
5051 //----------------------------------------------------------------------
5052
5053         sqshlu b15, b18, #99
5054         sqshlu h19, h17, #99
5055         sqshlu s16, s14, #99
5056         sqshlu d11, d13, #99
5057
5058 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
5059 // CHECK-ERROR:        sqshlu  b15, b18, #99
5060 // CHECK-ERROR:                          ^
5061 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
5062 // CHECK-ERROR:        sqshlu  h19, h17, #99
5063 // CHECK-ERROR:                          ^
5064 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
5065 // CHECK-ERROR:        sqshlu  s16, s14, #99
5066 // CHECK-ERROR:                          ^
5067 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
5068 // CHECK-ERROR:        sqshlu  d11, d13, #99
5069 // CHECK-ERROR:                          ^
5070
5071 //----------------------------------------------------------------------
5072 // Shift Right And Insert (Immediate)
5073 //----------------------------------------------------------------------
5074
5075         sri d10, d12, #99
5076
5077 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
5078 // CHECK-ERROR:        sri d10, d12, #99
5079 // CHECK-ERROR:                      ^
5080
5081 //----------------------------------------------------------------------
5082 // Shift Left And Insert (Immediate)
5083 //----------------------------------------------------------------------
5084
5085         sli d10, d14, #99
5086
5087 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
5088 // CHECK-ERROR:        sli d10, d14, #99
5089 // CHECK-ERROR:                      ^
5090
5091 //----------------------------------------------------------------------
5092 // Signed Saturating Shift Right Narrow (Immediate)
5093 //----------------------------------------------------------------------
5094
5095         sqshrn b10, h15, #99
5096         sqshrn h17, s10, #99
5097         sqshrn s18, d10, #99
5098
5099 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5100 // CHECK-ERROR:        sqshrn  b10, h15, #99
5101 // CHECK-ERROR:                          ^
5102 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5103 // CHECK-ERROR:        sqshrn  h17, s10, #99
5104 // CHECK-ERROR:                          ^
5105 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5106 // CHECK-ERROR:        sqshrn  s18, d10, #99
5107 // CHECK-ERROR:                          ^
5108
5109 //----------------------------------------------------------------------
5110 // Unsigned Saturating Shift Right Narrow (Immediate)
5111 //----------------------------------------------------------------------
5112
5113         uqshrn b12, h10, #99
5114         uqshrn h10, s14, #99
5115         uqshrn s10, d12, #99
5116
5117 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5118 // CHECK-ERROR:        uqshrn  b12, h10, #99
5119 // CHECK-ERROR:                          ^
5120 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5121 // CHECK-ERROR:        uqshrn  h10, s14, #99
5122 // CHECK-ERROR:                          ^
5123 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5124 // CHECK-ERROR:        uqshrn  s10, d12, #99
5125 // CHECK-ERROR:                          ^
5126
5127 //----------------------------------------------------------------------
5128 // Signed Saturating Rounded Shift Right Narrow (Immediate)
5129 //----------------------------------------------------------------------
5130
5131         sqrshrn b10, h13, #99
5132         sqrshrn h15, s10, #99
5133         sqrshrn s15, d12, #99
5134
5135 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5136 // CHECK-ERROR:        sqrshrn b10, h13, #99
5137 // CHECK-ERROR:                          ^
5138 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5139 // CHECK-ERROR:        sqrshrn h15, s10, #99
5140 // CHECK-ERROR:                          ^
5141 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5142 // CHECK-ERROR:        sqrshrn s15, d12, #99
5143 // CHECK-ERROR:                          ^
5144
5145 //----------------------------------------------------------------------
5146 // Unsigned Saturating Rounded Shift Right Narrow (Immediate)
5147 //----------------------------------------------------------------------
5148
5149         uqrshrn b10, h12, #99
5150         uqrshrn h12, s10, #99
5151         uqrshrn s10, d10, #99
5152
5153 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5154 // CHECK-ERROR:        uqrshrn b10, h12, #99
5155 // CHECK-ERROR:                          ^
5156 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5157 // CHECK-ERROR:        uqrshrn h12, s10, #99
5158 // CHECK-ERROR:                          ^
5159 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5160 // CHECK-ERROR:        uqrshrn s10, d10, #99
5161 // CHECK-ERROR:                          ^
5162
5163 //----------------------------------------------------------------------
5164 // Signed Saturating Shift Right Unsigned Narrow (Immediate)
5165 //----------------------------------------------------------------------
5166
5167         sqshrun b15, h10, #99
5168         sqshrun h20, s14, #99
5169         sqshrun s10, d15, #99
5170
5171 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5172 // CHECK-ERROR:        sqshrun b15, h10, #99
5173 // CHECK-ERROR:                          ^
5174 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5175 // CHECK-ERROR:        sqshrun h20, s14, #99
5176 // CHECK-ERROR:                          ^
5177 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5178 // CHECK-ERROR:        sqshrun s10, d15, #99
5179 // CHECK-ERROR:                          ^
5180
5181 //----------------------------------------------------------------------
5182 // Signed Saturating Rounded Shift Right Unsigned Narrow (Immediate)
5183 //----------------------------------------------------------------------
5184
5185         sqrshrun b17, h10, #99
5186         sqrshrun h10, s13, #99
5187         sqrshrun s22, d16, #99
5188
5189 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
5190 // CHECK-ERROR:        sqrshrun b17, h10, #99
5191 // CHECK-ERROR:                           ^
5192 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
5193 // CHECK-ERROR:        sqrshrun h10, s13, #99
5194 // CHECK-ERROR:                           ^
5195 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5196 // CHECK-ERROR:        sqrshrun s22, d16, #99
5197 // CHECK-ERROR:                           ^
5198
5199 //----------------------------------------------------------------------
5200 // Scalar Signed Fixed-point Convert To Floating-Point (Immediate)
5201 //----------------------------------------------------------------------
5202
5203     scvtf s22, s13, #0
5204     scvtf s22, s13, #33
5205     scvtf d21, d12, #65
5206     scvtf d21, s12, #31
5207
5208 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5209 // CHECK-ERROR:        scvtf s22, s13, #0
5210 // CHECK-ERROR:                        ^
5211 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5212 // CHECK-ERROR:        scvtf s22, s13, #33
5213 // CHECK-ERROR:                        ^
5214 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
5215 // CHECK-ERROR:        scvtf d21, d12, #65
5216 // CHECK-ERROR:                        ^
5217 // CHECK-ERROR: error: invalid operand for instruction
5218 // CHECK-ERROR:        scvtf d21, s12, #31
5219 // CHECK-ERROR:                   ^
5220
5221 //----------------------------------------------------------------------
5222 // Scalar Unsigned Fixed-point Convert To Floating-Point (Immediate)
5223 //----------------------------------------------------------------------
5224
5225     ucvtf s22, s13, #34
5226     ucvtf d21, d14, #65
5227     ucvtf d21, s14, #64
5228
5229 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
5230 // CHECK-ERROR:        ucvtf s22, s13, #34
5231 // CHECK-ERROR:                        ^
5232 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
5233 // CHECK-ERROR:        ucvtf d21, d14, #65
5234 // CHECK-ERROR:                        ^
5235 // CHECK-ERROR: error: invalid operand for instruction
5236 // CHECK-ERROR:        ucvtf d21, s14, #64
5237 // CHECK-ERROR:                   ^
5238
5239 //------------------------------------------------------------------------------
5240 // Element reverse
5241 //------------------------------------------------------------------------------
5242          rev64 v6.2d, v8.2d
5243          rev32 v30.2s, v31.2s
5244          rev32 v30.4s, v31.4s
5245          rev32 v30.2d, v31.2d
5246          rev16 v21.4h, v1.4h
5247          rev16 v21.8h, v1.8h
5248          rev16 v21.2s, v1.2s
5249          rev16 v21.4s, v1.4s
5250          rev16 v21.2d, v1.2d
5251
5252 // CHECK-ERROR: error: invalid operand for instruction
5253 // CHECK-ERROR:         rev64 v6.2d, v8.2d
5254 // CHECK-ERROR:                  ^
5255 // CHECK-ERROR: error: invalid operand for instruction
5256 // CHECK-ERROR:         rev32 v30.2s, v31.2s
5257 // CHECK-ERROR:                   ^
5258 // CHECK-ERROR: error: invalid operand for instruction
5259 // CHECK-ERROR:         rev32 v30.4s, v31.4s
5260 // CHECK-ERROR:                   ^
5261 // CHECK-ERROR: error: invalid operand for instruction
5262 // CHECK-ERROR:         rev32 v30.2d, v31.2d
5263 // CHECK-ERROR:                   ^
5264 // CHECK-ERROR: error: invalid operand for instruction
5265 // CHECK-ERROR:         rev16 v21.4h, v1.4h
5266 // CHECK-ERROR:                   ^
5267 // CHECK-ERROR: error: invalid operand for instruction
5268 // CHECK-ERROR:         rev16 v21.8h, v1.8h
5269 // CHECK-ERROR:                   ^
5270 // CHECK-ERROR: error: invalid operand for instruction
5271 // CHECK-ERROR:         rev16 v21.2s, v1.2s
5272 // CHECK-ERROR:                   ^
5273 // CHECK-ERROR: error: invalid operand for instruction
5274 // CHECK-ERROR:         rev16 v21.4s, v1.4s
5275 // CHECK-ERROR:                   ^
5276 // CHECK-ERROR: error: invalid operand for instruction
5277 // CHECK-ERROR:         rev16 v21.2d, v1.2d
5278 // CHECK-ERROR:                   ^
5279
5280 //------------------------------------------------------------------------------
5281 // Signed integer pairwise add long
5282 //------------------------------------------------------------------------------
5283
5284          saddlp v3.8h, v21.8h
5285          saddlp v8.8b, v5.8b
5286          saddlp v9.8h, v1.4s
5287          saddlp v0.4s, v1.2d
5288
5289 // CHECK-ERROR: error: invalid operand for instruction
5290 // CHECK-ERROR:         saddlp v3.8h, v21.8h
5291 // CHECK-ERROR:                           ^
5292 // CHECK-ERROR: error: invalid operand for instruction
5293 // CHECK-ERROR:         saddlp v8.8b, v5.8b
5294 // CHECK-ERROR:                   ^
5295 // CHECK-ERROR: error: invalid operand for instruction
5296 // CHECK-ERROR:         saddlp v9.8h, v1.4s
5297 // CHECK-ERROR:                          ^
5298 // CHECK-ERROR: error: invalid operand for instruction
5299 // CHECK-ERROR:         saddlp v0.4s, v1.2d
5300 // CHECK-ERROR:                          ^
5301
5302 //------------------------------------------------------------------------------
5303 // Unsigned integer pairwise add long
5304 //------------------------------------------------------------------------------
5305
5306          uaddlp v3.8h, v21.8h
5307          uaddlp v8.8b, v5.8b
5308          uaddlp v9.8h, v1.4s
5309          uaddlp v0.4s, v1.2d
5310
5311 // CHECK-ERROR: error: invalid operand for instruction
5312 // CHECK-ERROR:         uaddlp v3.8h, v21.8h
5313 // CHECK-ERROR:                           ^
5314 // CHECK-ERROR: error: invalid operand for instruction
5315 // CHECK-ERROR:         uaddlp v8.8b, v5.8b
5316 // CHECK-ERROR:                   ^
5317 // CHECK-ERROR: error: invalid operand for instruction
5318 // CHECK-ERROR:         uaddlp v9.8h, v1.4s
5319 // CHECK-ERROR:                          ^
5320 // CHECK-ERROR: error: invalid operand for instruction
5321 // CHECK-ERROR:         uaddlp v0.4s, v1.2d
5322 // CHECK-ERROR:                          ^
5323
5324 //------------------------------------------------------------------------------
5325 // Signed integer pairwise add and accumulate long
5326 //------------------------------------------------------------------------------
5327
5328          sadalp v3.16b, v21.16b
5329          sadalp v8.4h, v5.4h
5330          sadalp v9.4s, v1.4s
5331          sadalp v0.4h, v1.2s
5332          sadalp v12.2d, v4.8h
5333
5334 // CHECK-ERROR: error: invalid operand for instruction
5335 // CHECK-ERROR:         sadalp v3.16b, v21.16b
5336 // CHECK-ERROR:                   ^
5337 // CHECK-ERROR: error: invalid operand for instruction
5338 // CHECK-ERROR:         sadalp v8.4h, v5.4h
5339 // CHECK-ERROR:                          ^
5340 // CHECK-ERROR: error: invalid operand for instruction
5341 // CHECK-ERROR:         sadalp v9.4s, v1.4s
5342 // CHECK-ERROR:                          ^
5343 // CHECK-ERROR: error: invalid operand for instruction
5344 // CHECK-ERROR:         sadalp v0.4h, v1.2s
5345 // CHECK-ERROR:                          ^
5346 // CHECK-ERROR: error: invalid operand for instruction
5347 // CHECK-ERROR:         sadalp v12.2d, v4.8h
5348 // CHECK-ERROR:                           ^
5349
5350 //------------------------------------------------------------------------------
5351 // Unsigned integer pairwise add and accumulate long
5352 //------------------------------------------------------------------------------
5353
5354          uadalp v3.16b, v21.16b
5355          uadalp v8.4h, v5.4h
5356          uadalp v9.4s, v1.4s
5357          uadalp v0.4h, v1.2s
5358          uadalp v12.2d, v4.8h
5359
5360 // CHECK-ERROR: error: invalid operand for instruction
5361 // CHECK-ERROR:         uadalp v3.16b, v21.16b
5362 // CHECK-ERROR:                   ^
5363 // CHECK-ERROR: error: invalid operand for instruction
5364 // CHECK-ERROR:         uadalp v8.4h, v5.4h
5365 // CHECK-ERROR:                          ^
5366 // CHECK-ERROR: error: invalid operand for instruction
5367 // CHECK-ERROR:         uadalp v9.4s, v1.4s
5368 // CHECK-ERROR:                          ^
5369 // CHECK-ERROR: error: invalid operand for instruction
5370 // CHECK-ERROR:         uadalp v0.4h, v1.2s
5371 // CHECK-ERROR:                          ^
5372 // CHECK-ERROR: error: invalid operand for instruction
5373 // CHECK-ERROR:         uadalp v12.2d, v4.8h
5374 // CHECK-ERROR:                           ^
5375
5376 //------------------------------------------------------------------------------
5377 // Signed integer saturating accumulate of unsigned value
5378 //------------------------------------------------------------------------------
5379
5380          suqadd v0.16b, v31.8b
5381          suqadd v1.8b, v9.8h
5382          suqadd v13.4h, v21.4s
5383          suqadd v4.2s, v0.2d
5384
5385 // CHECK-ERROR: error: invalid operand for instruction
5386 // CHECK-ERROR:         suqadd v0.16b, v31.8b
5387 // CHECK-ERROR:                        ^
5388 // CHECK-ERROR: error: invalid operand for instruction
5389 // CHECK-ERROR:         suqadd v1.8b, v9.8h
5390 // CHECK-ERROR:                       ^
5391 // CHECK-ERROR: error: invalid operand for instruction
5392 // CHECK-ERROR:         suqadd v13.4h, v21.4s
5393 // CHECK-ERROR:                        ^
5394 // CHECK-ERROR: error: invalid operand for instruction
5395 // CHECK-ERROR:         suqadd v4.2s, v0.2d
5396 // CHECK-ERROR:                       ^
5397
5398 //------------------------------------------------------------------------------
5399 // Unsigned integer saturating accumulate of signed value
5400 //------------------------------------------------------------------------------
5401
5402          usqadd v0.16b, v31.8b
5403          usqadd v2.8h, v4.4h
5404          usqadd v13.4h, v21.4s
5405          usqadd v4.2s, v0.2d
5406
5407 // CHECK-ERROR: error: invalid operand for instruction
5408 // CHECK-ERROR:         usqadd v0.16b, v31.8b
5409 // CHECK-ERROR:                        ^
5410 // CHECK-ERROR: error: invalid operand for instruction
5411 // CHECK-ERROR:         usqadd v2.8h, v4.4h
5412 // CHECK-ERROR:                       ^
5413 // CHECK-ERROR: error: invalid operand for instruction
5414 // CHECK-ERROR:         usqadd v13.4h, v21.4s
5415 // CHECK-ERROR:                        ^
5416 // CHECK-ERROR: error: invalid operand for instruction
5417 // CHECK-ERROR:         usqadd v4.2s, v0.2d
5418 // CHECK-ERROR:                       ^
5419
5420 //------------------------------------------------------------------------------
5421 // Integer saturating absolute
5422 //------------------------------------------------------------------------------
5423
5424          sqabs v0.16b, v31.8b
5425          sqabs v2.8h, v4.4h
5426          sqabs v6.4s, v8.2s
5427          sqabs v6.2d, v8.2s
5428
5429 // CHECK-ERROR: error: invalid operand for instruction
5430 // CHECK-ERROR:         sqabs v0.16b, v31.8b
5431 // CHECK-ERROR:                       ^
5432 // CHECK-ERROR: error: invalid operand for instruction
5433 // CHECK-ERROR:         sqabs v2.8h, v4.4h
5434 // CHECK-ERROR:                      ^
5435 // CHECK-ERROR: error: invalid operand for instruction
5436 // CHECK-ERROR:         sqabs v6.4s, v8.2s
5437 // CHECK-ERROR:                      ^
5438 // CHECK-ERROR: error: invalid operand for instruction
5439 // CHECK-ERROR:         sqabs v6.2d, v8.2s
5440 // CHECK-ERROR:                      ^
5441
5442 //------------------------------------------------------------------------------
5443 // Signed integer saturating negate
5444 //------------------------------------------------------------------------------
5445
5446          sqneg v0.16b, v31.8b
5447          sqneg v2.8h, v4.4h
5448          sqneg v6.4s, v8.2s
5449          sqneg v6.2d, v8.2s
5450
5451 // CHECK-ERROR: error: invalid operand for instruction
5452 // CHECK-ERROR:         sqneg v0.16b, v31.8b
5453 // CHECK-ERROR:                       ^
5454 // CHECK-ERROR: error: invalid operand for instruction
5455 // CHECK-ERROR:         sqneg v2.8h, v4.4h
5456 // CHECK-ERROR:                      ^
5457 // CHECK-ERROR: error: invalid operand for instruction
5458 // CHECK-ERROR:         sqneg v6.4s, v8.2s
5459 // CHECK-ERROR:                      ^
5460 // CHECK-ERROR: error: invalid operand for instruction
5461 // CHECK-ERROR:         sqneg v6.2d, v8.2s
5462 // CHECK-ERROR:                      ^
5463
5464 //------------------------------------------------------------------------------
5465 // Integer absolute
5466 //------------------------------------------------------------------------------
5467
5468          abs v0.16b, v31.8b
5469          abs v2.8h, v4.4h
5470          abs v6.4s, v8.2s
5471          abs v6.2d, v8.2s
5472
5473 // CHECK-ERROR: error: invalid operand for instruction
5474 // CHECK-ERROR:         abs v0.16b, v31.8b
5475 // CHECK-ERROR:                     ^
5476 // CHECK-ERROR: error: invalid operand for instruction
5477 // CHECK-ERROR:         abs v2.8h, v4.4h
5478 // CHECK-ERROR:                    ^
5479 // CHECK-ERROR: error: invalid operand for instruction
5480 // CHECK-ERROR:         abs v6.4s, v8.2s
5481 // CHECK-ERROR:                    ^
5482 // CHECK-ERROR: error: invalid operand for instruction
5483 // CHECK-ERROR:         abs v6.2d, v8.2s
5484 // CHECK-ERROR:                    ^
5485
5486 //------------------------------------------------------------------------------
5487 // Integer count leading sign bits
5488 //------------------------------------------------------------------------------
5489
5490          cls v0.2d, v31.2d
5491
5492 // CHECK-ERROR: error: invalid operand for instruction
5493 // CHECK-ERROR:         cls v0.2d, v31.2d
5494 // CHECK-ERROR:                ^
5495
5496 //------------------------------------------------------------------------------
5497 // Integer count leading zeros
5498 //------------------------------------------------------------------------------
5499
5500          clz v0.2d, v31.2d
5501
5502 // CHECK-ERROR: error: invalid operand for instruction
5503 // CHECK-ERROR:         clz v0.2d, v31.2d
5504 // CHECK-ERROR:                ^
5505
5506 //------------------------------------------------------------------------------
5507 // Population count
5508 //------------------------------------------------------------------------------
5509
5510          cnt v2.8h, v4.8h
5511          cnt v6.4s, v8.4s
5512          cnt v6.2d, v8.2d
5513          cnt v13.4h, v21.4h
5514          cnt v4.2s, v0.2s
5515
5516 // CHECK-ERROR: error: invalid operand for instruction
5517 // CHECK-ERROR:         cnt v2.8h, v4.8h
5518 // CHECK-ERROR:                ^
5519 // CHECK-ERROR: error: invalid operand for instruction
5520 // CHECK-ERROR:         cnt v6.4s, v8.4s
5521 // CHECK-ERROR:                ^
5522 // CHECK-ERROR: error: invalid operand for instruction
5523 // CHECK-ERROR:         cnt v6.2d, v8.2d
5524 // CHECK-ERROR:                ^
5525 // CHECK-ERROR: error: invalid operand for instruction
5526 // CHECK-ERROR:         cnt v13.4h, v21.4h
5527 // CHECK-ERROR:                 ^
5528 // CHECK-ERROR: error: invalid operand for instruction
5529 // CHECK-ERROR:         cnt v4.2s, v0.2s
5530 // CHECK-ERROR:                ^
5531
5532
5533 //------------------------------------------------------------------------------
5534 // Bitwise NOT
5535 //------------------------------------------------------------------------------
5536
5537          not v2.8h, v4.8h
5538          not v6.4s, v8.4s
5539          not v6.2d, v8.2d
5540          not v13.4h, v21.4h
5541          not v4.2s, v0.2s
5542
5543 // CHECK-ERROR: error: invalid operand for instruction
5544 // CHECK-ERROR:         not v2.8h, v4.8h
5545 // CHECK-ERROR:                ^
5546 // CHECK-ERROR: error: invalid operand for instruction
5547 // CHECK-ERROR:         not v6.4s, v8.4s
5548 // CHECK-ERROR:                ^
5549 // CHECK-ERROR: error: invalid operand for instruction
5550 // CHECK-ERROR:         not v6.2d, v8.2d
5551 // CHECK-ERROR:                ^
5552 // CHECK-ERROR: error: invalid operand for instruction
5553 // CHECK-ERROR:         not v13.4h, v21.4h
5554 // CHECK-ERROR:                 ^
5555 // CHECK-ERROR: error: invalid operand for instruction
5556 // CHECK-ERROR:         not v4.2s, v0.2s
5557 // CHECK-ERROR:                ^
5558
5559 //------------------------------------------------------------------------------
5560 // Bitwise reverse
5561 //------------------------------------------------------------------------------
5562
5563          rbit v2.8h, v4.8h
5564          rbit v6.4s, v8.4s
5565          rbit v6.2d, v8.2d
5566          rbit v13.4h, v21.4h
5567          rbit v4.2s, v0.2s
5568
5569 // CHECK-ERROR: error: invalid operand for instruction
5570 // CHECK-ERROR:         rbit v2.8h, v4.8h
5571 // CHECK-ERROR:                 ^
5572 // CHECK-ERROR: error: invalid operand for instruction
5573 // CHECK-ERROR:         rbit v6.4s, v8.4s
5574 // CHECK-ERROR:                 ^
5575 // CHECK-ERROR: error: invalid operand for instruction
5576 // CHECK-ERROR:         rbit v6.2d, v8.2d
5577 // CHECK-ERROR:                 ^
5578 // CHECK-ERROR: error: invalid operand for instruction
5579 // CHECK-ERROR:         rbit v13.4h, v21.4h
5580 // CHECK-ERROR:                  ^
5581 // CHECK-ERROR: error: invalid operand for instruction
5582 // CHECK-ERROR:         rbit v4.2s, v0.2s
5583 // CHECK-ERROR:                 ^
5584
5585 //------------------------------------------------------------------------------
5586 // Floating-point absolute
5587 //------------------------------------------------------------------------------
5588
5589          fabs v0.16b, v31.16b
5590          fabs v2.8h, v4.8h
5591          fabs v1.8b, v9.8b
5592          fabs v13.4h, v21.4h
5593
5594 // CHECK-ERROR: error: invalid operand for instruction
5595 // CHECK-ERROR:         fabs v0.16b, v31.16b
5596 // CHECK-ERROR:                 ^
5597 // CHECK-ERROR: error: instruction requires: fullfp16
5598 // CHECK-ERROR:         fabs v2.8h, v4.8h
5599 // CHECK-ERROR:                 ^
5600 // CHECK-ERROR: error: invalid operand for instruction
5601 // CHECK-ERROR:         fabs v1.8b, v9.8b
5602 // CHECK-ERROR:                 ^
5603 // CHECK-ERROR: error: instruction requires: fullfp16
5604 // CHECK-ERROR:         fabs v13.4h, v21.4h
5605 // CHECK-ERROR:                  ^
5606
5607 //------------------------------------------------------------------------------
5608 // Floating-point negate
5609 //------------------------------------------------------------------------------
5610
5611          fneg v0.16b, v31.16b
5612          fneg v2.8h, v4.8h
5613          fneg v1.8b, v9.8b
5614          fneg v13.4h, v21.4h
5615
5616 // CHECK-ERROR: error: invalid operand for instruction
5617 // CHECK-ERROR:         fneg v0.16b, v31.16b
5618 // CHECK-ERROR:                 ^
5619 // CHECK-ERROR: error: instruction requires: fullfp16
5620 // CHECK-ERROR:         fneg v2.8h, v4.8h
5621 // CHECK-ERROR:                 ^
5622 // CHECK-ERROR: error: invalid operand for instruction
5623 // CHECK-ERROR:         fneg v1.8b, v9.8b
5624 // CHECK-ERROR:                 ^
5625 // CHECK-ERROR: error: instruction requires: fullfp16
5626 // CHECK-ERROR:         fneg v13.4h, v21.4h
5627 // CHECK-ERROR:                  ^
5628
5629 //------------------------------------------------------------------------------
5630 // Integer extract and narrow
5631 //------------------------------------------------------------------------------
5632
5633          xtn v0.16b, v31.8h
5634          xtn v2.8h, v4.4s
5635          xtn v6.4s, v8.2d
5636          xtn2 v1.8b, v9.8h
5637          xtn2 v13.4h, v21.4s
5638          xtn2 v4.2s, v0.2d
5639
5640 // CHECK-ERROR: error: invalid operand for instruction
5641 // CHECK-ERROR:         xtn v0.16b, v31.8h
5642 // CHECK-ERROR:             ^
5643 // CHECK-ERROR: error: invalid operand for instruction
5644 // CHECK-ERROR:         xtn v2.8h, v4.4s
5645 // CHECK-ERROR:             ^
5646 // CHECK-ERROR: error: invalid operand for instruction
5647 // CHECK-ERROR:         xtn v6.4s, v8.2d
5648 // CHECK-ERROR:             ^
5649 // CHECK-ERROR: error: invalid operand for instruction
5650 // CHECK-ERROR:         xtn2 v1.8b, v9.8h
5651 // CHECK-ERROR:              ^
5652 // CHECK-ERROR: error: invalid operand for instruction
5653 // CHECK-ERROR:         xtn2 v13.4h, v21.4s
5654 // CHECK-ERROR:              ^
5655 // CHECK-ERROR: error: invalid operand for instruction
5656 // CHECK-ERROR:         xtn2 v4.2s, v0.2d
5657 // CHECK-ERROR:              ^
5658
5659 //------------------------------------------------------------------------------
5660 // Signed integer saturating extract and unsigned narrow
5661 //------------------------------------------------------------------------------
5662
5663          sqxtun v0.16b, v31.8h
5664          sqxtun v2.8h, v4.4s
5665          sqxtun v6.4s, v8.2d
5666          sqxtun2 v1.8b, v9.8h
5667          sqxtun2 v13.4h, v21.4s
5668          sqxtun2 v4.2s, v0.2d
5669
5670 // CHECK-ERROR: error: invalid operand for instruction
5671 // CHECK-ERROR:         sqxtun v0.16b, v31.8h
5672 // CHECK-ERROR:                ^
5673 // CHECK-ERROR: error: invalid operand for instruction
5674 // CHECK-ERROR:         sqxtun v2.8h, v4.4s
5675 // CHECK-ERROR:                ^
5676 // CHECK-ERROR: error: invalid operand for instruction
5677 // CHECK-ERROR:         sqxtun v6.4s, v8.2d
5678 // CHECK-ERROR:                ^
5679 // CHECK-ERROR: error: invalid operand for instruction
5680 // CHECK-ERROR:         sqxtun2 v1.8b, v9.8h
5681 // CHECK-ERROR:                 ^
5682 // CHECK-ERROR: error: invalid operand for instruction
5683 // CHECK-ERROR:         sqxtun2 v13.4h, v21.4s
5684 // CHECK-ERROR:                 ^
5685 // CHECK-ERROR: error: invalid operand for instruction
5686 // CHECK-ERROR:         sqxtun2 v4.2s, v0.2d
5687 // CHECK-ERROR:                 ^
5688
5689 //------------------------------------------------------------------------------
5690 // Signed integer saturating extract and narrow
5691 //------------------------------------------------------------------------------
5692
5693          sqxtn v0.16b, v31.8h
5694          sqxtn v2.8h, v4.4s
5695          sqxtn v6.4s, v8.2d
5696          sqxtn2 v1.8b, v9.8h
5697          sqxtn2 v13.4h, v21.4s
5698          sqxtn2 v4.2s, v0.2d
5699
5700 // CHECK-ERROR: error: invalid operand for instruction
5701 // CHECK-ERROR:         sqxtn v0.16b, v31.8h
5702 // CHECK-ERROR:               ^
5703 // CHECK-ERROR: error: invalid operand for instruction
5704 // CHECK-ERROR:         sqxtn v2.8h, v4.4s
5705 // CHECK-ERROR:               ^
5706 // CHECK-ERROR: error: invalid operand for instruction
5707 // CHECK-ERROR:         sqxtn v6.4s, v8.2d
5708 // CHECK-ERROR:               ^
5709 // CHECK-ERROR: error: invalid operand for instruction
5710 // CHECK-ERROR:         sqxtn2 v1.8b, v9.8h
5711 // CHECK-ERROR:                ^
5712 // CHECK-ERROR: error: invalid operand for instruction
5713 // CHECK-ERROR:         sqxtn2 v13.4h, v21.4s
5714 // CHECK-ERROR:                ^
5715 // CHECK-ERROR: error: invalid operand for instruction
5716 // CHECK-ERROR:         sqxtn2 v4.2s, v0.2d
5717 // CHECK-ERROR:                ^
5718
5719 //------------------------------------------------------------------------------
5720 // Unsigned integer saturating extract and narrow
5721 //------------------------------------------------------------------------------
5722
5723          uqxtn v0.16b, v31.8h
5724          uqxtn v2.8h, v4.4s
5725          uqxtn v6.4s, v8.2d
5726          uqxtn2 v1.8b, v9.8h
5727          uqxtn2 v13.4h, v21.4s
5728          uqxtn2 v4.2s, v0.2d
5729
5730 // CHECK-ERROR: error: invalid operand for instruction
5731 // CHECK-ERROR:         uqxtn v0.16b, v31.8h
5732 // CHECK-ERROR:               ^
5733 // CHECK-ERROR: error: invalid operand for instruction
5734 // CHECK-ERROR:         uqxtn v2.8h, v4.4s
5735 // CHECK-ERROR:               ^
5736 // CHECK-ERROR: error: invalid operand for instruction
5737 // CHECK-ERROR:         uqxtn v6.4s, v8.2d
5738 // CHECK-ERROR:               ^
5739 // CHECK-ERROR: error: invalid operand for instruction
5740 // CHECK-ERROR:         uqxtn2 v1.8b, v9.8h
5741 // CHECK-ERROR:                ^
5742 // CHECK-ERROR: error: invalid operand for instruction
5743 // CHECK-ERROR:         uqxtn2 v13.4h, v21.4s
5744 // CHECK-ERROR:                ^
5745 // CHECK-ERROR: error: invalid operand for instruction
5746 // CHECK-ERROR:         uqxtn2 v4.2s, v0.2d
5747 // CHECK-ERROR:                ^
5748
5749 //------------------------------------------------------------------------------
5750 // Integer shift left long
5751 //------------------------------------------------------------------------------
5752
5753          shll2 v2.8h, v4.16b, #7
5754          shll2 v6.4s, v8.8h, #15
5755          shll2 v6.2d, v8.4s, #31
5756          shll v2.8h, v4.16b, #8
5757          shll v6.4s, v8.8h, #16
5758          shll v6.2d, v8.4s, #32
5759          shll v2.8h, v4.8b, #8
5760          shll v6.4s, v8.4h, #16
5761          shll v6.2d, v8.2s, #32
5762          shll2 v2.8h, v4.8b, #5
5763          shll2 v6.4s, v8.4h, #14
5764          shll2 v6.2d, v8.2s, #1
5765
5766 // CHECK-ERROR: error: invalid operand for instruction
5767 // CHECK-ERROR:         shll2 v2.8h, v4.16b, #7
5768 // CHECK-ERROR:                              ^
5769 // CHECK-ERROR: error: invalid operand for instruction
5770 // CHECK-ERROR:         shll2 v6.4s, v8.8h, #15
5771 // CHECK-ERROR:                             ^
5772 // CHECK-ERROR: error: invalid operand for instruction
5773 // CHECK-ERROR:         shll2 v6.2d, v8.4s, #31
5774 // CHECK-ERROR:                             ^
5775 // CHECK-ERROR: error: invalid operand for instruction
5776 // CHECK-ERROR:         shll v2.8h, v4.16b, #8
5777 // CHECK-ERROR:                     ^
5778 // CHECK-ERROR: error: invalid operand for instruction
5779 // CHECK-ERROR:         shll v6.4s, v8.8h, #16
5780 // CHECK-ERROR:                     ^
5781 // CHECK-ERROR: error: invalid operand for instruction
5782 // CHECK-ERROR:         shll v6.2d, v8.4s, #32
5783 // CHECK-ERROR:                     ^
5784 // CHECK-ERROR: error: invalid operand for instruction
5785 // CHECK-ERROR:         shll2 v2.8h, v4.8b, #5
5786 // CHECK-ERROR:                      ^
5787 // CHECK-ERROR: error: invalid operand for instruction
5788 // CHECK-ERROR:         shll2 v6.4s, v8.4h, #14
5789 // CHECK-ERROR:                      ^
5790 // CHECK-ERROR: error: invalid operand for instruction
5791 // CHECK-ERROR:         shll2 v6.2d, v8.2s, #1
5792 // CHECK-ERROR:                      ^
5793
5794 //------------------------------------------------------------------------------
5795 // Floating-point convert downsize
5796 //------------------------------------------------------------------------------
5797
5798          fcvtn v2.8h, v4.4s
5799          fcvtn v6.4s, v8.2d
5800          fcvtn2 v13.4h, v21.4s
5801          fcvtn2 v4.2s, v0.2d
5802
5803 // CHECK-ERROR: error: invalid operand for instruction
5804 // CHECK-ERROR:         fcvtn v2.8h, v4.4s
5805 // CHECK-ERROR:               ^
5806 // CHECK-ERROR: error: invalid operand for instruction
5807 // CHECK-ERROR:         fcvtn v6.4s, v8.2d
5808 // CHECK-ERROR:               ^
5809 // CHECK-ERROR: error: invalid operand for instruction
5810 // CHECK-ERROR:         fcvtn2 v13.4h, v21.4s
5811 // CHECK-ERROR:                ^
5812 // CHECK-ERROR: error: invalid operand for instruction
5813 // CHECK-ERROR:         fcvtn2 v4.2s, v0.2d
5814 // CHECK-ERROR:                ^
5815
5816 //------------------------------------------------------------------------------
5817 // Floating-point convert downsize with inexact
5818 //------------------------------------------------------------------------------
5819
5820          fcvtxn v6.4s, v8.2d
5821          fcvtxn2 v4.2s, v0.2d
5822
5823 // CHECK-ERROR: error: invalid operand for instruction
5824 // CHECK-ERROR:         fcvtxn v6.4s, v8.2d
5825 // CHECK-ERROR:                ^
5826 // CHECK-ERROR: error: invalid operand for instruction
5827 // CHECK-ERROR:         fcvtxn2 v4.2s, v0.2d
5828 // CHECK-ERROR:                 ^
5829
5830 //------------------------------------------------------------------------------
5831 // Floating-point convert upsize
5832 //------------------------------------------------------------------------------
5833
5834          fcvtl2 v9.4s, v1.4h
5835          fcvtl2 v0.2d, v1.2s
5836          fcvtl v12.4s, v4.8h
5837          fcvtl v17.2d, v28.4s
5838
5839 // CHECK-ERROR: error: invalid operand for instruction
5840 // CHECK-ERROR:         fcvtl2 v9.4s, v1.4h
5841 // CHECK-ERROR:                       ^
5842 // CHECK-ERROR: error: invalid operand for instruction
5843 // CHECK-ERROR:         fcvtl2 v0.2d, v1.2s
5844 // CHECK-ERROR:                       ^
5845 // CHECK-ERROR: error: invalid operand for instruction
5846 // CHECK-ERROR:         fcvtl v12.4s, v4.8h
5847 // CHECK-ERROR:                       ^
5848 // CHECK-ERROR: error: invalid operand for instruction
5849 // CHECK-ERROR:         fcvtl v17.2d, v28.4s
5850 // CHECK-ERROR:                       ^
5851
5852 //------------------------------------------------------------------------------
5853 // Floating-point round to integral
5854 //------------------------------------------------------------------------------
5855
5856          frintn v0.16b, v31.16b
5857          frintn v2.8h, v4.8h
5858          frintn v1.8b, v9.8b
5859          frintn v13.4h, v21.4h
5860
5861          frinta v0.16b, v31.16b
5862          frinta v2.8h, v4.8h
5863          frinta v1.8b, v9.8b
5864          frinta v13.4h, v21.4h
5865
5866          frintp v0.16b, v31.16b
5867          frintp v2.8h, v4.8h
5868          frintp v1.8b, v9.8b
5869          frintp v13.4h, v21.4h
5870
5871          frintm v0.16b, v31.16b
5872          frintm v2.8h, v4.8h
5873          frintm v1.8b, v9.8b
5874          frintm v13.4h, v21.4h
5875
5876          frintx v0.16b, v31.16b
5877          frintx v2.8h, v4.8h
5878          frintx v1.8b, v9.8b
5879          frintx v13.4h, v21.4h
5880
5881          frintz v0.16b, v31.16b
5882          frintz v2.8h, v4.8h
5883          frintz v1.8b, v9.8b
5884          frintz v13.4h, v21.4h
5885
5886          frinti v0.16b, v31.16b
5887          frinti v2.8h, v4.8h
5888          frinti v1.8b, v9.8b
5889          frinti v13.4h, v21.4h
5890
5891          fcvtns v0.16b, v31.16b
5892          fcvtns v2.8h, v4.8h
5893          fcvtns v1.8b, v9.8b
5894          fcvtns v13.4h, v21.4h
5895
5896          fcvtnu v0.16b, v31.16b
5897          fcvtnu v2.8h, v4.8h
5898          fcvtnu v1.8b, v9.8b
5899          fcvtnu v13.4h, v21.4h
5900
5901          fcvtps v0.16b, v31.16b
5902          fcvtps v2.8h, v4.8h
5903          fcvtps v1.8b, v9.8b
5904          fcvtps v13.4h, v21.4h
5905
5906          fcvtpu v0.16b, v31.16b
5907          fcvtpu v2.8h, v4.8h
5908          fcvtpu v1.8b, v9.8b
5909          fcvtpu v13.4h, v21.4h
5910
5911          fcvtms v0.16b, v31.16b
5912          fcvtms v2.8h, v4.8h
5913          fcvtms v1.8b, v9.8b
5914          fcvtms v13.4h, v21.4h
5915
5916          fcvtmu v0.16b, v31.16b
5917          fcvtmu v2.8h, v4.8h
5918          fcvtmu v1.8b, v9.8b
5919          fcvtmu v13.4h, v21.4h
5920
5921          fcvtzs v0.16b, v31.16b
5922          fcvtzs v2.8h, v4.8h
5923          fcvtzs v1.8b, v9.8b
5924          fcvtzs v13.4h, v21.4h
5925
5926          fcvtzu v0.16b, v31.16b
5927          fcvtzu v2.8h, v4.8h
5928          fcvtzu v1.8b, v9.8b
5929          fcvtzu v13.4h, v21.4h
5930
5931          fcvtas v0.16b, v31.16b
5932          fcvtas v2.8h, v4.8h
5933          fcvtas v1.8b, v9.8b
5934          fcvtas v13.4h, v21.4h
5935
5936          fcvtau v0.16b, v31.16b
5937          fcvtau v2.8h, v4.8h
5938          fcvtau v1.8b, v9.8b
5939          fcvtau v13.4h, v21.4h
5940
5941          urecpe v0.16b, v31.16b
5942          urecpe v2.8h, v4.8h
5943          urecpe v1.8b, v9.8b
5944          urecpe v13.4h, v21.4h
5945          urecpe v1.2d, v9.2d
5946
5947          ursqrte v0.16b, v31.16b
5948          ursqrte v2.8h, v4.8h
5949          ursqrte v1.8b, v9.8b
5950          ursqrte v13.4h, v21.4h
5951          ursqrte v1.2d, v9.2d
5952
5953          scvtf v0.16b, v31.16b
5954          scvtf v2.8h, v4.8h
5955          scvtf v1.8b, v9.8b
5956          scvtf v13.4h, v21.4h
5957
5958          ucvtf v0.16b, v31.16b
5959          ucvtf v2.8h, v4.8h
5960          ucvtf v1.8b, v9.8b
5961          ucvtf v13.4h, v21.4h
5962
5963          frecpe v0.16b, v31.16b
5964          frecpe v2.8h, v4.8h
5965          frecpe v1.8b, v9.8b
5966          frecpe v13.4h, v21.4h
5967
5968          frsqrte v0.16b, v31.16b
5969          frsqrte v2.8h, v4.8h
5970          frsqrte v1.8b, v9.8b
5971          frsqrte v13.4h, v21.4h
5972
5973          fsqrt v0.16b, v31.16b
5974          fsqrt v2.8h, v4.8h
5975          fsqrt v1.8b, v9.8b
5976          fsqrt v13.4h, v21.4h
5977
5978 // CHECK-ERROR: error: invalid operand for instruction
5979 // CHECK-ERROR:         frintn v0.16b, v31.16b
5980 // CHECK-ERROR:                   ^
5981 // CHECK-ERROR: error: instruction requires: fullfp16
5982 // CHECK-ERROR:         frintn v2.8h, v4.8h
5983 // CHECK-ERROR:                   ^
5984 // CHECK-ERROR: error: invalid operand for instruction
5985 // CHECK-ERROR:         frintn v1.8b, v9.8b
5986 // CHECK-ERROR:                   ^
5987 // CHECK-ERROR: error: instruction requires: fullfp16
5988 // CHECK-ERROR:         frintn v13.4h, v21.4h
5989 // CHECK-ERROR:                    ^
5990 // CHECK-ERROR: error: invalid operand for instruction
5991 // CHECK-ERROR:         frinta v0.16b, v31.16b
5992 // CHECK-ERROR:                   ^
5993 // CHECK-ERROR: error: instruction requires: fullfp16
5994 // CHECK-ERROR:         frinta v2.8h, v4.8h
5995 // CHECK-ERROR:                   ^
5996 // CHECK-ERROR: error: invalid operand for instruction
5997 // CHECK-ERROR:         frinta v1.8b, v9.8b
5998 // CHECK-ERROR:                   ^
5999 // CHECK-ERROR: error: instruction requires: fullfp16
6000 // CHECK-ERROR:         frinta v13.4h, v21.4h
6001 // CHECK-ERROR:                    ^
6002 // CHECK-ERROR: error: invalid operand for instruction
6003 // CHECK-ERROR:         frintp v0.16b, v31.16b
6004 // CHECK-ERROR:                   ^
6005 // CHECK-ERROR: error: instruction requires: fullfp16
6006 // CHECK-ERROR:         frintp v2.8h, v4.8h
6007 // CHECK-ERROR:                   ^
6008 // CHECK-ERROR: error: invalid operand for instruction
6009 // CHECK-ERROR:         frintp v1.8b, v9.8b
6010 // CHECK-ERROR:                   ^
6011 // CHECK-ERROR: error: instruction requires: fullfp16
6012 // CHECK-ERROR:         frintp v13.4h, v21.4h
6013 // CHECK-ERROR:                    ^
6014 // CHECK-ERROR: error: invalid operand for instruction
6015 // CHECK-ERROR:         frintm v0.16b, v31.16b
6016 // CHECK-ERROR:                   ^
6017 // CHECK-ERROR: error: instruction requires: fullfp16
6018 // CHECK-ERROR:         frintm v2.8h, v4.8h
6019 // CHECK-ERROR:                   ^
6020 // CHECK-ERROR: error: invalid operand for instruction
6021 // CHECK-ERROR:         frintm v1.8b, v9.8b
6022 // CHECK-ERROR:                   ^
6023 // CHECK-ERROR: error: instruction requires: fullfp16
6024 // CHECK-ERROR:         frintm v13.4h, v21.4h
6025 // CHECK-ERROR:                    ^
6026 // CHECK-ERROR: error: invalid operand for instruction
6027 // CHECK-ERROR:         frintx v0.16b, v31.16b
6028 // CHECK-ERROR:                   ^
6029 // CHECK-ERROR: error: instruction requires: fullfp16
6030 // CHECK-ERROR:         frintx v2.8h, v4.8h
6031 // CHECK-ERROR:                   ^
6032 // CHECK-ERROR: error: invalid operand for instruction
6033 // CHECK-ERROR:         frintx v1.8b, v9.8b
6034 // CHECK-ERROR:                   ^
6035 // CHECK-ERROR: error: instruction requires: fullfp16
6036 // CHECK-ERROR:         frintx v13.4h, v21.4h
6037 // CHECK-ERROR:                    ^
6038 // CHECK-ERROR: error: invalid operand for instruction
6039 // CHECK-ERROR:         frintz v0.16b, v31.16b
6040 // CHECK-ERROR:                   ^
6041 // CHECK-ERROR: error: instruction requires: fullfp16
6042 // CHECK-ERROR:         frintz v2.8h, v4.8h
6043 // CHECK-ERROR:                   ^
6044 // CHECK-ERROR: error: invalid operand for instruction
6045 // CHECK-ERROR:         frintz v1.8b, v9.8b
6046 // CHECK-ERROR:                   ^
6047 // CHECK-ERROR: error: instruction requires: fullfp16
6048 // CHECK-ERROR:         frintz v13.4h, v21.4h
6049 // CHECK-ERROR:                    ^
6050 // CHECK-ERROR: error: invalid operand for instruction
6051 // CHECK-ERROR:         frinti v0.16b, v31.16b
6052 // CHECK-ERROR:                   ^
6053 // CHECK-ERROR: error: instruction requires: fullfp16
6054 // CHECK-ERROR:         frinti v2.8h, v4.8h
6055 // CHECK-ERROR:                   ^
6056 // CHECK-ERROR: error: invalid operand for instruction
6057 // CHECK-ERROR:         frinti v1.8b, v9.8b
6058 // CHECK-ERROR:                   ^
6059 // CHECK-ERROR: error: instruction requires: fullfp16
6060 // CHECK-ERROR:         frinti v13.4h, v21.4h
6061 // CHECK-ERROR:                    ^
6062 // CHECK-ERROR: error: invalid operand for instruction
6063 // CHECK-ERROR:         fcvtns v0.16b, v31.16b
6064 // CHECK-ERROR:                   ^
6065 // CHECK-ERROR: error: instruction requires: fullfp16
6066 // CHECK-ERROR:         fcvtns v2.8h, v4.8h
6067 // CHECK-ERROR:                   ^
6068 // CHECK-ERROR: error: invalid operand for instruction
6069 // CHECK-ERROR:         fcvtns v1.8b, v9.8b
6070 // CHECK-ERROR:                   ^
6071 // CHECK-ERROR: error: instruction requires: fullfp16
6072 // CHECK-ERROR:         fcvtns v13.4h, v21.4h
6073 // CHECK-ERROR:                    ^
6074 // CHECK-ERROR: error: invalid operand for instruction
6075 // CHECK-ERROR:         fcvtnu v0.16b, v31.16b
6076 // CHECK-ERROR:                   ^
6077 // CHECK-ERROR: error: instruction requires: fullfp16
6078 // CHECK-ERROR:         fcvtnu v2.8h, v4.8h
6079 // CHECK-ERROR:                   ^
6080 // CHECK-ERROR: error: invalid operand for instruction
6081 // CHECK-ERROR:         fcvtnu v1.8b, v9.8b
6082 // CHECK-ERROR:                   ^
6083 // CHECK-ERROR: error: instruction requires: fullfp16
6084 // CHECK-ERROR:         fcvtnu v13.4h, v21.4h
6085 // CHECK-ERROR:                    ^
6086 // CHECK-ERROR: error: invalid operand for instruction
6087 // CHECK-ERROR:         fcvtps v0.16b, v31.16b
6088 // CHECK-ERROR:                   ^
6089 // CHECK-ERROR: error: instruction requires: fullfp16
6090 // CHECK-ERROR:         fcvtps v2.8h, v4.8h
6091 // CHECK-ERROR:                   ^
6092 // CHECK-ERROR: error: invalid operand for instruction
6093 // CHECK-ERROR:         fcvtps v1.8b, v9.8b
6094 // CHECK-ERROR:                   ^
6095 // CHECK-ERROR: error: instruction requires: fullfp16
6096 // CHECK-ERROR:         fcvtps v13.4h, v21.4h
6097 // CHECK-ERROR:                    ^
6098 // CHECK-ERROR: error: invalid operand for instruction
6099 // CHECK-ERROR:         fcvtpu v0.16b, v31.16b
6100 // CHECK-ERROR:                   ^
6101 // CHECK-ERROR: error: instruction requires: fullfp16
6102 // CHECK-ERROR:         fcvtpu v2.8h, v4.8h
6103 // CHECK-ERROR:                   ^
6104 // CHECK-ERROR: error: invalid operand for instruction
6105 // CHECK-ERROR:         fcvtpu v1.8b, v9.8b
6106 // CHECK-ERROR:                   ^
6107 // CHECK-ERROR: error: instruction requires: fullfp16
6108 // CHECK-ERROR:         fcvtpu v13.4h, v21.4h
6109 // CHECK-ERROR:                    ^
6110 // CHECK-ERROR: error: invalid operand for instruction
6111 // CHECK-ERROR:         fcvtms v0.16b, v31.16b
6112 // CHECK-ERROR:                   ^
6113 // CHECK-ERROR: error: instruction requires: fullfp16
6114 // CHECK-ERROR:         fcvtms v2.8h, v4.8h
6115 // CHECK-ERROR:                   ^
6116 // CHECK-ERROR: error: invalid operand for instruction
6117 // CHECK-ERROR:         fcvtms v1.8b, v9.8b
6118 // CHECK-ERROR:                   ^
6119 // CHECK-ERROR: error: instruction requires: fullfp16
6120 // CHECK-ERROR:         fcvtms v13.4h, v21.4h
6121 // CHECK-ERROR:                    ^
6122 // CHECK-ERROR: error: invalid operand for instruction
6123 // CHECK-ERROR:         fcvtmu v0.16b, v31.16b
6124 // CHECK-ERROR:                   ^
6125 // CHECK-ERROR: error: instruction requires: fullfp16
6126 // CHECK-ERROR:         fcvtmu v2.8h, v4.8h
6127 // CHECK-ERROR:                   ^
6128 // CHECK-ERROR: error: invalid operand for instruction
6129 // CHECK-ERROR:         fcvtmu v1.8b, v9.8b
6130 // CHECK-ERROR:                   ^
6131 // CHECK-ERROR: error: instruction requires: fullfp16
6132 // CHECK-ERROR:         fcvtmu v13.4h, v21.4h
6133 // CHECK-ERROR:                    ^
6134 // CHECK-ERROR: error: invalid operand for instruction
6135 // CHECK-ERROR:         fcvtzs v0.16b, v31.16b
6136 // CHECK-ERROR:                   ^
6137 // CHECK-ERROR: error: instruction requires: fullfp16
6138 // CHECK-ERROR:         fcvtzs v2.8h, v4.8h
6139 // CHECK-ERROR:                   ^
6140 // CHECK-ERROR: error: invalid operand for instruction
6141 // CHECK-ERROR:         fcvtzs v1.8b, v9.8b
6142 // CHECK-ERROR:                   ^
6143 // CHECK-ERROR: error: instruction requires: fullfp16
6144 // CHECK-ERROR:         fcvtzs v13.4h, v21.4h
6145 // CHECK-ERROR:                    ^
6146 // CHECK-ERROR: error: invalid operand for instruction
6147 // CHECK-ERROR:         fcvtzu v0.16b, v31.16b
6148 // CHECK-ERROR:                   ^
6149 // CHECK-ERROR: error: instruction requires: fullfp16
6150 // CHECK-ERROR:         fcvtzu v2.8h, v4.8h
6151 // CHECK-ERROR:                   ^
6152 // CHECK-ERROR: error: invalid operand for instruction
6153 // CHECK-ERROR:         fcvtzu v1.8b, v9.8b
6154 // CHECK-ERROR:                   ^
6155 // CHECK-ERROR: error: instruction requires: fullfp16
6156 // CHECK-ERROR:         fcvtzu v13.4h, v21.4h
6157 // CHECK-ERROR:                    ^
6158 // CHECK-ERROR: error: invalid operand for instruction
6159 // CHECK-ERROR:         fcvtas v0.16b, v31.16b
6160 // CHECK-ERROR:                   ^
6161 // CHECK-ERROR: error: instruction requires: fullfp16
6162 // CHECK-ERROR:         fcvtas v2.8h, v4.8h
6163 // CHECK-ERROR:                   ^
6164 // CHECK-ERROR: error: invalid operand for instruction
6165 // CHECK-ERROR:         fcvtas v1.8b, v9.8b
6166 // CHECK-ERROR:                   ^
6167 // CHECK-ERROR: error: instruction requires: fullfp16
6168 // CHECK-ERROR:         fcvtas v13.4h, v21.4h
6169 // CHECK-ERROR:                    ^
6170 // CHECK-ERROR: error: invalid operand for instruction
6171 // CHECK-ERROR:         fcvtau v0.16b, v31.16b
6172 // CHECK-ERROR:                   ^
6173 // CHECK-ERROR: error: instruction requires: fullfp16
6174 // CHECK-ERROR:         fcvtau v2.8h, v4.8h
6175 // CHECK-ERROR:                   ^
6176 // CHECK-ERROR: error: invalid operand for instruction
6177 // CHECK-ERROR:         fcvtau v1.8b, v9.8b
6178 // CHECK-ERROR:                   ^
6179 // CHECK-ERROR: error: instruction requires: fullfp16
6180 // CHECK-ERROR:         fcvtau v13.4h, v21.4h
6181 // CHECK-ERROR:                    ^
6182 // CHECK-ERROR: error: invalid operand for instruction
6183 // CHECK-ERROR:         urecpe v0.16b, v31.16b
6184 // CHECK-ERROR:                   ^
6185 // CHECK-ERROR: error: invalid operand for instruction
6186 // CHECK-ERROR:         urecpe v2.8h, v4.8h
6187 // CHECK-ERROR:                   ^
6188 // CHECK-ERROR: error: invalid operand for instruction
6189 // CHECK-ERROR:         urecpe v1.8b, v9.8b
6190 // CHECK-ERROR:                   ^
6191 // CHECK-ERROR: error: invalid operand for instruction
6192 // CHECK-ERROR:         urecpe v13.4h, v21.4h
6193 // CHECK-ERROR:                    ^
6194 // CHECK-ERROR: error: invalid operand for instruction
6195 // CHECK-ERROR:         urecpe v1.2d, v9.2d
6196 // CHECK-ERROR:                   ^
6197 // CHECK-ERROR: error: invalid operand for instruction
6198 // CHECK-ERROR:         ursqrte v0.16b, v31.16b
6199 // CHECK-ERROR:                    ^
6200 // CHECK-ERROR: error: invalid operand for instruction
6201 // CHECK-ERROR:         ursqrte v2.8h, v4.8h
6202 // CHECK-ERROR:                    ^
6203 // CHECK-ERROR: error: invalid operand for instruction
6204 // CHECK-ERROR:         ursqrte v1.8b, v9.8b
6205 // CHECK-ERROR:                    ^
6206 // CHECK-ERROR: error: invalid operand for instruction
6207 // CHECK-ERROR:         ursqrte v13.4h, v21.4h
6208 // CHECK-ERROR:                     ^
6209 // CHECK-ERROR: error: invalid operand for instruction
6210 // CHECK-ERROR:         ursqrte v1.2d, v9.2d
6211 // CHECK-ERROR:                    ^
6212 // CHECK-ERROR: error: invalid operand for instruction
6213 // CHECK-ERROR:         scvtf v0.16b, v31.16b
6214 // CHECK-ERROR:                  ^
6215 // CHECK-ERROR: error: instruction requires: fullfp16
6216 // CHECK-ERROR:         scvtf v2.8h, v4.8h
6217 // CHECK-ERROR:                  ^
6218 // CHECK-ERROR: error: invalid operand for instruction
6219 // CHECK-ERROR:         scvtf v1.8b, v9.8b
6220 // CHECK-ERROR:                  ^
6221 // CHECK-ERROR: error: instruction requires: fullfp16
6222 // CHECK-ERROR:         scvtf v13.4h, v21.4h
6223 // CHECK-ERROR:                   ^
6224 // CHECK-ERROR: error: invalid operand for instruction
6225 // CHECK-ERROR:         ucvtf v0.16b, v31.16b
6226 // CHECK-ERROR:                  ^
6227 // CHECK-ERROR: error: instruction requires: fullfp16
6228 // CHECK-ERROR:         ucvtf v2.8h, v4.8h
6229 // CHECK-ERROR:                  ^
6230 // CHECK-ERROR: error: invalid operand for instruction
6231 // CHECK-ERROR:         ucvtf v1.8b, v9.8b
6232 // CHECK-ERROR:                  ^
6233 // CHECK-ERROR: error: instruction requires: fullfp16
6234 // CHECK-ERROR:         ucvtf v13.4h, v21.4h
6235 // CHECK-ERROR:                   ^
6236 // CHECK-ERROR: error: invalid operand for instruction
6237 // CHECK-ERROR:         frecpe v0.16b, v31.16b
6238 // CHECK-ERROR:                   ^
6239 // CHECK-ERROR: error: instruction requires: fullfp16
6240 // CHECK-ERROR:         frecpe v2.8h, v4.8h
6241 // CHECK-ERROR:                   ^
6242 // CHECK-ERROR: error: invalid operand for instruction
6243 // CHECK-ERROR:         frecpe v1.8b, v9.8b
6244 // CHECK-ERROR:                   ^
6245 // CHECK-ERROR: error: instruction requires: fullfp16
6246 // CHECK-ERROR:         frecpe v13.4h, v21.4h
6247 // CHECK-ERROR:                    ^
6248 // CHECK-ERROR: error: invalid operand for instruction
6249 // CHECK-ERROR:         frsqrte v0.16b, v31.16b
6250 // CHECK-ERROR:                    ^
6251 // CHECK-ERROR: error: instruction requires: fullfp16
6252 // CHECK-ERROR:         frsqrte v2.8h, v4.8h
6253 // CHECK-ERROR:                    ^
6254 // CHECK-ERROR: error: invalid operand for instruction
6255 // CHECK-ERROR:         frsqrte v1.8b, v9.8b
6256 // CHECK-ERROR:                    ^
6257 // CHECK-ERROR: error: instruction requires: fullfp16
6258 // CHECK-ERROR:         frsqrte v13.4h, v21.4h
6259 // CHECK-ERROR:                     ^
6260 // CHECK-ERROR: error: invalid operand for instruction
6261 // CHECK-ERROR:         fsqrt v0.16b, v31.16b
6262 // CHECK-ERROR:                  ^
6263 // CHECK-ERROR: error: instruction requires: fullfp16
6264 // CHECK-ERROR:         fsqrt v2.8h, v4.8h
6265 // CHECK-ERROR:                  ^
6266 // CHECK-ERROR: error: invalid operand for instruction
6267 // CHECK-ERROR:         fsqrt v1.8b, v9.8b
6268 // CHECK-ERROR:                  ^
6269 // CHECK-ERROR: error: instruction requires: fullfp16
6270 // CHECK-ERROR:         fsqrt v13.4h, v21.4h
6271 // CHECK-ERROR:                   ^
6272
6273 //----------------------------------------------------------------------
6274 // Scalar Floating-point Convert To Signed Fixed-point (Immediate)
6275 //----------------------------------------------------------------------
6276
6277     fcvtzs s21, s12, #0
6278     fcvtzs d21, d12, #65
6279     fcvtzs s21, d12, #1
6280
6281 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
6282 // CHECK-ERROR:        fcvtzs s21, s12, #0
6283 // CHECK-ERROR:                         ^
6284 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
6285 // CHECK-ERROR:        fcvtzs d21, d12, #65
6286 // CHECK-ERROR:                         ^
6287 // CHECK-ERROR: error: invalid operand for instruction
6288 // CHECK-ERROR:        fcvtzs s21, d12, #1
6289 // CHECK-ERROR:                    ^
6290
6291 //----------------------------------------------------------------------
6292 // Scalar Floating-point Convert To Unsigned Fixed-point (Immediate)
6293 //----------------------------------------------------------------------
6294
6295     fcvtzu s21, s12, #33
6296     fcvtzu d21, d12, #0
6297     fcvtzu s21, d12, #1
6298
6299 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
6300 // CHECK-ERROR:        fcvtzu s21, s12, #33
6301 // CHECK-ERROR:                         ^
6302 // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
6303 // CHECK-ERROR:        fcvtzu d21, d12, #0
6304 // CHECK-ERROR:                         ^
6305 // CHECK-ERROR: error: invalid operand for instruction
6306 // CHECK-ERROR:        fcvtzu s21, d12, #1
6307 // CHECK-ERROR:                    ^
6308
6309 //----------------------------------------------------------------------
6310 // Scalar Unsigned Saturating Extract Narrow
6311 //----------------------------------------------------------------------
6312
6313         aese v0.8h, v1.8h
6314         aese v0.4s, v1.4s
6315         aese v0.2d, v1.2d
6316         aesd v0.8h, v1.8h
6317         aesmc v0.8h, v1.8h
6318         aesimc v0.8h, v1.8h
6319
6320 // CHECK:  error: invalid operand for instruction
6321 // CHECK:         aese v0.8h, v1.8h
6322 // CHECK:                 ^
6323 // CHECK:  error: invalid operand for instruction
6324 // CHECK:         aese v0.4s, v1.4s
6325 // CHECK:                 ^
6326 // CHECK:  error: invalid operand for instruction
6327 // CHECK:         aese v0.2d, v1.2d
6328 // CHECK:                 ^
6329 // CHECK:  error: invalid operand for instruction
6330 // CHECK:         aesd v0.8h, v1.8h
6331 // CHECK:                 ^
6332 // CHECK:  error: invalid operand for instruction
6333 // CHECK:         aesmc v0.8h, v1.8h
6334 // CHECK:                  ^
6335 // CHECK:  error: invalid operand for instruction
6336 // CHECK:         aesimc v0.8h, v1.8h
6337 // CHECK:                   ^
6338
6339         sha1h b0, b1
6340         sha1h h0, h1
6341         sha1h d0, d1
6342         sha1h q0, q1
6343         sha1su1 v0.16b, v1.16b
6344         sha1su1 v0.8h, v1.8h
6345         sha1su1 v0.2d, v1.2d
6346         sha256su0 v0.16b, v1.16b
6347
6348 // CHECK:  error: invalid operand for instruction
6349 // CHECK:         sha1h b0, b1
6350 // CHECK:               ^
6351 // CHECK:  error: invalid operand for instruction
6352 // CHECK:         sha1h h0, h1
6353 // CHECK:               ^
6354 // CHECK:  error: invalid operand for instruction
6355 // CHECK:         sha1h d0, d1
6356 // CHECK:               ^
6357 // CHECK:  error: invalid operand for instruction
6358 // CHECK:         sha1h q0, q1
6359 // CHECK:               ^
6360 // CHECK:  error: invalid operand for instruction
6361 // CHECK:         sha1su1 v0.16b, v1.16b
6362 // CHECK:                    ^
6363 // CHECK:  error: invalid operand for instruction
6364 // CHECK:         sha1su1 v0.8h, v1.8h
6365 // CHECK:                    ^
6366 // CHECK:  error: invalid operand for instruction
6367 // CHECK:         sha1su1 v0.2d, v1.2d
6368 // CHECK:                    ^
6369 // CHECK:  error: invalid operand for instruction
6370 // CHECK:         sha256su0 v0.16b, v1.16b
6371 // CHECK:                      ^
6372
6373         sha1c q0, q1, v2.4s
6374         sha1p q0, q1, v2.4s
6375         sha1m q0, q1, v2.4s
6376         sha1su0 v0.16b, v1.16b, v2.16b
6377         sha1su0 v0.8h, v1.8h, v2.8h
6378         sha1su0 v0.2d, v1.2d, v2.2d
6379         sha256h q0, q1, q2
6380         sha256h v0.4s, v1.4s, v2.4s
6381         sha256h2 q0, q1, q2
6382         sha256su1 v0.16b, v1.16b, v2.16b
6383
6384 // CHECK:  error: invalid operand for instruction
6385 // CHECK:         sha1c q0, q1, v2.4s
6386 // CHECK:                   ^
6387 // CHECK:  error: invalid operand for instruction
6388 // CHECK:         sha1p q0, q1, v2.4s
6389 // CHECK:                   ^
6390 // CHECK:  error: invalid operand for instruction
6391 // CHECK:         sha1m q0, q1, v2.4s
6392 // CHECK:                   ^
6393 // CHECK:  error: invalid operand for instruction
6394 // CHECK:         sha1su0 v0.16b, v1.16b, v2.16b
6395 // CHECK:                    ^
6396 // CHECK:  error: invalid operand for instruction
6397 // CHECK:         sha1su0 v0.8h, v1.8h, v2.8h
6398 // CHECK:                    ^
6399 // CHECK:  error: invalid operand for instruction
6400 // CHECK:         sha1su0 v0.2d, v1.2d, v2.2d
6401 // CHECK:                    ^
6402 // CHECK:  error: too few operands for instruction
6403 // CHECK:         sha256h q0, q1, q2
6404 // CHECK:         ^
6405 // CHECK:  error: invalid operand for instruction
6406 // CHECK:         sha256h v0.4s, v1.4s, v2.4s
6407 // CHECK:                    ^
6408 // CHECK:  error: too few operands for instruction
6409 // CHECK:         sha256h2 q0, q1, q2
6410 // CHECK:         ^
6411 // CHECK:  error: invalid operand for instruction
6412 // CHECK:         sha256su1 v0.16b, v1.16b, v2.16b
6413 // CHECK:                      ^
6414
6415 //----------------------------------------------------------------------
6416 // Bitwise extract
6417 //----------------------------------------------------------------------
6418
6419         ext v0.8b, v1.8b, v2.4h, #0x3
6420         ext v0.4h, v1.4h, v2.4h, #0x3
6421         ext v0.2s, v1.2s, v2.2s, #0x1
6422         ext v0.1d, v1.1d, v2.1d, #0x0
6423
6424 // CHECK-ERROR: error: invalid operand for instruction
6425 // CHECK-ERROR:         ext v0.8b, v1.8b, v2.4h, #0x3
6426 // CHECK-ERROR:                              ^
6427 // CHECK-ERROR: error: invalid operand for instruction
6428 // CHECK-ERROR:         ext v0.4h, v1.4h, v2.4h, #0x3
6429 // CHECK-ERROR:                ^
6430 // CHECK-ERROR: error: invalid operand for instruction
6431 // CHECK-ERROR:         ext v0.2s, v1.2s, v2.2s, #0x1
6432 // CHECK-ERROR:                ^
6433 // CHECK-ERROR: error: invalid operand for instruction
6434 // CHECK-ERROR:         ext v0.1d, v1.1d, v2.1d, #0x0
6435 // CHECK-ERROR:                ^
6436
6437         ext v0.16b, v1.16b, v2.8h, #0x3
6438         ext v0.8h, v1.8h, v2.8h, #0x3
6439         ext v0.4s, v1.4s, v2.4s, #0x1
6440         ext v0.2d, v1.2d, v2.2d, #0x0
6441
6442 // CHECK-ERROR: error: invalid operand for instruction
6443 // CHECK-ERROR:         ext v0.16b, v1.16b, v2.8h, #0x3
6444 // CHECK-ERROR:                                ^
6445 // CHECK-ERROR: error: invalid operand for instruction
6446 // CHECK-ERROR:         ext v0.8h, v1.8h, v2.8h, #0x3
6447 // CHECK-ERROR:                ^
6448 // CHECK-ERROR: error: invalid operand for instruction
6449 // CHECK-ERROR:         ext v0.4s, v1.4s, v2.4s, #0x1
6450 // CHECK-ERROR:                ^
6451 // CHECK-ERROR: error: invalid operand for instruction
6452 // CHECK-ERROR:         ext v0.2d, v1.2d, v2.2d, #0x0
6453 // CHECK-ERROR:                ^
6454
6455
6456 //----------------------------------------------------------------------
6457 // Permutation with 3 vectors
6458 //----------------------------------------------------------------------
6459
6460         uzp1 v0.16b, v1.8b, v2.8b
6461         uzp1 v0.8b, v1.4b, v2.4b
6462         uzp1 v0.8h, v1.4h, v2.4h
6463         uzp1 v0.4h, v1.2h, v2.2h
6464         uzp1 v0.4s, v1.2s, v2.2s
6465         uzp1 v0.2s, v1.1s, v2.1s
6466         uzp1 v0.2d, v1.1d, v2.1d
6467         uzp1 v0.1d, v1.1d, v2.1d
6468
6469 // CHECK-ERROR:  error: invalid operand for instruction
6470 // CHECK-ERROR:         uzp1 v0.16b, v1.8b, v2.8b
6471 // CHECK-ERROR:                      ^
6472 // CHECK-ERROR:  error: invalid operand for instruction
6473 // CHECK-ERROR:         uzp1 v0.8b, v1.4b, v2.4b
6474 // CHECK-ERROR:                     ^
6475 // CHECK-ERROR:  error: invalid operand for instruction
6476 // CHECK-ERROR:         uzp1 v0.8h, v1.4h, v2.4h
6477 // CHECK-ERROR:                     ^
6478 // CHECK-ERROR:  error: invalid operand for instruction
6479 // CHECK-ERROR:         uzp1 v0.4h, v1.2h, v2.2h
6480 // CHECK-ERROR:                     ^
6481 // CHECK-ERROR:  error: invalid operand for instruction
6482 // CHECK-ERROR:         uzp1 v0.4s, v1.2s, v2.2s
6483 // CHECK-ERROR:                     ^
6484 // CHECK-ERROR:  error: invalid operand for instruction
6485 // CHECK-ERROR:         uzp1 v0.2s, v1.1s, v2.1s
6486 // CHECK-ERROR:                     ^
6487 // CHECK-ERROR:  error: invalid operand for instruction
6488 // CHECK-ERROR:         uzp1 v0.2d, v1.1d, v2.1d
6489 // CHECK-ERROR:                     ^
6490 // CHECK-ERROR:  error: invalid operand for instruction
6491 // CHECK-ERROR:         uzp1 v0.1d, v1.1d, v2.1d
6492 // CHECK-ERROR:                 ^
6493
6494         uzp2 v0.16b, v1.8b, v2.8b
6495         uzp2 v0.8b, v1.4b, v2.4b
6496         uzp2 v0.8h, v1.4h, v2.4h
6497         uzp2 v0.4h, v1.2h, v2.2h
6498         uzp2 v0.4s, v1.2s, v2.2s
6499         uzp2 v0.2s, v1.1s, v2.1s
6500         uzp2 v0.2d, v1.1d, v2.1d
6501         uzp2 v0.1d, v1.1d, v2.1d
6502
6503 // CHECK-ERROR:  error: invalid operand for instruction
6504 // CHECK-ERROR:         uzp2 v0.16b, v1.8b, v2.8b
6505 // CHECK-ERROR:                      ^
6506 // CHECK-ERROR:  error: invalid operand for instruction
6507 // CHECK-ERROR:         uzp2 v0.8b, v1.4b, v2.4b
6508 // CHECK-ERROR:                     ^
6509 // CHECK-ERROR:  error: invalid operand for instruction
6510 // CHECK-ERROR:         uzp2 v0.8h, v1.4h, v2.4h
6511 // CHECK-ERROR:                     ^
6512 // CHECK-ERROR:  error: invalid operand for instruction
6513 // CHECK-ERROR:         uzp2 v0.4h, v1.2h, v2.2h
6514 // CHECK-ERROR:                     ^
6515 // CHECK-ERROR:  error: invalid operand for instruction
6516 // CHECK-ERROR:         uzp2 v0.4s, v1.2s, v2.2s
6517 // CHECK-ERROR:                     ^
6518 // CHECK-ERROR:  error: invalid operand for instruction
6519 // CHECK-ERROR:         uzp2 v0.2s, v1.1s, v2.1s
6520 // CHECK-ERROR:                     ^
6521 // CHECK-ERROR:  error: invalid operand for instruction
6522 // CHECK-ERROR:         uzp2 v0.2d, v1.1d, v2.1d
6523 // CHECK-ERROR:                     ^
6524 // CHECK-ERROR:  error: invalid operand for instruction
6525 // CHECK-ERROR:         uzp2 v0.1d, v1.1d, v2.1d
6526 // CHECK-ERROR:                 ^
6527
6528         zip1 v0.16b, v1.8b, v2.8b
6529         zip1 v0.8b, v1.4b, v2.4b
6530         zip1 v0.8h, v1.4h, v2.4h
6531         zip1 v0.4h, v1.2h, v2.2h
6532         zip1 v0.4s, v1.2s, v2.2s
6533         zip1 v0.2s, v1.1s, v2.1s
6534         zip1 v0.2d, v1.1d, v2.1d
6535         zip1 v0.1d, v1.1d, v2.1d
6536
6537 // CHECK-ERROR:  error: invalid operand for instruction
6538 // CHECK-ERROR:         zip1 v0.16b, v1.8b, v2.8b
6539 // CHECK-ERROR:                      ^
6540 // CHECK-ERROR:  error: invalid operand for instruction
6541 // CHECK-ERROR:         zip1 v0.8b, v1.4b, v2.4b
6542 // CHECK-ERROR:                     ^
6543 // CHECK-ERROR:  error: invalid operand for instruction
6544 // CHECK-ERROR:         zip1 v0.8h, v1.4h, v2.4h
6545 // CHECK-ERROR:                     ^
6546 // CHECK-ERROR:  error: invalid operand for instruction
6547 // CHECK-ERROR:         zip1 v0.4h, v1.2h, v2.2h
6548 // CHECK-ERROR:                     ^
6549 // CHECK-ERROR:  error: invalid operand for instruction
6550 // CHECK-ERROR:         zip1 v0.4s, v1.2s, v2.2s
6551 // CHECK-ERROR:                     ^
6552 // CHECK-ERROR:  error: invalid operand for instruction
6553 // CHECK-ERROR:         zip1 v0.2s, v1.1s, v2.1s
6554 // CHECK-ERROR:                     ^
6555 // CHECK-ERROR:  error: invalid operand for instruction
6556 // CHECK-ERROR:         zip1 v0.2d, v1.1d, v2.1d
6557 // CHECK-ERROR:                     ^
6558 // CHECK-ERROR:  error: invalid operand for instruction
6559 // CHECK-ERROR:         zip1 v0.1d, v1.1d, v2.1d
6560 // CHECK-ERROR:                 ^
6561
6562         zip2 v0.16b, v1.8b, v2.8b
6563         zip2 v0.8b, v1.4b, v2.4b
6564         zip2 v0.8h, v1.4h, v2.4h
6565         zip2 v0.4h, v1.2h, v2.2h
6566         zip2 v0.4s, v1.2s, v2.2s
6567         zip2 v0.2s, v1.1s, v2.1s
6568         zip2 v0.2d, v1.1d, v2.1d
6569         zip2 v0.1d, v1.1d, v2.1d
6570
6571 // CHECK-ERROR:  error: invalid operand for instruction
6572 // CHECK-ERROR:         zip2 v0.16b, v1.8b, v2.8b
6573 // CHECK-ERROR:                      ^
6574 // CHECK-ERROR:  error: invalid operand for instruction
6575 // CHECK-ERROR:         zip2 v0.8b, v1.4b, v2.4b
6576 // CHECK-ERROR:                     ^
6577 // CHECK-ERROR:  error: invalid operand for instruction
6578 // CHECK-ERROR:         zip2 v0.8h, v1.4h, v2.4h
6579 // CHECK-ERROR:                     ^
6580 // CHECK-ERROR:  error: invalid operand for instruction
6581 // CHECK-ERROR:         zip2 v0.4h, v1.2h, v2.2h
6582 // CHECK-ERROR:                     ^
6583 // CHECK-ERROR:  error: invalid operand for instruction
6584 // CHECK-ERROR:         zip2 v0.4s, v1.2s, v2.2s
6585 // CHECK-ERROR:                     ^
6586 // CHECK-ERROR:  error: invalid operand for instruction
6587 // CHECK-ERROR:         zip2 v0.2s, v1.1s, v2.1s
6588 // CHECK-ERROR:                     ^
6589 // CHECK-ERROR:  error: invalid operand for instruction
6590 // CHECK-ERROR:         zip2 v0.2d, v1.1d, v2.1d
6591 // CHECK-ERROR:                     ^
6592 // CHECK-ERROR:  error: invalid operand for instruction
6593 // CHECK-ERROR:         zip2 v0.1d, v1.1d, v2.1d
6594 // CHECK-ERROR:                 ^
6595
6596         trn1 v0.16b, v1.8b, v2.8b
6597         trn1 v0.8b, v1.4b, v2.4b
6598         trn1 v0.8h, v1.4h, v2.4h
6599         trn1 v0.4h, v1.2h, v2.2h
6600         trn1 v0.4s, v1.2s, v2.2s
6601         trn1 v0.2s, v1.1s, v2.1s
6602         trn1 v0.2d, v1.1d, v2.1d
6603         trn1 v0.1d, v1.1d, v2.1d
6604
6605 // CHECK-ERROR:  error: invalid operand for instruction
6606 // CHECK-ERROR:         trn1 v0.16b, v1.8b, v2.8b
6607 // CHECK-ERROR:                      ^
6608 // CHECK-ERROR:  error: invalid operand for instruction
6609 // CHECK-ERROR:         trn1 v0.8b, v1.4b, v2.4b
6610 // CHECK-ERROR:                     ^
6611 // CHECK-ERROR:  error: invalid operand for instruction
6612 // CHECK-ERROR:         trn1 v0.8h, v1.4h, v2.4h
6613 // CHECK-ERROR:                     ^
6614 // CHECK-ERROR:  error: invalid operand for instruction
6615 // CHECK-ERROR:         trn1 v0.4h, v1.2h, v2.2h
6616 // CHECK-ERROR:                     ^
6617 // CHECK-ERROR:  error: invalid operand for instruction
6618 // CHECK-ERROR:         trn1 v0.4s, v1.2s, v2.2s
6619 // CHECK-ERROR:                     ^
6620 // CHECK-ERROR:  error: invalid operand for instruction
6621 // CHECK-ERROR:         trn1 v0.2s, v1.1s, v2.1s
6622 // CHECK-ERROR:                     ^
6623 // CHECK-ERROR:  error: invalid operand for instruction
6624 // CHECK-ERROR:         trn1 v0.2d, v1.1d, v2.1d
6625 // CHECK-ERROR:                     ^
6626 // CHECK-ERROR:  error: invalid operand for instruction
6627 // CHECK-ERROR:         trn1 v0.1d, v1.1d, v2.1d
6628 // CHECK-ERROR:                 ^
6629
6630         trn2 v0.16b, v1.8b, v2.8b
6631         trn2 v0.8b, v1.4b, v2.4b
6632         trn2 v0.8h, v1.4h, v2.4h
6633         trn2 v0.4h, v1.2h, v2.2h
6634         trn2 v0.4s, v1.2s, v2.2s
6635         trn2 v0.2s, v1.1s, v2.1s
6636         trn2 v0.2d, v1.1d, v2.1d
6637         trn2 v0.1d, v1.1d, v2.1d
6638
6639 // CHECK-ERROR:  error: invalid operand for instruction
6640 // CHECK-ERROR:         trn2 v0.16b, v1.8b, v2.8b
6641 // CHECK-ERROR:                      ^
6642 // CHECK-ERROR:  error: invalid operand for instruction
6643 // CHECK-ERROR:         trn2 v0.8b, v1.4b, v2.4b
6644 // CHECK-ERROR:                     ^
6645 // CHECK-ERROR:  error: invalid operand for instruction
6646 // CHECK-ERROR:         trn2 v0.8h, v1.4h, v2.4h
6647 // CHECK-ERROR:                     ^
6648 // CHECK-ERROR:  error: invalid operand for instruction
6649 // CHECK-ERROR:         trn2 v0.4h, v1.2h, v2.2h
6650 // CHECK-ERROR:                     ^
6651 // CHECK-ERROR:  error: invalid operand for instruction
6652 // CHECK-ERROR:         trn2 v0.4s, v1.2s, v2.2s
6653 // CHECK-ERROR:                     ^
6654 // CHECK-ERROR:  error: invalid operand for instruction
6655 // CHECK-ERROR:         trn2 v0.2s, v1.1s, v2.1s
6656 // CHECK-ERROR:                     ^
6657 // CHECK-ERROR:  error: invalid operand for instruction
6658 // CHECK-ERROR:         trn2 v0.2d, v1.1d, v2.1d
6659 // CHECK-ERROR:                     ^
6660 // CHECK-ERROR:  error: invalid operand for instruction
6661 // CHECK-ERROR:         trn2 v0.1d, v1.1d, v2.1d
6662 // CHECK-ERROR:                 ^
6663
6664 //----------------------------------------------------------------------
6665 // Permutation with 3 vectors
6666 //----------------------------------------------------------------------
6667
6668         uzp1 v0.16b, v1.8b, v2.8b
6669         uzp1 v0.8b, v1.4b, v2.4b
6670         uzp1 v0.8h, v1.4h, v2.4h
6671         uzp1 v0.4h, v1.2h, v2.2h
6672         uzp1 v0.4s, v1.2s, v2.2s
6673         uzp1 v0.2s, v1.1s, v2.1s
6674         uzp1 v0.2d, v1.1d, v2.1d
6675         uzp1 v0.1d, v1.1d, v2.1d
6676
6677 // CHECK-ERROR:  error: invalid operand for instruction
6678 // CHECK-ERROR:         uzp1 v0.16b, v1.8b, v2.8b
6679 // CHECK-ERROR:                      ^
6680 // CHECK-ERROR:  error: invalid operand for instruction
6681 // CHECK-ERROR:         uzp1 v0.8b, v1.4b, v2.4b
6682 // CHECK-ERROR:                     ^
6683 // CHECK-ERROR:  error: invalid operand for instruction
6684 // CHECK-ERROR:         uzp1 v0.8h, v1.4h, v2.4h
6685 // CHECK-ERROR:                     ^
6686 // CHECK-ERROR:  error: invalid operand for instruction
6687 // CHECK-ERROR:         uzp1 v0.4h, v1.2h, v2.2h
6688 // CHECK-ERROR:                     ^
6689 // CHECK-ERROR:  error: invalid operand for instruction
6690 // CHECK-ERROR:         uzp1 v0.4s, v1.2s, v2.2s
6691 // CHECK-ERROR:                     ^
6692 // CHECK-ERROR:  error: invalid operand for instruction
6693 // CHECK-ERROR:         uzp1 v0.2s, v1.1s, v2.1s
6694 // CHECK-ERROR:                     ^
6695 // CHECK-ERROR:  error: invalid operand for instruction
6696 // CHECK-ERROR:         uzp1 v0.2d, v1.1d, v2.1d
6697 // CHECK-ERROR:                     ^
6698 // CHECK-ERROR:  error: invalid operand for instruction
6699 // CHECK-ERROR:         uzp1 v0.1d, v1.1d, v2.1d
6700 // CHECK-ERROR:                 ^
6701
6702         uzp2 v0.16b, v1.8b, v2.8b
6703         uzp2 v0.8b, v1.4b, v2.4b
6704         uzp2 v0.8h, v1.4h, v2.4h
6705         uzp2 v0.4h, v1.2h, v2.2h
6706         uzp2 v0.4s, v1.2s, v2.2s
6707         uzp2 v0.2s, v1.1s, v2.1s
6708         uzp2 v0.2d, v1.1d, v2.1d
6709         uzp2 v0.1d, v1.1d, v2.1d
6710
6711 // CHECK-ERROR:  error: invalid operand for instruction
6712 // CHECK-ERROR:         uzp2 v0.16b, v1.8b, v2.8b
6713 // CHECK-ERROR:                      ^
6714 // CHECK-ERROR:  error: invalid operand for instruction
6715 // CHECK-ERROR:         uzp2 v0.8b, v1.4b, v2.4b
6716 // CHECK-ERROR:                     ^
6717 // CHECK-ERROR:  error: invalid operand for instruction
6718 // CHECK-ERROR:         uzp2 v0.8h, v1.4h, v2.4h
6719 // CHECK-ERROR:                     ^
6720 // CHECK-ERROR:  error: invalid operand for instruction
6721 // CHECK-ERROR:         uzp2 v0.4h, v1.2h, v2.2h
6722 // CHECK-ERROR:                     ^
6723 // CHECK-ERROR:  error: invalid operand for instruction
6724 // CHECK-ERROR:         uzp2 v0.4s, v1.2s, v2.2s
6725 // CHECK-ERROR:                     ^
6726 // CHECK-ERROR:  error: invalid operand for instruction
6727 // CHECK-ERROR:         uzp2 v0.2s, v1.1s, v2.1s
6728 // CHECK-ERROR:                     ^
6729 // CHECK-ERROR:  error: invalid operand for instruction
6730 // CHECK-ERROR:         uzp2 v0.2d, v1.1d, v2.1d
6731 // CHECK-ERROR:                     ^
6732 // CHECK-ERROR:  error: invalid operand for instruction
6733 // CHECK-ERROR:         uzp2 v0.1d, v1.1d, v2.1d
6734 // CHECK-ERROR:                 ^
6735
6736         zip1 v0.16b, v1.8b, v2.8b
6737         zip1 v0.8b, v1.4b, v2.4b
6738         zip1 v0.8h, v1.4h, v2.4h
6739         zip1 v0.4h, v1.2h, v2.2h
6740         zip1 v0.4s, v1.2s, v2.2s
6741         zip1 v0.2s, v1.1s, v2.1s
6742         zip1 v0.2d, v1.1d, v2.1d
6743         zip1 v0.1d, v1.1d, v2.1d
6744
6745 // CHECK-ERROR:  error: invalid operand for instruction
6746 // CHECK-ERROR:         zip1 v0.16b, v1.8b, v2.8b
6747 // CHECK-ERROR:                      ^
6748 // CHECK-ERROR:  error: invalid operand for instruction
6749 // CHECK-ERROR:         zip1 v0.8b, v1.4b, v2.4b
6750 // CHECK-ERROR:                     ^
6751 // CHECK-ERROR:  error: invalid operand for instruction
6752 // CHECK-ERROR:         zip1 v0.8h, v1.4h, v2.4h
6753 // CHECK-ERROR:                     ^
6754 // CHECK-ERROR:  error: invalid operand for instruction
6755 // CHECK-ERROR:         zip1 v0.4h, v1.2h, v2.2h
6756 // CHECK-ERROR:                     ^
6757 // CHECK-ERROR:  error: invalid operand for instruction
6758 // CHECK-ERROR:         zip1 v0.4s, v1.2s, v2.2s
6759 // CHECK-ERROR:                     ^
6760 // CHECK-ERROR:  error: invalid operand for instruction
6761 // CHECK-ERROR:         zip1 v0.2s, v1.1s, v2.1s
6762 // CHECK-ERROR:                     ^
6763 // CHECK-ERROR:  error: invalid operand for instruction
6764 // CHECK-ERROR:         zip1 v0.2d, v1.1d, v2.1d
6765 // CHECK-ERROR:                     ^
6766 // CHECK-ERROR:  error: invalid operand for instruction
6767 // CHECK-ERROR:         zip1 v0.1d, v1.1d, v2.1d
6768 // CHECK-ERROR:                 ^
6769
6770         zip2 v0.16b, v1.8b, v2.8b
6771         zip2 v0.8b, v1.4b, v2.4b
6772         zip2 v0.8h, v1.4h, v2.4h
6773         zip2 v0.4h, v1.2h, v2.2h
6774         zip2 v0.4s, v1.2s, v2.2s
6775         zip2 v0.2s, v1.1s, v2.1s
6776         zip2 v0.2d, v1.1d, v2.1d
6777         zip2 v0.1d, v1.1d, v2.1d
6778
6779 // CHECK-ERROR:  error: invalid operand for instruction
6780 // CHECK-ERROR:         zip2 v0.16b, v1.8b, v2.8b
6781 // CHECK-ERROR:                      ^
6782 // CHECK-ERROR:  error: invalid operand for instruction
6783 // CHECK-ERROR:         zip2 v0.8b, v1.4b, v2.4b
6784 // CHECK-ERROR:                     ^
6785 // CHECK-ERROR:  error: invalid operand for instruction
6786 // CHECK-ERROR:         zip2 v0.8h, v1.4h, v2.4h
6787 // CHECK-ERROR:                     ^
6788 // CHECK-ERROR:  error: invalid operand for instruction
6789 // CHECK-ERROR:         zip2 v0.4h, v1.2h, v2.2h
6790 // CHECK-ERROR:                     ^
6791 // CHECK-ERROR:  error: invalid operand for instruction
6792 // CHECK-ERROR:         zip2 v0.4s, v1.2s, v2.2s
6793 // CHECK-ERROR:                     ^
6794 // CHECK-ERROR:  error: invalid operand for instruction
6795 // CHECK-ERROR:         zip2 v0.2s, v1.1s, v2.1s
6796 // CHECK-ERROR:                     ^
6797 // CHECK-ERROR:  error: invalid operand for instruction
6798 // CHECK-ERROR:         zip2 v0.2d, v1.1d, v2.1d
6799 // CHECK-ERROR:                     ^
6800 // CHECK-ERROR:  error: invalid operand for instruction
6801 // CHECK-ERROR:         zip2 v0.1d, v1.1d, v2.1d
6802 // CHECK-ERROR:                 ^
6803
6804         trn1 v0.16b, v1.8b, v2.8b
6805         trn1 v0.8b, v1.4b, v2.4b
6806         trn1 v0.8h, v1.4h, v2.4h
6807         trn1 v0.4h, v1.2h, v2.2h
6808         trn1 v0.4s, v1.2s, v2.2s
6809         trn1 v0.2s, v1.1s, v2.1s
6810         trn1 v0.2d, v1.1d, v2.1d
6811         trn1 v0.1d, v1.1d, v2.1d
6812
6813 // CHECK-ERROR:  error: invalid operand for instruction
6814 // CHECK-ERROR:         trn1 v0.16b, v1.8b, v2.8b
6815 // CHECK-ERROR:                      ^
6816 // CHECK-ERROR:  error: invalid operand for instruction
6817 // CHECK-ERROR:         trn1 v0.8b, v1.4b, v2.4b
6818 // CHECK-ERROR:                     ^
6819 // CHECK-ERROR:  error: invalid operand for instruction
6820 // CHECK-ERROR:         trn1 v0.8h, v1.4h, v2.4h
6821 // CHECK-ERROR:                     ^
6822 // CHECK-ERROR:  error: invalid operand for instruction
6823 // CHECK-ERROR:         trn1 v0.4h, v1.2h, v2.2h
6824 // CHECK-ERROR:                     ^
6825 // CHECK-ERROR:  error: invalid operand for instruction
6826 // CHECK-ERROR:         trn1 v0.4s, v1.2s, v2.2s
6827 // CHECK-ERROR:                     ^
6828 // CHECK-ERROR:  error: invalid operand for instruction
6829 // CHECK-ERROR:         trn1 v0.2s, v1.1s, v2.1s
6830 // CHECK-ERROR:                     ^
6831 // CHECK-ERROR:  error: invalid operand for instruction
6832 // CHECK-ERROR:         trn1 v0.2d, v1.1d, v2.1d
6833 // CHECK-ERROR:                     ^
6834 // CHECK-ERROR:  error: invalid operand for instruction
6835 // CHECK-ERROR:         trn1 v0.1d, v1.1d, v2.1d
6836 // CHECK-ERROR:                 ^
6837
6838         trn2 v0.16b, v1.8b, v2.8b
6839         trn2 v0.8b, v1.4b, v2.4b
6840         trn2 v0.8h, v1.4h, v2.4h
6841         trn2 v0.4h, v1.2h, v2.2h
6842         trn2 v0.4s, v1.2s, v2.2s
6843         trn2 v0.2s, v1.1s, v2.1s
6844         trn2 v0.2d, v1.1d, v2.1d
6845         trn2 v0.1d, v1.1d, v2.1d
6846
6847 // CHECK-ERROR:  error: invalid operand for instruction
6848 // CHECK-ERROR:         trn2 v0.16b, v1.8b, v2.8b
6849 // CHECK-ERROR:                      ^
6850 // CHECK-ERROR:  error: invalid operand for instruction
6851 // CHECK-ERROR:         trn2 v0.8b, v1.4b, v2.4b
6852 // CHECK-ERROR:                     ^
6853 // CHECK-ERROR:  error: invalid operand for instruction
6854 // CHECK-ERROR:         trn2 v0.8h, v1.4h, v2.4h
6855 // CHECK-ERROR:                     ^
6856 // CHECK-ERROR:  error: invalid operand for instruction
6857 // CHECK-ERROR:         trn2 v0.4h, v1.2h, v2.2h
6858 // CHECK-ERROR:                     ^
6859 // CHECK-ERROR:  error: invalid operand for instruction
6860 // CHECK-ERROR:         trn2 v0.4s, v1.2s, v2.2s
6861 // CHECK-ERROR:                     ^
6862 // CHECK-ERROR:  error: invalid operand for instruction
6863 // CHECK-ERROR:         trn2 v0.2s, v1.1s, v2.1s
6864 // CHECK-ERROR:                     ^
6865 // CHECK-ERROR:  error: invalid operand for instruction
6866 // CHECK-ERROR:         trn2 v0.2d, v1.1d, v2.1d
6867 // CHECK-ERROR:                     ^
6868 // CHECK-ERROR:  error: invalid operand for instruction
6869 // CHECK-ERROR:         trn2 v0.1d, v1.1d, v2.1d
6870 // CHECK-ERROR:                 ^
6871
6872 //----------------------------------------------------------------------
6873 // Floating Point  multiply (scalar, by element)
6874 //----------------------------------------------------------------------
6875       // mismatched and invalid vector types
6876       fmul    s0, s1, v1.h[0]
6877       fmul    h0, h1, v1.s[0]
6878       // invalid lane
6879       fmul    s2, s29, v10.s[4]
6880
6881 // CHECK-ERROR: error: invalid operand for instruction
6882 // CHECK-ERROR:          fmul    s0, s1, v1.h[0]
6883 // CHECK-ERROR:                             ^
6884 // CHECK-ERROR: error: invalid operand for instruction
6885 // CHECK-ERROR:          fmul    h0, h1, v1.s[0]
6886 // CHECK-ERROR:                  ^
6887 // CHECK-ERROR: vector lane must be an integer in range
6888 // CHECK-ERROR:          fmul    s2, s29, v10.s[4]
6889 // CHECK-ERROR:                                 ^
6890
6891 //----------------------------------------------------------------------
6892 // Floating Point  multiply extended (scalar, by element)
6893 //----------------------------------------------------------------------
6894       // mismatched and invalid vector types
6895       fmulx    d0, d1, v1.b[0]
6896       fmulx    h0, h1, v1.d[0]
6897       // invalid lane
6898       fmulx    d2, d29, v10.d[3]
6899
6900 // CHECK-ERROR: error: invalid operand for instruction
6901 // CHECK-ERROR:          fmulx    d0, d1, v1.b[0]
6902 // CHECK-ERROR:                              ^
6903 // CHECK-ERROR: error: invalid operand for instruction
6904 // CHECK-ERROR:          fmulx    h0, h1, v1.d[0]
6905 // CHECK-ERROR:                   ^
6906 // CHECK-ERROR: vector lane must be an integer in range
6907 // CHECK-ERROR:          fmulx    d2, d29, v10.d[3]
6908 // CHECK-ERROR:                                  ^
6909
6910 //----------------------------------------------------------------------
6911 // Floating Point fused multiply-add (scalar, by element)
6912 //----------------------------------------------------------------------
6913       // mismatched and invalid vector types
6914       fmla    b0, b1, v1.b[0]
6915       fmla    d30, s11, v1.d[1]
6916       // invalid lane
6917       fmla    s16, s22, v16.s[5]
6918
6919 // CHECK-ERROR: error: invalid operand for instruction
6920 // CHECK-ERROR:          fmla    b0, b1, v1.b[0]
6921 // CHECK-ERROR:                  ^
6922 // CHECK-ERROR: error: invalid operand for instruction
6923 // CHECK-ERROR:          fmla    d30, s11, v1.d[1]
6924 // CHECK-ERROR:                       ^
6925 // CHECK-ERROR: vector lane must be an integer in range
6926 // CHECK-ERROR:          fmla    s16, s22, v16.s[5]
6927 // CHECK-ERROR:                                  ^
6928
6929 //----------------------------------------------------------------------
6930 // Floating Point fused multiply-subtract (scalar, by element)
6931 //----------------------------------------------------------------------
6932     // mismatched and invalid vector types
6933     fmls    s29, h10, v28.s[1]
6934     fmls    h7, h17, v26.s[2]
6935     // invalid lane
6936     fmls    d16, d22, v16.d[-1]
6937
6938 // CHECK-ERROR: error: invalid operand for instruction
6939 // CHECK-ERROR:          fmls    s29, h10, v28.s[1]
6940 // CHECK-ERROR:                       ^
6941 // CHECK-ERROR: error: invalid operand for instruction
6942 // CHECK-ERROR:          fmls    h7, h17, v26.s[2]
6943 // CHECK-ERROR:                  ^
6944 // CHECK-ERROR: error: vector lane must be an integer in range [0, 1]
6945 // CHECK-ERROR:          fmls    d16, d22, v16.d[-1]
6946 // CHECK-ERROR:                                  ^
6947
6948 //----------------------------------------------------------------------
6949 // Scalar Signed saturating doubling multiply-add long
6950 // (scalar, by element)
6951 //----------------------------------------------------------------------
6952     // mismatched and invalid vector types
6953     sqdmlal s0, h0, v0.s[0]
6954     sqdmlal s8, s9, v14.s[1]
6955     // invalid lane
6956     sqdmlal d4, s5, v1.s[5]
6957     // invalid vector index
6958     sqdmlal s0, h0, v17.h[0]
6959
6960 // CHECK-ERROR: error: invalid operand for instruction
6961 // CHECK-ERROR:          sqdmlal s0, h0, v0.s[0]
6962 // CHECK-ERROR:                             ^
6963 // CHECK-ERROR: error: invalid operand for instruction
6964 // CHECK-ERROR:          sqdmlal s8, s9, v14.s[1]
6965 // CHECK-ERROR:                  ^
6966 // CHECK-ERROR: vector lane must be an integer in range
6967 // CHECK-ERROR:          sqdmlal d4, s5, v1.s[5]
6968 // CHECK-ERROR:                               ^
6969 // CHECK-ERROR: error: invalid operand for instruction
6970 // CHECK-ERROR:          sqdmlal s0, h0, v17.h[0]
6971 // CHECK-ERROR:                           ^
6972
6973 //----------------------------------------------------------------------
6974 // Scalar Signed saturating doubling multiply-subtract long
6975 // (scalar, by element)
6976 //----------------------------------------------------------------------
6977     // mismatched and invalid vector types
6978     sqdmlsl s1, h1, v1.d[0]
6979     sqdmlsl d1, h1, v13.s[0]
6980     // invalid lane
6981     sqdmlsl d1, s1, v13.s[4]
6982     // invalid vector index
6983     sqdmlsl s1, h1, v20.h[7]
6984
6985 // CHECK-ERROR: error: invalid operand for instruction
6986 // CHECK-ERROR:          sqdmlsl s1, h1, v1.d[0]
6987 // CHECK-ERROR:                             ^
6988 // CHECK-ERROR: error: invalid operand for instruction
6989 // CHECK-ERROR:          sqdmlsl d1, h1, v13.s[0]
6990 // CHECK-ERROR:                      ^
6991 // CHECK-ERROR: vector lane must be an integer in range
6992 // CHECK-ERROR:          sqdmlsl d1, s1, v13.s[4]
6993 // CHECK-ERROR:                                ^
6994 // CHECK-ERROR: error: invalid operand for instruction
6995 // CHECK-ERROR:          sqdmlsl s1, h1, v20.h[7]
6996 // CHECK-ERROR:                           ^
6997
6998 //----------------------------------------------------------------------
6999 // Scalar Signed saturating doubling multiply long (scalar, by element)
7000 //----------------------------------------------------------------------
7001     // mismatched and invalid vector types
7002     // invalid lane
7003     // invalid vector index
7004     // mismatched and invalid vector types
7005     sqdmull s1, h1, v1.s[1]
7006     sqdmull s1, s1, v4.s[0]
7007     // invalid lane
7008     sqdmull s12, h17, v9.h[9]
7009     // invalid vector index
7010     sqdmull s1, h1, v16.h[5]
7011
7012 // CHECK-ERROR: error: invalid operand for instruction
7013 // CHECK-ERROR:          sqdmull s1, h1, v1.s[1]
7014 // CHECK-ERROR:                             ^
7015 // CHECK-ERROR: error: invalid operand for instruction
7016 // CHECK-ERROR:          sqdmull s1, s1, v4.s[0]
7017 // CHECK-ERROR:                  ^
7018 // CHECK-ERROR: vector lane must be an integer in range
7019 // CHECK-ERROR:          sqdmull s12, h17, v9.h[9]
7020 // CHECK-ERROR:                                 ^
7021 // CHECK-ERROR: error: invalid operand for instruction
7022 // CHECK-ERROR:          sqdmull s1, h1, v16.h[5]
7023 // CHECK-ERROR:                           ^
7024
7025 //----------------------------------------------------------------------
7026 // Scalar Signed saturating doubling multiply returning
7027 // high half (scalar, by element)
7028 //----------------------------------------------------------------------
7029     // mismatched and invalid vector types
7030     sqdmulh h0, s1, v0.h[0]
7031     sqdmulh s25, s26, v27.h[3]
7032     // invalid lane
7033     sqdmulh s25, s26, v27.s[4]
7034     // invalid vector index
7035     sqdmulh s0, h1, v30.h[0]
7036
7037 // CHECK-ERROR: error: invalid operand for instruction
7038 // CHECK-ERROR:          sqdmulh h0, s1, v0.h[0]
7039 // CHECK-ERROR:                      ^
7040 // CHECK-ERROR: error: invalid operand for instruction
7041 // CHECK-ERROR:          sqdmulh s25, s26, v27.h[3]
7042 // CHECK-ERROR:                  ^
7043 // CHECK-ERROR: vector lane must be an integer in range
7044 // CHECK-ERROR:          sqdmulh s25, s26, v27.s[4]
7045 // CHECK-ERROR:                                  ^
7046 // CHECK-ERROR: error: invalid operand for instruction
7047 // CHECK-ERROR:          sqdmulh s0, h1, v30.h[0]
7048 // CHECK-ERROR:                      ^
7049
7050 //----------------------------------------------------------------------
7051 // Scalar Signed saturating rounding doubling multiply
7052 // returning high half (scalar, by element)
7053 //----------------------------------------------------------------------
7054     // mismatched and invalid vector types
7055     sqrdmulh h31, h30, v14.s[2]
7056     sqrdmulh s5, h6, v7.s[2]
7057     // invalid lane
7058     sqrdmulh h31, h30, v14.h[9]
7059     // invalid vector index
7060     sqrdmulh h31, h30, v20.h[4]
7061
7062 // CHECK-ERROR: error: invalid operand for instruction
7063 // CHECK-ERROR:          sqrdmulh h31, h30, v14.s[2]
7064 // CHECK-ERROR:                                 ^
7065 // CHECK-ERROR: error: invalid operand for instruction
7066 // CHECK-ERROR:          sqrdmulh s5, h6, v7.s[2]
7067 // CHECK-ERROR:                       ^
7068 // CHECK-ERROR: vector lane must be an integer in range
7069 // CHECK-ERROR:          sqrdmulh h31, h30, v14.h[9]
7070 // CHECK-ERROR:                                 ^
7071 // CHECK-ERROR: error: invalid operand for instruction
7072 // CHECK-ERROR:          sqrdmulh h31, h30, v20.h[4]
7073 // CHECK-ERROR:                              ^
7074
7075 //----------------------------------------------------------------------
7076 // Scalar Duplicate element (scalar)
7077 //----------------------------------------------------------------------
7078       // mismatched and invalid vector types
7079       dup b0, v1.d[0]
7080       dup h0, v31.b[8]
7081       dup s0, v2.h[4]
7082       dup d0, v17.s[3]
7083       // invalid  lane
7084       dup d0, v17.d[4]
7085       dup s0, v1.s[7]
7086       dup h0, v31.h[16]
7087       dup b1, v3.b[16]
7088 // CHECK-ERROR: error: invalid operand for instruction
7089 // CHECK-ERROR:          dup b0, v1.d[0]
7090 // CHECK-ERROR:                     ^
7091 // CHECK-ERROR: error: invalid operand for instruction
7092 // CHECK-ERROR:          dup h0, v31.b[8]
7093 // CHECK-ERROR:                      ^
7094 // CHECK-ERROR: error: invalid operand for instruction
7095 // CHECK-ERROR:          dup s0, v2.h[4]
7096 // CHECK-ERROR:                     ^
7097 // CHECK-ERROR: error: invalid operand for instruction
7098 // CHECK-ERROR:          dup d0, v17.s[3]
7099 // CHECK-ERROR:                      ^
7100 // CHECK-ERROR: vector lane must be an integer in range
7101 // CHECK-ERROR:          dup d0, v17.d[4]
7102 // CHECK-ERROR:                        ^
7103 // CHECK-ERROR: vector lane must be an integer in range
7104 // CHECK-ERROR:          dup s0, v1.s[7]
7105 // CHECK-ERROR:                       ^
7106 // CHECK-ERROR: vector lane must be an integer in range
7107 // CHECK-ERROR:          dup h0, v31.h[16]
7108 // CHECK-ERROR:                        ^
7109 // CHECK-ERROR: vector lane must be an integer in range
7110 // CHECK-ERROR:          dup b1, v3.b[16]
7111 // CHECK-ERROR:                       ^
7112
7113 //----------------------------------------------------------------------
7114 // Table look up
7115 //----------------------------------------------------------------------
7116
7117         tbl v0.8b, {v1.8b}, v2.8b
7118         tbl v0.8b, {v1.8b, v2.8b}, v2.8b
7119         tbl v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
7120         tbl v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
7121         tbl v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
7122
7123 // CHECK-ERROR: error: invalid operand for instruction
7124 // CHECK-ERROR:        tbl v0.8b, {v1.8b}, v2.8b
7125 // CHECK-ERROR:                   ^
7126 // CHECK-ERROR: error: invalid operand for instruction
7127 // CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b}, v2.8b
7128 // CHECK-ERROR:                   ^
7129 // CHECK-ERROR: error: invalid operand for instruction
7130 // CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
7131 // CHECK-ERROR:                   ^
7132 // CHECK-ERROR: error: invalid operand for instruction
7133 // CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
7134 // CHECK-ERROR:                   ^
7135 // CHECK-ERROR: error: invalid number of vectors
7136 // CHECK-ERROR:        tbl v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
7137 // CHECK-ERROR:                                                    ^
7138
7139         tbx v0.8b, {v1.8b}, v2.8b
7140         tbx v0.8b, {v1.8b, v2.8b}, v2.8b
7141         tbx v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
7142         tbx v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
7143         tbx v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
7144
7145 // CHECK-ERROR: error: invalid operand for instruction
7146 // CHECK-ERROR:        tbx v0.8b, {v1.8b}, v2.8b
7147 // CHECK-ERROR:                   ^
7148 // CHECK-ERROR: error: invalid operand for instruction
7149 // CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b}, v2.8b
7150 // CHECK-ERROR:                   ^
7151 // CHECK-ERROR: error: invalid operand for instruction
7152 // CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
7153 // CHECK-ERROR:                   ^
7154 // CHECK-ERROR: error: invalid operand for instruction
7155 // CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
7156 // CHECK-ERROR:                   ^
7157 // CHECK-ERROR: error: invalid number of vectors
7158 // CHECK-ERROR:        tbx v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
7159 // CHECK-ERROR:                                                    ^
7160
7161 //----------------------------------------------------------------------
7162 // Scalar Floating-point Convert To Lower Precision Narrow, Rounding To
7163 // Odd
7164 //----------------------------------------------------------------------
7165
7166     fcvtxn s0, s1
7167
7168 // CHECK-ERROR: error: invalid operand for instruction
7169 // CHECK-ERROR:        fcvtxn s0, s1
7170 // CHECK-ERROR:                   ^
7171
7172 //----------------------------------------------------------------------
7173 // Scalar Floating-point Convert To Signed Integer, Rounding To Nearest
7174 // With Ties To Away
7175 //----------------------------------------------------------------------
7176
7177     fcvtas s0, d0
7178     fcvtas d0, s0
7179
7180 // CHECK-ERROR: error: invalid operand for instruction
7181 // CHECK-ERROR:        fcvtas s0, d0
7182 // CHECK-ERROR:                   ^
7183 // CHECK-ERROR: error: invalid operand for instruction
7184 // CHECK-ERROR:        fcvtas d0, s0
7185 // CHECK-ERROR:                   ^
7186
7187 //----------------------------------------------------------------------
7188 // Scalar Floating-point Convert To Unsigned Integer, Rounding To
7189 // Nearest With Ties To Away
7190 //----------------------------------------------------------------------
7191
7192     fcvtau s0, d0
7193     fcvtau d0, s0
7194
7195 // CHECK-ERROR: error: invalid operand for instruction
7196 // CHECK-ERROR:        fcvtau s0, d0
7197 // CHECK-ERROR:                   ^
7198 // CHECK-ERROR: error: invalid operand for instruction
7199 // CHECK-ERROR:        fcvtau d0, s0
7200 // CHECK-ERROR:                   ^
7201
7202 //----------------------------------------------------------------------
7203 // Scalar Floating-point Convert To Signed Integer, Rounding Toward
7204 // Minus Infinity
7205 //----------------------------------------------------------------------
7206
7207     fcvtms s0, d0
7208     fcvtms d0, s0
7209
7210 // CHECK-ERROR: error: invalid operand for instruction
7211 // CHECK-ERROR:        fcvtms s0, d0
7212 // CHECK-ERROR:                   ^
7213 // CHECK-ERROR: error: invalid operand for instruction
7214 // CHECK-ERROR:        fcvtms d0, s0
7215 // CHECK-ERROR:                   ^
7216
7217 //----------------------------------------------------------------------
7218 // Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
7219 // Minus Infinity
7220 //----------------------------------------------------------------------
7221
7222     fcvtmu s0, d0
7223     fcvtmu d0, s0
7224
7225 // CHECK-ERROR: error: invalid operand for instruction
7226 // CHECK-ERROR:        fcvtmu s0, d0
7227 // CHECK-ERROR:                   ^
7228 // CHECK-ERROR: error: invalid operand for instruction
7229 // CHECK-ERROR:        fcvtmu d0, s0
7230 // CHECK-ERROR:                   ^
7231
7232 //----------------------------------------------------------------------
7233 // Scalar Floating-point Convert To Signed Integer, Rounding To Nearest
7234 // With Ties To Even
7235 //----------------------------------------------------------------------
7236
7237     fcvtns s0, d0
7238     fcvtns d0, s0
7239
7240 // CHECK-ERROR: error: invalid operand for instruction
7241 // CHECK-ERROR:        fcvtns s0, d0
7242 // CHECK-ERROR:                   ^
7243 // CHECK-ERROR: error: invalid operand for instruction
7244 // CHECK-ERROR:        fcvtns d0, s0
7245 // CHECK-ERROR:                   ^
7246
7247 //----------------------------------------------------------------------
7248 // Scalar Floating-point Convert To Unsigned Integer, Rounding To
7249 // Nearest With Ties To Even
7250 //----------------------------------------------------------------------
7251
7252     fcvtnu s0, d0
7253     fcvtnu d0, s0
7254
7255 // CHECK-ERROR: error: invalid operand for instruction
7256 // CHECK-ERROR:        fcvtnu s0, d0
7257 // CHECK-ERROR:                   ^
7258 // CHECK-ERROR: error: invalid operand for instruction
7259 // CHECK-ERROR:        fcvtnu d0, s0
7260 // CHECK-ERROR:                   ^
7261
7262 //----------------------------------------------------------------------
7263 // Scalar Floating-point Convert To Signed Integer, Rounding Toward
7264 // Positive Infinity
7265 //----------------------------------------------------------------------
7266
7267     fcvtps s0, d0
7268     fcvtps d0, s0
7269
7270 // CHECK-ERROR: error: invalid operand for instruction
7271 // CHECK-ERROR:        fcvtps s0, d0
7272 // CHECK-ERROR:                   ^
7273 // CHECK-ERROR: error: invalid operand for instruction
7274 // CHECK-ERROR:        fcvtps d0, s0
7275 // CHECK-ERROR:                   ^
7276
7277 //----------------------------------------------------------------------
7278 // Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
7279 // Positive Infinity
7280 //----------------------------------------------------------------------
7281
7282     fcvtpu s0, d0
7283     fcvtpu d0, s0
7284
7285 // CHECK-ERROR: error: invalid operand for instruction
7286 // CHECK-ERROR:        fcvtpu s0, d0
7287 // CHECK-ERROR:                   ^
7288 // CHECK-ERROR: error: invalid operand for instruction
7289 // CHECK-ERROR:        fcvtpu d0, s0
7290 // CHECK-ERROR:                   ^
7291
7292 //----------------------------------------------------------------------
7293 // Scalar Floating-point Convert To Signed Integer, Rounding Toward Zero
7294 //----------------------------------------------------------------------
7295
7296     fcvtzs s0, d0
7297     fcvtzs d0, s0
7298
7299 // CHECK-ERROR: error: invalid operand for instruction
7300 // CHECK-ERROR:        fcvtzs s0, d0
7301 // CHECK-ERROR:                   ^
7302 // CHECK-ERROR: error: invalid operand for instruction
7303 // CHECK-ERROR:        fcvtzs d0, s0
7304 // CHECK-ERROR:                   ^
7305
7306 //----------------------------------------------------------------------
7307 // Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
7308 // Zero
7309 //----------------------------------------------------------------------
7310
7311     fcvtzu s0, d0
7312     fcvtzu d0, s0
7313
7314 // CHECK-ERROR: error: invalid operand for instruction
7315 // CHECK-ERROR:        fcvtzu s0, d0
7316 // CHECK-ERROR:                   ^
7317 // CHECK-ERROR: error: invalid operand for instruction
7318 // CHECK-ERROR:        fcvtzu d0, s0
7319 // CHECK-ERROR:                   ^
7320
7321 //----------------------------------------------------------------------
7322 // Scalar Floating-point Absolute Difference
7323 //----------------------------------------------------------------------
7324
7325
7326     fabd s29, d24, s20
7327     fabd d29, s24, d20
7328
7329 // CHECK-ERROR: error: invalid operand for instruction
7330 // CHECK-ERROR:        fabd s29, d24, s20
7331 // CHECK-ERROR:                  ^
7332 // CHECK-ERROR: error: invalid operand for instruction
7333 // CHECK-ERROR:        fabd d29, s24, d20
7334 // CHECK-ERROR:                  ^