PageRenderTime 60ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/test/MC/AArch64/basic-a64-diagnostics.s

http://github.com/earl/llvm-mirror
Assembly | 3893 lines | 3879 code | 14 blank | 0 comment | 9 complexity | 7a0d7fb06ab593b2178a9ef085589a76 MD5 | raw file
Possible License(s): BSD-3-Clause, Apache-2.0 
    

  1. // RUN: not llvm-mc -triple aarch64-none-linux-gnu < %s 2> %t
    2. 

  2. // RUN: FileCheck --check-prefix=CHECK-ERROR --check-prefix=CHECK-ERROR-ARM64 < %t %s
    3. 

  3. 

  4. //------------------------------------------------------------------------------
    5. 

  5. // Add/sub (extended register)
    6. 

  6. //------------------------------------------------------------------------------
    7. 

  7. 

  8.         // Mismatched final register and extend
    9. 

  9.         add x2, x3, x5, sxtb
    10. 

  10.         add x2, x4, w2, uxtx
    11. 

  11.         add x2, x4, w2, lsl #3
    12. 

  12.         add w5, w7, x9, sxtx
    13. 

  13. // CHECK-ERROR: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    14. 

  14. // CHECK-ERROR:         add x2, x3, x5, sxtb
    15. 

  15. // CHECK-ERROR:                         ^
    16. 

  16. // CHECK-ERROR: error: expected '[su]xt[bhw]' with optional integer in range [0, 4]
    17. 

  17. // CHECK-ERROR:         add x2, x4, w2, uxtx
    18. 

  18. // CHECK-ERROR:                         ^
    19. 

  19. // CHECK-ERROR: error: expected '[su]xt[bhw]' with optional integer in range [0, 4]
    20. 

  20. // CHECK-ERROR:         add x2, x4, w2, lsl #3
    21. 

  21. // CHECK-ERROR:                         ^
    22. 

  22. // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
    23. 

  23. // CHECK-ERROR:         add w5, w7, x9, sxtx
    24. 

  24. // CHECK-ERROR:                     ^
    25. 

  25. 

  26.         // Out of range extends
    27. 

  27.         add x9, x10, w11, uxtb #-1
    28. 

  28.         add x3, x5, w7, uxtb #5
    29. 

  29.         sub x9, x15, x2, uxth #5
    30. 

  30. // CHECK-ERROR: error: expected integer shift amount
    31. 

  31. // CHECK-ERROR:         add x9, x10, w11, uxtb #-1
    32. 

  32. // CHECK-ERROR:                                 ^
    33. 

  33. // CHECK-ERROR: error: expected '[su]xt[bhw]' with optional integer in range [0, 4]
    34. 

  34. // CHECK-ERROR:         add x3, x5, w7, uxtb #5
    35. 

  35. // CHECK-ERROR:                         ^
    36. 

  36. // CHECK-ERROR: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    37. 

  37. // CHECK-ERROR:         sub x9, x15, x2, uxth #5
    38. 

  38. // CHECK-ERROR:                          ^
    39. 

  39. 

  40.         // Wrong registers on normal variants
    41. 

  41.         add xzr, x3, x5, uxtx
    42. 

  42.         sub x3, xzr, w9, sxth #1
    43. 

  43.         add x1, x2, sp, uxtx
    44. 

  44. // CHECK-ERROR: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    45. 

  45. // CHECK-ERROR:         add xzr, x3, x5, uxtx
    46. 

  46. // CHECK-ERROR:                          ^
    47. 

  47. // CHECK-ERROR: error: invalid operand for instruction
    48. 

  48. // CHECK-ERROR:         sub x3, xzr, w9, sxth #1
    49. 

  49. // CHECK-ERROR:                 ^
    50. 

  50. // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
    51. 

  51. // CHECK-ERROR:         add x1, x2, sp, uxtx
    52. 

  52. // CHECK-ERROR:                     ^
    53. 

  53. 

  54.         // Wrong registers on flag-setting variants
    55. 

  55.         adds sp, x3, w2, uxtb
    56. 

  56.         adds x3, xzr, x9, uxtx
    57. 

  57.         subs x2, x1, sp, uxtx
    58. 

  58.         adds x2, x1, sp, uxtb #2
    59. 

  59. // CHECK-ERROR: error: invalid operand for instruction
    60. 

  60. // CHECK-ERROR:         adds sp, x3, w2, uxtb
    61. 

  61. // CHECK-ERROR:              ^
    62. 

  62. // CHECK-ERROR: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    63. 

  63. // CHECK-ERROR:         adds x3, xzr, x9, uxtx
    64. 

  64. // CHECK-ERROR:                           ^
    65. 

  65. // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
    66. 

  66. // CHECK-ERROR:         subs x2, x1, sp, uxtx
    67. 

  67. // CHECK-ERROR:                      ^
    68. 

  68. // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
    69. 

  69. // CHECK-ERROR:         adds x2, x1, sp, uxtb #2
    70. 

  70. // CHECK-ERROR:                      ^
    71. 

  71. 

  72.         // Amount not optional if lsl valid and used
    73. 

  73.         add sp, x5, x7, lsl
    74. 

  74. // CHECK-ERROR: error: expected #imm after shift specifier
    75. 

  75. // CHECK-ERROR:         add sp, x5, x7, lsl
    76. 

  76. // CHECK-ERROR:                             ^
    77. 

  77. 

  78. //------------------------------------------------------------------------------
    79. 

  79. // Add/sub (immediate)
    80. 

  80. //------------------------------------------------------------------------------
    81. 

  81. 

  82. // Out of range immediates: more than 12 bits
    83. 

  83.         add w4, w5, #-4097
    84. 

  84.         add w5, w6, #0x1000
    85. 

  85.         add w4, w5, #-4096, lsl #12
    86. 

  86.         add w5, w6, #0x1000, lsl #12
    87. 

  87. // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
    88. 

  88. // CHECK-ERROR-NEXT:         add w4, w5, #-4097
    89. 

  89. // CHECK-ERROR-NEXT:                     ^
    90. 

  90. // CHECK-ERROR-AARCH64-NEXT: error: expected compatible register, symbol or integer in range [0, 4095]
    91. 

  91. // CHECK-ERROR-AARCH64-NEXT:         add w5, w6, #0x1000
    92. 

  92. // CHECK-ERROR-AARCH64-NEXT:                     ^
    93. 

  93. // CHECK-ERROR-NEXT: error: expected compatible register, symbol or integer in range [0, 4095]
    94. 

  94. // CHECK-ERROR-NEXT:         add w4, w5, #-4096, lsl #12
    95. 

  95. // CHECK-ERROR-NEXT:                     ^
    96. 

  96. // CHECK-ERROR-NEXT: error: expected compatible register, symbol or integer in range [0, 4095]
    97. 

  97. // CHECK-ERROR-NEXT:         add w5, w6, #0x1000, lsl #12
    98. 

  98. // CHECK-ERROR-NEXT:                     ^
    99. 

  99. 

  100. // Only lsl #0 and lsl #12 are allowed
    101. 

  101.         add w2, w3, #0x1, lsl #1
    102. 

  102.         add w5, w17, #0xfff, lsl #13
    103. 

  103.         add w17, w20, #0x1000, lsl #12
    104. 

  104.         sub xsp, x34, #0x100, lsl #-1
    105. 

  105. // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
    106. 

  106. // CHECK-ERROR-NEXT:         add w2, w3, #0x1, lsl #1
    107. 

  107. // CHECK-ERROR-NEXT:                                ^
    108. 

  108. // CHECK-ERROR-NEXT: error: expected compatible register, symbol or integer in range [0, 4095]
    109. 

  109. // CHECK-ERROR-NEXT:         add w5, w17, #0xfff, lsl #13
    110. 

  110. // CHECK-ERROR-NEXT:                                   ^
    111. 

  111. // CHECK-ERROR-NEXT: error: expected compatible register, symbol or integer in range [0, 4095]
    112. 

  112. // CHECK-ERROR-NEXT:         add w17, w20, #0x1000, lsl #12
    113. 

  113. // CHECK-ERROR-NEXT:                       ^
    114. 

  114. // CHECK-ERROR-NEXT: error: only 'lsl #+N' valid after immediate
    115. 

  115. // CHECK-ERROR-NEXT:         sub xsp, x34, #0x100, lsl #-1
    116. 

  116. // CHECK-ERROR-NEXT:                                    ^
    117. 

  117. 

  118. // Incorrect registers (w31 doesn't exist at all, and 31 decodes to sp for these).
    119. 

  119.         add w31, w20, #1234
    120. 

  120.         add wzr, w20, #0x123
    121. 

  121.         add w20, wzr, #0x321
    122. 

  122.         add wzr, wzr, #0xfff
    123. 

  123. // CHECK-ERROR: error: invalid operand for instruction
    124. 

  124. // CHECK-ERROR-NEXT:         add w31, w20, #1234
    125. 

  125. // CHECK-ERROR-NEXT:             ^
    126. 

  126. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    127. 

  127. // CHECK-ERROR-NEXT:         add wzr, w20, #0x123
    128. 

  128. // CHECK-ERROR-NEXT:             ^
    129. 

  129. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    130. 

  130. // CHECK-ERROR-NEXT:         add w20, wzr, #0x321
    131. 

  131. // CHECK-ERROR-NEXT:                  ^
    132. 

  132. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    133. 

  133. // CHECK-ERROR-NEXT:         add wzr, wzr, #0xfff
    134. 

  134. // CHECK-ERROR-NEXT:             ^
    135. 

  135. 

  136. // Mixed register classes
    137. 

  137.         add xsp, w2, #123
    138. 

  138.         sub w2, x30, #32
    139. 

  139. // CHECK-ERROR: error: invalid operand for instruction
    140. 

  140. // CHECK-ERROR-NEXT:         add xsp, w2, #123
    141. 

  141. // CHECK-ERROR-NEXT:             ^
    142. 

  142. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    143. 

  143. // CHECK-ERROR-NEXT:         sub w2, x30, #32
    144. 

  144. // CHECK-ERROR-NEXT:                 ^
    145. 

  145. 

  146. // Out of range immediate
    147. 

  147.         adds w0, w5, #0x10000
    148. 

  148. // CHECK-ERROR-AARCH64: error: expected compatible register, symbol or integer in range [0, 4095]
    149. 

  149. // CHECK-ERROR-AARCH64-NEXT:         adds w0, w5, #0x10000
    150. 

  150. // CHECK-ERROR-AARCH64-NEXT:                      ^
    151. 

  151. 

  152. // Wn|WSP should be in second place
    153. 

  153.         adds w4, wzr, #0x123
    154. 

  154. // ...but wzr is the 31 destination
    155. 

  155.         subs wsp, w5, #123
    156. 

  156.         subs x5, xzr, #0x456, lsl #12
    157. 

  157. // CHECK-ERROR: error: invalid operand for instruction
    158. 

  158. // CHECK-ERROR-NEXT:         adds w4, wzr, #0x123
    159. 

  159. // CHECK-ERROR-NEXT:                  ^
    160. 

  160. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    161. 

  161. // CHECK-ERROR-NEXT:         subs wsp, w5, #123
    162. 

  162. // CHECK-ERROR-NEXT:              ^
    163. 

  163. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    164. 

  164. // CHECK-ERROR-NEXT:         subs x5, xzr, #0x456, lsl #12
    165. 

  165. // CHECK-ERROR-NEXT:                  ^
    166. 

  166. 

  167.         // MOV alias should not accept any fiddling
    168. 

  168.         mov x2, xsp, #123
    169. 

  169.         mov wsp, w27, #0xfff, lsl #12
    170. 

  170. // CHECK-ERROR: error: expected compatible register or logical immediate
    171. 

  171. // CHECK-ERROR-NEXT:         mov x2, xsp, #123
    172. 

  172. // CHECK-ERROR-NEXT:                 ^
    173. 

  173. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    174. 

  174. // CHECK-ERROR-NEXT:         mov wsp, w27, #0xfff, lsl #12
    175. 

  175. // CHECK-ERROR-NEXT:                       ^
    176. 

  176. 

  177.         // A relocation should be provided for symbols
    178. 

  178.         add x3, x9, #variable
    179. 

  179.         add x3, x9, #variable-16
    180. 

  180. // CHECK-ERROR: error: expected compatible register, symbol or integer in range [0, 4095]
    181. 

  181. // CHECK-ERROR-NEXT:         add x3, x9, #variable
    182. 

  182. // CHECK-ERROR-NEXT:                      ^
    183. 

  183. // CHECK-ERROR-NEXT: error: expected compatible register, symbol or integer in range [0, 4095]
    184. 

  184. // CHECK-ERROR-NEXT:         add x3, x9, #variable-16
    185. 

  185. // CHECK-ERROR-NEXT:                 ^
    186. 

  186. 

  187.         // Relocation on a sub
    188. 

  188.         sub x1, x0, :lo12:loc
    189. 

  189. // CHECK-ERROR: error: invalid immediate expression
    190. 

  190. // CHECK-ERROR:         sub x1, x0, :lo12:loc
    191. 

  191. // CHECK-ERROR:                     ^
    192. 

  192. 

  193. 

  194. //------------------------------------------------------------------------------
    195. 

  195. // Add-subtract (shifted register)
    196. 

  196. //------------------------------------------------------------------------------
    197. 

  197. 

  198.         add wsp, w1, w2, lsr #3
    199. 

  199.         add x4, sp, x9, asr #5
    200. 

  200.         add x9, x10, x5, ror #3
    201. 

  201. // CHECK-ERROR: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    202. 

  202. // CHECK-ERROR-NEXT:         add wsp, w1, w2, lsr #3
    203. 

  203. // CHECK-ERROR-NEXT:                          ^
    204. 

  204. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    205. 

  205. // CHECK-ERROR-NEXT:         add x4, sp, x9, asr #5
    206. 

  206. // CHECK-ERROR-NEXT:                         ^
    207. 

  207. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    208. 

  208. // CHECK-ERROR-NEXT:         add x9, x10, x5, ror #3
    209. 

  209. // CHECK-ERROR-NEXT:                          ^
    210. 

  210. 

  211.         add w1, w2, w3, lsl #-1
    212. 

  212.         add w1, w2, w3, lsl #32
    213. 

  213.         add w1, w2, w3, lsr #-1
    214. 

  214.         add w1, w2, w3, lsr #32
    215. 

  215.         add w1, w2, w3, asr #-1
    216. 

  216.         add w1, w2, w3, asr #32
    217. 

  217.         add x1, x2, x3, lsl #-1
    218. 

  218.         add x1, x2, x3, lsl #64
    219. 

  219.         add x1, x2, x3, lsr #-1
    220. 

  220.         add x1, x2, x3, lsr #64
    221. 

  221.         add x1, x2, x3, asr #-1
    222. 

  222.         add x1, x2, x3, asr #64
    223. 

  223. // CHECK-ERROR: error: expected integer shift amount
    224. 

  224. // CHECK-ERROR-NEXT:         add w1, w2, w3, lsl #-1
    225. 

  225. // CHECK-ERROR-NEXT:                              ^
    226. 

  226. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    227. 

  227. // CHECK-ERROR-NEXT:         add w1, w2, w3, lsl #32
    228. 

  228. // CHECK-ERROR-NEXT:                         ^
    229. 

  229. // CHECK-ERROR-NEXT: error: expected integer shift amount
    230. 

  230. // CHECK-ERROR-NEXT:         add w1, w2, w3, lsr #-1
    231. 

  231. // CHECK-ERROR-NEXT:                              ^
    232. 

  232. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    233. 

  233. // CHECK-ERROR-NEXT:         add w1, w2, w3, lsr #32
    234. 

  234. // CHECK-ERROR-NEXT:                         ^
    235. 

  235. // CHECK-ERROR-NEXT: error: expected integer shift amount
    236. 

  236. // CHECK-ERROR-NEXT:         add w1, w2, w3, asr #-1
    237. 

  237. // CHECK-ERROR-NEXT:                              ^
    238. 

  238. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    239. 

  239. // CHECK-ERROR-NEXT:         add w1, w2, w3, asr #32
    240. 

  240. // CHECK-ERROR-NEXT:                         ^
    241. 

  241. // CHECK-ERROR-NEXT: error: expected integer shift amount
    242. 

  242. // CHECK-ERROR-NEXT:         add x1, x2, x3, lsl #-1
    243. 

  243. // CHECK-ERROR-NEXT:                              ^
    244. 

  244. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    245. 

  245. // CHECK-ERROR-NEXT:         add x1, x2, x3, lsl #64
    246. 

  246. // CHECK-ERROR-NEXT:                         ^
    247. 

  247. // CHECK-ERROR-NEXT: error: expected integer shift amount
    248. 

  248. // CHECK-ERROR-NEXT:         add x1, x2, x3, lsr #-1
    249. 

  249. // CHECK-ERROR-NEXT:                              ^
    250. 

  250. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    251. 

  251. // CHECK-ERROR-NEXT:         add x1, x2, x3, lsr #64
    252. 

  252. // CHECK-ERROR-NEXT:                         ^
    253. 

  253. // CHECK-ERROR-NEXT: error: expected integer shift amount
    254. 

  254. // CHECK-ERROR-NEXT:         add x1, x2, x3, asr #-1
    255. 

  255. // CHECK-ERROR-NEXT:                              ^
    256. 

  256. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    257. 

  257. // CHECK-ERROR-NEXT:         add x1, x2, x3, asr #64
    258. 

  258. // CHECK-ERROR-NEXT:                         ^
    259. 

  259. 

  260.         adds w1, w2, w3, lsl #-1
    261. 

  261.         adds w1, w2, w3, lsl #32
    262. 

  262.         adds w1, w2, w3, lsr #-1
    263. 

  263.         adds w1, w2, w3, lsr #32
    264. 

  264.         adds w1, w2, w3, asr #-1
    265. 

  265.         adds w1, w2, w3, asr #32
    266. 

  266.         adds x1, x2, x3, lsl #-1
    267. 

  267.         adds x1, x2, x3, lsl #64
    268. 

  268.         adds x1, x2, x3, lsr #-1
    269. 

  269.         adds x1, x2, x3, lsr #64
    270. 

  270.         adds x1, x2, x3, asr #-1
    271. 

  271.         adds x1, x2, x3, asr #64
    272. 

  272. // CHECK-ERROR: error: expected integer shift amount
    273. 

  273. // CHECK-ERROR-NEXT:         adds w1, w2, w3, lsl #-1
    274. 

  274. // CHECK-ERROR-NEXT:                               ^
    275. 

  275. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    276. 

  276. // CHECK-ERROR-NEXT:         adds w1, w2, w3, lsl #32
    277. 

  277. // CHECK-ERROR-NEXT:                          ^
    278. 

  278. // CHECK-ERROR-NEXT: error: expected integer shift amount
    279. 

  279. // CHECK-ERROR-NEXT:         adds w1, w2, w3, lsr #-1
    280. 

  280. // CHECK-ERROR-NEXT:                               ^
    281. 

  281. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    282. 

  282. // CHECK-ERROR-NEXT:         adds w1, w2, w3, lsr #32
    283. 

  283. // CHECK-ERROR-NEXT:                          ^
    284. 

  284. // CHECK-ERROR-NEXT: error: expected integer shift amount
    285. 

  285. // CHECK-ERROR-NEXT:         adds w1, w2, w3, asr #-1
    286. 

  286. // CHECK-ERROR-NEXT:                               ^
    287. 

  287. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    288. 

  288. // CHECK-ERROR-NEXT:         adds w1, w2, w3, asr #32
    289. 

  289. // CHECK-ERROR-NEXT:                          ^
    290. 

  290. // CHECK-ERROR-NEXT: error: expected integer shift amount
    291. 

  291. // CHECK-ERROR-NEXT:         adds x1, x2, x3, lsl #-1
    292. 

  292. // CHECK-ERROR-NEXT:                               ^
    293. 

  293. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    294. 

  294. // CHECK-ERROR-NEXT:         adds x1, x2, x3, lsl #64
    295. 

  295. // CHECK-ERROR-NEXT:                          ^
    296. 

  296. // CHECK-ERROR-NEXT: error: expected integer shift amount
    297. 

  297. // CHECK-ERROR-NEXT:         adds x1, x2, x3, lsr #-1
    298. 

  298. // CHECK-ERROR-NEXT:                               ^
    299. 

  299. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    300. 

  300. // CHECK-ERROR-NEXT:         adds x1, x2, x3, lsr #64
    301. 

  301. // CHECK-ERROR-NEXT:                          ^
    302. 

  302. // CHECK-ERROR-NEXT: error: expected integer shift amount
    303. 

  303. // CHECK-ERROR-NEXT:         adds x1, x2, x3, asr #-1
    304. 

  304. // CHECK-ERROR-NEXT:                               ^
    305. 

  305. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    306. 

  306. // CHECK-ERROR-NEXT:         adds x1, x2, x3, asr #64
    307. 

  307. // CHECK-ERROR-NEXT:                          ^
    308. 

  308. 

  309.         sub w1, w2, w3, lsl #-1
    310. 

  310.         sub w1, w2, w3, lsl #32
    311. 

  311.         sub w1, w2, w3, lsr #-1
    312. 

  312.         sub w1, w2, w3, lsr #32
    313. 

  313.         sub w1, w2, w3, asr #-1
    314. 

  314.         sub w1, w2, w3, asr #32
    315. 

  315.         sub x1, x2, x3, lsl #-1
    316. 

  316.         sub x1, x2, x3, lsl #64
    317. 

  317.         sub x1, x2, x3, lsr #-1
    318. 

  318.         sub x1, x2, x3, lsr #64
    319. 

  319.         sub x1, x2, x3, asr #-1
    320. 

  320.         sub x1, x2, x3, asr #64
    321. 

  321. // CHECK-ERROR: error: expected integer shift amount
    322. 

  322. // CHECK-ERROR-NEXT:         sub w1, w2, w3, lsl #-1
    323. 

  323. // CHECK-ERROR-NEXT:                              ^
    324. 

  324. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    325. 

  325. // CHECK-ERROR-NEXT:         sub w1, w2, w3, lsl #32
    326. 

  326. // CHECK-ERROR-NEXT:                         ^
    327. 

  327. // CHECK-ERROR-NEXT: error: expected integer shift amount
    328. 

  328. // CHECK-ERROR-NEXT:         sub w1, w2, w3, lsr #-1
    329. 

  329. // CHECK-ERROR-NEXT:                              ^
    330. 

  330. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    331. 

  331. // CHECK-ERROR-NEXT:         sub w1, w2, w3, lsr #32
    332. 

  332. // CHECK-ERROR-NEXT:                         ^
    333. 

  333. // CHECK-ERROR-NEXT: error: expected integer shift amount
    334. 

  334. // CHECK-ERROR-NEXT:         sub w1, w2, w3, asr #-1
    335. 

  335. // CHECK-ERROR-NEXT:                              ^
    336. 

  336. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    337. 

  337. // CHECK-ERROR-NEXT:         sub w1, w2, w3, asr #32
    338. 

  338. // CHECK-ERROR-NEXT:                         ^
    339. 

  339. // CHECK-ERROR-NEXT: error: expected integer shift amount
    340. 

  340. // CHECK-ERROR-NEXT:         sub x1, x2, x3, lsl #-1
    341. 

  341. // CHECK-ERROR-NEXT:                              ^
    342. 

  342. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    343. 

  343. // CHECK-ERROR-NEXT:         sub x1, x2, x3, lsl #64
    344. 

  344. // CHECK-ERROR-NEXT:                         ^
    345. 

  345. // CHECK-ERROR-NEXT: error: expected integer shift amount
    346. 

  346. // CHECK-ERROR-NEXT:         sub x1, x2, x3, lsr #-1
    347. 

  347. // CHECK-ERROR-NEXT:                              ^
    348. 

  348. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    349. 

  349. // CHECK-ERROR-NEXT:         sub x1, x2, x3, lsr #64
    350. 

  350. // CHECK-ERROR-NEXT:                         ^
    351. 

  351. // CHECK-ERROR-NEXT: error: expected integer shift amount
    352. 

  352. // CHECK-ERROR-NEXT:         sub x1, x2, x3, asr #-1
    353. 

  353. // CHECK-ERROR-NEXT:                              ^
    354. 

  354. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    355. 

  355. // CHECK-ERROR-NEXT:         sub x1, x2, x3, asr #64
    356. 

  356. // CHECK-ERROR-NEXT:                         ^
    357. 

  357. 

  358.         subs w1, w2, w3, lsl #-1
    359. 

  359.         subs w1, w2, w3, lsl #32
    360. 

  360.         subs w1, w2, w3, lsr #-1
    361. 

  361.         subs w1, w2, w3, lsr #32
    362. 

  362.         subs w1, w2, w3, asr #-1
    363. 

  363.         subs w1, w2, w3, asr #32
    364. 

  364.         subs x1, x2, x3, lsl #-1
    365. 

  365.         subs x1, x2, x3, lsl #64
    366. 

  366.         subs x1, x2, x3, lsr #-1
    367. 

  367.         subs x1, x2, x3, lsr #64
    368. 

  368.         subs x1, x2, x3, asr #-1
    369. 

  369.         subs x1, x2, x3, asr #64
    370. 

  370. // CHECK-ERROR: error: expected integer shift amount
    371. 

  371. // CHECK-ERROR-NEXT:         subs w1, w2, w3, lsl #-1
    372. 

  372. // CHECK-ERROR-NEXT:                               ^
    373. 

  373. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    374. 

  374. // CHECK-ERROR-NEXT:         subs w1, w2, w3, lsl #32
    375. 

  375. // CHECK-ERROR-NEXT:                          ^
    376. 

  376. // CHECK-ERROR-NEXT: error: expected integer shift amount
    377. 

  377. // CHECK-ERROR-NEXT:         subs w1, w2, w3, lsr #-1
    378. 

  378. // CHECK-ERROR-NEXT:                               ^
    379. 

  379. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    380. 

  380. // CHECK-ERROR-NEXT:         subs w1, w2, w3, lsr #32
    381. 

  381. // CHECK-ERROR-NEXT:                          ^
    382. 

  382. // CHECK-ERROR-NEXT: error: expected integer shift amount
    383. 

  383. // CHECK-ERROR-NEXT:         subs w1, w2, w3, asr #-1
    384. 

  384. // CHECK-ERROR-NEXT:                               ^
    385. 

  385. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    386. 

  386. // CHECK-ERROR-NEXT:         subs w1, w2, w3, asr #32
    387. 

  387. // CHECK-ERROR-NEXT:                          ^
    388. 

  388. // CHECK-ERROR-NEXT: error: expected integer shift amount
    389. 

  389. // CHECK-ERROR-NEXT:         subs x1, x2, x3, lsl #-1
    390. 

  390. // CHECK-ERROR-NEXT:                               ^
    391. 

  391. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    392. 

  392. // CHECK-ERROR-NEXT:         subs x1, x2, x3, lsl #64
    393. 

  393. // CHECK-ERROR-NEXT:                          ^
    394. 

  394. // CHECK-ERROR-NEXT: error: expected integer shift amount
    395. 

  395. // CHECK-ERROR-NEXT:         subs x1, x2, x3, lsr #-1
    396. 

  396. // CHECK-ERROR-NEXT:                               ^
    397. 

  397. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    398. 

  398. // CHECK-ERROR-NEXT:         subs x1, x2, x3, lsr #64
    399. 

  399. // CHECK-ERROR-NEXT:                          ^
    400. 

  400. // CHECK-ERROR-NEXT: error: expected integer shift amount
    401. 

  401. // CHECK-ERROR-NEXT:         subs x1, x2, x3, asr #-1
    402. 

  402. // CHECK-ERROR-NEXT:                               ^
    403. 

  403. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    404. 

  404. // CHECK-ERROR-NEXT:         subs x1, x2, x3, asr #64
    405. 

  405. // CHECK-ERROR-NEXT:                          ^
    406. 

  406. 

  407.         cmn w9, w10, lsl #-1
    408. 

  408.         cmn w9, w10, lsl #32
    409. 

  409.         cmn w11, w12, lsr #-1
    410. 

  410.         cmn w11, w12, lsr #32
    411. 

  411.         cmn w19, wzr, asr #-1
    412. 

  412.         cmn wzr, wzr, asr #32
    413. 

  413.         cmn x9, x10, lsl #-1
    414. 

  414.         cmn x9, x10, lsl #64
    415. 

  415.         cmn x11, x12, lsr #-1
    416. 

  416.         cmn x11, x12, lsr #64
    417. 

  417.         cmn x19, xzr, asr #-1
    418. 

  418.         cmn xzr, xzr, asr #64
    419. 

  419. // CHECK-ERROR: error: expected integer shift amount
    420. 

  420. // CHECK-ERROR-NEXT:         cmn w9, w10, lsl #-1
    421. 

  421. // CHECK-ERROR-NEXT:                           ^
    422. 

  422. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    423. 

  423. // CHECK-ERROR-NEXT:         cmn w9, w10, lsl #32
    424. 

  424. // CHECK-ERROR-NEXT:                      ^
    425. 

  425. // CHECK-ERROR-NEXT: error: expected integer shift amount
    426. 

  426. // CHECK-ERROR-NEXT:         cmn w11, w12, lsr #-1
    427. 

  427. // CHECK-ERROR-NEXT:                            ^
    428. 

  428. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    429. 

  429. // CHECK-ERROR-NEXT:         cmn w11, w12, lsr #32
    430. 

  430. // CHECK-ERROR-NEXT:                       ^
    431. 

  431. // CHECK-ERROR-NEXT: error: expected integer shift amount
    432. 

  432. // CHECK-ERROR-NEXT:         cmn w19, wzr, asr #-1
    433. 

  433. // CHECK-ERROR-NEXT:                            ^
    434. 

  434. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    435. 

  435. // CHECK-ERROR-NEXT:         cmn wzr, wzr, asr #32
    436. 

  436. // CHECK-ERROR-NEXT:                       ^
    437. 

  437. // CHECK-ERROR-NEXT: error: expected integer shift amount
    438. 

  438. // CHECK-ERROR-NEXT:         cmn x9, x10, lsl #-1
    439. 

  439. // CHECK-ERROR-NEXT:                           ^
    440. 

  440. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    441. 

  441. // CHECK-ERROR-NEXT:         cmn x9, x10, lsl #64
    442. 

  442. // CHECK-ERROR-NEXT:                      ^
    443. 

  443. // CHECK-ERROR-NEXT: error: expected integer shift amount
    444. 

  444. // CHECK-ERROR-NEXT:         cmn x11, x12, lsr #-1
    445. 

  445. // CHECK-ERROR-NEXT:                            ^
    446. 

  446. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    447. 

  447. // CHECK-ERROR-NEXT:         cmn x11, x12, lsr #64
    448. 

  448. // CHECK-ERROR-NEXT:                       ^
    449. 

  449. // CHECK-ERROR-NEXT: error: expected integer shift amount
    450. 

  450. // CHECK-ERROR-NEXT:         cmn x19, xzr, asr #-1
    451. 

  451. // CHECK-ERROR-NEXT:                            ^
    452. 

  452. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    453. 

  453. // CHECK-ERROR-NEXT:         cmn xzr, xzr, asr #64
    454. 

  454. // CHECK-ERROR-NEXT:                       ^
    455. 

  455. 

  456.         cmp w9, w10, lsl #-1
    457. 

  457.         cmp w9, w10, lsl #32
    458. 

  458.         cmp w11, w12, lsr #-1
    459. 

  459.         cmp w11, w12, lsr #32
    460. 

  460.         cmp w19, wzr, asr #-1
    461. 

  461.         cmp wzr, wzr, asr #32
    462. 

  462.         cmp x9, x10, lsl #-1
    463. 

  463.         cmp x9, x10, lsl #64
    464. 

  464.         cmp x11, x12, lsr #-1
    465. 

  465.         cmp x11, x12, lsr #64
    466. 

  466.         cmp x19, xzr, asr #-1
    467. 

  467.         cmp xzr, xzr, asr #64
    468. 

  468. // CHECK-ERROR: error: expected integer shift amount
    469. 

  469. // CHECK-ERROR-NEXT:         cmp w9, w10, lsl #-1
    470. 

  470. // CHECK-ERROR-NEXT:                           ^
    471. 

  471. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    472. 

  472. // CHECK-ERROR-NEXT:         cmp w9, w10, lsl #32
    473. 

  473. // CHECK-ERROR-NEXT:                      ^
    474. 

  474. // CHECK-ERROR-NEXT: error: expected integer shift amount
    475. 

  475. // CHECK-ERROR-NEXT:         cmp w11, w12, lsr #-1
    476. 

  476. // CHECK-ERROR-NEXT:                            ^
    477. 

  477. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    478. 

  478. // CHECK-ERROR-NEXT:         cmp w11, w12, lsr #32
    479. 

  479. // CHECK-ERROR-NEXT:                       ^
    480. 

  480. // CHECK-ERROR-NEXT: error: expected integer shift amount
    481. 

  481. // CHECK-ERROR-NEXT:         cmp w19, wzr, asr #-1
    482. 

  482. // CHECK-ERROR-NEXT:                            ^
    483. 

  483. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    484. 

  484. // CHECK-ERROR-NEXT:         cmp wzr, wzr, asr #32
    485. 

  485. // CHECK-ERROR-NEXT:                       ^
    486. 

  486. // CHECK-ERROR-NEXT: error: expected integer shift amount
    487. 

  487. // CHECK-ERROR-NEXT:         cmp x9, x10, lsl #-1
    488. 

  488. // CHECK-ERROR-NEXT:                           ^
    489. 

  489. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    490. 

  490. // CHECK-ERROR-NEXT:         cmp x9, x10, lsl #64
    491. 

  491. // CHECK-ERROR-NEXT:                      ^
    492. 

  492. // CHECK-ERROR-NEXT: error: expected integer shift amount
    493. 

  493. // CHECK-ERROR-NEXT:         cmp x11, x12, lsr #-1
    494. 

  494. // CHECK-ERROR-NEXT:                            ^
    495. 

  495. // CHECK-ERROR-NEXT: error: expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]
    496. 

  496. // CHECK-ERROR-NEXT:         cmp x11, x12, lsr #64
    497. 

  497. // CHECK-ERROR-NEXT:                       ^
    498. 

  498. // CHECK-ERROR-NEXT: error: expected integer shift amount
    499. 

  499. // CHECK-ERROR-NEXT:         cmp x19, xzr, asr #-1
    500. 

  500. // CHECK-ERROR-NEXT:                            ^
    501. 

  501. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    502. 

  502. // CHECK-ERROR-NEXT:         cmp xzr, xzr, asr #64
    503. 

  503. // CHECK-ERROR-NEXT:                       ^
    504. 

  504. 

  505.         neg w9, w10, lsl #-1
    506. 

  506.         neg w9, w10, lsl #32
    507. 

  507.         neg w11, w12, lsr #-1
    508. 

  508.         neg w11, w12, lsr #32
    509. 

  509.         neg w19, wzr, asr #-1
    510. 

  510.         neg wzr, wzr, asr #32
    511. 

  511.         neg x9, x10, lsl #-1
    512. 

  512.         neg x9, x10, lsl #64
    513. 

  513.         neg x11, x12, lsr #-1
    514. 

  514.         neg x11, x12, lsr #64
    515. 

  515.         neg x19, xzr, asr #-1
    516. 

  516.         neg xzr, xzr, asr #64
    517. 

  517. // CHECK-ERROR: error: expected integer shift amount
    518. 

  518. // CHECK-ERROR-NEXT:         neg w9, w10, lsl #-1
    519. 

  519. // CHECK-ERROR-NEXT:                           ^
    520. 

  520. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    521. 

  521. // CHECK-ERROR-NEXT:         neg w9, w10, lsl #32
    522. 

  522. // CHECK-ERROR-NEXT:                      ^
    523. 

  523. // CHECK-ERROR-NEXT: error: expected integer shift amount
    524. 

  524. // CHECK-ERROR-NEXT:         neg w11, w12, lsr #-1
    525. 

  525. // CHECK-ERROR-NEXT:                            ^
    526. 

  526. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    527. 

  527. // CHECK-ERROR-NEXT:         neg w11, w12, lsr #32
    528. 

  528. // CHECK-ERROR-NEXT:                       ^
    529. 

  529. // CHECK-ERROR-NEXT: error: expected integer shift amount
    530. 

  530. // CHECK-ERROR-NEXT:         neg w19, wzr, asr #-1
    531. 

  531. // CHECK-ERROR-NEXT:                            ^
    532. 

  532. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    533. 

  533. // CHECK-ERROR-NEXT:         neg wzr, wzr, asr #32
    534. 

  534. // CHECK-ERROR-NEXT:                       ^
    535. 

  535. // CHECK-ERROR-NEXT: error: expected integer shift amount
    536. 

  536. // CHECK-ERROR-NEXT:         neg x9, x10, lsl #-1
    537. 

  537. // CHECK-ERROR-NEXT:                           ^
    538. 

  538. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    539. 

  539. // CHECK-ERROR-NEXT:         neg x9, x10, lsl #64
    540. 

  540. // CHECK-ERROR-NEXT:                      ^
    541. 

  541. // CHECK-ERROR-NEXT: error: expected integer shift amount
    542. 

  542. // CHECK-ERROR-NEXT:         neg x11, x12, lsr #-1
    543. 

  543. // CHECK-ERROR-NEXT:                            ^
    544. 

  544. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    545. 

  545. // CHECK-ERROR-NEXT:         neg x11, x12, lsr #64
    546. 

  546. // CHECK-ERROR-NEXT:                       ^
    547. 

  547. // CHECK-ERROR-NEXT: error: expected integer shift amount
    548. 

  548. // CHECK-ERROR-NEXT:         neg x19, xzr, asr #-1
    549. 

  549. // CHECK-ERROR-NEXT:                            ^
    550. 

  550. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    551. 

  551. // CHECK-ERROR-NEXT:         neg xzr, xzr, asr #64
    552. 

  552. // CHECK-ERROR-NEXT:                       ^
    553. 

  553. 

  554.         negs w9, w10, lsl #-1
    555. 

  555.         negs w9, w10, lsl #32
    556. 

  556.         negs w11, w12, lsr #-1
    557. 

  557.         negs w11, w12, lsr #32
    558. 

  558.         negs w19, wzr, asr #-1
    559. 

  559.         negs wzr, wzr, asr #32
    560. 

  560.         negs x9, x10, lsl #-1
    561. 

  561.         negs x9, x10, lsl #64
    562. 

  562.         negs x11, x12, lsr #-1
    563. 

  563.         negs x11, x12, lsr #64
    564. 

  564.         negs x19, xzr, asr #-1
    565. 

  565.         negs xzr, xzr, asr #64
    566. 

  566. // CHECK-ERROR: error: expected integer shift amount
    567. 

  567. // CHECK-ERROR-NEXT:         negs w9, w10, lsl #-1
    568. 

  568. // CHECK-ERROR-NEXT:                            ^
    569. 

  569. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    570. 

  570. // CHECK-ERROR-NEXT:         negs w9, w10, lsl #32
    571. 

  571. // CHECK-ERROR-NEXT:                       ^
    572. 

  572. // CHECK-ERROR-NEXT: error: expected integer shift amount
    573. 

  573. // CHECK-ERROR-NEXT:         negs w11, w12, lsr #-1
    574. 

  574. // CHECK-ERROR-NEXT:                             ^
    575. 

  575. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    576. 

  576. // CHECK-ERROR-NEXT:         negs w11, w12, lsr #32
    577. 

  577. // CHECK-ERROR-NEXT:                        ^
    578. 

  578. // CHECK-ERROR-NEXT: error: expected integer shift amount
    579. 

  579. // CHECK-ERROR-NEXT:         negs w19, wzr, asr #-1
    580. 

  580. // CHECK-ERROR-NEXT:                             ^
    581. 

  581. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    582. 

  582. // CHECK-ERROR-NEXT:         negs wzr, wzr, asr #32
    583. 

  583. // CHECK-ERROR-NEXT:                        ^
    584. 

  584. // CHECK-ERROR-NEXT: error: expected integer shift amount
    585. 

  585. // CHECK-ERROR-NEXT:         negs x9, x10, lsl #-1
    586. 

  586. // CHECK-ERROR-NEXT:                            ^
    587. 

  587. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    588. 

  588. // CHECK-ERROR-NEXT:         negs x9, x10, lsl #64
    589. 

  589. // CHECK-ERROR-NEXT:                       ^
    590. 

  590. // CHECK-ERROR-NEXT: error: expected integer shift amount
    591. 

  591. // CHECK-ERROR-NEXT:         negs x11, x12, lsr #-1
    592. 

  592. // CHECK-ERROR-NEXT:                             ^
    593. 

  593. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    594. 

  594. // CHECK-ERROR-NEXT:         negs x11, x12, lsr #64
    595. 

  595. // CHECK-ERROR-NEXT:                        ^
    596. 

  596. // CHECK-ERROR-NEXT: error: expected integer shift amount
    597. 

  597. // CHECK-ERROR-NEXT:         negs x19, xzr, asr #-1
    598. 

  598. // CHECK-ERROR-NEXT:                             ^
    599. 

  599. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    600. 

  600. // CHECK-ERROR-NEXT:         negs xzr, xzr, asr #64
    601. 

  601. // CHECK-ERROR-NEXT:                        ^
    602. 

  602. 

  603. //------------------------------------------------------------------------------
    604. 

  604. // Add-subtract (shifted register)
    605. 

  605. //------------------------------------------------------------------------------
    606. 

  606. 

  607.         adc wsp, w3, w5
    608. 

  608.         adc w1, wsp, w2
    609. 

  609.         adc w0, w10, wsp
    610. 

  610. // CHECK-ERROR: error: invalid operand for instruction
    611. 

  611. // CHECK-ERROR-NEXT:        adc wsp, w3, w5
    612. 

  612. // CHECK-ERROR-NEXT:            ^
    613. 

  613. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    614. 

  614. // CHECK-ERROR-NEXT:         adc w1, wsp, w2
    615. 

  615. // CHECK-ERROR-NEXT:                 ^
    616. 

  616. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    617. 

  617. // CHECK-ERROR-NEXT:         adc w0, w10, wsp
    618. 

  618. // CHECK-ERROR-NEXT:                      ^
    619. 

  619. 

  620.         adc sp, x3, x5
    621. 

  621.         adc x1, sp, x2
    622. 

  622.         adc x0, x10, sp
    623. 

  623. // CHECK-ERROR: error: invalid operand for instruction
    624. 

  624. // CHECK-ERROR-NEXT:         adc sp, x3, x5
    625. 

  625. // CHECK-ERROR-NEXT:             ^
    626. 

  626. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    627. 

  627. // CHECK-ERROR-NEXT:         adc x1, sp, x2
    628. 

  628. // CHECK-ERROR-NEXT:                 ^
    629. 

  629. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    630. 

  630. // CHECK-ERROR-NEXT:         adc x0, x10, sp
    631. 

  631. // CHECK-ERROR-NEXT:                      ^
    632. 

  632. 

  633.         adcs wsp, w3, w5
    634. 

  634.         adcs w1, wsp, w2
    635. 

  635.         adcs w0, w10, wsp
    636. 

  636. // CHECK-ERROR: error: invalid operand for instruction
    637. 

  637. // CHECK-ERROR-NEXT:         adcs wsp, w3, w5
    638. 

  638. // CHECK-ERROR-NEXT:              ^
    639. 

  639. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    640. 

  640. // CHECK-ERROR-NEXT:         adcs w1, wsp, w2
    641. 

  641. // CHECK-ERROR-NEXT:                  ^
    642. 

  642. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    643. 

  643. // CHECK-ERROR-NEXT:         adcs w0, w10, wsp
    644. 

  644. // CHECK-ERROR-NEXT:                       ^
    645. 

  645. 

  646.         adcs sp, x3, x5
    647. 

  647.         adcs x1, sp, x2
    648. 

  648.         adcs x0, x10, sp
    649. 

  649. // CHECK-ERROR: error: invalid operand for instruction
    650. 

  650. // CHECK-ERROR-NEXT:         adcs sp, x3, x5
    651. 

  651. // CHECK-ERROR-NEXT:              ^
    652. 

  652. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    653. 

  653. // CHECK-ERROR-NEXT:         adcs x1, sp, x2
    654. 

  654. // CHECK-ERROR-NEXT:                  ^
    655. 

  655. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    656. 

  656. // CHECK-ERROR-NEXT:         adcs x0, x10, sp
    657. 

  657. // CHECK-ERROR-NEXT:                       ^
    658. 

  658. 

  659.         sbc wsp, w3, w5
    660. 

  660.         sbc w1, wsp, w2
    661. 

  661.         sbc w0, w10, wsp
    662. 

  662. // CHECK-ERROR: error: invalid operand for instruction
    663. 

  663. // CHECK-ERROR-NEXT:         sbc wsp, w3, w5
    664. 

  664. // CHECK-ERROR-NEXT:             ^
    665. 

  665. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    666. 

  666. // CHECK-ERROR-NEXT:         sbc w1, wsp, w2
    667. 

  667. // CHECK-ERROR-NEXT:                 ^
    668. 

  668. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    669. 

  669. // CHECK-ERROR-NEXT:         sbc w0, w10, wsp
    670. 

  670. // CHECK-ERROR-NEXT:                      ^
    671. 

  671. 

  672.         sbc sp, x3, x5
    673. 

  673.         sbc x1, sp, x2
    674. 

  674.         sbc x0, x10, sp
    675. 

  675. // CHECK-ERROR: error: invalid operand for instruction
    676. 

  676. // CHECK-ERROR-NEXT:         sbc sp, x3, x5
    677. 

  677. // CHECK-ERROR-NEXT:             ^
    678. 

  678. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    679. 

  679. // CHECK-ERROR-NEXT:         sbc x1, sp, x2
    680. 

  680. // CHECK-ERROR-NEXT:                 ^
    681. 

  681. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    682. 

  682. // CHECK-ERROR-NEXT:         sbc x0, x10, sp
    683. 

  683. // CHECK-ERROR-NEXT:                      ^
    684. 

  684. 

  685.         sbcs wsp, w3, w5
    686. 

  686.         sbcs w1, wsp, w2
    687. 

  687.         sbcs w0, w10, wsp
    688. 

  688. // CHECK-ERROR: error: invalid operand for instruction
    689. 

  689. // CHECK-ERROR-NEXT:         sbcs wsp, w3, w5
    690. 

  690. // CHECK-ERROR-NEXT:              ^
    691. 

  691. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    692. 

  692. // CHECK-ERROR-NEXT:         sbcs w1, wsp, w2
    693. 

  693. // CHECK-ERROR-NEXT:                  ^
    694. 

  694. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    695. 

  695. // CHECK-ERROR-NEXT:         sbcs w0, w10, wsp
    696. 

  696. // CHECK-ERROR-NEXT:                       ^
    697. 

  697. 

  698.         sbcs sp, x3, x5
    699. 

  699.         sbcs x1, sp, x2
    700. 

  700.         sbcs x0, x10, sp
    701. 

  701. // CHECK-ERROR: error: invalid operand for instruction
    702. 

  702. // CHECK-ERROR-NEXT:         sbcs sp, x3, x5
    703. 

  703. // CHECK-ERROR-NEXT:              ^
    704. 

  704. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    705. 

  705. // CHECK-ERROR-NEXT:         sbcs x1, sp, x2
    706. 

  706. // CHECK-ERROR-NEXT:                  ^
    707. 

  707. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    708. 

  708. // CHECK-ERROR-NEXT:         sbcs x0, x10, sp
    709. 

  709. // CHECK-ERROR-NEXT:                       ^
    710. 

  710. 

  711.         ngc wsp, w3
    712. 

  712.         ngc w9, wsp
    713. 

  713.         ngc sp, x9
    714. 

  714.         ngc x2, sp
    715. 

  715. // CHECK-ERROR: error: invalid operand for instruction
    716. 

  716. // CHECK-ERROR-NEXT:         ngc wsp, w3
    717. 

  717. // CHECK-ERROR-NEXT:             ^
    718. 

  718. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    719. 

  719. // CHECK-ERROR-NEXT:         ngc w9, wsp
    720. 

  720. // CHECK-ERROR-NEXT:                 ^
    721. 

  721. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    722. 

  722. // CHECK-ERROR-NEXT:         ngc sp, x9
    723. 

  723. // CHECK-ERROR-NEXT:             ^
    724. 

  724. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    725. 

  725. // CHECK-ERROR-NEXT:         ngc x2, sp
    726. 

  726. // CHECK-ERROR-NEXT:                 ^
    727. 

  727. 

  728.         ngcs wsp, w3
    729. 

  729.         ngcs w9, wsp
    730. 

  730.         ngcs sp, x9
    731. 

  731.         ngcs x2, sp
    732. 

  732. // CHECK-ERROR: error: invalid operand for instruction
    733. 

  733. // CHECK-ERROR-NEXT:         ngcs wsp, w3
    734. 

  734. // CHECK-ERROR-NEXT:              ^
    735. 

  735. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    736. 

  736. // CHECK-ERROR-NEXT:         ngcs w9, wsp
    737. 

  737. // CHECK-ERROR-NEXT:                  ^
    738. 

  738. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    739. 

  739. // CHECK-ERROR-NEXT:         ngcs sp, x9
    740. 

  740. // CHECK-ERROR-NEXT:              ^
    741. 

  741. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    742. 

  742. // CHECK-ERROR-NEXT:         ngcs x2, sp
    743. 

  743. // CHECK-ERROR-NEXT:                  ^
    744. 

  744. 

  745. //------------------------------------------------------------------------------
    746. 

  746. // Logical (immediates)
    747. 

  747. //------------------------------------------------------------------------------
    748. 

  748. 

  749.         and w2, w3, #4294967296
    750. 

  750.         eor w2, w3, #4294967296
    751. 

  751.         orr w2, w3, #4294967296
    752. 

  752.         ands w2, w3, #4294967296
    753. 

  753. // CHECK-ERROR: error: expected compatible register or logical immediate
    754. 

  754. // CHECK-ERROR-NEXT:         and w2, w3, #4294967296
    755. 

  755. // CHECK-ERROR-NEXT:                     ^
    756. 

  756. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    757. 

  757. // CHECK-ERROR-NEXT:         eor w2, w3, #4294967296
    758. 

  758. // CHECK-ERROR-NEXT:                     ^
    759. 

  759. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    760. 

  760. // CHECK-ERROR-NEXT:         orr w2, w3, #4294967296
    761. 

  761. // CHECK-ERROR-NEXT:                     ^
    762. 

  762. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    763. 

  763. // CHECK-ERROR-NEXT:         ands w2, w3, #4294967296
    764. 

  764. // CHECK-ERROR-NEXT:                      ^
    765. 

  765. 

  766. //------------------------------------------------------------------------------
    767. 

  767. // Bitfield
    768. 

  768. //------------------------------------------------------------------------------
    769. 

  769. 

  770.         sbfm x3, w13, #0, #0
    771. 

  771.         sbfm w12, x9, #0, #0
    772. 

  772.         sbfm sp, x3, #3, #5
    773. 

  773.         sbfm w3, wsp, #1, #9
    774. 

  774.         sbfm x9, x5, #-1, #0
    775. 

  775.         sbfm x9, x5, #0, #-1
    776. 

  776. // CHECK-ERROR: error: invalid operand for instruction
    777. 

  777. // CHECK-ERROR-NEXT:         sbfm x3, w13, #0, #0
    778. 

  778. // CHECK-ERROR-NEXT:                  ^
    779. 

  779. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    780. 

  780. // CHECK-ERROR-NEXT:         sbfm w12, x9, #0, #0
    781. 

  781. // CHECK-ERROR-NEXT:                   ^
    782. 

  782. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    783. 

  783. // CHECK-ERROR-NEXT:         sbfm sp, x3, #3, #5
    784. 

  784. // CHECK-ERROR-NEXT:              ^
    785. 

  785. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    786. 

  786. // CHECK-ERROR-NEXT:         sbfm w3, wsp, #1, #9
    787. 

  787. // CHECK-ERROR-NEXT:                  ^
    788. 

  788. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    789. 

  789. // CHECK-ERROR-NEXT:         sbfm x9, x5, #-1, #0
    790. 

  790. // CHECK-ERROR-NEXT:                      ^
    791. 

  791. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    792. 

  792. // CHECK-ERROR-NEXT:         sbfm x9, x5, #0, #-1
    793. 

  793. // CHECK-ERROR-NEXT:                          ^
    794. 

  794. 

  795.         sbfm w3, w5, #32, #1
    796. 

  796.         sbfm w7, w11, #19, #32
    797. 

  797.         sbfm x29, x30, #64, #0
    798. 

  798.         sbfm x10, x20, #63, #64
    799. 

  799. // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
    800. 

  800. // CHECK-ERROR-NEXT:         sbfm w3, w5, #32, #1
    801. 

  801. // CHECK-ERROR-NEXT:                      ^
    802. 

  802. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    803. 

  803. // CHECK-ERROR-NEXT:         sbfm w7, w11, #19, #32
    804. 

  804. // CHECK-ERROR-NEXT:                            ^
    805. 

  805. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    806. 

  806. // CHECK-ERROR-NEXT:         sbfm x29, x30, #64, #0
    807. 

  807. // CHECK-ERROR-NEXT:                        ^
    808. 

  808. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    809. 

  809. // CHECK-ERROR-NEXT:         sbfm x10, x20, #63, #64
    810. 

  810. // CHECK-ERROR-NEXT:                             ^
    811. 

  811. 

  812.         ubfm w3, w5, #32, #1
    813. 

  813.         ubfm w7, w11, #19, #32
    814. 

  814.         ubfm x29, x30, #64, #0
    815. 

  815.         ubfm x10, x20, #63, #64
    816. 

  816. // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
    817. 

  817. // CHECK-ERROR-NEXT:         ubfm w3, w5, #32, #1
    818. 

  818. // CHECK-ERROR-NEXT:                      ^
    819. 

  819. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    820. 

  820. // CHECK-ERROR-NEXT:         ubfm w7, w11, #19, #32
    821. 

  821. // CHECK-ERROR-NEXT:                            ^
    822. 

  822. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    823. 

  823. // CHECK-ERROR-NEXT:         ubfm x29, x30, #64, #0
    824. 

  824. // CHECK-ERROR-NEXT:                        ^
    825. 

  825. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    826. 

  826. // CHECK-ERROR-NEXT:         ubfm x10, x20, #63, #64
    827. 

  827. // CHECK-ERROR-NEXT:                             ^
    828. 

  828. 

  829.         bfm w3, w5, #32, #1
    830. 

  830.         bfm w7, w11, #19, #32
    831. 

  831.         bfm x29, x30, #64, #0
    832. 

  832.         bfm x10, x20, #63, #64
    833. 

  833. // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
    834. 

  834. // CHECK-ERROR-NEXT:         bfm w3, w5, #32, #1
    835. 

  835. // CHECK-ERROR-NEXT:                      ^
    836. 

  836. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    837. 

  837. // CHECK-ERROR-NEXT:         bfm w7, w11, #19, #32
    838. 

  838. // CHECK-ERROR-NEXT:                            ^
    839. 

  839. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    840. 

  840. // CHECK-ERROR-NEXT:         bfm x29, x30, #64, #0
    841. 

  841. // CHECK-ERROR-NEXT:                        ^
    842. 

  842. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    843. 

  843. // CHECK-ERROR-NEXT:         bfm x10, x20, #63, #64
    844. 

  844. // CHECK-ERROR-NEXT:                             ^
    845. 

  845. 

  846.         sxtb x3, x2
    847. 

  847.         sxth xzr, xzr
    848. 

  848.         sxtw x3, x5
    849. 

  849. // CHECK-ERROR-AARCH64: error: invalid operand for instruction
    850. 

  850. // CHECK-ERROR-AARCH64-NEXT:         sxtb x3, x2
    851. 

  851. // CHECK-ERROR-AARCH64-NEXT:                  ^
    852. 

  852. // CHECK-ERROR-AARCH64-NEXT: error: invalid operand for instruction
    853. 

  853. // CHECK-ERROR-AARCH64-NEXT:         sxth xzr, xzr
    854. 

  854. // CHECK-ERROR-AARCH64-NEXT:                   ^
    855. 

  855. // CHECK-ERROR-AARCH64-NEXT: error: invalid operand for instruction
    856. 

  856. // CHECK-ERROR-AARCH64-NEXT:         sxtw x3, x5
    857. 

  857. // CHECK-ERROR-AARCH64-NEXT:                  ^
    858. 

  858. 

  859.         uxtb x3, x12
    860. 

  860.         uxth x5, x9
    861. 

  861.         uxtw x3, x5
    862. 

  862.         uxtb x2, sp
    863. 

  863.         uxtb sp, xzr
    864. 

  864. // CHECK-ERROR: error: invalid operand for instruction
    865. 

  865. // CHECK-ERROR-NEXT:         uxtb x3, x12
    866. 

  866. // CHECK-ERROR-NEXT:                  ^
    867. 

  867. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    868. 

  868. // CHECK-ERROR-NEXT:         uxth x5, x9
    869. 

  869. // CHECK-ERROR-NEXT:                  ^
    870. 

  870. // CHECK-ERROR-AARCH64-NEXT: error: invalid instruction
    871. 

  871. // CHECK-ERROR-AARCH64-NEXT:         uxtw x3, x5
    872. 

  872. // CHECK-ERROR-AARCH64-NEXT:         ^
    873. 

  873. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    874. 

  874. // CHECK-ERROR-NEXT:         uxtb x2, sp
    875. 

  875. // CHECK-ERROR-NEXT:                  ^
    876. 

  876. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    877. 

  877. // CHECK-ERROR-NEXT:         uxtb sp, xzr
    878. 

  878. // CHECK-ERROR-NEXT:              ^
    879. 

  879. 

  880.         asr x3, w2, #1
    881. 

  881.         asr sp, x2, #1
    882. 

  882.         asr x25, x26, #-1
    883. 

  883.         asr x25, x26, #64
    884. 

  884.         asr w9, w8, #32
    885. 

  885. // CHECK-ERROR: error: invalid operand for instruction
    886. 

  886. // CHECK-ERROR-NEXT:         asr x3, w2, #1
    887. 

  887. // CHECK-ERROR-NEXT:                 ^
    888. 

  888. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    889. 

  889. // CHECK-ERROR-NEXT:         asr sp, x2, #1
    890. 

  890. // CHECK-ERROR-NEXT:             ^
    891. 

  891. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    892. 

  892. // CHECK-ERROR-NEXT:         asr x25, x26, #-1
    893. 

  893. // CHECK-ERROR-NEXT:                       ^
    894. 

  894. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    895. 

  895. // CHECK-ERROR-NEXT:         asr x25, x26, #64
    896. 

  896. // CHECK-ERROR-NEXT:                       ^
    897. 

  897. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    898. 

  898. // CHECK-ERROR-NEXT:         asr w9, w8, #32
    899. 

  899. // CHECK-ERROR-NEXT:                     ^
    900. 

  900. 

  901.         sbfiz w1, w2, #0, #0
    902. 

  902.         sbfiz wsp, w9, #0, #1
    903. 

  903.         sbfiz w9, w10, #32, #1
    904. 

  904.         sbfiz w11, w12, #32, #0
    905. 

  905.         sbfiz w9, w10, #10, #23
    906. 

  906.         sbfiz x3, x5, #12, #53
    907. 

  907.         sbfiz sp, x3, #7, #6
    908. 

  908.         sbfiz w3, wsp, #10, #8
    909. 

  909. // CHECK-ERROR-AARCH64: error: expected integer in range [<lsb>, 31]
    910. 

  910. // CHECK-ERROR-ARM64: error: expected integer in range [1, 32]
    911. 

  911. // CHECK-ERROR-NEXT:         sbfiz w1, w2, #0, #0
    912. 

  912. // CHECK-ERROR-NEXT:                           ^
    913. 

  913. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    914. 

  914. // CHECK-ERROR-NEXT:         sbfiz wsp, w9, #0, #1
    915. 

  915. // CHECK-ERROR-NEXT:               ^
    916. 

  916. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    917. 

  917. // CHECK-ERROR-NEXT:         sbfiz w9, w10, #32, #1
    918. 

  918. // CHECK-ERROR-NEXT:                        ^
    919. 

  919. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    920. 

  920. // CHECK-ERROR-NEXT:         sbfiz w11, w12, #32, #0
    921. 

  921. // CHECK-ERROR-NEXT:                         ^
    922. 

  922. // CHECK-ERROR-NEXT: error: requested insert overflows register
    923. 

  923. // CHECK-ERROR-NEXT:         sbfiz w9, w10, #10, #23
    924. 

  924. // CHECK-ERROR-NEXT:                             ^
    925. 

  925. // CHECK-ERROR-NEXT: error: requested insert overflows register
    926. 

  926. // CHECK-ERROR-NEXT:         sbfiz x3, x5, #12, #53
    927. 

  927. // CHECK-ERROR-NEXT:                            ^
    928. 

  928. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    929. 

  929. // CHECK-ERROR-NEXT:         sbfiz sp, x3, #7, #6
    930. 

  930. // CHECK-ERROR-NEXT:               ^
    931. 

  931. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    932. 

  932. // CHECK-ERROR-NEXT:         sbfiz w3, wsp, #10, #8
    933. 

  933. // CHECK-ERROR-NEXT:                   ^
    934. 

  934. 

  935.         sbfx w1, w2, #0, #0
    936. 

  936.         sbfx wsp, w9, #0, #1
    937. 

  937.         sbfx w9, w10, #32, #1
    938. 

  938.         sbfx w11, w12, #32, #0
    939. 

  939.         sbfx w9, w10, #10, #23
    940. 

  940.         sbfx x3, x5, #12, #53
    941. 

  941.         sbfx sp, x3, #7, #6
    942. 

  942.         sbfx w3, wsp, #10, #8
    943. 

  943. // CHECK-ERROR-AARCH64: error: expected integer in range [<lsb>, 31]
    944. 

  944. // CHECK-ERROR-ARM64: error: expected integer in range [1, 32]
    945. 

  945. // CHECK-ERROR-NEXT:         sbfx w1, w2, #0, #0
    946. 

  946. // CHECK-ERROR-NEXT:                          ^
    947. 

  947. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    948. 

  948. // CHECK-ERROR-NEXT:         sbfx wsp, w9, #0, #1
    949. 

  949. // CHECK-ERROR-NEXT:              ^
    950. 

  950. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    951. 

  951. // CHECK-ERROR-NEXT:         sbfx w9, w10, #32, #1
    952. 

  952. // CHECK-ERROR-NEXT:                       ^
    953. 

  953. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    954. 

  954. // CHECK-ERROR-NEXT:         sbfx w11, w12, #32, #0
    955. 

  955. // CHECK-ERROR-NEXT:                        ^
    956. 

  956. // CHECK-ERROR-NEXT: error: requested extract overflows register
    957. 

  957. // CHECK-ERROR-NEXT:         sbfx w9, w10, #10, #23
    958. 

  958. // CHECK-ERROR-NEXT:                            ^
    959. 

  959. // CHECK-ERROR-NEXT: error: requested extract overflows register
    960. 

  960. // CHECK-ERROR-NEXT:         sbfx x3, x5, #12, #53
    961. 

  961. // CHECK-ERROR-NEXT:                           ^
    962. 

  962. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    963. 

  963. // CHECK-ERROR-NEXT:         sbfx sp, x3, #7, #6
    964. 

  964. // CHECK-ERROR-NEXT:              ^
    965. 

  965. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    966. 

  966. // CHECK-ERROR-NEXT:         sbfx w3, wsp, #10, #8
    967. 

  967. // CHECK-ERROR-NEXT:                  ^
    968. 

  968. 

  969.         bfi w1, w2, #0, #0
    970. 

  970.         bfi wsp, w9, #0, #1
    971. 

  971.         bfi w9, w10, #32, #1
    972. 

  972.         bfi w11, w12, #32, #0
    973. 

  973.         bfi w9, w10, #10, #23
    974. 

  974.         bfi x3, x5, #12, #53
    975. 

  975.         bfi sp, x3, #7, #6
    976. 

  976.         bfi w3, wsp, #10, #8
    977. 

  977. // CHECK-ERROR-AARCH64: error: expected integer in range [<lsb>, 31]
    978. 

  978. // CHECK-ERROR-ARM64: error: expected integer in range [1, 32]
    979. 

  979. // CHECK-ERROR-NEXT:         bfi w1, w2, #0, #0
    980. 

  980. // CHECK-ERROR-NEXT:                         ^
    981. 

  981. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    982. 

  982. // CHECK-ERROR-NEXT:         bfi wsp, w9, #0, #1
    983. 

  983. // CHECK-ERROR-NEXT:             ^
    984. 

  984. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    985. 

  985. // CHECK-ERROR-NEXT:         bfi w9, w10, #32, #1
    986. 

  986. // CHECK-ERROR-NEXT:                      ^
    987. 

  987. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    988. 

  988. // CHECK-ERROR-NEXT:         bfi w11, w12, #32, #0
    989. 

  989. // CHECK-ERROR-NEXT:                       ^
    990. 

  990. // CHECK-ERROR-NEXT: error: requested insert overflows register
    991. 

  991. // CHECK-ERROR-NEXT:         bfi w9, w10, #10, #23
    992. 

  992. // CHECK-ERROR-NEXT:                           ^
    993. 

  993. // CHECK-ERROR-NEXT: error: requested insert overflows register
    994. 

  994. // CHECK-ERROR-NEXT:         bfi x3, x5, #12, #53
    995. 

  995. // CHECK-ERROR-NEXT:                          ^
    996. 

  996. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    997. 

  997. // CHECK-ERROR-NEXT:         bfi sp, x3, #7, #6
    998. 

  998. // CHECK-ERROR-NEXT:             ^
    999. 

  999. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1000. 

  1000. // CHECK-ERROR-NEXT:         bfi w3, wsp, #10, #8
    1001. 

  1001. // CHECK-ERROR-NEXT:                 ^
    1002. 

  1002. 

  1003.         bfxil w1, w2, #0, #0
    1004. 

  1004.         bfxil wsp, w9, #0, #1
    1005. 

  1005.         bfxil w9, w10, #32, #1
    1006. 

  1006.         bfxil w11, w12, #32, #0
    1007. 

  1007.         bfxil w9, w10, #10, #23
    1008. 

  1008.         bfxil x3, x5, #12, #53
    1009. 

  1009.         bfxil sp, x3, #7, #6
    1010. 

  1010.         bfxil w3, wsp, #10, #8
    1011. 

  1011. // CHECK-ERROR-AARCH64: error: expected integer in range [<lsb>, 31]
    1012. 

  1012. // CHECK-ERROR-ARM64: error: expected integer in range [1, 32]
    1013. 

  1013. // CHECK-ERROR-NEXT:         bfxil w1, w2, #0, #0
    1014. 

  1014. // CHECK-ERROR-NEXT:                           ^
    1015. 

  1015. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1016. 

  1016. // CHECK-ERROR-NEXT:         bfxil wsp, w9, #0, #1
    1017. 

  1017. // CHECK-ERROR-NEXT:               ^
    1018. 

  1018. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1019. 

  1019. // CHECK-ERROR-NEXT:         bfxil w9, w10, #32, #1
    1020. 

  1020. // CHECK-ERROR-NEXT:                        ^
    1021. 

  1021. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1022. 

  1022. // CHECK-ERROR-NEXT:         bfxil w11, w12, #32, #0
    1023. 

  1023. // CHECK-ERROR-NEXT:                         ^
    1024. 

  1024. // CHECK-ERROR-NEXT: error: requested extract overflows register
    1025. 

  1025. // CHECK-ERROR-NEXT:         bfxil w9, w10, #10, #23
    1026. 

  1026. // CHECK-ERROR-NEXT:                             ^
    1027. 

  1027. // CHECK-ERROR-NEXT: error: requested extract overflows register
    1028. 

  1028. // CHECK-ERROR-NEXT:         bfxil x3, x5, #12, #53
    1029. 

  1029. // CHECK-ERROR-NEXT:                            ^
    1030. 

  1030. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1031. 

  1031. // CHECK-ERROR-NEXT:         bfxil sp, x3, #7, #6
    1032. 

  1032. // CHECK-ERROR-NEXT:               ^
    1033. 

  1033. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1034. 

  1034. // CHECK-ERROR-NEXT:         bfxil w3, wsp, #10, #8
    1035. 

  1035. // CHECK-ERROR-NEXT:                   ^
    1036. 

  1036. 

  1037.         ubfiz w1, w2, #0, #0
    1038. 

  1038.         ubfiz wsp, w9, #0, #1
    1039. 

  1039.         ubfiz w9, w10, #32, #1
    1040. 

  1040.         ubfiz w11, w12, #32, #0
    1041. 

  1041.         ubfiz w9, w10, #10, #23
    1042. 

  1042.         ubfiz x3, x5, #12, #53
    1043. 

  1043.         ubfiz sp, x3, #7, #6
    1044. 

  1044.         ubfiz w3, wsp, #10, #8
    1045. 

  1045. // CHECK-ERROR-AARCH64: error: expected integer in range [<lsb>, 31]
    1046. 

  1046. // CHECK-ERROR-ARM64: error: expected integer in range [1, 32]
    1047. 

  1047. // CHECK-ERROR-NEXT:         ubfiz w1, w2, #0, #0
    1048. 

  1048. // CHECK-ERROR-NEXT:                           ^
    1049. 

  1049. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1050. 

  1050. // CHECK-ERROR-NEXT:         ubfiz wsp, w9, #0, #1
    1051. 

  1051. // CHECK-ERROR-NEXT:               ^
    1052. 

  1052. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1053. 

  1053. // CHECK-ERROR-NEXT:         ubfiz w9, w10, #32, #1
    1054. 

  1054. // CHECK-ERROR-NEXT:                        ^
    1055. 

  1055. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1056. 

  1056. // CHECK-ERROR-NEXT:         ubfiz w11, w12, #32, #0
    1057. 

  1057. // CHECK-ERROR-NEXT:                         ^
    1058. 

  1058. // CHECK-ERROR-NEXT: error: requested insert overflows register
    1059. 

  1059. // CHECK-ERROR-NEXT:         ubfiz w9, w10, #10, #23
    1060. 

  1060. // CHECK-ERROR-NEXT:                             ^
    1061. 

  1061. // CHECK-ERROR-NEXT: error: requested insert overflows register
    1062. 

  1062. // CHECK-ERROR-NEXT:         ubfiz x3, x5, #12, #53
    1063. 

  1063. // CHECK-ERROR-NEXT:                            ^
    1064. 

  1064. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1065. 

  1065. // CHECK-ERROR-NEXT:         ubfiz sp, x3, #7, #6
    1066. 

  1066. // CHECK-ERROR-NEXT:               ^
    1067. 

  1067. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1068. 

  1068. // CHECK-ERROR-NEXT:         ubfiz w3, wsp, #10, #8
    1069. 

  1069. // CHECK-ERROR-NEXT:                   ^
    1070. 

  1070. 

  1071.         ubfx w1, w2, #0, #0
    1072. 

  1072.         ubfx wsp, w9, #0, #1
    1073. 

  1073.         ubfx w9, w10, #32, #1
    1074. 

  1074.         ubfx w11, w12, #32, #0
    1075. 

  1075.         ubfx w9, w10, #10, #23
    1076. 

  1076.         ubfx x3, x5, #12, #53
    1077. 

  1077.         ubfx sp, x3, #7, #6
    1078. 

  1078.         ubfx w3, wsp, #10, #8
    1079. 

  1079. // CHECK-ERROR-AARCH64: error: expected integer in range [<lsb>, 31]
    1080. 

  1080. // CHECK-ERROR-ARM64: error: expected integer in range [1, 32]
    1081. 

  1081. // CHECK-ERROR-NEXT:         ubfx w1, w2, #0, #0
    1082. 

  1082. // CHECK-ERROR-NEXT:                      ^
    1083. 

  1083. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1084. 

  1084. // CHECK-ERROR-NEXT:         ubfx wsp, w9, #0, #1
    1085. 

  1085. // CHECK-ERROR-NEXT:              ^
    1086. 

  1086. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1087. 

  1087. // CHECK-ERROR-NEXT:         ubfx w9, w10, #32, #1
    1088. 

  1088. // CHECK-ERROR-NEXT:                       ^
    1089. 

  1089. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1090. 

  1090. // CHECK-ERROR-NEXT:         ubfx w11, w12, #32, #0
    1091. 

  1091. // CHECK-ERROR-NEXT:                        ^
    1092. 

  1092. // CHECK-ERROR-NEXT: error: requested extract overflows register
    1093. 

  1093. // CHECK-ERROR-NEXT:         ubfx w9, w10, #10, #23
    1094. 

  1094. // CHECK-ERROR-NEXT:                            ^
    1095. 

  1095. // CHECK-ERROR-NEXT: error: requested extract overflows register
    1096. 

  1096. // CHECK-ERROR-NEXT:         ubfx x3, x5, #12, #53
    1097. 

  1097. // CHECK-ERROR-NEXT:                           ^
    1098. 

  1098. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1099. 

  1099. // CHECK-ERROR-NEXT:         ubfx sp, x3, #7, #6
    1100. 

  1100. // CHECK-ERROR-NEXT:              ^
    1101. 

  1101. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1102. 

  1102. // CHECK-ERROR-NEXT:         ubfx w3, wsp, #10, #8
    1103. 

  1103. // CHECK-ERROR-NEXT:                  ^
    1104. 

  1104. 

  1105.         bfc wsp, #3, #6
    1106. 

  1106.         bfc w4, #2, #31
    1107. 

  1107.         bfc sp, #0, #1
    1108. 

  1108.         bfc x6, #0, #0
    1109. 

  1109. // CHECK-ERROR: error: invalid operand for instruction
    1110. 

  1110. // CHECK-ERROR-NEXT:        bfc wsp, #3, #6
    1111. 

  1111. // CHECK-ERROR-NEXT:            ^
    1112. 

  1112. // CHECK-ERROR-NEXT: error: requested insert overflows register
    1113. 

  1113. // CHECK-ERROR-NEXT:         bfc w4, #2, #31
    1114. 

  1114. // CHECK-ERROR-NEXT:                     ^
    1115. 

  1115. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1116. 

  1116. // CHECK-ERROR-NEXT:         bfc sp, #0, #1
    1117. 

  1117. // CHECK-ERROR-NEXT:             ^
    1118. 

  1118. // CHECK-ERROR-NEXT: error: expected integer in range [1, 32]
    1119. 

  1119. // CHECK-ERROR-NEXT:         bfc x6, #0, #0
    1120. 

  1120. // CHECK-ERROR-NEXT:                     ^
    1121. 

  1121. 

  1122. //------------------------------------------------------------------------------
    1123. 

  1123. // Compare & branch (immediate)
    1124. 

  1124. //------------------------------------------------------------------------------
    1125. 

  1125. 

  1126.         cbnz wsp, lbl
    1127. 

  1127.         cbz  sp, lbl
    1128. 

  1128.         cbz  x3, x5
    1129. 

  1129. // CHECK-ERROR: error: invalid operand for instruction
    1130. 

  1130. // CHECK-ERROR-NEXT:           cbnz wsp, lbl
    1131. 

  1131. // CHECK-ERROR-NEXT:                ^
    1132. 

  1132. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1133. 

  1133. // CHECK-ERROR-NEXT:           cbz sp, lbl
    1134. 

  1134. // CHECK-ERROR-NEXT:               ^
    1135. 

  1135. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    1136. 

  1136. // CHECK-ERROR-NEXT:           cbz x3, x5
    1137. 

  1137. // CHECK-ERROR-NEXT:                   ^
    1138. 

  1138. 

  1139.         cbz w20, #1048576
    1140. 

  1140.         cbnz xzr, #-1048580
    1141. 

  1141.         cbz x29, #1
    1142. 

  1142. // CHECK-ERROR: error: expected label or encodable integer pc offset
    1143. 

  1143. // CHECK-ERROR-NEXT:           cbz w20, #1048576
    1144. 

  1144. // CHECK-ERROR-NEXT:                     ^
    1145. 

  1145. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    1146. 

  1146. // CHECK-ERROR-NEXT:           cbnz xzr, #-1048580
    1147. 

  1147. // CHECK-ERROR-NEXT:                    ^
    1148. 

  1148. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    1149. 

  1149. // CHECK-ERROR-NEXT:           cbz x29, #1
    1150. 

  1150. // CHECK-ERROR-NEXT:                    ^
    1151. 

  1151. 

  1152. //------------------------------------------------------------------------------
    1153. 

  1153. // Conditional branch (immediate)
    1154. 

  1154. //------------------------------------------------------------------------------
    1155. 

  1155. 

  1156.         b.zf lbl
    1157. 

  1157. // CHECK-ERROR: error: invalid condition code
    1158. 

  1158. // CHECK-ERROR-NEXT:           b.zf lbl
    1159. 

  1159. // CHECK-ERROR-NEXT:             ^
    1160. 

  1160. 

  1161.         b.eq #1048576
    1162. 

  1162.         b.ge #-1048580
    1163. 

  1163.         b.cc #1
    1164. 

  1164. // CHECK-ERROR: error: expected label or encodable integer pc offset
    1165. 

  1165. // CHECK-ERROR-NEXT:           b.eq #1048576
    1166. 

  1166. // CHECK-ERROR-NEXT:                ^
    1167. 

  1167. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    1168. 

  1168. // CHECK-ERROR-NEXT:           b.ge #-1048580
    1169. 

  1169. // CHECK-ERROR-NEXT:                ^
    1170. 

  1170. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    1171. 

  1171. // CHECK-ERROR-NEXT:           b.cc #1
    1172. 

  1172. // CHECK-ERROR-NEXT:                ^
    1173. 

  1173. 

  1174. //------------------------------------------------------------------------------
    1175. 

  1175. // Conditional compare (immediate)
    1176. 

  1176. //------------------------------------------------------------------------------
    1177. 

  1177. 

  1178.         ccmp wsp, #4, #2, ne
    1179. 

  1179.         ccmp w25, #-1, #15, hs
    1180. 

  1180.         ccmp w3, #32, #0, ge
    1181. 

  1181.         ccmp w19, #5, #-1, lt
    1182. 

  1182.         ccmp w20, #7, #16, hs
    1183. 

  1183. // CHECK-ERROR: error: invalid operand for instruction
    1184. 

  1184. // CHECK-ERROR-NEXT:        ccmp wsp, #4, #2, ne
    1185. 

  1185. // CHECK-ERROR-NEXT:             ^
    1186. 

  1186. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1187. 

  1187. // CHECK-ERROR-NEXT:        ccmp w25, #-1, #15, hs
    1188. 

  1188. // CHECK-ERROR-NEXT:                  ^
    1189. 

  1189. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1190. 

  1190. // CHECK-ERROR-NEXT:        ccmp w3, #32, #0, ge
    1191. 

  1191. // CHECK-ERROR-NEXT:                 ^
    1192. 

  1192. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1193. 

  1193. // CHECK-ERROR-NEXT:        ccmp w19, #5, #-1, lt
    1194. 

  1194. // CHECK-ERROR-NEXT:                      ^
    1195. 

  1195. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1196. 

  1196. // CHECK-ERROR-NEXT:        ccmp w20, #7, #16, hs
    1197. 

  1197. // CHECK-ERROR-NEXT:                      ^
    1198. 

  1198. 

  1199.         ccmp sp, #4, #2, ne
    1200. 

  1200.         ccmp x25, #-1, #15, hs
    1201. 

  1201.         ccmp x3, #32, #0, ge
    1202. 

  1202.         ccmp x19, #5, #-1, lt
    1203. 

  1203.         ccmp x20, #7, #16, hs
    1204. 

  1204. // CHECK-ERROR: error: invalid operand for instruction
    1205. 

  1205. // CHECK-ERROR-NEXT:        ccmp sp, #4, #2, ne
    1206. 

  1206. // CHECK-ERROR-NEXT:             ^
    1207. 

  1207. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1208. 

  1208. // CHECK-ERROR-NEXT:        ccmp x25, #-1, #15, hs
    1209. 

  1209. // CHECK-ERROR-NEXT:                  ^
    1210. 

  1210. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1211. 

  1211. // CHECK-ERROR-NEXT:        ccmp x3, #32, #0, ge
    1212. 

  1212. // CHECK-ERROR-NEXT:                 ^
    1213. 

  1213. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1214. 

  1214. // CHECK-ERROR-NEXT:        ccmp x19, #5, #-1, lt
    1215. 

  1215. // CHECK-ERROR-NEXT:                      ^
    1216. 

  1216. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1217. 

  1217. // CHECK-ERROR-NEXT:        ccmp x20, #7, #16, hs
    1218. 

  1218. // CHECK-ERROR-NEXT:                      ^
    1219. 

  1219. 

  1220.         ccmn wsp, #4, #2, ne
    1221. 

  1221.         ccmn w25, #-1, #15, hs
    1222. 

  1222.         ccmn w3, #32, #0, ge
    1223. 

  1223.         ccmn w19, #5, #-1, lt
    1224. 

  1224.         ccmn w20, #7, #16, hs
    1225. 

  1225. // CHECK-ERROR: error: invalid operand for instruction
    1226. 

  1226. // CHECK-ERROR-NEXT:        ccmn wsp, #4, #2, ne
    1227. 

  1227. // CHECK-ERROR-NEXT:             ^
    1228. 

  1228. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1229. 

  1229. // CHECK-ERROR-NEXT:        ccmn w25, #-1, #15, hs
    1230. 

  1230. // CHECK-ERROR-NEXT:                  ^
    1231. 

  1231. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1232. 

  1232. // CHECK-ERROR-NEXT:        ccmn w3, #32, #0, ge
    1233. 

  1233. // CHECK-ERROR-NEXT:                 ^
    1234. 

  1234. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1235. 

  1235. // CHECK-ERROR-NEXT:        ccmn w19, #5, #-1, lt
    1236. 

  1236. // CHECK-ERROR-NEXT:                      ^
    1237. 

  1237. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1238. 

  1238. // CHECK-ERROR-NEXT:        ccmn w20, #7, #16, hs
    1239. 

  1239. // CHECK-ERROR-NEXT:                      ^
    1240. 

  1240. 

  1241.         ccmn sp, #4, #2, ne
    1242. 

  1242.         ccmn x25, #-1, #15, hs
    1243. 

  1243.         ccmn x3, #32, #0, ge
    1244. 

  1244.         ccmn x19, #5, #-1, lt
    1245. 

  1245.         ccmn x20, #7, #16, hs
    1246. 

  1246. // CHECK-ERROR: error: invalid operand for instruction
    1247. 

  1247. // CHECK-ERROR-NEXT:        ccmn sp, #4, #2, ne
    1248. 

  1248. // CHECK-ERROR-NEXT:             ^
    1249. 

  1249. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1250. 

  1250. // CHECK-ERROR-NEXT:        ccmn x25, #-1, #15, hs
    1251. 

  1251. // CHECK-ERROR-NEXT:                  ^
    1252. 

  1252. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1253. 

  1253. // CHECK-ERROR-NEXT:        ccmn x3, #32, #0, ge
    1254. 

  1254. // CHECK-ERROR-NEXT:                 ^
    1255. 

  1255. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1256. 

  1256. // CHECK-ERROR-NEXT:        ccmn x19, #5, #-1, lt
    1257. 

  1257. // CHECK-ERROR-NEXT:                      ^
    1258. 

  1258. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1259. 

  1259. // CHECK-ERROR-NEXT:        ccmn x20, #7, #16, hs
    1260. 

  1260. // CHECK-ERROR-NEXT:                      ^
    1261. 

  1261. 

  1262. //------------------------------------------------------------------------------
    1263. 

  1263. // Conditional compare (register)
    1264. 

  1264. //------------------------------------------------------------------------------
    1265. 

  1265. 

  1266.         ccmp wsp, w4, #2, ne
    1267. 

  1267.         ccmp w3, wsp, #0, ge
    1268. 

  1268.         ccmp w19, w5, #-1, lt
    1269. 

  1269.         ccmp w20, w7, #16, hs
    1270. 

  1270. // CHECK-ERROR: error: invalid operand for instruction
    1271. 

  1271. // CHECK-ERROR-NEXT:        ccmp wsp, w4, #2, ne
    1272. 

  1272. // CHECK-ERROR-NEXT:             ^
    1273. 

  1273. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1274. 

  1274. // CHECK-ERROR-NEXT:        ccmp w3, wsp, #0, ge
    1275. 

  1275. // CHECK-ERROR-NEXT:                 ^
    1276. 

  1276. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1277. 

  1277. // CHECK-ERROR-NEXT:        ccmp w19, w5, #-1, lt
    1278. 

  1278. // CHECK-ERROR-NEXT:                      ^
    1279. 

  1279. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1280. 

  1280. // CHECK-ERROR-NEXT:        ccmp w20, w7, #16, hs
    1281. 

  1281. // CHECK-ERROR-NEXT:                      ^
    1282. 

  1282. 

  1283.         ccmp sp, x4, #2, ne
    1284. 

  1284.         ccmp x25, sp, #15, hs
    1285. 

  1285.         ccmp x19, x5, #-1, lt
    1286. 

  1286.         ccmp x20, x7, #16, hs
    1287. 

  1287. // CHECK-ERROR: error: invalid operand for instruction
    1288. 

  1288. // CHECK-ERROR-NEXT:        ccmp sp, x4, #2, ne
    1289. 

  1289. // CHECK-ERROR-NEXT:             ^
    1290. 

  1290. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1291. 

  1291. // CHECK-ERROR-NEXT:        ccmp x25, sp, #15, hs
    1292. 

  1292. // CHECK-ERROR-NEXT:                  ^
    1293. 

  1293. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1294. 

  1294. // CHECK-ERROR-NEXT:        ccmp x19, x5, #-1, lt
    1295. 

  1295. // CHECK-ERROR-NEXT:                      ^
    1296. 

  1296. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1297. 

  1297. // CHECK-ERROR-NEXT:        ccmp x20, x7, #16, hs
    1298. 

  1298. // CHECK-ERROR-NEXT:                      ^
    1299. 

  1299. 

  1300.         ccmn wsp, w4, #2, ne
    1301. 

  1301.         ccmn w25, wsp, #15, hs
    1302. 

  1302.         ccmn w19, w5, #-1, lt
    1303. 

  1303.         ccmn w20, w7, #16, hs
    1304. 

  1304. // CHECK-ERROR: error: invalid operand for instruction
    1305. 

  1305. // CHECK-ERROR-NEXT:        ccmn wsp, w4, #2, ne
    1306. 

  1306. // CHECK-ERROR-NEXT:             ^
    1307. 

  1307. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1308. 

  1308. // CHECK-ERROR-NEXT:        ccmn w25, wsp, #15, hs
    1309. 

  1309. // CHECK-ERROR-NEXT:                  ^
    1310. 

  1310. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1311. 

  1311. // CHECK-ERROR-NEXT:        ccmn w19, w5, #-1, lt
    1312. 

  1312. // CHECK-ERROR-NEXT:                      ^
    1313. 

  1313. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1314. 

  1314. // CHECK-ERROR-NEXT:        ccmn w20, w7, #16, hs
    1315. 

  1315. // CHECK-ERROR-NEXT:                      ^
    1316. 

  1316. 

  1317.         ccmn sp, x4, #2, ne
    1318. 

  1318.         ccmn x25, sp, #15, hs
    1319. 

  1319.         ccmn x19, x5, #-1, lt
    1320. 

  1320.         ccmn x20, x7, #16, hs
    1321. 

  1321. // CHECK-ERROR: error: invalid operand for instruction
    1322. 

  1322. // CHECK-ERROR-NEXT:        ccmn sp, x4, #2, ne
    1323. 

  1323. // CHECK-ERROR-NEXT:             ^
    1324. 

  1324. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1325. 

  1325. // CHECK-ERROR-NEXT:        ccmn x25, sp, #15, hs
    1326. 

  1326. // CHECK-ERROR-NEXT:                  ^
    1327. 

  1327. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1328. 

  1328. // CHECK-ERROR-NEXT:        ccmn x19, x5, #-1, lt
    1329. 

  1329. // CHECK-ERROR-NEXT:                      ^
    1330. 

  1330. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1331. 

  1331. // CHECK-ERROR-NEXT:        ccmn x20, x7, #16, hs
    1332. 

  1332. // CHECK-ERROR-NEXT:                      ^
    1333. 

  1333. 

  1334. //------------------------------------------------------------------------------
    1335. 

  1335. // Conditional select
    1336. 

  1336. //------------------------------------------------------------------------------
    1337. 

  1337. 

  1338.         csel w4, wsp, w9, eq
    1339. 

  1339.         csel wsp, w2, w3, ne
    1340. 

  1340.         csel w10, w11, wsp, ge
    1341. 

  1341.         csel w1, w2, w3, #3
    1342. 

  1342.         csel x4, sp, x9, eq
    1343. 

  1343.         csel sp, x2, x3, ne
    1344. 

  1344.         csel x10, x11, sp, ge
    1345. 

  1345.         csel x1, x2, x3, #3
    1346. 

  1346. // CHECK-ERROR: error: invalid operand for instruction
    1347. 

  1347. // CHECK-ERROR-NEXT:        csel w4, wsp, w9, eq
    1348. 

  1348. // CHECK-ERROR-NEXT:                 ^
    1349. 

  1349. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1350. 

  1350. // CHECK-ERROR-NEXT:        csel wsp, w2, w3, ne
    1351. 

  1351. // CHECK-ERROR-NEXT:             ^
    1352. 

  1352. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1353. 

  1353. // CHECK-ERROR-NEXT:        csel w10, w11, wsp, ge
    1354. 

  1354. // CHECK-ERROR-NEXT:                       ^
    1355. 

  1355. // CHECK-ERROR-NEXT: error: expected AArch64 condition code
    1356. 

  1356. // CHECK-ERROR-NEXT:        csel w1, w2, w3, #3
    1357. 

  1357. // CHECK-ERROR-NEXT:                         ^
    1358. 

  1358. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1359. 

  1359. // CHECK-ERROR-NEXT:        csel x4, sp, x9, eq
    1360. 

  1360. // CHECK-ERROR-NEXT:                 ^
    1361. 

  1361. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1362. 

  1362. // CHECK-ERROR-NEXT:        csel sp, x2, x3, ne
    1363. 

  1363. // CHECK-ERROR-NEXT:             ^
    1364. 

  1364. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1365. 

  1365. // CHECK-ERROR-NEXT:        csel x10, x11, sp, ge
    1366. 

  1366. // CHECK-ERROR-NEXT:                       ^
    1367. 

  1367. // CHECK-ERROR-NEXT: error: expected AArch64 condition code
    1368. 

  1368. // CHECK-ERROR-NEXT:        csel x1, x2, x3, #3
    1369. 

  1369. // CHECK-ERROR-NEXT:                         ^
    1370. 

  1370. 

  1371.         csinc w20, w21, wsp, mi
    1372. 

  1372.         csinc sp, x30, x29, eq
    1373. 

  1373. // CHECK-ERROR: error: invalid operand for instruction
    1374. 

  1374. // CHECK-ERROR-NEXT:        csinc w20, w21, wsp, mi
    1375. 

  1375. // CHECK-ERROR-NEXT:                        ^
    1376. 

  1376. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1377. 

  1377. // CHECK-ERROR-NEXT:        csinc sp, x30, x29, eq
    1378. 

  1378. // CHECK-ERROR-NEXT:              ^
    1379. 

  1379. 

  1380.         csinv w20, wsp, wsp, mi
    1381. 

  1381.         csinv sp, x30, x29, le
    1382. 

  1382. // CHECK-ERROR: error: invalid operand for instruction
    1383. 

  1383. // CHECK-ERROR-NEXT:        csinv w20, wsp, wsp, mi
    1384. 

  1384. // CHECK-ERROR-NEXT:                   ^
    1385. 

  1385. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1386. 

  1386. // CHECK-ERROR-NEXT:        csinv sp, x30, x29, le
    1387. 

  1387. // CHECK-ERROR-NEXT:              ^
    1388. 

  1388. 

  1389.         csneg w20, w21, wsp, mi
    1390. 

  1390.         csneg x0, sp, x29, le
    1391. 

  1391. // CHECK-ERROR: error: invalid operand for instruction
    1392. 

  1392. // CHECK-ERROR-NEXT:        csneg w20, w21, wsp, mi
    1393. 

  1393. // CHECK-ERROR-NEXT:                        ^
    1394. 

  1394. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1395. 

  1395. // CHECK-ERROR-NEXT:        csneg x0, sp, x29, le
    1396. 

  1396. // CHECK-ERROR-NEXT:                  ^
    1397. 

  1397. 

  1398.         cset wsp, lt
    1399. 

  1399.         csetm sp, ge
    1400. 

  1400.         cset w1, al
    1401. 

  1401.         csetm x6, nv
    1402. 

  1402. // CHECK-ERROR: error: invalid operand for instruction
    1403. 

  1403. // CHECK-ERROR-NEXT:        cset wsp, lt
    1404. 

  1404. // CHECK-ERROR-NEXT:             ^
    1405. 

  1405. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1406. 

  1406. // CHECK-ERROR-NEXT:        csetm sp, ge
    1407. 

  1407. // CHECK-ERROR-NEXT:              ^
    1408. 

  1408. // CHECK-ERROR-NEXT: error: condition codes AL and NV are invalid for this instruction
    1409. 

  1409. // CHECK-ERROR-NEXT:        cset w1, al
    1410. 

  1410. // CHECK-ERROR-NEXT:                   ^
    1411. 

  1411. // CHECK-ERROR-NEXT: error: condition codes AL and NV are invalid for this instruction
    1412. 

  1412. // CHECK-ERROR-NEXT:        csetm x6, nv
    1413. 

  1413. // CHECK-ERROR-NEXT:                    ^
    1414. 

  1414. 

  1415.         cinc w3, wsp, ne
    1416. 

  1416.         cinc sp, x9, eq
    1417. 

  1417.         cinc x2, x0, nv
    1418. 

  1418. // CHECK-ERROR: error: invalid operand for instruction
    1419. 

  1419. // CHECK-ERROR-NEXT:        cinc w3, wsp, ne
    1420. 

  1420. // CHECK-ERROR-NEXT:                 ^
    1421. 

  1421. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1422. 

  1422. // CHECK-ERROR-NEXT:        cinc sp, x9, eq
    1423. 

  1423. // CHECK-ERROR-NEXT:             ^
    1424. 

  1424. // CHECK-ERROR-NEXT: error: condition codes AL and NV are invalid for this instruction
    1425. 

  1425. // CHECK-ERROR-NEXT:        cinc x2, x0, nv
    1426. 

  1426. // CHECK-ERROR-NEXT:                       ^
    1427. 

  1427. 

  1428.         cinv w3, wsp, ne
    1429. 

  1429.         cinv sp, x9, eq
    1430. 

  1430.         cinv w8, x7, nv
    1431. 

  1431. // CHECK-ERROR: error: invalid operand for instruction
    1432. 

  1432. // CHECK-ERROR-NEXT:        cinv w3, wsp, ne
    1433. 

  1433. // CHECK-ERROR-NEXT:                 ^
    1434. 

  1434. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1435. 

  1435. // CHECK-ERROR-NEXT:        cinv sp, x9, eq
    1436. 

  1436. // CHECK-ERROR-NEXT:             ^
    1437. 

  1437. // CHECK-ERROR-NEXT: error: condition codes AL and NV are invalid for this instruction
    1438. 

  1438. // CHECK-ERROR-NEXT:        cinv w8, x7, nv
    1439. 

  1439. // CHECK-ERROR-NEXT:                       ^
    1440. 

  1440. 

  1441.         cneg w3, wsp, ne
    1442. 

  1442.         cneg sp, x9, eq
    1443. 

  1443.         cneg x4, x5, al
    1444. 

  1444. // CHECK-ERROR: error: invalid operand for instruction
    1445. 

  1445. // CHECK-ERROR-NEXT:        cneg w3, wsp, ne
    1446. 

  1446. // CHECK-ERROR-NEXT:                 ^
    1447. 

  1447. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1448. 

  1448. // CHECK-ERROR-NEXT:        cneg sp, x9, eq
    1449. 

  1449. // CHECK-ERROR-NEXT:             ^
    1450. 

  1450. // CHECK-ERROR-NEXT: error: condition codes AL and NV are invalid for this instruction
    1451. 

  1451. // CHECK-ERROR-NEXT:        cneg x4, x5, al
    1452. 

  1452. // CHECK-ERROR-NEXT:                       ^
    1453. 

  1453. 

  1454. //------------------------------------------------------------------------------
    1455. 

  1455. // Data Processing (1 source)
    1456. 

  1456. //------------------------------------------------------------------------------
    1457. 

  1457.         rbit x23, w2
    1458. 

  1458. //CHECK-ERROR: error: invalid operand for instruction
    1459. 

  1459. //CHECK-ERROR-NEXT:     rbit x23, w2
    1460. 

  1460. 

  1461.         cls sp, x2
    1462. 

  1462. //CHECK-ERROR: error: invalid operand for instruction
    1463. 

  1463. //CHECK-ERROR-NEXT:     cls sp, x2
    1464. 

  1464. 

  1465.         clz wsp, w3
    1466. 

  1466. //CHECK-ERROR: error: invalid operand for instruction
    1467. 

  1467. //CHECK-ERROR-NEXT:     clz wsp, w3
    1468. 

  1468. 

  1469. //------------------------------------------------------------------------------
    1470. 

  1470. // Data Processing (2 sources)
    1471. 

  1471. //------------------------------------------------------------------------------
    1472. 

  1472.         udiv x23, w2, x18
    1473. 

  1473. //CHECK-ERROR: error: invalid operand for instruction
    1474. 

  1474. //CHECK-ERROR-NEXT:     udiv x23, w2, x18
    1475. 

  1475. 

  1476.         lsl sp, x2, x4
    1477. 

  1477. //CHECK-ERROR: error: invalid operand for instruction
    1478. 

  1478. //CHECK-ERROR-NEXT:     lsl sp, x2, x4
    1479. 

  1479. 

  1480.         asr wsp, w3, w9
    1481. 

  1481. //CHECK-ERROR: error: invalid operand for instruction
    1482. 

  1482. //CHECK-ERROR-NEXT:     asr wsp, w3, w9
    1483. 

  1483. 

  1484. //------------------------------------------------------------------------------
    1485. 

  1485. // Data Processing (3 sources)
    1486. 

  1486. //------------------------------------------------------------------------------
    1487. 

  1487. 

  1488.         madd sp, x3, x9, x10
    1489. 

  1489. //CHECK-ERROR: error: invalid operand for instruction
    1490. 

  1490. //CHECK-ERROR-NEXT:     madd sp, x3, x9, x10
    1491. 

  1491. 

  1492. //------------------------------------------------------------------------------
    1493. 

  1493. // Exception generation
    1494. 

  1494. //------------------------------------------------------------------------------
    1495. 

  1495.         svc #-1
    1496. 

  1496.         hlt #65536
    1497. 

  1497.         dcps4 #43
    1498. 

  1498.         dcps4
    1499. 

  1499. // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 65535]
    1500. 

  1500. // CHECK-ERROR-NEXT:         svc #-1
    1501. 

  1501. // CHECK-ERROR-NEXT:             ^
    1502. 

  1502. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 65535]
    1503. 

  1503. // CHECK-ERROR-NEXT:         hlt #65536
    1504. 

  1504. // CHECK-ERROR-NEXT:             ^
    1505. 

  1505. // CHECK-ERROR-NEXT: error: {{invalid instruction|unrecognized instruction mnemonic}}
    1506. 

  1506. // CHECK-ERROR-NEXT:         dcps4 #43
    1507. 

  1507. // CHECK-ERROR-NEXT:         ^
    1508. 

  1508. // CHECK-ERROR-NEXT: error: {{invalid instruction|unrecognized instruction mnemonic}}
    1509. 

  1509. // CHECK-ERROR-NEXT:         dcps4
    1510. 

  1510. // CHECK-ERROR-NEXT:         ^
    1511. 

  1511. 

  1512. //------------------------------------------------------------------------------
    1513. 

  1513. // Extract (immediate)
    1514. 

  1514. //------------------------------------------------------------------------------
    1515. 

  1515. 

  1516.         extr w2, w20, w30, #-1
    1517. 

  1517.         extr w9, w19, w20, #32
    1518. 

  1518. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1519. 

  1519. // CHECK-ERROR-NEXT:         extr w2, w20, w30, #-1
    1520. 

  1520. // CHECK-ERROR-NEXT:                            ^
    1521. 

  1521. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1522. 

  1522. // CHECK-ERROR-NEXT:         extr w9, w19, w20, #32
    1523. 

  1523. // CHECK-ERROR-NEXT:                            ^
    1524. 

  1524. 

  1525.         extr x10, x15, x20, #-1
    1526. 

  1526.         extr x20, x25, x30, #64
    1527. 

  1527. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    1528. 

  1528. // CHECK-ERROR-NEXT:         extr x10, x15, x20, #-1
    1529. 

  1529. // CHECK-ERROR-NEXT:                             ^
    1530. 

  1530. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    1531. 

  1531. // CHECK-ERROR-NEXT:         extr x20, x25, x30, #64
    1532. 

  1532. // CHECK-ERROR-NEXT:                             ^
    1533. 

  1533. 

  1534.         ror w9, w10, #32
    1535. 

  1535.         ror x10, x11, #64
    1536. 

  1536. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    1537. 

  1537. // CHECK-ERROR-NEXT:         ror w9, w10, #32
    1538. 

  1538. // CHECK-ERROR-NEXT:                      ^
    1539. 

  1539. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    1540. 

  1540. // CHECK-ERROR-NEXT:         ror x10, x11, #64
    1541. 

  1541. // CHECK-ERROR-NEXT:                       ^
    1542. 

  1542. 

  1543. //------------------------------------------------------------------------------
    1544. 

  1544. // Floating-point compare
    1545. 

  1545. //------------------------------------------------------------------------------
    1546. 

  1546. 

  1547.         fcmp s3, d2
    1548. 

  1548. // CHECK-ERROR-AARCH64: error: expected floating-point constant #0.0
    1549. 

  1549. // CHECK-ERROR-ARM64: error: invalid operand for instruction
    1550. 

  1550. // CHECK-ERROR-NEXT:         fcmp s3, d2
    1551. 

  1551. // CHECK-ERROR-NEXT:                  ^
    1552. 

  1552. 

  1553.         fcmp s9, #-0.0
    1554. 

  1554.         fcmp d3, #-0.0
    1555. 

  1555.         fcmp s1, #1.0
    1556. 

  1556.         fcmpe s30, #-0.0
    1557. 

  1557. // CHECK-ERROR: error: expected floating-point constant #0.0
    1558. 

  1558. // CHECK-ERROR-NEXT:         fcmp s9, #-0.0
    1559. 

  1559. // CHECK-ERROR-NEXT:                  ^
    1560. 

  1560. // CHECK-ERROR-NEXT: error: expected floating-point constant #0.0
    1561. 

  1561. // CHECK-ERROR-NEXT:         fcmp d3, #-0.0
    1562. 

  1562. // CHECK-ERROR-NEXT:                  ^
    1563. 

  1563. // CHECK-ERROR-NEXT: error: expected floating-point constant #0.0
    1564. 

  1564. // CHECK-ERROR-NEXT:         fcmp s1, #1.0
    1565. 

  1565. // CHECK-ERROR-NEXT:                  ^
    1566. 

  1566. // CHECK-ERROR-NEXT: error: expected floating-point constant #0.0
    1567. 

  1567. // CHECK-ERROR-NEXT:         fcmpe s30, #-0.0
    1568. 

  1568. // CHECK-ERROR-NEXT:                    ^
    1569. 

  1569. 

  1570. //------------------------------------------------------------------------------
    1571. 

  1571. // Floating-point conditional compare
    1572. 

  1572. //------------------------------------------------------------------------------
    1573. 

  1573. 

  1574.         fccmp s19, s5, #-1, lt
    1575. 

  1575.         fccmp s20, s7, #16, hs
    1576. 

  1576. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1577. 

  1577. // CHECK-ERROR-NEXT:        fccmp s19, s5, #-1, lt
    1578. 

  1578. // CHECK-ERROR-NEXT:                      ^
    1579. 

  1579. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1580. 

  1580. // CHECK-ERROR-NEXT:        fccmp s20, s7, #16, hs
    1581. 

  1581. // CHECK-ERROR-NEXT:                      ^
    1582. 

  1582. 

  1583.         fccmp d19, d5, #-1, lt
    1584. 

  1584.         fccmp d20, d7, #16, hs
    1585. 

  1585. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1586. 

  1586. // CHECK-ERROR-NEXT:        fccmp d19, d5, #-1, lt
    1587. 

  1587. // CHECK-ERROR-NEXT:                      ^
    1588. 

  1588. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1589. 

  1589. // CHECK-ERROR-NEXT:        fccmp d20, d7, #16, hs
    1590. 

  1590. // CHECK-ERROR-NEXT:                      ^
    1591. 

  1591. 

  1592.         fccmpe s19, s5, #-1, lt
    1593. 

  1593.         fccmpe s20, s7, #16, hs
    1594. 

  1594. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1595. 

  1595. // CHECK-ERROR-NEXT:        fccmpe s19, s5, #-1, lt
    1596. 

  1596. // CHECK-ERROR-NEXT:                      ^
    1597. 

  1597. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1598. 

  1598. // CHECK-ERROR-NEXT:        fccmpe s20, s7, #16, hs
    1599. 

  1599. // CHECK-ERROR-NEXT:                      ^
    1600. 

  1600. 

  1601.         fccmpe d19, d5, #-1, lt
    1602. 

  1602.         fccmpe d20, d7, #16, hs
    1603. 

  1603. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1604. 

  1604. // CHECK-ERROR-NEXT:        fccmpe d19, d5, #-1, lt
    1605. 

  1605. // CHECK-ERROR-NEXT:                      ^
    1606. 

  1606. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    1607. 

  1607. // CHECK-ERROR-NEXT:        fccmpe d20, d7, #16, hs
    1608. 

  1608. // CHECK-ERROR-NEXT:                      ^
    1609. 

  1609. 

  1610. //------------------------------------------------------------------------------
    1611. 

  1611. // Floating-point conditional compare
    1612. 

  1612. //------------------------------------------------------------------------------
    1613. 

  1613. 

  1614.         fcsel q3, q20, q9, pl
    1615. 

  1615.         fcsel h9, h10, h11, mi
    1616. 

  1616.         fcsel b9, b10, b11, mi
    1617. 

  1617. // CHECK-ERROR: error: invalid operand for instruction
    1618. 

  1618. // CHECK-ERROR-NEXT:         fcsel q3, q20, q9, pl
    1619. 

  1619. // CHECK-ERROR-NEXT:               ^
    1620. 

  1620. // CHECK-ERROR-NEXT: error: instruction requires: fullfp16
    1621. 

  1621. // CHECK-ERROR-NEXT:         fcsel h9, h10, h11, mi
    1622. 

  1622. // CHECK-ERROR-NEXT:               ^
    1623. 

  1623. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1624. 

  1624. // CHECK-ERROR-NEXT:         fcsel b9, b10, b11, mi
    1625. 

  1625. // CHECK-ERROR-NEXT:               ^
    1626. 

  1626. 

  1627. //------------------------------------------------------------------------------
    1628. 

  1628. // Floating-point data-processing (1 source)
    1629. 

  1629. //------------------------------------------------------------------------------
    1630. 

  1630. 

  1631.         fmov d0, s3
    1632. 

  1632.         fcvt d0, d1
    1633. 

  1633. // CHECK-ERROR: error: expected compatible register or floating-point constant
    1634. 

  1634. // CHECK-ERROR-NEXT:           fmov d0, s3
    1635. 

  1635. // CHECK-ERROR-NEXT:                    ^
    1636. 

  1636. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1637. 

  1637. // CHECK-ERROR-NEXT:           fcvt d0, d1
    1638. 

  1638. // CHECK-ERROR-NEXT:                    ^
    1639. 

  1639. 

  1640. 

  1641. //------------------------------------------------------------------------------
    1642. 

  1642. // Floating-point data-processing (2 sources)
    1643. 

  1643. //------------------------------------------------------------------------------
    1644. 

  1644. 

  1645.         fadd s0, d3, d7
    1646. 

  1646.         fmaxnm d3, s19, d12
    1647. 

  1647.         fnmul d1, d9, s18
    1648. 

  1648. // CHECK-ERROR: error: invalid operand for instruction
    1649. 

  1649. // CHECK-ERROR-NEXT:           fadd s0, d3, d7
    1650. 

  1650. // CHECK-ERROR-NEXT: ^
    1651. 

  1651. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1652. 

  1652. // CHECK-ERROR-NEXT:           fmaxnm d3, s19, d12
    1653. 

  1653. // CHECK-ERROR-NEXT: ^
    1654. 

  1654. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1655. 

  1655. // CHECK-ERROR-NEXT:           fnmul d1, d9, s18
    1656. 

  1656. // CHECK-ERROR-NEXT: ^
    1657. 

  1657. 

  1658. //------------------------------------------------------------------------------
    1659. 

  1659. // Floating-point data-processing (3 sources)
    1660. 

  1660. //------------------------------------------------------------------------------
    1661. 

  1661. 

  1662.         fmadd b3, b4, b5, b6
    1663. 

  1663.         fmsub h1, h2, h3, h4
    1664. 

  1664.         fnmadd q3, q5, q6, q7
    1665. 

  1665.         fnmsub s2, s4, d5, h9
    1666. 

  1666. // CHECK-ERROR: error: invalid operand for instruction
    1667. 

  1667. // CHECK-ERROR-NEXT:         fmadd b3, b4, b5, b6
    1668. 

  1668. // CHECK-ERROR-NEXT:               ^
    1669. 

  1669. // CHECK-ERROR-NEXT: error: instruction requires: fullfp16
    1670. 

  1670. // CHECK-ERROR-NEXT:         fmsub h1, h2, h3, h4
    1671. 

  1671. // CHECK-ERROR-NEXT:               ^
    1672. 

  1672. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1673. 

  1673. // CHECK-ERROR-NEXT:         fnmadd q3, q5, q6, q7
    1674. 

  1674. // CHECK-ERROR-NEXT:                ^
    1675. 

  1675. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1676. 

  1676. // CHECK-ERROR-NEXT:         fnmsub s2, s4, d5, h9
    1677. 

  1677. // CHECK-ERROR-NEXT:                ^
    1678. 

  1678. 

  1679. //------------------------------------------------------------------------------
    1680. 

  1680. // Floating-point conditional compare
    1681. 

  1681. //------------------------------------------------------------------------------
    1682. 

  1682. 

  1683.         fcvtzs w13, s31, #0
    1684. 

  1684.         fcvtzs w19, s20, #33
    1685. 

  1685.         fcvtzs wsp, s19, #14
    1686. 

  1686. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 32]
    1687. 

  1687. // CHECK-ERROR-NEXT:        fcvtzs w13, s31, #0
    1688. 

  1688. // CHECK-ERROR-NEXT:                         ^
    1689. 

  1689. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 32]
    1690. 

  1690. // CHECK-ERROR-NEXT:        fcvtzs w19, s20, #33
    1691. 

  1691. // CHECK-ERROR-NEXT:                         ^
    1692. 

  1692. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1693. 

  1693. // CHECK-ERROR-NEXT:        fcvtzs wsp, s19, #14
    1694. 

  1694. // CHECK-ERROR-NEXT:               ^
    1695. 

  1695. 

  1696.         fcvtzs x13, s31, #0
    1697. 

  1697.         fcvtzs x19, s20, #65
    1698. 

  1698.         fcvtzs sp, s19, #14
    1699. 

  1699. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 64]
    1700. 

  1700. // CHECK-ERROR-NEXT:        fcvtzs x13, s31, #0
    1701. 

  1701. // CHECK-ERROR-NEXT:                         ^
    1702. 

  1702. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 64]
    1703. 

  1703. // CHECK-ERROR-NEXT:        fcvtzs x19, s20, #65
    1704. 

  1704. // CHECK-ERROR-NEXT:                         ^
    1705. 

  1705. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1706. 

  1706. // CHECK-ERROR-NEXT:        fcvtzs sp, s19, #14
    1707. 

  1707. // CHECK-ERROR-NEXT:               ^
    1708. 

  1708. 

  1709.         fcvtzu w13, s31, #0
    1710. 

  1710.         fcvtzu w19, s20, #33
    1711. 

  1711.         fcvtzu wsp, s19, #14
    1712. 

  1712. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 32]
    1713. 

  1713. // CHECK-ERROR-NEXT:        fcvtzu w13, s31, #0
    1714. 

  1714. // CHECK-ERROR-NEXT:                         ^
    1715. 

  1715. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 32]
    1716. 

  1716. // CHECK-ERROR-NEXT:        fcvtzu w19, s20, #33
    1717. 

  1717. // CHECK-ERROR-NEXT:                         ^
    1718. 

  1718. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1719. 

  1719. // CHECK-ERROR-NEXT:        fcvtzu wsp, s19, #14
    1720. 

  1720. // CHECK-ERROR-NEXT:               ^
    1721. 

  1721. 

  1722.         fcvtzu x13, s31, #0
    1723. 

  1723.         fcvtzu x19, s20, #65
    1724. 

  1724.         fcvtzu sp, s19, #14
    1725. 

  1725. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 64]
    1726. 

  1726. // CHECK-ERROR-NEXT:        fcvtzu x13, s31, #0
    1727. 

  1727. // CHECK-ERROR-NEXT:                         ^
    1728. 

  1728. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [1, 64]
    1729. 

  1729. // CHECK-ERROR-NEXT:        fcvtzu x19, s20, #65
    1730. 

  1730. // CHECK-ERROR-NEXT:                         ^
    1731. 

  1731. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1732. 

  1732. // CHECK-ERROR-NEXT:        fcvtzu sp, s19, #14
    1733. 

  1733. // CHECK-ERROR-NEXT:               ^
    1734. 

  1734. 

  1735.         scvtf w13, s31, #0
    1736. 

  1736.         scvtf w19, s20, #33
    1737. 

  1737.         scvtf wsp, s19, #14
    1738. 

  1738. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1739. 

  1739. // CHECK-ERROR-NEXT:        scvtf w13, s31, #0
    1740. 

  1740. // CHECK-ERROR-NEXT:              ^
    1741. 

  1741. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1742. 

  1742. // CHECK-ERROR-NEXT:        scvtf w19, s20, #33
    1743. 

  1743. // CHECK-ERROR-NEXT:              ^
    1744. 

  1744. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1745. 

  1745. // CHECK-ERROR-NEXT:        scvtf wsp, s19, #14
    1746. 

  1746. // CHECK-ERROR-NEXT:              ^
    1747. 

  1747. 

  1748.         scvtf x13, s31, #0
    1749. 

  1749.         scvtf x19, s20, #65
    1750. 

  1750.         scvtf sp, s19, #14
    1751. 

  1751. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1752. 

  1752. // CHECK-ERROR-NEXT:        scvtf x13, s31, #0
    1753. 

  1753. // CHECK-ERROR-NEXT:              ^
    1754. 

  1754. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1755. 

  1755. // CHECK-ERROR-NEXT:        scvtf x19, s20, #65
    1756. 

  1756. // CHECK-ERROR-NEXT:              ^
    1757. 

  1757. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1758. 

  1758. // CHECK-ERROR-NEXT:        scvtf sp, s19, #14
    1759. 

  1759. // CHECK-ERROR-NEXT:              ^
    1760. 

  1760. 

  1761.         ucvtf w13, s31, #0
    1762. 

  1762.         ucvtf w19, s20, #33
    1763. 

  1763.         ucvtf wsp, s19, #14
    1764. 

  1764. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1765. 

  1765. // CHECK-ERROR-NEXT:        ucvtf w13, s31, #0
    1766. 

  1766. // CHECK-ERROR-NEXT:              ^
    1767. 

  1767. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1768. 

  1768. // CHECK-ERROR-NEXT:        ucvtf w19, s20, #33
    1769. 

  1769. // CHECK-ERROR-NEXT:              ^
    1770. 

  1770. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1771. 

  1771. // CHECK-ERROR-NEXT:        ucvtf wsp, s19, #14
    1772. 

  1772. // CHECK-ERROR-NEXT:              ^
    1773. 

  1773. 

  1774.         ucvtf x13, s31, #0
    1775. 

  1775.         ucvtf x19, s20, #65
    1776. 

  1776.         ucvtf sp, s19, #14
    1777. 

  1777. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1778. 

  1778. // CHECK-ERROR-NEXT:        ucvtf x13, s31, #0
    1779. 

  1779. // CHECK-ERROR-NEXT:              ^
    1780. 

  1780. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1781. 

  1781. // CHECK-ERROR-NEXT:        ucvtf x19, s20, #65
    1782. 

  1782. // CHECK-ERROR-NEXT:              ^
    1783. 

  1783. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1784. 

  1784. // CHECK-ERROR-NEXT:        ucvtf sp, s19, #14
    1785. 

  1785. // CHECK-ERROR-NEXT:              ^
    1786. 

  1786. 

  1787. //------------------------------------------------------------------------------
    1788. 

  1788. // Floating-point immediate
    1789. 

  1789. //------------------------------------------------------------------------------
    1790. 

  1790.         ;; Exponent too large
    1791. 

  1791.         fmov d3, #0.0625
    1792. 

  1792.         fmov s2, #32.0
    1793. 

  1793.         fmov s2, #32
    1794. 

  1794.         fmov v0.4s, #-32
    1795. 

  1795. // CHECK-ERROR: error: expected compatible register or floating-point constant
    1796. 

  1796. // CHECK-ERROR-NEXT:           fmov d3, #0.0625
    1797. 

  1797. // CHECK-ERROR-NEXT:                    ^
    1798. 

  1798. // CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
    1799. 

  1799. // CHECK-ERROR-NEXT:           fmov s2, #32.0
    1800. 

  1800. // CHECK-ERROR-NEXT:                    ^
    1801. 

  1801. // CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
    1802. 

  1802. // CHECK-ERROR-NEXT:           fmov s2, #32
    1803. 

  1803. // CHECK-ERROR-NEXT:                    ^
    1804. 

  1804. // CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
    1805. 

  1805. // CHECK-ERROR-NEXT:           fmov v0.4s, #-32
    1806. 

  1806. // CHECK-ERROR-NEXT:                       ^
    1807. 

  1807. 

  1808.         ;; Fraction too precise
    1809. 

  1809.         fmov s9, #1.03125
    1810. 

  1810.         fmov s28, #1.96875
    1811. 

  1811. // CHECK-ERROR: error: expected compatible register or floating-point constant
    1812. 

  1812. // CHECK-ERROR-NEXT:           fmov s9, #1.03125
    1813. 

  1813. // CHECK-ERROR-NEXT:                    ^
    1814. 

  1814. // CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
    1815. 

  1815. // CHECK-ERROR-NEXT:           fmov s28, #1.96875
    1816. 

  1816. // CHECK-ERROR-NEXT:                     ^
    1817. 

  1817. 

  1818.         ;; Explicitly encoded value too large
    1819. 

  1819.         fmov s15, #0x100
    1820. 

  1820. // CHECK-ERROR: error: encoded floating point value out of range
    1821. 

  1821. // CHECK-ERROR-NEXT:           fmov s15, #0x100
    1822. 

  1822. // CHECK-ERROR-NEXT:                     ^
    1823. 

  1823. 

  1824.         ;; Not possible to fmov ZR to a whole vector
    1825. 

  1825.         fmov v0.4s, #0.0
    1826. 

  1826. // CHECK-ERROR: error: expected compatible register or floating-point constant
    1827. 

  1827. // CHECK-ERROR-NEXT:           fmov v0.4s, #0.0
    1828. 

  1828. // CHECK-ERROR-NEXT:                       ^
    1829. 

  1829. 

  1830. //------------------------------------------------------------------------------
    1831. 

  1831. // Floating-point <-> integer conversion
    1832. 

  1832. //------------------------------------------------------------------------------
    1833. 

  1833. 

  1834.         fmov x3, v0.d[0]
    1835. 

  1835.         fmov v29.1d[1], x2
    1836. 

  1836.         fmov x7, v0.d[2]
    1837. 

  1837.         fcvtns sp, s5
    1838. 

  1838.         scvtf s6, wsp
    1839. 

  1839. // CHECK-ERROR: error: expected lane specifier '[1]'
    1840. 

  1840. // CHECK-ERROR-NEXT:         fmov x3, v0.d[0]
    1841. 

  1841. // CHECK-ERROR-NEXT:                       ^
    1842. 

  1842. // CHECK-ERROR-AARCH64-NEXT: error: lane number incompatible with layout
    1843. 

  1843. // CHECK-ERROR-ARM64-NEXT: error: invalid operand for instruction
    1844. 

  1844. // CHECK-ERROR-NEXT: fmov v29.1d[1], x2
    1845. 

  1845. // CHECK-ERROR-NEXT:             ^
    1846. 

  1846. // CHECK-ERROR-AARCH64-NEXT: error: lane number incompatible with layout
    1847. 

  1847. // CHECK-ERROR-ARM64-NEXT: error: expected lane specifier '[1]'
    1848. 

  1848. // CHECK-ERROR-NEXT: fmov x7, v0.d[2]
    1849. 

  1849. // CHECK-ERROR-NEXT:               ^
    1850. 

  1850. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1851. 

  1851. // CHECK-ERROR-NEXT:         fcvtns sp, s5
    1852. 

  1852. // CHECK-ERROR-NEXT:                ^
    1853. 

  1853. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1854. 

  1854. // CHECK-ERROR-NEXT:         scvtf s6, wsp
    1855. 

  1855. // CHECK-ERROR-NEXT:                   ^
    1856. 

  1856. 

  1857. //------------------------------------------------------------------------------
    1858. 

  1858. // Load-register (literal)
    1859. 

  1859. //------------------------------------------------------------------------------
    1860. 

  1860. 

  1861.         ldr sp, some_label
    1862. 

  1862.         ldrsw w3, somewhere
    1863. 

  1863.         ldr v0, some_label
    1864. 

  1864. // CHECK-ERROR: error: invalid operand for instruction
    1865. 

  1865. // CHECK-ERROR-NEXT:         ldr sp, some_label
    1866. 

  1866. // CHECK-ERROR-NEXT:             ^
    1867. 

  1867. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1868. 

  1868. // CHECK-ERROR-NEXT:         ldrsw w3, somewhere
    1869. 

  1869. // CHECK-ERROR-NEXT:               ^
    1870. 

  1870. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1871. 

  1871. // CHECK-ERROR-NEXT:         ldr v0, some_label
    1872. 

  1872. // CHECK-ERROR-NEXT:             ^
    1873. 

  1873. 

  1874.         ldrsw x2, #1048576
    1875. 

  1875.         ldr q0, #-1048580
    1876. 

  1876.         ldr x0, #2
    1877. 

  1877. // CHECK-ERROR: error: expected label or encodable integer pc offset
    1878. 

  1878. // CHECK-ERROR-NEXT:         ldrsw x2, #1048576
    1879. 

  1879. // CHECK-ERROR-NEXT:                   ^
    1880. 

  1880. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    1881. 

  1881. // CHECK-ERROR-NEXT:         ldr q0, #-1048580
    1882. 

  1882. // CHECK-ERROR-NEXT:                   ^
    1883. 

  1883. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    1884. 

  1884. // CHECK-ERROR-NEXT:         ldr x0, #2
    1885. 

  1885. // CHECK-ERROR-NEXT:                 ^
    1886. 

  1886. 

  1887. //------------------------------------------------------------------------------
    1888. 

  1888. // Load/store exclusive
    1889. 

  1889. //------------------------------------------------------------------------------
    1890. 

  1890. 

  1891.        stxrb w2, w3, [x4, #20]
    1892. 

  1892.        stlxrh w10, w11, [w2]
    1893. 

  1893. // CHECK-ERROR-AARCH64: error: expected '#0'
    1894. 

  1894. // CHECK-ERROR-ARM64: error: index must be absent or #0
    1895. 

  1895. // CHECK-ERROR-NEXT:         stxrb w2, w3, [x4, #20]
    1896. 

  1896. // CHECK-ERROR-NEXT:                       ^
    1897. 

  1897. // CHECK-ERROR: error: invalid operand for instruction
    1898. 

  1898. // CHECK-ERROR-NEXT:         stlxrh w10, w11, [w2]
    1899. 

  1899. // CHECK-ERROR-NEXT:                           ^
    1900. 

  1900. 

  1901.        stlxr  x20, w21, [sp]
    1902. 

  1902. // CHECK-ERROR: error: invalid operand for instruction
    1903. 

  1903. // CHECK-ERROR-NEXT:         stlxr  x20, w21, [sp]
    1904. 

  1904. // CHECK-ERROR-NEXT:                ^
    1905. 

  1905. 

  1906.        ldxr   sp, [sp]
    1907. 

  1907. // CHECK-ERROR: error: invalid operand for instruction
    1908. 

  1908. // CHECK-ERROR-NEXT:         ldxr   sp, [sp]
    1909. 

  1909. // CHECK-ERROR-NEXT:                ^
    1910. 

  1910. 

  1911.        stxp x1, x2, x3, [x4]
    1912. 

  1912. // CHECK-ERROR: error: invalid operand for instruction
    1913. 

  1913. // CHECK-ERROR-NEXT:         stxp x1, x2,  x3, [x4]
    1914. 

  1914. // CHECK-ERROR-NEXT:              ^
    1915. 

  1915. 

  1916.        stlxp w5, x1, w4, [x5]
    1917. 

  1917. // CHECK-ERROR: error: invalid operand for instruction
    1918. 

  1918. // CHECK-ERROR-NEXT:         stlxp w5, x1, w4, [x5]
    1919. 

  1919. // CHECK-ERROR-NEXT:                       ^
    1920. 

  1920. 

  1921.        stlxp w17, w6, x7, [x22]
    1922. 

  1922. // CHECK-ERROR: error: invalid operand for instruction
    1923. 

  1923. // CHECK-ERROR-NEXT:         stlxp w17, w6, x7, [x22]
    1924. 

  1924. // CHECK-ERROR-NEXT:                        ^
    1925. 

  1925. 

  1926. //------------------------------------------------------------------------------
    1927. 

  1927. // Load/store (unscaled immediate)
    1928. 

  1928. //------------------------------------------------------------------------------
    1929. 

  1929.         ldur v0, [x0, #0]
    1930. 

  1930.         stur v0, [x0, #0]
    1931. 

  1931. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1932. 

  1932. // CHECK-ERROR-NEXT:         ldur v0, [x0, #0]
    1933. 

  1933. // CHECK-ERROR-NEXT:              ^
    1934. 

  1934. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    1935. 

  1935. // CHECK-ERROR-NEXT:         stur v0, [x0, #0]
    1936. 

  1936. // CHECK-ERROR-NEXT:              ^
    1937. 

  1937. 

  1938.         ldurb w2, [sp, #256]
    1939. 

  1939.         sturh w17, [x1, #256]
    1940. 

  1940.         ldursw x20, [x1, #256]
    1941. 

  1941.         ldur x12, [sp, #256]
    1942. 

  1942. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    1943. 

  1943. // CHECK-ERROR-NEXT:        ldurb w2, [sp, #256]
    1944. 

  1944. // CHECK-ERROR-NEXT:                  ^
    1945. 

  1945. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    1946. 

  1946. // CHECK-ERROR-NEXT:         sturh w17, [x1, #256]
    1947. 

  1947. // CHECK-ERROR-NEXT:                    ^
    1948. 

  1948. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    1949. 

  1949. // CHECK-ERROR-NEXT:         ldursw x20, [x1, #256]
    1950. 

  1950. // CHECK-ERROR-NEXT:                     ^
    1951. 

  1951. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    1952. 

  1952. // CHECK-ERROR-NEXT:         ldur x12, [sp, #256]
    1953. 

  1953. // CHECK-ERROR-NEXT:                   ^
    1954. 

  1954. 

  1955.         stur h2, [x2, #-257]
    1956. 

  1956.         stur b2, [x2, #-257]
    1957. 

  1957.         ldursb x9, [sp, #-257]
    1958. 

  1958.         ldur w2, [x30, #-257]
    1959. 

  1959.         stur q9, [x20, #-257]
    1960. 

  1960. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    1961. 

  1961. // CHECK-ERROR-NEXT:         stur h2, [x2, #-257]
    1962. 

  1962. // CHECK-ERROR-NEXT:                  ^
    1963. 

  1963. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    1964. 

  1964. // CHECK-ERROR-NEXT:         stur b2, [x2, #-257]
    1965. 

  1965. // CHECK-ERROR-NEXT:                  ^
    1966. 

  1966. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    1967. 

  1967. // CHECK-ERROR-NEXT:         ldursb x9, [sp, #-257]
    1968. 

  1968. // CHECK-ERROR-NEXT:                    ^
    1969. 

  1969. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    1970. 

  1970. // CHECK-ERROR-NEXT:         ldur w2, [x30, #-257]
    1971. 

  1971. // CHECK-ERROR-NEXT:                  ^
    1972. 

  1972. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    1973. 

  1973. // CHECK-ERROR-NEXT:         stur q9, [x20, #-257]
    1974. 

  1974. // CHECK-ERROR-NEXT:                  ^
    1975. 

  1975. 

  1976.         prfum pstl3strm, [xzr]
    1977. 

  1977. // CHECK-ERROR: error: invalid operand for instruction
    1978. 

  1978. // CHECK-ERROR-NEXT:         prfum pstl3strm, [xzr]
    1979. 

  1979. // CHECK-ERROR-NEXT:                           ^
    1980. 

  1980. 

  1981. //------------------------------------------------------------------------------
    1982. 

  1982. // Load-store register (immediate post-indexed)
    1983. 

  1983. //------------------------------------------------------------------------------
    1984. 

  1984.         ldr v0, [x0], #0
    1985. 

  1985.         str v0, [x0], #0
    1986. 

  1986. // CHECK-ERROR: error: invalid operand for instruction
    1987. 

  1987. // CHECK-ERROR-NEXT:         ldr v0, [x0], #0
    1988. 

  1988. // CHECK-ERROR-NEXT:             ^
    1989. 

  1989. // CHECK-ERROR: error: invalid operand for instruction
    1990. 

  1990. // CHECK-ERROR-NEXT:         str v0, [x0], #0
    1991. 

  1991. // CHECK-ERROR-NEXT:             ^
    1992. 

  1992. 

  1993.         ldr x3, [x4, #25], #0
    1994. 

  1994.         ldr x4, [x9, #0], #4
    1995. 

  1995. // CHECK-ERROR-AARCH64: error: invalid operand for instruction
    1996. 

  1996. // CHECK-ERROR-ARM64: error: invalid operand for instruction
    1997. 

  1997. // CHECK-ERROR-NEXT:         ldr x3, [x4, #25], #0
    1998. 

  1998. // CHECK-ERROR-NEXT:                 ^
    1999. 

  1999. // CHECK-ERROR-AARCH64-NEXT: error: expected label or encodable integer pc offset
    2000. 

  2000. // CHECK-ERROR-AARCH64-NEXT:         ldr x4, [x9, #0], #4
    2001. 

  2001. // CHECK-ERROR-AARCH64-NEXT:                           ^
    2002. 

  2002. 

  2003.         strb w1, [x19], #256
    2004. 

  2004.         strb w9, [sp], #-257
    2005. 

  2005.         strh w1, [x19], #256
    2006. 

  2006.         strh w9, [sp], #-257
    2007. 

  2007.         str w1, [x19], #256
    2008. 

  2008.         str w9, [sp], #-257
    2009. 

  2009. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2010. 

  2010. // CHECK-ERROR-NEXT:         strb w1, [x19], #256
    2011. 

  2011. // CHECK-ERROR-NEXT:                         ^
    2012. 

  2012. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2013. 

  2013. // CHECK-ERROR-NEXT:         strb w9, [sp], #-257
    2014. 

  2014. // CHECK-ERROR-NEXT:                        ^
    2015. 

  2015. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2016. 

  2016. // CHECK-ERROR-NEXT:         strh w1, [x19], #256
    2017. 

  2017. // CHECK-ERROR-NEXT:                         ^
    2018. 

  2018. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2019. 

  2019. // CHECK-ERROR-NEXT:         strh w9, [sp], #-257
    2020. 

  2020. // CHECK-ERROR-NEXT:                        ^
    2021. 

  2021. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2022. 

  2022. // CHECK-ERROR-NEXT:         str w1, [x19], #256
    2023. 

  2023. // CHECK-ERROR-NEXT:                        ^
    2024. 

  2024. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2025. 

  2025. // CHECK-ERROR-NEXT:         str w9, [sp], #-257
    2026. 

  2026. // CHECK-ERROR-NEXT:                       ^
    2027. 

  2027. 

  2028.         ldrb w1, [x19], #256
    2029. 

  2029.         ldrb w9, [sp], #-257
    2030. 

  2030.         ldrh w1, [x19], #256
    2031. 

  2031.         ldrh w9, [sp], #-257
    2032. 

  2032.         ldr w1, [x19], #256
    2033. 

  2033.         ldr w9, [sp], #-257
    2034. 

  2034. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2035. 

  2035. // CHECK-ERROR-NEXT:         ldrb w1, [x19], #256
    2036. 

  2036. // CHECK-ERROR-NEXT:                         ^
    2037. 

  2037. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2038. 

  2038. // CHECK-ERROR-NEXT:         ldrb w9, [sp], #-257
    2039. 

  2039. // CHECK-ERROR-NEXT:                        ^
    2040. 

  2040. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2041. 

  2041. // CHECK-ERROR-NEXT:         ldrh w1, [x19], #256
    2042. 

  2042. // CHECK-ERROR-NEXT:                         ^
    2043. 

  2043. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2044. 

  2044. // CHECK-ERROR-NEXT:         ldrh w9, [sp], #-257
    2045. 

  2045. // CHECK-ERROR-NEXT:                        ^
    2046. 

  2046. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2047. 

  2047. // CHECK-ERROR-NEXT:         ldr w1, [x19], #256
    2048. 

  2048. // CHECK-ERROR-NEXT:                        ^
    2049. 

  2049. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2050. 

  2050. // CHECK-ERROR-NEXT:         ldr w9, [sp], #-257
    2051. 

  2051. // CHECK-ERROR-NEXT:                       ^
    2052. 

  2052. 

  2053.         ldrsb x2, [x3], #256
    2054. 

  2054.         ldrsb x22, [x13], #-257
    2055. 

  2055.         ldrsh x2, [x3], #256
    2056. 

  2056.         ldrsh x22, [x13], #-257
    2057. 

  2057.         ldrsw x2, [x3], #256
    2058. 

  2058.         ldrsw x22, [x13], #-257
    2059. 

  2059. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2060. 

  2060. // CHECK-ERROR-NEXT:         ldrsb x2, [x3], #256
    2061. 

  2061. // CHECK-ERROR-NEXT:                         ^
    2062. 

  2062. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2063. 

  2063. // CHECK-ERROR-NEXT:         ldrsb x22, [x13], #-257
    2064. 

  2064. // CHECK-ERROR-NEXT:                           ^
    2065. 

  2065. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2066. 

  2066. // CHECK-ERROR-NEXT:         ldrsh x2, [x3], #256
    2067. 

  2067. // CHECK-ERROR-NEXT:                         ^
    2068. 

  2068. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2069. 

  2069. // CHECK-ERROR-NEXT:         ldrsh x22, [x13], #-257
    2070. 

  2070. // CHECK-ERROR-NEXT:                           ^
    2071. 

  2071. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2072. 

  2072. // CHECK-ERROR-NEXT:         ldrsw x2, [x3], #256
    2073. 

  2073. // CHECK-ERROR-NEXT:                         ^
    2074. 

  2074. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2075. 

  2075. // CHECK-ERROR-NEXT:         ldrsw x22, [x13], #-257
    2076. 

  2076. // CHECK-ERROR-NEXT:                           ^
    2077. 

  2077. 

  2078.         ldrsb w2, [x3], #256
    2079. 

  2079.         ldrsb w22, [x13], #-257
    2080. 

  2080.         ldrsh w2, [x3], #256
    2081. 

  2081.         ldrsh w22, [x13], #-257
    2082. 

  2082. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2083. 

  2083. // CHECK-ERROR-NEXT:         ldrsb w2, [x3], #256
    2084. 

  2084. // CHECK-ERROR-NEXT:                         ^
    2085. 

  2085. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2086. 

  2086. // CHECK-ERROR-NEXT:         ldrsb w22, [x13], #-257
    2087. 

  2087. // CHECK-ERROR-NEXT:                           ^
    2088. 

  2088. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2089. 

  2089. // CHECK-ERROR-NEXT:         ldrsh w2, [x3], #256
    2090. 

  2090. // CHECK-ERROR-NEXT:                         ^
    2091. 

  2091. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2092. 

  2092. // CHECK-ERROR-NEXT:         ldrsh w22, [x13], #-257
    2093. 

  2093. // CHECK-ERROR-NEXT:                           ^
    2094. 

  2094. 

  2095.         str b3, [x3], #256
    2096. 

  2096.         str b3, [x13], #-257
    2097. 

  2097.         str h3, [x3], #256
    2098. 

  2098.         str h3, [x13], #-257
    2099. 

  2099.         str s3, [x3], #256
    2100. 

  2100.         str s3, [x13], #-257
    2101. 

  2101.         str d3, [x3], #256
    2102. 

  2102.         str d3, [x13], #-257
    2103. 

  2103.         str q3, [x3], #256
    2104. 

  2104.         str q3, [x13], #-257
    2105. 

  2105. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2106. 

  2106. // CHECK-ERROR-NEXT:         str b3, [x3], #256
    2107. 

  2107. // CHECK-ERROR-NEXT:                       ^
    2108. 

  2108. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2109. 

  2109. // CHECK-ERROR-NEXT:         str b3, [x13], #-257
    2110. 

  2110. // CHECK-ERROR-NEXT:                        ^
    2111. 

  2111. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2112. 

  2112. // CHECK-ERROR-NEXT:         str h3, [x3], #256
    2113. 

  2113. // CHECK-ERROR-NEXT:                       ^
    2114. 

  2114. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2115. 

  2115. // CHECK-ERROR-NEXT:         str h3, [x13], #-257
    2116. 

  2116. // CHECK-ERROR-NEXT:                        ^
    2117. 

  2117. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2118. 

  2118. // CHECK-ERROR-NEXT:         str s3, [x3], #256
    2119. 

  2119. // CHECK-ERROR-NEXT:                       ^
    2120. 

  2120. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2121. 

  2121. // CHECK-ERROR-NEXT:         str s3, [x13], #-257
    2122. 

  2122. // CHECK-ERROR-NEXT:                        ^
    2123. 

  2123. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2124. 

  2124. // CHECK-ERROR-NEXT:         str d3, [x3], #256
    2125. 

  2125. // CHECK-ERROR-NEXT:                       ^
    2126. 

  2126. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2127. 

  2127. // CHECK-ERROR-NEXT:         str d3, [x13], #-257
    2128. 

  2128. // CHECK-ERROR-NEXT:                        ^
    2129. 

  2129. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2130. 

  2130. // CHECK-ERROR-NEXT:         str q3, [x3], #256
    2131. 

  2131. // CHECK-ERROR-NEXT:                       ^
    2132. 

  2132. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2133. 

  2133. // CHECK-ERROR-NEXT:         str q3, [x13], #-257
    2134. 

  2134. // CHECK-ERROR-NEXT:                        ^
    2135. 

  2135. 

  2136.         ldr b3, [x3], #256
    2137. 

  2137.         ldr b3, [x13], #-257
    2138. 

  2138.         ldr h3, [x3], #256
    2139. 

  2139.         ldr h3, [x13], #-257
    2140. 

  2140.         ldr s3, [x3], #256
    2141. 

  2141.         ldr s3, [x13], #-257
    2142. 

  2142.         ldr d3, [x3], #256
    2143. 

  2143.         ldr d3, [x13], #-257
    2144. 

  2144.         ldr q3, [x3], #256
    2145. 

  2145.         ldr q3, [x13], #-257
    2146. 

  2146. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2147. 

  2147. // CHECK-ERROR-NEXT:         ldr b3, [x3], #256
    2148. 

  2148. // CHECK-ERROR-NEXT:                       ^
    2149. 

  2149. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2150. 

  2150. // CHECK-ERROR-NEXT:         ldr b3, [x13], #-257
    2151. 

  2151. // CHECK-ERROR-NEXT:                        ^
    2152. 

  2152. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2153. 

  2153. // CHECK-ERROR-NEXT:         ldr h3, [x3], #256
    2154. 

  2154. // CHECK-ERROR-NEXT:                       ^
    2155. 

  2155. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2156. 

  2156. // CHECK-ERROR-NEXT:         ldr h3, [x13], #-257
    2157. 

  2157. // CHECK-ERROR-NEXT:                        ^
    2158. 

  2158. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2159. 

  2159. // CHECK-ERROR-NEXT:         ldr s3, [x3], #256
    2160. 

  2160. // CHECK-ERROR-NEXT:                       ^
    2161. 

  2161. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2162. 

  2162. // CHECK-ERROR-NEXT:         ldr s3, [x13], #-257
    2163. 

  2163. // CHECK-ERROR-NEXT:                        ^
    2164. 

  2164. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2165. 

  2165. // CHECK-ERROR-NEXT:         ldr d3, [x3], #256
    2166. 

  2166. // CHECK-ERROR-NEXT:                       ^
    2167. 

  2167. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2168. 

  2168. // CHECK-ERROR-NEXT:         ldr d3, [x13], #-257
    2169. 

  2169. // CHECK-ERROR-NEXT:                        ^
    2170. 

  2170. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2171. 

  2171. // CHECK-ERROR-NEXT:         ldr q3, [x3], #256
    2172. 

  2172. // CHECK-ERROR-NEXT:                       ^
    2173. 

  2173. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2174. 

  2174. // CHECK-ERROR-NEXT:         ldr q3, [x13], #-257
    2175. 

  2175. // CHECK-ERROR-NEXT:                        ^
    2176. 

  2176. 

  2177. //------------------------------------------------------------------------------
    2178. 

  2178. // Load-store register (immediate pre-indexed)
    2179. 

  2179. //------------------------------------------------------------------------------
    2180. 

  2180.         ldr v0, [x0, #0]!
    2181. 

  2181.         str v0, [x0, #0]!
    2182. 

  2182. // CHECK-ERROR: error: invalid operand for instruction
    2183. 

  2183. // CHECK-ERROR-NEXT:         ldr v0, [x0, #0]!
    2184. 

  2184. // CHECK-ERROR-NEXT:             ^
    2185. 

  2185. // CHECK-ERROR: error: invalid operand for instruction
    2186. 

  2186. // CHECK-ERROR-NEXT:         str v0, [x0, #0]!
    2187. 

  2187. // CHECK-ERROR-NEXT:             ^
    2188. 

  2188. 

  2189.         ldr x3, [x4]!
    2190. 

  2190. // CHECK-ERROR: error:
    2191. 

  2191. // CHECK-ERROR-NEXT:         ldr x3, [x4]!
    2192. 

  2192. // CHECK-ERROR-NEXT:                     ^
    2193. 

  2193. 

  2194.         strb w1, [x19, #256]!
    2195. 

  2195.         strb w9, [sp, #-257]!
    2196. 

  2196.         strh w1, [x19, #256]!
    2197. 

  2197.         strh w9, [sp, #-257]!
    2198. 

  2198.         str w1, [x19, #256]!
    2199. 

  2199.         str w9, [sp, #-257]!
    2200. 

  2200. // CHECK-ERROR: error: invalid operand for instruction
    2201. 

  2201. // CHECK-ERROR-NEXT:         strb w1, [x19, #256]!
    2202. 

  2202. // CHECK-ERROR-NEXT:                             ^
    2203. 

  2203. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2204. 

  2204. // CHECK-ERROR-NEXT:         strb w9, [sp, #-257]!
    2205. 

  2205. // CHECK-ERROR-NEXT:                  ^
    2206. 

  2206. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2207. 

  2207. // CHECK-ERROR-NEXT:         strh w1, [x19, #256]!
    2208. 

  2208. // CHECK-ERROR-NEXT:                             ^
    2209. 

  2209. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2210. 

  2210. // CHECK-ERROR-NEXT:         strh w9, [sp, #-257]!
    2211. 

  2211. // CHECK-ERROR-NEXT:                  ^
    2212. 

  2212. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2213. 

  2213. // CHECK-ERROR-NEXT:         str w1, [x19, #256]!
    2214. 

  2214. // CHECK-ERROR-NEXT:                            ^
    2215. 

  2215. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2216. 

  2216. // CHECK-ERROR-NEXT:         str w9, [sp, #-257]!
    2217. 

  2217. // CHECK-ERROR-NEXT:                 ^
    2218. 

  2218. 

  2219.         ldrb w1, [x19, #256]!
    2220. 

  2220.         ldrb w9, [sp, #-257]!
    2221. 

  2221.         ldrh w1, [x19, #256]!
    2222. 

  2222.         ldrh w9, [sp, #-257]!
    2223. 

  2223.         ldr w1, [x19, #256]!
    2224. 

  2224.         ldr w9, [sp, #-257]!
    2225. 

  2225. // CHECK-ERROR: error: invalid operand for instruction
    2226. 

  2226. // CHECK-ERROR-NEXT:         ldrb w1, [x19, #256]!
    2227. 

  2227. // CHECK-ERROR-NEXT:                             ^
    2228. 

  2228. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2229. 

  2229. // CHECK-ERROR-NEXT:         ldrb w9, [sp, #-257]!
    2230. 

  2230. // CHECK-ERROR-NEXT:                  ^
    2231. 

  2231. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2232. 

  2232. // CHECK-ERROR-NEXT:         ldrh w1, [x19, #256]!
    2233. 

  2233. // CHECK-ERROR-NEXT:                             ^
    2234. 

  2234. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2235. 

  2235. // CHECK-ERROR-NEXT:         ldrh w9, [sp, #-257]!
    2236. 

  2236. // CHECK-ERROR-NEXT:                  ^
    2237. 

  2237. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2238. 

  2238. // CHECK-ERROR-NEXT:         ldr w1, [x19, #256]!
    2239. 

  2239. // CHECK-ERROR-NEXT:                            ^
    2240. 

  2240. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2241. 

  2241. // CHECK-ERROR-NEXT:         ldr w9, [sp, #-257]!
    2242. 

  2242. // CHECK-ERROR-NEXT:                 ^
    2243. 

  2243. 

  2244.         ldrsb x2, [x3, #256]!
    2245. 

  2245.         ldrsb x22, [x13, #-257]!
    2246. 

  2246.         ldrsh x2, [x3, #256]!
    2247. 

  2247.         ldrsh x22, [x13, #-257]!
    2248. 

  2248.         ldrsw x2, [x3, #256]!
    2249. 

  2249.         ldrsw x22, [x13, #-257]!
    2250. 

  2250. // CHECK-ERROR: error: invalid operand for instruction
    2251. 

  2251. // CHECK-ERROR-NEXT:         ldrsb x2, [x3, #256]!
    2252. 

  2252. // CHECK-ERROR-NEXT:                             ^
    2253. 

  2253. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2254. 

  2254. // CHECK-ERROR-NEXT:         ldrsb x22, [x13, #-257]!
    2255. 

  2255. // CHECK-ERROR-NEXT:                    ^
    2256. 

  2256. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2257. 

  2257. // CHECK-ERROR-NEXT:         ldrsh x2, [x3, #256]!
    2258. 

  2258. // CHECK-ERROR-NEXT:                             ^
    2259. 

  2259. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2260. 

  2260. // CHECK-ERROR-NEXT:         ldrsh x22, [x13, #-257]!
    2261. 

  2261. // CHECK-ERROR-NEXT:                    ^
    2262. 

  2262. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2263. 

  2263. // CHECK-ERROR-NEXT:         ldrsw x2, [x3, #256]!
    2264. 

  2264. // CHECK-ERROR-NEXT:                             ^
    2265. 

  2265. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2266. 

  2266. // CHECK-ERROR-NEXT:         ldrsw x22, [x13, #-257]!
    2267. 

  2267. // CHECK-ERROR-NEXT:                    ^
    2268. 

  2268. 

  2269.         ldrsb w2, [x3, #256]!
    2270. 

  2270.         ldrsb w22, [x13, #-257]!
    2271. 

  2271.         ldrsh w2, [x3, #256]!
    2272. 

  2272.         ldrsh w22, [x13, #-257]!
    2273. 

  2273. // CHECK-ERROR: error: invalid operand for instruction
    2274. 

  2274. // CHECK-ERROR-NEXT:         ldrsb w2, [x3, #256]!
    2275. 

  2275. // CHECK-ERROR-NEXT:                             ^
    2276. 

  2276. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2277. 

  2277. // CHECK-ERROR-NEXT:         ldrsb w22, [x13, #-257]!
    2278. 

  2278. // CHECK-ERROR-NEXT:                    ^
    2279. 

  2279. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2280. 

  2280. // CHECK-ERROR-NEXT:         ldrsh w2, [x3, #256]!
    2281. 

  2281. // CHECK-ERROR-NEXT:                             ^
    2282. 

  2282. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2283. 

  2283. // CHECK-ERROR-NEXT:         ldrsh w22, [x13, #-257]!
    2284. 

  2284. // CHECK-ERROR-NEXT:                    ^
    2285. 

  2285. 

  2286.         str b3, [x3, #256]!
    2287. 

  2287.         str b3, [x13, #-257]!
    2288. 

  2288.         str h3, [x3, #256]!
    2289. 

  2289.         str h3, [x13, #-257]!
    2290. 

  2290.         str s3, [x3, #256]!
    2291. 

  2291.         str s3, [x13, #-257]!
    2292. 

  2292.         str d3, [x3, #256]!
    2293. 

  2293.         str d3, [x13, #-257]!
    2294. 

  2294. // CHECK-ERROR: error: invalid operand for instruction
    2295. 

  2295. // CHECK-ERROR-NEXT:         str b3, [x3, #256]!
    2296. 

  2296. // CHECK-ERROR-NEXT:                           ^
    2297. 

  2297. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2298. 

  2298. // CHECK-ERROR-NEXT:         str b3, [x13, #-257]!
    2299. 

  2299. // CHECK-ERROR-NEXT:                 ^
    2300. 

  2300. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2301. 

  2301. // CHECK-ERROR-NEXT:         str h3, [x3, #256]!
    2302. 

  2302. // CHECK-ERROR-NEXT:                           ^
    2303. 

  2303. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2304. 

  2304. // CHECK-ERROR-NEXT:         str h3, [x13, #-257]!
    2305. 

  2305. // CHECK-ERROR-NEXT:                 ^
    2306. 

  2306. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2307. 

  2307. // CHECK-ERROR-NEXT:         str s3, [x3, #256]!
    2308. 

  2308. // CHECK-ERROR-NEXT:                           ^
    2309. 

  2309. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2310. 

  2310. // CHECK-ERROR-NEXT:         str s3, [x13, #-257]!
    2311. 

  2311. // CHECK-ERROR-NEXT:                 ^
    2312. 

  2312. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2313. 

  2313. // CHECK-ERROR-NEXT:         str d3, [x3, #256]!
    2314. 

  2314. // CHECK-ERROR-NEXT:                           ^
    2315. 

  2315. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2316. 

  2316. // CHECK-ERROR-NEXT:         str d3, [x13, #-257]!
    2317. 

  2317. // CHECK-ERROR-NEXT:                 ^
    2318. 

  2318. 

  2319.         ldr b3, [x3, #256]!
    2320. 

  2320.         ldr b3, [x13, #-257]!
    2321. 

  2321.         ldr h3, [x3, #256]!
    2322. 

  2322.         ldr h3, [x13, #-257]!
    2323. 

  2323.         ldr s3, [x3, #256]!
    2324. 

  2324.         ldr s3, [x13, #-257]!
    2325. 

  2325.         ldr d3, [x3, #256]!
    2326. 

  2326.         ldr d3, [x13, #-257]!
    2327. 

  2327. // CHECK-ERROR: error: invalid operand for instruction
    2328. 

  2328. // CHECK-ERROR-NEXT:         ldr b3, [x3, #256]!
    2329. 

  2329. // CHECK-ERROR-NEXT:                           ^
    2330. 

  2330. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2331. 

  2331. // CHECK-ERROR-NEXT:         ldr b3, [x13, #-257]!
    2332. 

  2332. // CHECK-ERROR-NEXT:                 ^
    2333. 

  2333. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2334. 

  2334. // CHECK-ERROR-NEXT:         ldr h3, [x3, #256]!
    2335. 

  2335. // CHECK-ERROR-NEXT:                           ^
    2336. 

  2336. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2337. 

  2337. // CHECK-ERROR-NEXT:         ldr h3, [x13, #-257]!
    2338. 

  2338. // CHECK-ERROR-NEXT:                 ^
    2339. 

  2339. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2340. 

  2340. // CHECK-ERROR-NEXT:         ldr s3, [x3, #256]!
    2341. 

  2341. // CHECK-ERROR-NEXT:                           ^
    2342. 

  2342. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2343. 

  2343. // CHECK-ERROR-NEXT:         ldr s3, [x13, #-257]!
    2344. 

  2344. // CHECK-ERROR-NEXT:                 ^
    2345. 

  2345. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2346. 

  2346. // CHECK-ERROR-NEXT:         ldr d3, [x3, #256]!
    2347. 

  2347. // CHECK-ERROR-NEXT:                           ^
    2348. 

  2348. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2349. 

  2349. // CHECK-ERROR-NEXT:         ldr d3, [x13, #-257]!
    2350. 

  2350. // CHECK-ERROR-NEXT:                 ^
    2351. 

  2351. 

  2352. //------------------------------------------------------------------------------
    2353. 

  2353. // Load/store (unprivileged)
    2354. 

  2354. //------------------------------------------------------------------------------
    2355. 

  2355. 

  2356.         ldtrb w2, [sp, #256]
    2357. 

  2357.         sttrh w17, [x1, #256]
    2358. 

  2358.         ldtrsw x20, [x1, #256]
    2359. 

  2359.         ldtr x12, [sp, #256]
    2360. 

  2360. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2361. 

  2361. // CHECK-ERROR-NEXT:        ldtrb w2, [sp, #256]
    2362. 

  2362. // CHECK-ERROR-NEXT:                  ^
    2363. 

  2363. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2364. 

  2364. // CHECK-ERROR-NEXT:         sttrh w17, [x1, #256]
    2365. 

  2365. // CHECK-ERROR-NEXT:                    ^
    2366. 

  2366. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2367. 

  2367. // CHECK-ERROR-NEXT:         ldtrsw x20, [x1, #256]
    2368. 

  2368. // CHECK-ERROR-NEXT:                     ^
    2369. 

  2369. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2370. 

  2370. // CHECK-ERROR-NEXT:         ldtr x12, [sp, #256]
    2371. 

  2371. // CHECK-ERROR-NEXT:                   ^
    2372. 

  2372. 

  2373.         sttr h2, [x2, #-257]
    2374. 

  2374.         sttr b2, [x2, #-257]
    2375. 

  2375.         ldtrsb x9, [sp, #-257]
    2376. 

  2376.         ldtr w2, [x30, #-257]
    2377. 

  2377.         sttr q9, [x20, #-257]
    2378. 

  2378. // CHECK-ERROR: error: invalid operand for instruction
    2379. 

  2379. // CHECK-ERROR-NEXT:         sttr h2, [x2, #-257]
    2380. 

  2380. // CHECK-ERROR-NEXT:              ^
    2381. 

  2381. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2382. 

  2382. // CHECK-ERROR-NEXT:         sttr b2, [x2, #-257]
    2383. 

  2383. // CHECK-ERROR-NEXT:              ^
    2384. 

  2384. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2385. 

  2385. // CHECK-ERROR-NEXT:         ldtrsb x9, [sp, #-257]
    2386. 

  2386. // CHECK-ERROR-NEXT:                    ^
    2387. 

  2387. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2388. 

  2388. // CHECK-ERROR-NEXT:         ldtr w2, [x30, #-257]
    2389. 

  2389. // CHECK-ERROR-NEXT:                  ^
    2390. 

  2390. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2391. 

  2391. // CHECK-ERROR-NEXT:         sttr q9, [x20, #-257]
    2392. 

  2392. // CHECK-ERROR-NEXT:                  ^
    2393. 

  2393. 

  2394. 

  2395. //------------------------------------------------------------------------------
    2396. 

  2396. // Load/store (unsigned immediate)
    2397. 

  2397. //------------------------------------------------------------------------------
    2398. 

  2398.         ldr v0, [x0, #0]
    2399. 

  2399.         str v0, [x0, #0]
    2400. 

  2400. // CHECK-ERROR: error: invalid operand for instruction
    2401. 

  2401. // CHECK-ERROR-NEXT:         ldr v0, [x0, #0]
    2402. 

  2402. // CHECK-ERROR-NEXT:             ^
    2403. 

  2403. // CHECK-ERROR: error: invalid operand for instruction
    2404. 

  2404. // CHECK-ERROR-NEXT:         str v0, [x0, #0]
    2405. 

  2405. // CHECK-ERROR-NEXT:             ^
    2406. 

  2406. 

  2407. //// Out of range immediates
    2408. 

  2408.         ldr q0, [x11, #65536]
    2409. 

  2409.         ldr x0, [sp, #32768]
    2410. 

  2410.         ldr w0, [x4, #16384]
    2411. 

  2411.         ldrh w2, [x21, #8192]
    2412. 

  2412.         ldrb w3, [x12, #4096]
    2413. 

  2413. // CHECK-ERROR: error: {{expected|index must be an}} integer in range [-256, 255]
    2414. 

  2414. // CHECK-ERROR-NEXT:         ldr q0, [x11, #65536]
    2415. 

  2415. // CHECK-ERROR-NEXT:                 ^
    2416. 

  2416. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2417. 

  2417. // CHECK-ERROR-NEXT:         ldr x0, [sp, #32768]
    2418. 

  2418. // CHECK-ERROR-NEXT:                 ^
    2419. 

  2419. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2420. 

  2420. // CHECK-ERROR-NEXT:         ldr w0, [x4, #16384]
    2421. 

  2421. // CHECK-ERROR-NEXT:                 ^
    2422. 

  2422. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2423. 

  2423. // CHECK-ERROR-NEXT:         ldrh w2, [x21, #8192]
    2424. 

  2424. // CHECK-ERROR-NEXT:                  ^
    2425. 

  2425. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2426. 

  2426. // CHECK-ERROR-NEXT:         ldrb w3, [x12, #4096]
    2427. 

  2427. // CHECK-ERROR-NEXT:                  ^
    2428. 

  2428. 

  2429. //// Misaligned addresses
    2430. 

  2430.         ldr w0, [x0, #2]
    2431. 

  2431.         ldrsh w2, [x0, #123]
    2432. 

  2432.         str q0, [x0, #8]
    2433. 

  2433. // CHECK-ERROR-AARCH64: error: too few operands for instruction
    2434. 

  2434. // CHECK-ERROR-AARCH64-NEXT:         ldr w0, [x0, #2]
    2435. 

  2435. // CHECK-ERROR-AARCH64-NEXT:                 ^
    2436. 

  2436. // CHECK-ERROR-AARCH64-NEXT: error: too few operands for instruction
    2437. 

  2437. // CHECK-ERROR-AARCH64-NEXT:         ldrsh w2, [x0, #123]
    2438. 

  2438. // CHECK-ERROR-AARCH64-NEXT:                   ^
    2439. 

  2439. // CHECK-ERROR-AARCH64-NEXT: error: too few operands for instruction
    2440. 

  2440. // CHECK-ERROR-AARCH64-NEXT:         str q0, [x0, #8]
    2441. 

  2441. // CHECK-ERROR-AARCH64-NEXT:                 ^
    2442. 

  2442. 

  2443. //// 32-bit addresses
    2444. 

  2444.         ldr w0, [w20]
    2445. 

  2445.         ldrsh x3, [wsp]
    2446. 

  2446. // CHECK-ERROR: error: invalid operand for instruction
    2447. 

  2447. // CHECK-ERROR-NEXT:         ldr w0, [w20]
    2448. 

  2448. // CHECK-ERROR-NEXT:                  ^
    2449. 

  2449. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2450. 

  2450. // CHECK-ERROR-NEXT:         ldrsh x3, [wsp]
    2451. 

  2451. // CHECK-ERROR-NEXT:                    ^
    2452. 

  2452. 

  2453. //// Store things
    2454. 

  2454.         strb w0, [wsp]
    2455. 

  2455.         strh w31, [x23, #1]
    2456. 

  2456.         str x5, [x22, #12]
    2457. 

  2457.         str w7, [x12, #16384]
    2458. 

  2458. // CHECK-ERROR: error: invalid operand for instruction
    2459. 

  2459. // CHECK-ERROR-NEXT: strb w0, [wsp]
    2460. 

  2460. // CHECK-ERROR-NEXT:           ^
    2461. 

  2461. // CHECK-ERROR-AARCH64: error: invalid operand for instruction
    2462. 

  2462. // CHECK-ERROR-AARCH64-NEXT:         strh w31, [x23, #1]
    2463. 

  2463. // CHECK-ERROR-AARCH64-NEXT:              ^
    2464. 

  2464. // CHECK-ERROR-AARCH64-NEXT: error: too few operands for instruction
    2465. 

  2465. // CHECK-ERROR-AARCH64-NEXT:         str x5, [x22, #12]
    2466. 

  2466. // CHECK-ERROR-AARCH64-NEXT:                 ^
    2467. 

  2467. // CHECK-ERROR-NEXT: error: {{expected|index must be an}} integer in range [-256, 255]
    2468. 

  2468. // CHECK-ERROR-NEXT:         str w7, [x12, #16384]
    2469. 

  2469. // CHECK-ERROR-NEXT:                 ^
    2470. 

  2470. 

  2471. //// Bad PRFMs
    2472. 

  2472.         prfm #-1, [sp]
    2473. 

  2473.         prfm #32, [sp, #8]
    2474. 

  2474.         prfm pldl1strm, [w3, #8]
    2475. 

  2475.         prfm wibble, [sp]
    2476. 

  2476. // CHECK-ERROR-AARCH64: error: Invalid immediate for instruction
    2477. 

  2477. // CHECK-ERROR-ARM64: error: prefetch operand out of range, [0,31] expected
    2478. 

  2478. // CHECK-ERROR-NEXT:        prfm #-1, [sp]
    2479. 

  2479. // CHECK-ERROR-NEXT:             ^
    2480. 

  2480. // CHECK-ERROR-AARCH64-NEXT: error: Invalid immediate for instruction
    2481. 

  2481. // CHECK-ERROR-ARM64-NEXT: error: prefetch operand out of range, [0,31] expected
    2482. 

  2482. // CHECK-ERROR-NEXT:        prfm #32, [sp, #8]
    2483. 

  2483. // CHECK-ERROR-NEXT:             ^
    2484. 

  2484. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2485. 

  2485. // CHECK-ERROR-NEXT:        prfm pldl1strm, [w3, #8]
    2486. 

  2486. // CHECK-ERROR-NEXT:                         ^
    2487. 

  2487. // CHECK-ERROR-AARCH64-NEXT: error: operand specifier not recognised
    2488. 

  2488. // CHECK-ERROR-ARM64-NEXT: error: prefetch hint expected
    2489. 

  2489. // CHECK-ERROR-NEXT:        prfm wibble, [sp]
    2490. 

  2490. // CHECK-ERROR-NEXT:             ^
    2491. 

  2491. 

  2492. //------------------------------------------------------------------------------
    2493. 

  2493. // Load/store register (register offset)
    2494. 

  2494. //------------------------------------------------------------------------------
    2495. 

  2495.         ldr v0, [x0, xzr]
    2496. 

  2496.         ldr v0, [x0, x1, lsl #0]
    2497. 

  2497.         ldr v0, [x0, x1, lsl #0]
    2498. 

  2498.         str v0, [x0, xzr]
    2499. 

  2499.         str v0, [x0, x1, lsl #0]
    2500. 

  2500.         str v0, [x0, x1, lsl #0]
    2501. 

  2501. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2502. 

  2502. // CHECK-ERROR-NEXT:         ldr v0, [x0, xzr]
    2503. 

  2503. // CHECK-ERROR-NEXT:             ^
    2504. 

  2504. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2505. 

  2505. // CHECK-ERROR-NEXT:         ldr v0, [x0, x1, lsl #0]
    2506. 

  2506. // CHECK-ERROR-NEXT:             ^
    2507. 

  2507. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2508. 

  2508. // CHECK-ERROR-NEXT:         ldr v0, [x0, x1, lsl #0]
    2509. 

  2509. // CHECK-ERROR-NEXT:             ^
    2510. 

  2510. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2511. 

  2511. // CHECK-ERROR-NEXT:         str v0, [x0, xzr]
    2512. 

  2512. // CHECK-ERROR-NEXT:             ^
    2513. 

  2513. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2514. 

  2514. // CHECK-ERROR-NEXT:         str v0, [x0, x1, lsl #0]
    2515. 

  2515. // CHECK-ERROR-NEXT:             ^
    2516. 

  2516. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2517. 

  2517. // CHECK-ERROR-NEXT:         str v0, [x0, x1, lsl #0]
    2518. 

  2518. // CHECK-ERROR-NEXT:             ^
    2519. 

  2519. 

  2520.         ldr w3, [xzr, x3]
    2521. 

  2521.         ldr w4, [x0, x4, lsl]
    2522. 

  2522.         ldr w9, [x5, x5, uxtw]
    2523. 

  2523.         ldr w10, [x6, x9, sxtw #2]
    2524. 

  2524.         ldr w11, [x7, w2, lsl #2]
    2525. 

  2525.         ldr w12, [x8, w1, sxtx]
    2526. 

  2526. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2527. 

  2527. // CHECK-ERROR-NEXT:        ldr w3, [xzr, x3]
    2528. 

  2528. // CHECK-ERROR-NEXT:                 ^
    2529. 

  2529. // CHECK-ERROR-NEXT: error: expected #imm after shift specifier
    2530. 

  2530. // CHECK-ERROR-NEXT:         ldr w4, [x0, x4, lsl]
    2531. 

  2531. // CHECK-ERROR-NEXT:                             ^
    2532. 

  2532. // CHECK-ERROR-NEXT: error: expected 'lsl' or 'sxtx' with optional shift of #0 or #2
    2533. 

  2533. // CHECK-ERROR-NEXT:         ldr w9, [x5, x5, uxtw]
    2534. 

  2534. // CHECK-ERROR-NEXT:                          ^
    2535. 

  2535. // CHECK-ERROR-NEXT: error: expected 'lsl' or 'sxtx' with optional shift of #0 or #2
    2536. 

  2536. // CHECK-ERROR-NEXT:         ldr w10, [x6, x9, sxtw #2]
    2537. 

  2537. // CHECK-ERROR-NEXT:                           ^
    2538. 

  2538. // CHECK-ERROR-NEXT: error: expected 'uxtw' or 'sxtw' with optional shift of #0 or #2
    2539. 

  2539. // CHECK-ERROR-NEXT:         ldr w11, [x7, w2, lsl #2]
    2540. 

  2540. // CHECK-ERROR-NEXT:                           ^
    2541. 

  2541. // CHECK-ERROR-NEXT: error: expected 'uxtw' or 'sxtw' with optional shift of #0 or #2
    2542. 

  2542. // CHECK-ERROR-NEXT:         ldr w12, [x8, w1, sxtx]
    2543. 

  2543. // CHECK-ERROR-NEXT:                           ^
    2544. 

  2544. 

  2545.         ldrsb w9, [x4, x2, lsl #-1]
    2546. 

  2546.         strb w9, [x4, x2, lsl #1]
    2547. 

  2547. // CHECK-ERROR-NEXT: error: expected integer shift amount
    2548. 

  2548. // CHECK-ERROR-NEXT:         ldrsb w9, [x4, x2, lsl #-1]
    2549. 

  2549. // CHECK-ERROR-NEXT:                                 ^
    2550. 

  2550. // CHECK-ERROR-NEXT: error: expected 'lsl' or 'sxtx' with optional shift of #0
    2551. 

  2551. // CHECK-ERROR-NEXT:         strb w9, [x4, x2, lsl #1]
    2552. 

  2552. // CHECK-ERROR-NEXT:                  ^
    2553. 

  2553. 

  2554.         ldrsh w9, [x4, x2, lsl #-1]
    2555. 

  2555.         ldr h13, [x4, w2, uxtw #2]
    2556. 

  2556. // CHECK-ERROR-NEXT: error: expected integer shift amount
    2557. 

  2557. // CHECK-ERROR-NEXT:         ldrsh w9, [x4, x2, lsl #-1]
    2558. 

  2558. // CHECK-ERROR-NEXT:                                 ^
    2559. 

  2559. // CHECK-ERROR-NEXT: error: expected 'uxtw' or 'sxtw' with optional shift of #0 or #1
    2560. 

  2560. // CHECK-ERROR-NEXT:         ldr h13, [x4, w2, uxtw #2]
    2561. 

  2561. // CHECK-ERROR-NEXT:                           ^
    2562. 

  2562. 

  2563.         str w9, [x5, w9, sxtw #-1]
    2564. 

  2564.         str s3, [sp, w9, uxtw #1]
    2565. 

  2565.         ldrsw x9, [x15, x4, sxtx #3]
    2566. 

  2566. // CHECK-ERROR-NEXT: error: expected integer shift amount
    2567. 

  2567. // CHECK-ERROR-NEXT:         str w9, [x5, w9, sxtw #-1]
    2568. 

  2568. // CHECK-ERROR-NEXT:                                ^
    2569. 

  2569. // CHECK-ERROR-NEXT: error: expected 'uxtw' or 'sxtw' with optional shift of #0 or #2
    2570. 

  2570. // CHECK-ERROR-NEXT:         str s3, [sp, w9, uxtw #1]
    2571. 

  2571. // CHECK-ERROR-NEXT:                          ^
    2572. 

  2572. // CHECK-ERROR-NEXT: error: expected 'lsl' or 'sxtx' with optional shift of #0 or #2
    2573. 

  2573. // CHECK-ERROR-NEXT:         ldrsw x9, [x15, x4, sxtx #3]
    2574. 

  2574. // CHECK-ERROR-NEXT:                             ^
    2575. 

  2575. 

  2576.         str xzr, [x5, x9, sxtx #-1]
    2577. 

  2577.         prfm pldl3keep, [sp, x20, lsl #2]
    2578. 

  2578.         ldr d3, [x20, wzr, uxtw #4]
    2579. 

  2579. // CHECK-ERROR-NEXT: error: expected integer shift amount
    2580. 

  2580. // CHECK-ERROR-NEXT:         str xzr, [x5, x9, sxtx #-1]
    2581. 

  2581. // CHECK-ERROR-NEXT:                                 ^
    2582. 

  2582. // CHECK-ERROR-NEXT: error: expected 'lsl' or 'sxtx' with optional shift of #0 or #3
    2583. 

  2583. // CHECK-ERROR-NEXT:         prfm pldl3keep, [sp, x20, lsl #2]
    2584. 

  2584. // CHECK-ERROR-NEXT:                         ^
    2585. 

  2585. // CHECK-ERROR-NEXT: error: expected 'uxtw' or 'sxtw' with optional shift of #0 or #3
    2586. 

  2586. // CHECK-ERROR-NEXT:         ldr d3, [x20, wzr, uxtw #4]
    2587. 

  2587. // CHECK-ERROR-NEXT:                 ^
    2588. 

  2588. 

  2589.         ldr q5, [sp, x2, lsl #-1]
    2590. 

  2590.         ldr q10, [x20, w4, uxtw #2]
    2591. 

  2591.         str q21, [x20, w4, uxtw #5]
    2592. 

  2592. // CHECK-ERROR-NEXT: error: expected integer shift amount
    2593. 

  2593. // CHECK-ERROR-NEXT:         ldr q5, [sp, x2, lsl #-1]
    2594. 

  2594. // CHECK-ERROR-NEXT:                               ^
    2595. 

  2595. // CHECK-ERROR-AARCH64-NEXT: error: expected 'lsl' or 'sxtw' with optional shift of #0 or #4
    2596. 

  2596. // CHECK-ERROR-ARM64-NEXT: error: expected 'uxtw' or 'sxtw' with optional shift of #0 or #4
    2597. 

  2597. // CHECK-ERROR-NEXT:         ldr q10, [x20, w4, uxtw #2]
    2598. 

  2598. // CHECK-ERROR-NEXT:                  ^
    2599. 

  2599. // CHECK-ERROR-AARCH64-NEXT: error: expected 'lsl' or 'sxtw' with optional shift of #0 or #4
    2600. 

  2600. // CHECK-ERROR-ARM64-NEXT: error: expected 'uxtw' or 'sxtw' with optional shift of #0 or #4
    2601. 

  2601. // CHECK-ERROR-NEXT:         str q21, [x20, w4, uxtw #5]
    2602. 

  2602. // CHECK-ERROR-NEXT:                  ^
    2603. 

  2603. 

  2604. //------------------------------------------------------------------------------
    2605. 

  2605. // Load/store register pair (offset)
    2606. 

  2606. //------------------------------------------------------------------------------
    2607. 

  2607.         ldp v0, v1, [x0, #0]
    2608. 

  2608.         stp v0, v1, [x0, #0]
    2609. 

  2609. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2610. 

  2610. // CHECK-ERROR-NEXT:         ldp v0, v1, [x0, #0]
    2611. 

  2611. // CHECK-ERROR-NEXT:             ^
    2612. 

  2612. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2613. 

  2613. // CHECK-ERROR-NEXT:         stp v0, v1, [x0, #0]
    2614. 

  2614. // CHECK-ERROR-NEXT:             ^
    2615. 

  2615. 

  2616.         ldp w3, w2, [x4, #1]
    2617. 

  2617.         stp w1, w2, [x3, #253]
    2618. 

  2618.         stp w9, w10, [x5, #256]
    2619. 

  2619.         ldp w11, w12, [x9, #-260]
    2620. 

  2620.         stp wsp, w9, [sp]
    2621. 

  2621. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2622. 

  2622. // CHECK-ERROR-NEXT:         ldp w3, w2, [x4, #1]
    2623. 

  2623. // CHECK-ERROR-NEXT:                          ^
    2624. 

  2624. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2625. 

  2625. // CHECK-ERROR-NEXT:         stp w1, w2, [x3, #253]
    2626. 

  2626. // CHECK-ERROR-NEXT:                     ^
    2627. 

  2627. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2628. 

  2628. // CHECK-ERROR-NEXT:         stp w9, w10, [x5, #256]
    2629. 

  2629. // CHECK-ERROR-NEXT:                      ^
    2630. 

  2630. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2631. 

  2631. // CHECK-ERROR-NEXT:         ldp w11, w12, [x9, #-260]
    2632. 

  2632. // CHECK-ERROR-NEXT:                       ^
    2633. 

  2633. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2634. 

  2634. // CHECK-ERROR-NEXT:         stp wsp, w9, [sp]
    2635. 

  2635. // CHECK-ERROR-NEXT:             ^
    2636. 

  2636. 

  2637.         ldpsw x9, x2, [sp, #2]
    2638. 

  2638.         ldpsw x1, x2, [x10, #256]
    2639. 

  2639.         ldpsw x3, x4, [x11, #-260]
    2640. 

  2640. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2641. 

  2641. // CHECK-ERROR-NEXT:         ldpsw x9, x2, [sp, #2]
    2642. 

  2642. // CHECK-ERROR-NEXT:                       ^
    2643. 

  2643. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2644. 

  2644. // CHECK-ERROR-NEXT:         ldpsw x1, x2, [x10, #256]
    2645. 

  2645. // CHECK-ERROR-NEXT:                       ^
    2646. 

  2646. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2647. 

  2647. // CHECK-ERROR-NEXT:         ldpsw x3, x4, [x11, #-260]
    2648. 

  2648. // CHECK-ERROR-NEXT:                       ^
    2649. 

  2649. 

  2650.         ldp x2, x5, [sp, #4]
    2651. 

  2651.         ldp x5, x6, [x9, #512]
    2652. 

  2652.         stp x7, x8, [x10, #-520]
    2653. 

  2653. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2654. 

  2654. // CHECK-ERROR-NEXT:         ldp x2, x5, [sp, #4]
    2655. 

  2655. // CHECK-ERROR-NEXT:                     ^
    2656. 

  2656. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2657. 

  2657. // CHECK-ERROR-NEXT:         ldp x5, x6, [x9, #512]
    2658. 

  2658. // CHECK-ERROR-NEXT:                     ^
    2659. 

  2659. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2660. 

  2660. // CHECK-ERROR-NEXT:         stp x7, x8, [x10, #-520]
    2661. 

  2661. // CHECK-ERROR-NEXT:                     ^
    2662. 

  2662. 

  2663.         ldp sp, x3, [x10]
    2664. 

  2664.         stp x3, sp, [x9]
    2665. 

  2665. // CHECK-ERROR: error: invalid operand for instruction
    2666. 

  2666. // CHECK-ERROR-NEXT:         ldp sp, x3, [x10]
    2667. 

  2667. // CHECK-ERROR-NEXT:             ^
    2668. 

  2668. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2669. 

  2669. // CHECK-ERROR-NEXT:         stp x3, sp, [x9]
    2670. 

  2670. // CHECK-ERROR-NEXT:                 ^
    2671. 

  2671. 

  2672.         stp s3, s5, [sp, #-2]
    2673. 

  2673.         ldp s6, s26, [x4, #-260]
    2674. 

  2674.         stp s13, s19, [x5, #256]
    2675. 

  2675. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2676. 

  2676. // CHECK-ERROR-NEXT:         stp s3, s5, [sp, #-2]
    2677. 

  2677. // CHECK-ERROR-NEXT:                     ^
    2678. 

  2678. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2679. 

  2679. // CHECK-ERROR-NEXT:         ldp s6, s26, [x4, #-260]
    2680. 

  2680. // CHECK-ERROR-NEXT:                      ^
    2681. 

  2681. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2682. 

  2682. // CHECK-ERROR-NEXT:         stp s13, s19, [x5, #256]
    2683. 

  2683. // CHECK-ERROR-NEXT:                       ^
    2684. 

  2684. 

  2685.         ldp d3, d4, [xzr]
    2686. 

  2686.         ldp d5, d6, [x0, #512]
    2687. 

  2687.         stp d7, d8, [x0, #-520]
    2688. 

  2688. // CHECK-ERROR: error: invalid operand for instruction
    2689. 

  2689. // CHECK-ERROR-NEXT:         ldp d3, d4, [xzr]
    2690. 

  2690. // CHECK-ERROR-NEXT:                      ^
    2691. 

  2691. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2692. 

  2692. // CHECK-ERROR-NEXT:         ldp d5, d6, [x0, #512]
    2693. 

  2693. // CHECK-ERROR-NEXT:                     ^
    2694. 

  2694. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2695. 

  2695. // CHECK-ERROR-NEXT:         stp d7, d8, [x0, #-520]
    2696. 

  2696. // CHECK-ERROR-NEXT:                     ^
    2697. 

  2697. 

  2698.         ldp d3, q2, [sp]
    2699. 

  2699.         ldp q3, q5, [sp, #8]
    2700. 

  2700.         stp q20, q25, [x5, #1024]
    2701. 

  2701.         ldp q30, q15, [x23, #-1040]
    2702. 

  2702. // CHECK-ERROR: error: invalid operand for instruction
    2703. 

  2703. // CHECK-ERROR-NEXT:         ldp d3, q2, [sp]
    2704. 

  2704. // CHECK-ERROR-NEXT:                 ^
    2705. 

  2705. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2706. 

  2706. // CHECK-ERROR-NEXT:         ldp q3, q5, [sp, #8]
    2707. 

  2707. // CHECK-ERROR-NEXT:                     ^
    2708. 

  2708. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2709. 

  2709. // CHECK-ERROR-NEXT:         stp q20, q25, [x5, #1024]
    2710. 

  2710. // CHECK-ERROR-NEXT:                       ^
    2711. 

  2711. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2712. 

  2712. // CHECK-ERROR-NEXT:         ldp q30, q15, [x23, #-1040]
    2713. 

  2713. // CHECK-ERROR-NEXT:                       ^
    2714. 

  2714. 

  2715. //------------------------------------------------------------------------------
    2716. 

  2716. // Load/store register pair (post-indexed)
    2717. 

  2717. //------------------------------------------------------------------------------
    2718. 

  2718.         ldp v0, v1, [x0], #0
    2719. 

  2719.         stp v0, v1, [x0], #0
    2720. 

  2720. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2721. 

  2721. // CHECK-ERROR-NEXT:         ldp v0, v1, [x0], #0
    2722. 

  2722. // CHECK-ERROR-NEXT:             ^
    2723. 

  2723. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2724. 

  2724. // CHECK-ERROR-NEXT:         stp v0, v1, [x0], #0
    2725. 

  2725. // CHECK-ERROR-NEXT:             ^
    2726. 

  2726. 

  2727.         ldp w3, w2, [x4], #1
    2728. 

  2728.         stp w1, w2, [x3], #253
    2729. 

  2729.         stp w9, w10, [x5], #256
    2730. 

  2730.         ldp w11, w12, [x9], #-260
    2731. 

  2731.         stp wsp, w9, [sp], #0
    2732. 

  2732. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2733. 

  2733. // CHECK-ERROR-NEXT:         ldp w3, w2, [x4], #1
    2734. 

  2734. // CHECK-ERROR-NEXT:                           ^
    2735. 

  2735. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2736. 

  2736. // CHECK-ERROR-NEXT:         stp w1, w2, [x3], #253
    2737. 

  2737. // CHECK-ERROR-NEXT:                     ^
    2738. 

  2738. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2739. 

  2739. // CHECK-ERROR-NEXT:         stp w9, w10, [x5], #256
    2740. 

  2740. // CHECK-ERROR-NEXT:                      ^
    2741. 

  2741. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2742. 

  2742. // CHECK-ERROR-NEXT:         ldp w11, w12, [x9], #-260
    2743. 

  2743. // CHECK-ERROR-NEXT:                       ^
    2744. 

  2744. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2745. 

  2745. // CHECK-ERROR-NEXT:         stp wsp, w9, [sp], #0
    2746. 

  2746. // CHECK-ERROR-NEXT:             ^
    2747. 

  2747. 

  2748.         ldpsw x9, x2, [sp], #2
    2749. 

  2749.         ldpsw x1, x2, [x10], #256
    2750. 

  2750.         ldpsw x3, x4, [x11], #-260
    2751. 

  2751. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2752. 

  2752. // CHECK-ERROR-NEXT:         ldpsw x9, x2, [sp], #2
    2753. 

  2753. // CHECK-ERROR-NEXT:                       ^
    2754. 

  2754. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2755. 

  2755. // CHECK-ERROR-NEXT:         ldpsw x1, x2, [x10], #256
    2756. 

  2756. // CHECK-ERROR-NEXT:                       ^
    2757. 

  2757. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2758. 

  2758. // CHECK-ERROR-NEXT:         ldpsw x3, x4, [x11], #-260
    2759. 

  2759. // CHECK-ERROR-NEXT:                       ^
    2760. 

  2760. 

  2761.         ldp x2, x5, [sp], #4
    2762. 

  2762.         ldp x5, x6, [x9], #512
    2763. 

  2763.         stp x7, x8, [x10], #-520
    2764. 

  2764. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2765. 

  2765. // CHECK-ERROR-NEXT:         ldp x2, x5, [sp], #4
    2766. 

  2766. // CHECK-ERROR-NEXT:                           ^
    2767. 

  2767. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2768. 

  2768. // CHECK-ERROR-NEXT:         ldp x5, x6, [x9], #512
    2769. 

  2769. // CHECK-ERROR-NEXT:                           ^
    2770. 

  2770. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2771. 

  2771. // CHECK-ERROR-NEXT:         stp x7, x8, [x10], #-520
    2772. 

  2772. // CHECK-ERROR-NEXT:                            ^
    2773. 

  2773. 

  2774.         ldp sp, x3, [x10], #0
    2775. 

  2775.         stp x3, sp, [x9], #0
    2776. 

  2776. // CHECK-ERROR: error: invalid operand for instruction
    2777. 

  2777. // CHECK-ERROR-NEXT:         ldp sp, x3, [x10], #0
    2778. 

  2778. // CHECK-ERROR-NEXT:             ^
    2779. 

  2779. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2780. 

  2780. // CHECK-ERROR-NEXT:         stp x3, sp, [x9], #0
    2781. 

  2781. // CHECK-ERROR-NEXT:                 ^
    2782. 

  2782. 

  2783.         stp s3, s5, [sp], #-2
    2784. 

  2784.         ldp s6, s26, [x4], #-260
    2785. 

  2785.         stp s13, s19, [x5], #256
    2786. 

  2786. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2787. 

  2787. // CHECK-ERROR-NEXT:         stp s3, s5, [sp], #-2
    2788. 

  2788. // CHECK-ERROR-NEXT:                     ^
    2789. 

  2789. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2790. 

  2790. // CHECK-ERROR-NEXT:         ldp s6, s26, [x4], #-260
    2791. 

  2791. // CHECK-ERROR-NEXT:                      ^
    2792. 

  2792. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2793. 

  2793. // CHECK-ERROR-NEXT:         stp s13, s19, [x5], #256
    2794. 

  2794. // CHECK-ERROR-NEXT:                       ^
    2795. 

  2795. 

  2796.         ldp d3, d4, [xzr], #0
    2797. 

  2797.         ldp d5, d6, [x0], #512
    2798. 

  2798.         stp d7, d8, [x0], #-520
    2799. 

  2799. // CHECK-ERROR: error: invalid operand for instruction
    2800. 

  2800. // CHECK-ERROR-NEXT:         ldp d3, d4, [xzr], #0
    2801. 

  2801. // CHECK-ERROR-NEXT:                      ^
    2802. 

  2802. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2803. 

  2803. // CHECK-ERROR-NEXT:         ldp d5, d6, [x0], #512
    2804. 

  2804. // CHECK-ERROR-NEXT:                     ^
    2805. 

  2805. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2806. 

  2806. // CHECK-ERROR-NEXT:         stp d7, d8, [x0], #-520
    2807. 

  2807. // CHECK-ERROR-NEXT:                     ^
    2808. 

  2808. 

  2809.         ldp d3, q2, [sp], #0
    2810. 

  2810.         ldp q3, q5, [sp], #8
    2811. 

  2811.         stp q20, q25, [x5], #1024
    2812. 

  2812.         ldp q30, q15, [x23], #-1040
    2813. 

  2813. // CHECK-ERROR: error: invalid operand for instruction
    2814. 

  2814. // CHECK-ERROR-NEXT:         ldp d3, q2, [sp], #0
    2815. 

  2815. // CHECK-ERROR-NEXT:                 ^
    2816. 

  2816. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2817. 

  2817. // CHECK-ERROR-NEXT:         ldp q3, q5, [sp], #8
    2818. 

  2818. // CHECK-ERROR-NEXT:                     ^
    2819. 

  2819. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2820. 

  2820. // CHECK-ERROR-NEXT:         stp q20, q25, [x5], #1024
    2821. 

  2821. // CHECK-ERROR-NEXT:                       ^
    2822. 

  2822. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2823. 

  2823. // CHECK-ERROR-NEXT:         ldp q30, q15, [x23], #-1040
    2824. 

  2824. // CHECK-ERROR-NEXT:                       ^
    2825. 

  2825. 

  2826. //------------------------------------------------------------------------------
    2827. 

  2827. // Load/store register pair (pre-indexed)
    2828. 

  2828. //------------------------------------------------------------------------------
    2829. 

  2829.         ldp v0, v1, [x0, #0]!
    2830. 

  2830.         stp v0, v1, [x0, #0]!
    2831. 

  2831. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2832. 

  2832. // CHECK-ERROR-NEXT:         ldp v0, v1, [x0, #0]!
    2833. 

  2833. // CHECK-ERROR-NEXT:             ^
    2834. 

  2834. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2835. 

  2835. // CHECK-ERROR-NEXT:         stp v0, v1, [x0, #0]!
    2836. 

  2836. // CHECK-ERROR-NEXT:             ^
    2837. 

  2837. 

  2838.         ldp w3, w2, [x4, #1]!
    2839. 

  2839.         stp w1, w2, [x3, #253]!
    2840. 

  2840.         stp w9, w10, [x5, #256]!
    2841. 

  2841.         ldp w11, w12, [x9, #-260]!
    2842. 

  2842.         stp wsp, w9, [sp, #0]!
    2843. 

  2843. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2844. 

  2844. // CHECK-ERROR-NEXT:         ldp w3, w2, [x4, #1]!
    2845. 

  2845. // CHECK-ERROR-NEXT:                           ^
    2846. 

  2846. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2847. 

  2847. // CHECK-ERROR-NEXT:         stp w1, w2, [x3, #253]!
    2848. 

  2848. // CHECK-ERROR-NEXT:                     ^
    2849. 

  2849. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2850. 

  2850. // CHECK-ERROR-NEXT:         stp w9, w10, [x5, #256]!
    2851. 

  2851. // CHECK-ERROR-NEXT:                      ^
    2852. 

  2852. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2853. 

  2853. // CHECK-ERROR-NEXT:         ldp w11, w12, [x9, #-260]!
    2854. 

  2854. // CHECK-ERROR-NEXT:                       ^
    2855. 

  2855. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2856. 

  2856. // CHECK-ERROR-NEXT:         stp wsp, w9, [sp, #0]!
    2857. 

  2857. // CHECK-ERROR-NEXT:             ^
    2858. 

  2858. 

  2859.         ldpsw x9, x2, [sp, #2]!
    2860. 

  2860.         ldpsw x1, x2, [x10, #256]!
    2861. 

  2861.         ldpsw x3, x4, [x11, #-260]!
    2862. 

  2862. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2863. 

  2863. // CHECK-ERROR-NEXT:         ldpsw x9, x2, [sp, #2]!
    2864. 

  2864. // CHECK-ERROR-NEXT:                       ^
    2865. 

  2865. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2866. 

  2866. // CHECK-ERROR-NEXT:         ldpsw x1, x2, [x10, #256]!
    2867. 

  2867. // CHECK-ERROR-NEXT:                       ^
    2868. 

  2868. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2869. 

  2869. // CHECK-ERROR-NEXT:         ldpsw x3, x4, [x11, #-260]!
    2870. 

  2870. // CHECK-ERROR-NEXT:                       ^
    2871. 

  2871. 

  2872.         ldp x2, x5, [sp, #4]!
    2873. 

  2873.         ldp x5, x6, [x9, #512]!
    2874. 

  2874.         stp x7, x8, [x10, #-520]!
    2875. 

  2875. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2876. 

  2876. // CHECK-ERROR-NEXT:         ldp x2, x5, [sp, #4]!
    2877. 

  2877. // CHECK-ERROR-NEXT:                     ^
    2878. 

  2878. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2879. 

  2879. // CHECK-ERROR-NEXT:         ldp x5, x6, [x9, #512]!
    2880. 

  2880. // CHECK-ERROR-NEXT:                     ^
    2881. 

  2881. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2882. 

  2882. // CHECK-ERROR-NEXT:         stp x7, x8, [x10, #-520]!
    2883. 

  2883. // CHECK-ERROR-NEXT:                     ^
    2884. 

  2884. 

  2885.         ldp sp, x3, [x10, #0]!
    2886. 

  2886.         stp x3, sp, [x9, #0]!
    2887. 

  2887. // CHECK-ERROR: error: invalid operand for instruction
    2888. 

  2888. // CHECK-ERROR-NEXT:         ldp sp, x3, [x10, #0]!
    2889. 

  2889. // CHECK-ERROR-NEXT:             ^
    2890. 

  2890. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2891. 

  2891. // CHECK-ERROR-NEXT:         stp x3, sp, [x9, #0]!
    2892. 

  2892. // CHECK-ERROR-NEXT:                 ^
    2893. 

  2893. 

  2894.         stp s3, s5, [sp, #-2]!
    2895. 

  2895.         ldp s6, s26, [x4, #-260]!
    2896. 

  2896.         stp s13, s19, [x5, #256]!
    2897. 

  2897. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2898. 

  2898. // CHECK-ERROR-NEXT:         stp s3, s5, [sp, #-2]!
    2899. 

  2899. // CHECK-ERROR-NEXT:                     ^
    2900. 

  2900. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2901. 

  2901. // CHECK-ERROR-NEXT:         ldp s6, s26, [x4, #-260]!
    2902. 

  2902. // CHECK-ERROR-NEXT:                      ^
    2903. 

  2903. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2904. 

  2904. // CHECK-ERROR-NEXT:         stp s13, s19, [x5, #256]!
    2905. 

  2905. // CHECK-ERROR-NEXT:                       ^
    2906. 

  2906. 

  2907.         ldp d3, d4, [xzr, #0]!
    2908. 

  2908.         ldp d5, d6, [x0, #512]!
    2909. 

  2909.         stp d7, d8, [x0, #-520]!
    2910. 

  2910. // CHECK-ERROR: error: invalid operand for instruction
    2911. 

  2911. // CHECK-ERROR-NEXT:         ldp d3, d4, [xzr, #0]!
    2912. 

  2912. // CHECK-ERROR-NEXT:                      ^
    2913. 

  2913. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2914. 

  2914. // CHECK-ERROR-NEXT:         ldp d5, d6, [x0, #512]!
    2915. 

  2915. // CHECK-ERROR-NEXT:                     ^
    2916. 

  2916. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2917. 

  2917. // CHECK-ERROR-NEXT:         stp d7, d8, [x0, #-520]!
    2918. 

  2918. // CHECK-ERROR-NEXT:                     ^
    2919. 

  2919. 

  2920.         ldp d3, q2, [sp, #0]!
    2921. 

  2921.         ldp q3, q5, [sp, #8]!
    2922. 

  2922.         stp q20, q25, [x5, #1024]!
    2923. 

  2923.         ldp q30, q15, [x23, #-1040]!
    2924. 

  2924. // CHECK-ERROR: error: invalid operand for instruction
    2925. 

  2925. // CHECK-ERROR-NEXT:         ldp d3, q2, [sp, #0]!
    2926. 

  2926. // CHECK-ERROR-NEXT:                 ^
    2927. 

  2927. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2928. 

  2928. // CHECK-ERROR-NEXT:         ldp q3, q5, [sp, #8]!
    2929. 

  2929. // CHECK-ERROR-NEXT:                     ^
    2930. 

  2930. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2931. 

  2931. // CHECK-ERROR-NEXT:         stp q20, q25, [x5, #1024]!
    2932. 

  2932. // CHECK-ERROR-NEXT:                       ^
    2933. 

  2933. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    2934. 

  2934. // CHECK-ERROR-NEXT:         ldp q30, q15, [x23, #-1040]!
    2935. 

  2935. // CHECK-ERROR-NEXT:                       ^
    2936. 

  2936. 

  2937. //------------------------------------------------------------------------------
    2938. 

  2938. // Load/store register pair (offset)
    2939. 

  2939. //------------------------------------------------------------------------------
    2940. 

  2940.         ldnp v0, v1, [x0, #0]
    2941. 

  2941.         stnp v0, v1, [x0, #0]
    2942. 

  2942. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2943. 

  2943. // CHECK-ERROR-NEXT:         ldnp v0, v1, [x0, #0]
    2944. 

  2944. // CHECK-ERROR-NEXT:              ^
    2945. 

  2945. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2946. 

  2946. // CHECK-ERROR-NEXT:         stnp v0, v1, [x0, #0]
    2947. 

  2947. // CHECK-ERROR-NEXT:              ^
    2948. 

  2948. 

  2949.         ldnp w3, w2, [x4, #1]
    2950. 

  2950.         stnp w1, w2, [x3, #253]
    2951. 

  2951.         stnp w9, w10, [x5, #256]
    2952. 

  2952.         ldnp w11, w12, [x9, #-260]
    2953. 

  2953.         stnp wsp, w9, [sp]
    2954. 

  2954. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2955. 

  2955. // CHECK-ERROR-NEXT:         ldnp w3, w2, [x4, #1]
    2956. 

  2956. // CHECK-ERROR-NEXT:                           ^
    2957. 

  2957. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2958. 

  2958. // CHECK-ERROR-NEXT:         stnp w1, w2, [x3, #253]
    2959. 

  2959. // CHECK-ERROR-NEXT:                           ^
    2960. 

  2960. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2961. 

  2961. // CHECK-ERROR-NEXT:         stnp w9, w10, [x5, #256]
    2962. 

  2962. // CHECK-ERROR-NEXT:                            ^
    2963. 

  2963. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2964. 

  2964. // CHECK-ERROR-NEXT:         ldnp w11, w12, [x9, #-260]
    2965. 

  2965. // CHECK-ERROR-NEXT:                             ^
    2966. 

  2966. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2967. 

  2967. // CHECK-ERROR-NEXT:         stnp wsp, w9, [sp]
    2968. 

  2968. // CHECK-ERROR-NEXT:              ^
    2969. 

  2969. 

  2970.         ldnp x2, x5, [sp, #4]
    2971. 

  2971.         ldnp x5, x6, [x9, #512]
    2972. 

  2972.         stnp x7, x8, [x10, #-520]
    2973. 

  2973. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2974. 

  2974. // CHECK-ERROR-NEXT:         ldnp x2, x5, [sp, #4]
    2975. 

  2975. // CHECK-ERROR-NEXT:                           ^
    2976. 

  2976. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2977. 

  2977. // CHECK-ERROR-NEXT:         ldnp x5, x6, [x9, #512]
    2978. 

  2978. // CHECK-ERROR-NEXT:                           ^
    2979. 

  2979. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    2980. 

  2980. // CHECK-ERROR-NEXT:         stnp x7, x8, [x10, #-520]
    2981. 

  2981. // CHECK-ERROR-NEXT:                            ^
    2982. 

  2982. 

  2983.         ldnp sp, x3, [x10]
    2984. 

  2984.         stnp x3, sp, [x9]
    2985. 

  2985. // CHECK-ERROR: error: invalid operand for instruction
    2986. 

  2986. // CHECK-ERROR-NEXT:         ldnp sp, x3, [x10]
    2987. 

  2987. // CHECK-ERROR-NEXT:             ^
    2988. 

  2988. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    2989. 

  2989. // CHECK-ERROR-NEXT:         stnp x3, sp, [x9]
    2990. 

  2990. // CHECK-ERROR-NEXT:                 ^
    2991. 

  2991. 

  2992.         stnp s3, s5, [sp, #-2]
    2993. 

  2993.         ldnp s6, s26, [x4, #-260]
    2994. 

  2994.         stnp s13, s19, [x5, #256]
    2995. 

  2995. // CHECK-ERROR: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2996. 

  2996. // CHECK-ERROR-NEXT:         stnp s3, s5, [sp, #-2]
    2997. 

  2997. // CHECK-ERROR-NEXT:                     ^
    2998. 

  2998. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    2999. 

  2999. // CHECK-ERROR-NEXT:         ldnp s6, s26, [x4, #-260]
    3000. 

  3000. // CHECK-ERROR-NEXT:                      ^
    3001. 

  3001. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 4 in range [-256, 252]
    3002. 

  3002. // CHECK-ERROR-NEXT:         stnp s13, s19, [x5, #256]
    3003. 

  3003. // CHECK-ERROR-NEXT:                       ^
    3004. 

  3004. 

  3005.         ldnp d3, d4, [xzr]
    3006. 

  3006.         ldnp d5, d6, [x0, #512]
    3007. 

  3007.         stnp d7, d8, [x0, #-520]
    3008. 

  3008. // CHECK-ERROR: error: invalid operand for instruction
    3009. 

  3009. // CHECK-ERROR-NEXT:         ldnp d3, d4, [xzr]
    3010. 

  3010. // CHECK-ERROR-NEXT:                      ^
    3011. 

  3011. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    3012. 

  3012. // CHECK-ERROR-NEXT:         ldnp d5, d6, [x0, #512]
    3013. 

  3013. // CHECK-ERROR-NEXT:                     ^
    3014. 

  3014. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 8 in range [-512, 504]
    3015. 

  3015. // CHECK-ERROR-NEXT:         stnp d7, d8, [x0, #-520]
    3016. 

  3016. // CHECK-ERROR-NEXT:                     ^
    3017. 

  3017. 

  3018.         ldnp d3, q2, [sp]
    3019. 

  3019.         ldnp q3, q5, [sp, #8]
    3020. 

  3020.         stnp q20, q25, [x5, #1024]
    3021. 

  3021.         ldnp q30, q15, [x23, #-1040]
    3022. 

  3022. // CHECK-ERROR: error: invalid operand for instruction
    3023. 

  3023. // CHECK-ERROR-NEXT:         ldnp d3, q2, [sp]
    3024. 

  3024. // CHECK-ERROR-NEXT:                 ^
    3025. 

  3025. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    3026. 

  3026. // CHECK-ERROR-NEXT:         ldnp q3, q5, [sp, #8]
    3027. 

  3027. // CHECK-ERROR-NEXT:                     ^
    3028. 

  3028. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    3029. 

  3029. // CHECK-ERROR-NEXT:         stnp q20, q25, [x5, #1024]
    3030. 

  3030. // CHECK-ERROR-NEXT:                       ^
    3031. 

  3031. // CHECK-ERROR-NEXT: error: {{expected integer|index must be a}} multiple of 16 in range [-1024, 1008]
    3032. 

  3032. // CHECK-ERROR-NEXT:         ldnp q30, q15, [x23, #-1040]
    3033. 

  3033. // CHECK-ERROR-NEXT:                       ^
    3034. 

  3034. 

  3035. //------------------------------------------------------------------------------
    3036. 

  3036. // Logical (shifted register)
    3037. 

  3037. //------------------------------------------------------------------------------
    3038. 

  3038.         orr w0, w1, #0xffffffff
    3039. 

  3039.         and x3, x5, #0xffffffffffffffff
    3040. 

  3040. // CHECK-ERROR: error: expected compatible register or logical immediate
    3041. 

  3041. // CHECK-ERROR-NEXT:         orr w0, w1, #0xffffffff
    3042. 

  3042. // CHECK-ERROR-NEXT:                     ^
    3043. 

  3043. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    3044. 

  3044. // CHECK-ERROR-NEXT:         and x3, x5, #0xffffffffffffffff
    3045. 

  3045. // CHECK-ERROR-NEXT:                     ^
    3046. 

  3046. 

  3047.         ands w3, w9, #0x0
    3048. 

  3048.         eor x2, x0, #0x0
    3049. 

  3049. // CHECK-ERROR: error: expected compatible register or logical immediate
    3050. 

  3050. // CHECK-ERROR-NEXT:         ands w3, w9, #0x0
    3051. 

  3051. // CHECK-ERROR-NEXT:                      ^
    3052. 

  3052. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    3053. 

  3053. // CHECK-ERROR-NEXT:         eor x2, x0, #0x0
    3054. 

  3054. // CHECK-ERROR-NEXT:                     ^
    3055. 

  3055. 

  3056.         eor w3, w5, #0x83
    3057. 

  3057.         eor x9, x20, #0x1234
    3058. 

  3058. // CHECK-ERROR: error: expected compatible register or logical immediate
    3059. 

  3059. // CHECK-ERROR-NEXT:         eor w3, w5, #0x83
    3060. 

  3060. // CHECK-ERROR-NEXT:                     ^
    3061. 

  3061. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    3062. 

  3062. // CHECK-ERROR-NEXT:         eor x9, x20, #0x1234
    3063. 

  3063. // CHECK-ERROR-NEXT:                      ^
    3064. 

  3064. 

  3065.         and wzr, w4, 0xffff0000
    3066. 

  3066.         eor xzr, x9, #0xffff0000ffff0000
    3067. 

  3067. // CHECK-ERROR: error: invalid operand for instruction
    3068. 

  3068. // CHECK-ERROR-NEXT:         and wzr, w4, 0xffff0000
    3069. 

  3069. // CHECK-ERROR-NEXT:                      ^
    3070. 

  3070. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    3071. 

  3071. // CHECK-ERROR-NEXT:         eor xzr, x9, #0xffff0000ffff0000
    3072. 

  3072. // CHECK-ERROR-NEXT:                      ^
    3073. 

  3073. 

  3074.         orr w3, wsp, #0xf0f0f0f0
    3075. 

  3075.         ands x3, sp, #0xaaaaaaaaaaaaaaaa
    3076. 

  3076. // CHECK-ERROR: error: invalid operand for instruction
    3077. 

  3077. // CHECK-ERROR-NEXT:         orr w3, wsp, #0xf0f0f0f0
    3078. 

  3078. // CHECK-ERROR-NEXT:                 ^
    3079. 

  3079. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    3080. 

  3080. // CHECK-ERROR-NEXT:         ands x3, sp, #0xaaaaaaaaaaaaaaaa
    3081. 

  3081. // CHECK-ERROR-NEXT:                  ^
    3082. 

  3082. 

  3083.         tst sp, #0xe0e0e0e0e0e0e0e0
    3084. 

  3084. // CHECK-ERROR: error: invalid operand for instruction
    3085. 

  3085. // CHECK-ERROR-NEXT:         tst sp, #0xe0e0e0e0e0e0e0e0
    3086. 

  3086. // CHECK-ERROR-NEXT:             ^
    3087. 

  3087. 

  3088.         // movi has been removed from the specification. Make sure it's really gone.
    3089. 

  3089.         movi wzr, #0x44444444
    3090. 

  3090.         movi w3, #0xffff
    3091. 

  3091.         movi x9, #0x0000ffff00000000
    3092. 

  3092. // CHECK-ERROR: error: invalid operand for instruction
    3093. 

  3093. // CHECK-ERROR-NEXT:         movi wzr, #0x44444444
    3094. 

  3094. // CHECK-ERROR-NEXT:         ^
    3095. 

  3095. // CHECK-ERROR: error: invalid operand for instruction
    3096. 

  3096. // CHECK-ERROR-NEXT:         movi w3, #0xffff
    3097. 

  3097. // CHECK-ERROR-NEXT:         ^
    3098. 

  3098. // CHECK-ERROR: error: invalid operand for instruction
    3099. 

  3099. // CHECK-ERROR-NEXT:         movi x9, #0x0000ffff00000000
    3100. 

  3100. // CHECK-ERROR-NEXT:         ^
    3101. 

  3101. 

  3102. //------------------------------------------------------------------------------
    3103. 

  3103. // Logical (shifted register)
    3104. 

  3104. //------------------------------------------------------------------------------
    3105. 

  3105. 

  3106.         //// Out of range shifts
    3107. 

  3107.         and w2, w24, w6, lsl #-1
    3108. 

  3108.         and w4, w6, w12, lsl #32
    3109. 

  3109.         and x4, x6, x12, lsl #64
    3110. 

  3110.         and x2, x5, x11, asr
    3111. 

  3111. // CHECK-ERROR: error: expected integer shift amount
    3112. 

  3112. // CHECK-ERROR-NEXT:         and w2, w24, w6, lsl #-1
    3113. 

  3113. // CHECK-ERROR-NEXT:                               ^
    3114. 

  3114. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]
    3115. 

  3115. // CHECK-ERROR-NEXT:         and w4, w6, w12, lsl #32
    3116. 

  3116. // CHECK-ERROR-NEXT:                          ^
    3117. 

  3117. // CHECK-ERROR-NEXT: error: expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]
    3118. 

  3118. // CHECK-ERROR-NEXT:         and x4, x6, x12, lsl #64
    3119. 

  3119. // CHECK-ERROR-NEXT:                          ^
    3120. 

  3120. // CHECK-ERROR-NEXT: error: expected #imm after shift specifier
    3121. 

  3121. // CHECK-ERROR-NEXT:         and x2, x5, x11, asr
    3122. 

  3122. // CHECK-ERROR-NEXT:                             ^
    3123. 

  3123. 

  3124.         //// sp not allowed
    3125. 

  3125.         orn wsp, w3, w5
    3126. 

  3126.         bics x20, sp, x9, lsr #0
    3127. 

  3127.         orn x2, x6, sp, lsl #3
    3128. 

  3128. // FIXME: the diagnostic we get for 'orn wsp, w3, w5' is from the orn alias,
    3129. 

  3129. // which is a better match than the genuine ORNWri, whereas it would be better
    3130. 

  3130. // to get the ORNWri diagnostic when the alias did not match, i.e. the
    3131. 

  3131. // alias' diagnostics should have a lower priority.
    3132. 

  3132. // CHECK-ERROR: error: expected compatible register or logical immediate
    3133. 

  3133. // CHECK-ERROR-NEXT:         orn wsp, w3, w5
    3134. 

  3134. // CHECK-ERROR-NEXT:                      ^
    3135. 

  3135. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    3136. 

  3136. // CHECK-ERROR-NEXT:         bics x20, sp, x9, lsr #0
    3137. 

  3137. // CHECK-ERROR-NEXT:                   ^
    3138. 

  3138. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    3139. 

  3139. // CHECK-ERROR-NEXT:         orn x2, x6, sp, lsl #3
    3140. 

  3140. // CHECK-ERROR-NEXT:                     ^
    3141. 

  3141. 

  3142.         //// Mismatched registers
    3143. 

  3143.         and x3, w2, w1
    3144. 

  3144.         ands w1, x12, w2
    3145. 

  3145.         and x4, x5, w6, lsl #12
    3146. 

  3146.         orr w2, w5, x7, asr #0
    3147. 

  3147. // CHECK-ERROR: error: invalid operand for instruction
    3148. 

  3148. // CHECK-ERROR-NEXT:         and x3, w2, w1
    3149. 

  3149. // CHECK-ERROR-NEXT:                 ^
    3150. 

  3150. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    3151. 

  3151. // CHECK-ERROR-NEXT:         ands w1, x12, w2
    3152. 

  3152. // CHECK-ERROR-NEXT:                  ^
    3153. 

  3153. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    3154. 

  3154. // CHECK-ERROR-NEXT:         and x4, x5, w6, lsl #12
    3155. 

  3155. // CHECK-ERROR-NEXT:                     ^
    3156. 

  3156. // CHECK-ERROR-NEXT: error: expected compatible register or logical immediate
    3157. 

  3157. // CHECK-ERROR-NEXT:         orr w2, w5, x7, asr #0
    3158. 

  3158. // CHECK-ERROR-NEXT:                     ^
    3159. 

  3159. 

  3160.         //// Shifts should not be allowed on mov
    3161. 

  3161.         mov w3, w7, lsl #13
    3162. 

  3162. // CHECK-ERROR: error: invalid operand for instruction
    3163. 

  3163. // CHECK-ERROR-NEXT:         mov w3, w7, lsl #13
    3164. 

  3164. // CHECK-ERROR-NEXT:                     ^
    3165. 

  3165. 

  3166. //------------------------------------------------------------------------------
    3167. 

  3167. // Move wide (immediate)
    3168. 

  3168. //------------------------------------------------------------------------------
    3169. 

  3169. 

  3170.         movz w3, #65536, lsl #0
    3171. 

  3171.         movz w4, #65536
    3172. 

  3172.         movn w1, #2, lsl #1
    3173. 

  3173.         movk w3, #0, lsl #-1
    3174. 

  3174.         movn w2, #-1, lsl #0
    3175. 

  3175.         movz x3, #-1
    3176. 

  3176.         movk w3, #1, lsl #32
    3177. 

  3177.         movn x2, #12, lsl #64
    3178. 

  3178. // CHECK-ERROR: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3179. 

  3179. // CHECK-ERROR-NEXT:         movz w3, #65536, lsl #0
    3180. 

  3180. // CHECK-ERROR-NEXT:                  ^
    3181. 

  3181. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3182. 

  3182. // CHECK-ERROR-NEXT:         movz w4, #65536
    3183. 

  3183. // CHECK-ERROR-NEXT:                  ^
    3184. 

  3184. // CHECK-ERROR-AARCH64-NEXT: error: expected relocated symbol or integer in range [0, 65535]
    3185. 

  3185. // CHECK-ERROR-ARM64-NEXT: error: expected 'lsl' with optional integer 0 or 16
    3186. 

  3186. // CHECK-ERROR-NEXT:         movn w1, #2, lsl #1
    3187. 

  3187. // CHECK-ERROR-NEXT:                  ^
    3188. 

  3188. // CHECK-ERROR-AARCH64-NEXT: error: only 'lsl #+N' valid after immediate
    3189. 

  3189. // CHECK-ERROR-ARM64-NEXT: error: expected integer shift amount
    3190. 

  3190. // CHECK-ERROR-NEXT:         movk w3, #0, lsl #-1
    3191. 

  3191. // CHECK-ERROR-NEXT:                           ^
    3192. 

  3192. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3193. 

  3193. // CHECK-ERROR-NEXT:         movn w2, #-1, lsl #0
    3194. 

  3194. // CHECK-ERROR-NEXT:                  ^
    3195. 

  3195. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3196. 

  3196. // CHECK-ERROR-NEXT:         movz x3, #-1
    3197. 

  3197. // CHECK-ERROR-NEXT:                  ^
    3198. 

  3198. // CHECK-ERROR-AARCH64-NEXT: error: expected relocated symbol or integer in range [0, 65535]
    3199. 

  3199. // CHECK-ERROR-ARM64-NEXT: error: expected 'lsl' with optional integer 0 or 16
    3200. 

  3200. // CHECK-ERROR-NEXT:         movk w3, #1, lsl #32
    3201. 

  3201. // CHECK-ERROR-NEXT:                  ^
    3202. 

  3202. // CHECK-ERROR-AARCH64-NEXT: error: expected relocated symbol or integer in range [0, 65535]
    3203. 

  3203. // CHECK-ERROR-ARM64-NEXT: error: expected 'lsl' with optional integer 0, 16, 32 or 48
    3204. 

  3204. // CHECK-ERROR-NEXT:         movn x2, #12, lsl #64
    3205. 

  3205. // CHECK-ERROR-NEXT:                  ^
    3206. 

  3206. 

  3207.         movz x12, #:abs_g0:sym, lsl #16
    3208. 

  3208.         movz x12, #:abs_g0:sym, lsl #0
    3209. 

  3209.         movn x2, #:abs_g0:sym
    3210. 

  3210.         movk w3, #:abs_g0:sym
    3211. 

  3211.         movz x3, #:abs_g0_nc:sym
    3212. 

  3212.         movn x4, #:abs_g0_nc:sym
    3213. 

  3213. // CHECK-ERROR: error: invalid operand for instruction
    3214. 

  3214. // CHECK-ERROR-NEXT:         movz x12, #:abs_g0:sym, lsl #16
    3215. 

  3215. // CHECK-ERROR-NEXT:                                 ^
    3216. 

  3216. // CHECK-ERROR:  error: invalid operand for instruction
    3217. 

  3217. // CHECK-ERROR-NEXT:         movz x12, #:abs_g0:sym, lsl #0
    3218. 

  3218. // CHECK-ERROR-NEXT:                                 ^
    3219. 

  3219. 

  3220.         movn x2, #:abs_g1:sym
    3221. 

  3221.         movk w3, #:abs_g1:sym
    3222. 

  3222.         movz x3, #:abs_g1_nc:sym
    3223. 

  3223.         movn x4, #:abs_g1_nc:sym
    3224. 

  3224. 

  3225.         movz w12, #:abs_g2:sym
    3226. 

  3226.         movn x12, #:abs_g2:sym
    3227. 

  3227.         movk x13, #:abs_g2:sym
    3228. 

  3228.         movk w3, #:abs_g2_nc:sym
    3229. 

  3229.         movz x13, #:abs_g2_nc:sym
    3230. 

  3230.         movn x24, #:abs_g2_nc:sym
    3231. 

  3231. // CHECK-ERROR: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3232. 

  3232. // CHECK-ERROR-NEXT:         movz w12, #:abs_g2:sym
    3233. 

  3233. // CHECK-ERROR-NEXT:                   ^
    3234. 

  3234. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3235. 

  3235. // CHECK-ERROR-NEXT:         movk w3, #:abs_g2_nc:sym
    3236. 

  3236. // CHECK-ERROR-NEXT:                  ^
    3237. 

  3237. 

  3238.         movn x19, #:abs_g3:sym
    3239. 

  3239.         movz w20, #:abs_g3:sym
    3240. 

  3240.         movk w21, #:abs_g3:sym
    3241. 

  3241. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3242. 

  3242. // CHECK-ERROR-NEXT:         movz w20, #:abs_g3:sym
    3243. 

  3243. // CHECK-ERROR-NEXT:                   ^
    3244. 

  3244. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3245. 

  3245. // CHECK-ERROR-NEXT:         movk w21, #:abs_g3:sym
    3246. 

  3246. // CHECK-ERROR-NEXT:                   ^
    3247. 

  3247. 

  3248.         movk x19, #:abs_g0_s:sym
    3249. 

  3249.         movk w23, #:abs_g0_s:sym
    3250. 

  3250. 

  3251.         movk x19, #:abs_g1_s:sym
    3252. 

  3252.         movk w23, #:abs_g1_s:sym
    3253. 

  3253. 

  3254.         movz w2, #:abs_g2_s:sym
    3255. 

  3255.         movn w29, #:abs_g2_s:sym
    3256. 

  3256.         movk x19, #:abs_g2_s:sym
    3257. 

  3257.         movk w23, #:abs_g2_s:sym
    3258. 

  3258. // CHECK-ERROR: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3259. 

  3259. // CHECK-ERROR-NEXT:         movz w2, #:abs_g2_s:sym
    3260. 

  3260. // CHECK-ERROR-NEXT:                    ^
    3261. 

  3261. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3262. 

  3262. // CHECK-ERROR-NEXT:         movn w29, #:abs_g2_s:sym
    3263. 

  3263. // CHECK-ERROR-NEXT:                   ^
    3264. 

  3264. // CHECK-ERROR-NEXT: error: {{expected relocated symbol or|immediate must be an}} integer in range [0, 65535]
    3265. 

  3265. // CHECK-ERROR-NEXT:         movk w23, #:abs_g2_s:sym
    3266. 

  3266. // CHECK-ERROR-NEXT:                   ^
    3267. 

  3267. 

  3268. //------------------------------------------------------------------------------
    3269. 

  3269. // PC-relative addressing
    3270. 

  3270. //------------------------------------------------------------------------------
    3271. 

  3271. 

  3272.         adr sp, loc             // expects xzr
    3273. 

  3273.         adr x0, :got:loc        // bad relocation type
    3274. 

  3274.         adr x1, :lo12:loc
    3275. 

  3275.         adrp x3, #20            // Immediate unaligned
    3276. 

  3276.         adrp w2, loc            // 64-bit register needed
    3277. 

  3277.         adrp x5, :got_lo12:loc  // bad relocation type
    3278. 

  3278. // CHECK-ERROR: error: invalid operand for instruction
    3279. 

  3279. // CHECK-ERROR-NEXT:         adr sp, loc
    3280. 

  3280. // CHECK-ERROR-NEXT:             ^
    3281. 

  3281. // CHECK-ERROR-NEXT: error: unexpected adr label
    3282. 

  3282. // CHECK-ERROR-NEXT:         adr x0, :got:loc
    3283. 

  3283. // CHECK-ERROR-NEXT:             ^
    3284. 

  3284. // CHECK-ERROR-NEXT: error: unexpected adr label
    3285. 

  3285. // CHECK-ERROR-NEXT:         adr x1, :lo12:loc
    3286. 

  3286. // CHECK-ERROR-NEXT:             ^
    3287. 

  3287. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    3288. 

  3288. // CHECK-ERROR-NEXT:         adrp x3, #20
    3289. 

  3289. // CHECK-ERROR-NEXT:                  ^
    3290. 

  3290. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    3291. 

  3291. // CHECK-ERROR-NEXT:         adrp w2, loc
    3292. 

  3292. // CHECK-ERROR-NEXT:              ^
    3293. 

  3293. // CHECK-ERROR-NEXT: error: page or gotpage label reference expected
    3294. 

  3294. // CHECK-ERROR-NEXT:         adrp x5, :got_lo12:loc
    3295. 

  3295. // CHECK-ERROR-NEXT:             ^
    3296. 

  3296. 

  3297.         adr x9, #1048576
    3298. 

  3298.         adr x2, #-1048577
    3299. 

  3299.         adrp x9, #4294967296
    3300. 

  3300.         adrp x20, #-4294971392
    3301. 

  3301. // CHECK-ERROR: error: expected label or encodable integer pc offset
    3302. 

  3302. // CHECK-ERROR-NEXT:         adr x9, #1048576
    3303. 

  3303. // CHECK-ERROR-NEXT:                 ^
    3304. 

  3304. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    3305. 

  3305. // CHECK-ERROR-NEXT:         adr x2, #-1048577
    3306. 

  3306. // CHECK-ERROR-NEXT:                  ^
    3307. 

  3307. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    3308. 

  3308. // CHECK-ERROR-NEXT:         adrp x9, #4294967296
    3309. 

  3309. // CHECK-ERROR-NEXT:                  ^
    3310. 

  3310. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    3311. 

  3311. // CHECK-ERROR-NEXT:         adrp x20, #-4294971392
    3312. 

  3312. // CHECK-ERROR-NEXT:                   ^
    3313. 

  3313. 

  3314. //------------------------------------------------------------------------------
    3315. 

  3315. // System
    3316. 

  3316. //------------------------------------------------------------------------------
    3317. 

  3317. 

  3318.         hint #-1
    3319. 

  3319.         hint #128
    3320. 

  3320. // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 127]
    3321. 

  3321. // CHECK-ERROR-NEXT:         hint #-1
    3322. 

  3322. // CHECK-ERROR-NEXT:              ^
    3323. 

  3323. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 127]
    3324. 

  3324. // CHECK-ERROR-NEXT:         hint #128
    3325. 

  3325. // CHECK-ERROR-NEXT:              ^
    3326. 

  3326. 

  3327.         clrex #-1
    3328. 

  3328.         clrex #16
    3329. 

  3329. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    3330. 

  3330. // CHECK-ERROR-NEXT:         clrex #-1
    3331. 

  3331. // CHECK-ERROR-NEXT:               ^
    3332. 

  3332. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 15]
    3333. 

  3333. // CHECK-ERROR-NEXT:         clrex #16
    3334. 

  3334. // CHECK-ERROR-NEXT:               ^
    3335. 

  3335. 

  3336.         dsb #-1
    3337. 

  3337.         dsb #16
    3338. 

  3338.         dsb foo
    3339. 

  3339.         dmb #-1
    3340. 

  3340.         dmb #16
    3341. 

  3341.         dmb foo
    3342. 

  3342. // CHECK-ERROR-NEXT: error: {{Invalid immediate for instruction|barrier operand out of range}}
    3343. 

  3343. // CHECK-ERROR-NEXT:         dsb #-1
    3344. 

  3344. // CHECK-ERROR-NEXT:             ^
    3345. 

  3345. // CHECK-ERROR-NEXT: error: {{Invalid immediate for instruction|barrier operand out of range}}
    3346. 

  3346. // CHECK-ERROR-NEXT:         dsb #16
    3347. 

  3347. // CHECK-ERROR-NEXT:             ^
    3348. 

  3348. // CHECK-ERROR-NEXT: error: invalid barrier option name
    3349. 

  3349. // CHECK-ERROR-NEXT:         dsb foo
    3350. 

  3350. // CHECK-ERROR-NEXT:             ^
    3351. 

  3351. // CHECK-ERROR-NEXT: error: {{Invalid immediate for instruction|barrier operand out of range}}
    3352. 

  3352. // CHECK-ERROR-NEXT:         dmb #-1
    3353. 

  3353. // CHECK-ERROR-NEXT:             ^
    3354. 

  3354. // CHECK-ERROR-NEXT: error: {{Invalid immediate for instruction|barrier operand out of range}}
    3355. 

  3355. // CHECK-ERROR-NEXT:         dmb #16
    3356. 

  3356. // CHECK-ERROR-NEXT:             ^
    3357. 

  3357. // CHECK-ERROR-NEXT: error: invalid barrier option name
    3358. 

  3358. // CHECK-ERROR-NEXT:         dmb foo
    3359. 

  3359. // CHECK-ERROR-NEXT:             ^
    3360. 

  3360. 

  3361.         isb #-1
    3362. 

  3362.         isb #16
    3363. 

  3363.         isb foo
    3364. 

  3364. // CHECK-ERROR-NEXT: error: {{Invalid immediate for instruction|barrier operand out of range}}
    3365. 

  3365. // CHECK-ERROR-NEXT:         isb #-1
    3366. 

  3366. // CHECK-ERROR-NEXT:             ^
    3367. 

  3367. // CHECK-ERROR-NEXT: error: {{Invalid immediate for instruction|barrier operand out of range}}
    3368. 

  3368. // CHECK-ERROR-NEXT:         isb #16
    3369. 

  3369. // CHECK-ERROR-NEXT:             ^
    3370. 

  3370. // CHECK-ERROR-NEXT: error: 'sy' or #imm operand expected
    3371. 

  3371. // CHECK-ERROR-NEXT:        isb foo
    3372. 

  3372. // CHECK-ERROR-NEXT:            ^
    3373. 

  3373. 

  3374.         msr daifset, x4
    3375. 

  3375.         msr spsel, #-1
    3376. 

  3376.         msr spsel #-1
    3377. 

  3377.         msr daifclr, #16
    3378. 

  3378. // CHECK-ERROR: [[@LINE-4]]:22: error: {{expected|immediate must be an}} integer in range [0, 15]
    3379. 

  3379. // CHECK-ERROR: [[@LINE-4]]:20: error: {{expected|immediate must be an}} integer in range [0, 15]
    3380. 

  3380. // CHECK-ERROR: [[@LINE-4]]:{{9|19}}: error: {{too few operands for instruction|expected comma before next operand|unexpected token in argument list}}
    3381. 

  3381. // CHECK-ERROR: [[@LINE-4]]:22: error: {{expected|immediate must be an}} integer in range [0, 15]
    3382. 

  3382. 

  3383.         sys #8, c1, c2, #7, x9
    3384. 

  3384.         sys #3, c16, c2, #3, x10
    3385. 

  3385.         sys #2, c11, c16, #5
    3386. 

  3386.         sys #4, c9, c8, #8, xzr
    3387. 

  3387.         sysl x11, #8, c1, c2, #7
    3388. 

  3388.         sysl x13, #3, c16, c2, #3
    3389. 

  3389.         sysl x9, #2, c11, c16, #5
    3390. 

  3390.         sysl x4, #4, c9, c8, #8
    3391. 

  3391. // CHECK-ERROR: error:  {{expected|immediate must be an}} integer in range [0, 7]
    3392. 

  3392. // CHECK-ERROR-NEXT:         sys #8, c1, c2, #7, x9
    3393. 

  3393. // CHECK-ERROR-NEXT:             ^
    3394. 

  3394. // CHECK-ERROR-NEXT: error: Expected cN operand where 0 <= N <= 15
    3395. 

  3395. // CHECK-ERROR-NEXT:         sys #3, c16, c2, #3, x10
    3396. 

  3396. // CHECK-ERROR-NEXT:                 ^
    3397. 

  3397. // CHECK-ERROR-NEXT: error: Expected cN operand where 0 <= N <= 15
    3398. 

  3398. // CHECK-ERROR-NEXT:         sys #2, c11, c16, #5
    3399. 

  3399. // CHECK-ERROR-NEXT:                      ^
    3400. 

  3400. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 7]
    3401. 

  3401. // CHECK-ERROR-NEXT:         sys #4, c9, c8, #8, xzr
    3402. 

  3402. // CHECK-ERROR-NEXT:                         ^
    3403. 

  3403. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 7]
    3404. 

  3404. // CHECK-ERROR-NEXT:         sysl x11, #8, c1, c2, #7
    3405. 

  3405. // CHECK-ERROR-NEXT:                   ^
    3406. 

  3406. // CHECK-ERROR-NEXT: error: Expected cN operand where 0 <= N <= 15
    3407. 

  3407. // CHECK-ERROR-NEXT:         sysl x13, #3, c16, c2, #3
    3408. 

  3408. // CHECK-ERROR-NEXT:                       ^
    3409. 

  3409. // CHECK-ERROR-NEXT: error: Expected cN operand where 0 <= N <= 15
    3410. 

  3410. // CHECK-ERROR-NEXT:         sysl x9, #2, c11, c16, #5
    3411. 

  3411. // CHECK-ERROR-NEXT:                           ^
    3412. 

  3412. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 7]
    3413. 

  3413. // CHECK-ERROR-NEXT:         sysl x4, #4, c9, c8, #8
    3414. 

  3414. // CHECK-ERROR-NEXT:                              ^
    3415. 

  3415. 

  3416.         ic ialluis, x2
    3417. 

  3417.         ic allu, x7
    3418. 

  3418.         ic ivau
    3419. 

  3419. // CHECK-ERROR-NEXT: error: specified {{IC|ic}} op does not use a register
    3420. 

  3420. // CHECK-ERROR-NEXT:         ic ialluis, x2
    3421. 

  3421. // CHECK-ERROR-NEXT:                     ^
    3422. 

  3422. // CHECK-ERROR-AARCH64-NEXT: error: operand specifier not recognised
    3423. 

  3423. // CHECK-ERROR-ARM64-NEXT: error: invalid operand for IC instruction
    3424. 

  3424. // CHECK-ERROR-NEXT:         ic allu, x7
    3425. 

  3425. // CHECK-ERROR-NEXT:            ^
    3426. 

  3426. // CHECK-ERROR-NEXT: error: specified {{IC|ic}} op requires a register
    3427. 

  3427. // CHECK-ERROR-NEXT:         ic ivau
    3428. 

  3428. // CHECK-ERROR-NEXT:            ^
    3429. 

  3429. 

  3430.         tlbi IPAS2E1IS
    3431. 

  3431.         tlbi IPAS2LE1IS
    3432. 

  3432.         tlbi VMALLE1IS, x12
    3433. 

  3433.         tlbi ALLE2IS, x11
    3434. 

  3434.         tlbi ALLE3IS, x20
    3435. 

  3435.         tlbi VAE1IS
    3436. 

  3436.         tlbi VAE2IS
    3437. 

  3437.         tlbi VAE3IS
    3438. 

  3438.         tlbi ASIDE1IS
    3439. 

  3439.         tlbi VAAE1IS
    3440. 

  3440.         tlbi ALLE1IS, x0
    3441. 

  3441.         tlbi VALE1IS
    3442. 

  3442.         tlbi VALE2IS
    3443. 

  3443.         tlbi VALE3IS
    3444. 

  3444.         tlbi VMALLS12E1IS, xzr
    3445. 

  3445.         tlbi VAALE1IS
    3446. 

  3446.         tlbi IPAS2E1
    3447. 

  3447.         tlbi IPAS2LE1
    3448. 

  3448.         tlbi VMALLE1, x9
    3449. 

  3449.         tlbi ALLE2, x10
    3450. 

  3450.         tlbi ALLE3, x11
    3451. 

  3451.         tlbi VAE1
    3452. 

  3452.         tlbi VAE2
    3453. 

  3453.         tlbi VAE3
    3454. 

  3454.         tlbi ASIDE1
    3455. 

  3455.         tlbi VAAE1
    3456. 

  3456.         tlbi ALLE1, x25
    3457. 

  3457.         tlbi VALE1
    3458. 

  3458.         tlbi VALE2
    3459. 

  3459.         tlbi VALE3
    3460. 

  3460.         tlbi VMALLS12E1, x15
    3461. 

  3461.         tlbi VAALE1
    3462. 

  3462. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3463. 

  3463. // CHECK-ERROR-NEXT:         tlbi IPAS2E1IS
    3464. 

  3464. // CHECK-ERROR-NEXT:              ^
    3465. 

  3465. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3466. 

  3466. // CHECK-ERROR-NEXT:         tlbi IPAS2LE1IS
    3467. 

  3467. // CHECK-ERROR-NEXT:              ^
    3468. 

  3468. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3469. 

  3469. // CHECK-ERROR-NEXT:         tlbi VMALLE1IS, x12
    3470. 

  3470. // CHECK-ERROR-NEXT:                         ^
    3471. 

  3471. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3472. 

  3472. // CHECK-ERROR-NEXT:         tlbi ALLE2IS, x11
    3473. 

  3473. // CHECK-ERROR-NEXT:                       ^
    3474. 

  3474. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3475. 

  3475. // CHECK-ERROR-NEXT:         tlbi ALLE3IS, x20
    3476. 

  3476. // CHECK-ERROR-NEXT:                       ^
    3477. 

  3477. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3478. 

  3478. // CHECK-ERROR-NEXT:         tlbi VAE1IS
    3479. 

  3479. // CHECK-ERROR-NEXT:              ^
    3480. 

  3480. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3481. 

  3481. // CHECK-ERROR-NEXT:         tlbi VAE2IS
    3482. 

  3482. // CHECK-ERROR-NEXT:              ^
    3483. 

  3483. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3484. 

  3484. // CHECK-ERROR-NEXT:         tlbi VAE3IS
    3485. 

  3485. // CHECK-ERROR-NEXT:              ^
    3486. 

  3486. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3487. 

  3487. // CHECK-ERROR-NEXT:         tlbi ASIDE1IS
    3488. 

  3488. // CHECK-ERROR-NEXT:              ^
    3489. 

  3489. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3490. 

  3490. // CHECK-ERROR-NEXT:         tlbi VAAE1IS
    3491. 

  3491. // CHECK-ERROR-NEXT:              ^
    3492. 

  3492. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3493. 

  3493. // CHECK-ERROR-NEXT:         tlbi ALLE1IS, x0
    3494. 

  3494. // CHECK-ERROR-NEXT:                       ^
    3495. 

  3495. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3496. 

  3496. // CHECK-ERROR-NEXT:         tlbi VALE1IS
    3497. 

  3497. // CHECK-ERROR-NEXT:              ^
    3498. 

  3498. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3499. 

  3499. // CHECK-ERROR-NEXT:         tlbi VALE2IS
    3500. 

  3500. // CHECK-ERROR-NEXT:              ^
    3501. 

  3501. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3502. 

  3502. // CHECK-ERROR-NEXT:         tlbi VALE3IS
    3503. 

  3503. // CHECK-ERROR-NEXT:              ^
    3504. 

  3504. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3505. 

  3505. // CHECK-ERROR-NEXT:         tlbi VMALLS12E1IS, xzr
    3506. 

  3506. // CHECK-ERROR-NEXT:                            ^
    3507. 

  3507. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3508. 

  3508. // CHECK-ERROR-NEXT:         tlbi VAALE1IS
    3509. 

  3509. // CHECK-ERROR-NEXT:              ^
    3510. 

  3510. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3511. 

  3511. // CHECK-ERROR-NEXT:         tlbi IPAS2E1
    3512. 

  3512. // CHECK-ERROR-NEXT:              ^
    3513. 

  3513. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3514. 

  3514. // CHECK-ERROR-NEXT:         tlbi IPAS2LE1
    3515. 

  3515. // CHECK-ERROR-NEXT:              ^
    3516. 

  3516. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3517. 

  3517. // CHECK-ERROR-NEXT:         tlbi VMALLE1, x9
    3518. 

  3518. // CHECK-ERROR-NEXT:                       ^
    3519. 

  3519. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3520. 

  3520. // CHECK-ERROR-NEXT:         tlbi ALLE2, x10
    3521. 

  3521. // CHECK-ERROR-NEXT:                     ^
    3522. 

  3522. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3523. 

  3523. // CHECK-ERROR-NEXT:         tlbi ALLE3, x11
    3524. 

  3524. // CHECK-ERROR-NEXT:                     ^
    3525. 

  3525. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3526. 

  3526. // CHECK-ERROR-NEXT:         tlbi VAE1
    3527. 

  3527. // CHECK-ERROR-NEXT:              ^
    3528. 

  3528. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3529. 

  3529. // CHECK-ERROR-NEXT:         tlbi VAE2
    3530. 

  3530. // CHECK-ERROR-NEXT:              ^
    3531. 

  3531. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3532. 

  3532. // CHECK-ERROR-NEXT:         tlbi VAE3
    3533. 

  3533. // CHECK-ERROR-NEXT:              ^
    3534. 

  3534. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3535. 

  3535. // CHECK-ERROR-NEXT:         tlbi ASIDE1
    3536. 

  3536. // CHECK-ERROR-NEXT:              ^
    3537. 

  3537. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3538. 

  3538. // CHECK-ERROR-NEXT:         tlbi VAAE1
    3539. 

  3539. // CHECK-ERROR-NEXT:              ^
    3540. 

  3540. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3541. 

  3541. // CHECK-ERROR-NEXT:         tlbi ALLE1, x25
    3542. 

  3542. // CHECK-ERROR-NEXT:                     ^
    3543. 

  3543. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3544. 

  3544. // CHECK-ERROR-NEXT:         tlbi VALE1
    3545. 

  3545. // CHECK-ERROR-NEXT:              ^
    3546. 

  3546. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3547. 

  3547. // CHECK-ERROR-NEXT:         tlbi VALE2
    3548. 

  3548. // CHECK-ERROR-NEXT:              ^
    3549. 

  3549. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3550. 

  3550. // CHECK-ERROR-NEXT:         tlbi VALE3
    3551. 

  3551. // CHECK-ERROR-NEXT:              ^
    3552. 

  3552. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op does not use a register
    3553. 

  3553. // CHECK-ERROR-NEXT:         tlbi VMALLS12E1, x15
    3554. 

  3554. // CHECK-ERROR-NEXT:                          ^
    3555. 

  3555. // CHECK-ERROR-NEXT: error: specified {{TLBI|tlbi}} op requires a register
    3556. 

  3556. // CHECK-ERROR-NEXT:         tlbi VAALE1
    3557. 

  3557. // CHECK-ERROR-NEXT:              ^
    3558. 

  3558. 

  3559. // For the MSR/MRS instructions, first make sure read-only and
    3560. 

  3560. // write-only registers actually are.
    3561. 

  3561.         msr MDCCSR_EL0, x12
    3562. 

  3562.         msr DBGDTRRX_EL0, x12
    3563. 

  3563.         msr MDRAR_EL1, x12
    3564. 

  3564.         msr OSLSR_EL1, x12
    3565. 

  3565.         msr DBGAUTHSTATUS_EL1, x12
    3566. 

  3566.         msr MIDR_EL1, x12
    3567. 

  3567.         msr CCSIDR_EL1, x12
    3568. 

  3568.         msr CLIDR_EL1, x12
    3569. 

  3569.         msr CCSIDR2_EL1, x12
    3570. 

  3570.         msr CTR_EL0, x12
    3571. 

  3571.         msr MPIDR_EL1, x12
    3572. 

  3572.         msr REVIDR_EL1, x12
    3573. 

  3573.         msr AIDR_EL1, x12
    3574. 

  3574.         msr DCZID_EL0, x12
    3575. 

  3575.         msr ID_PFR0_EL1, x12
    3576. 

  3576.         msr ID_PFR1_EL1, x12
    3577. 

  3577.         msr ID_DFR0_EL1, x12
    3578. 

  3578.         msr ID_AFR0_EL1, x12
    3579. 

  3579.         msr ID_MMFR0_EL1, x12
    3580. 

  3580.         msr ID_MMFR1_EL1, x12
    3581. 

  3581.         msr ID_MMFR2_EL1, x12
    3582. 

  3582.         msr ID_MMFR3_EL1, x12
    3583. 

  3583.         msr ID_MMFR4_EL1, x12
    3584. 

  3584.         msr ID_MMFR5_EL1, x12
    3585. 

  3585.         msr ID_ISAR0_EL1, x12
    3586. 

  3586.         msr ID_ISAR1_EL1, x12
    3587. 

  3587.         msr ID_ISAR2_EL1, x12
    3588. 

  3588.         msr ID_ISAR3_EL1, x12
    3589. 

  3589.         msr ID_ISAR4_EL1, x12
    3590. 

  3590.         msr ID_ISAR5_EL1, x12
    3591. 

  3591.         msr MVFR0_EL1, x12
    3592. 

  3592.         msr MVFR1_EL1, x12
    3593. 

  3593.         msr MVFR2_EL1, x12
    3594. 

  3594.         msr ID_AA64PFR0_EL1, x12
    3595. 

  3595.         msr ID_AA64PFR1_EL1, x12
    3596. 

  3596.         msr ID_AA64DFR0_EL1, x12
    3597. 

  3597.         msr ID_AA64DFR1_EL1, x12
    3598. 

  3598.         msr ID_AA64AFR0_EL1, x12
    3599. 

  3599.         msr ID_AA64AFR1_EL1, x12
    3600. 

  3600.         msr ID_AA64ISAR0_EL1, x12
    3601. 

  3601.         msr ID_AA64ISAR1_EL1, x12
    3602. 

  3602.         msr ID_AA64MMFR0_EL1, x12
    3603. 

  3603.         msr ID_AA64MMFR1_EL1, x12
    3604. 

  3604.         msr PMCEID0_EL0, x12
    3605. 

  3605.         msr PMCEID1_EL0, x12
    3606. 

  3606.         msr RVBAR_EL1, x12
    3607. 

  3607.         msr RVBAR_EL2, x12
    3608. 

  3608.         msr RVBAR_EL3, x12
    3609. 

  3609.         msr ISR_EL1, x12
    3610. 

  3610.         msr CNTPCT_EL0, x12
    3611. 

  3611.         msr CNTVCT_EL0, x12
    3612. 

  3612.         msr PMEVCNTR31_EL0, x12
    3613. 

  3613.         msr PMEVTYPER31_EL0, x12
    3614. 

  3614. // CHECK-ERROR: error: expected writable system register or pstate
    3615. 

  3615. // CHECK-ERROR-NEXT:         msr MDCCSR_EL0, x12
    3616. 

  3616. // CHECK-ERROR-NEXT:             ^
    3617. 

  3617. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3618. 

  3618. // CHECK-ERROR-NEXT:         msr DBGDTRRX_EL0, x12
    3619. 

  3619. // CHECK-ERROR-NEXT:             ^
    3620. 

  3620. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3621. 

  3621. // CHECK-ERROR-NEXT:         msr MDRAR_EL1, x12
    3622. 

  3622. // CHECK-ERROR-NEXT:             ^
    3623. 

  3623. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3624. 

  3624. // CHECK-ERROR-NEXT:         msr OSLSR_EL1, x12
    3625. 

  3625. // CHECK-ERROR-NEXT:             ^
    3626. 

  3626. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3627. 

  3627. // CHECK-ERROR-NEXT:         msr DBGAUTHSTATUS_EL1, x12
    3628. 

  3628. // CHECK-ERROR-NEXT:             ^
    3629. 

  3629. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3630. 

  3630. // CHECK-ERROR-NEXT:         msr MIDR_EL1, x12
    3631. 

  3631. // CHECK-ERROR-NEXT:             ^
    3632. 

  3632. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3633. 

  3633. // CHECK-ERROR-NEXT:         msr CCSIDR_EL1, x12
    3634. 

  3634. // CHECK-ERROR-NEXT:             ^
    3635. 

  3635. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3636. 

  3636. // CHECK-ERROR-NEXT:         msr CLIDR_EL1, x12
    3637. 

  3637. // CHECK-ERROR-NEXT:             ^
    3638. 

  3638. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3639. 

  3639. // CHECK-ERROR-NEXT:         msr CCSIDR2_EL1, x12
    3640. 

  3640. // CHECK-ERROR-NEXT:             ^
    3641. 

  3641. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3642. 

  3642. // CHECK-ERROR-NEXT:         msr CTR_EL0, x12
    3643. 

  3643. // CHECK-ERROR-NEXT:             ^
    3644. 

  3644. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3645. 

  3645. // CHECK-ERROR-NEXT:         msr MPIDR_EL1, x12
    3646. 

  3646. // CHECK-ERROR-NEXT:             ^
    3647. 

  3647. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3648. 

  3648. // CHECK-ERROR-NEXT:         msr REVIDR_EL1, x12
    3649. 

  3649. // CHECK-ERROR-NEXT:             ^
    3650. 

  3650. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3651. 

  3651. // CHECK-ERROR-NEXT:         msr AIDR_EL1, x12
    3652. 

  3652. // CHECK-ERROR-NEXT:             ^
    3653. 

  3653. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3654. 

  3654. // CHECK-ERROR-NEXT:         msr DCZID_EL0, x12
    3655. 

  3655. // CHECK-ERROR-NEXT:             ^
    3656. 

  3656. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3657. 

  3657. // CHECK-ERROR-NEXT:         msr ID_PFR0_EL1, x12
    3658. 

  3658. // CHECK-ERROR-NEXT:             ^
    3659. 

  3659. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3660. 

  3660. // CHECK-ERROR-NEXT:         msr ID_PFR1_EL1, x12
    3661. 

  3661. // CHECK-ERROR-NEXT:             ^
    3662. 

  3662. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3663. 

  3663. // CHECK-ERROR-NEXT:         msr ID_DFR0_EL1, x12
    3664. 

  3664. // CHECK-ERROR-NEXT:             ^
    3665. 

  3665. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3666. 

  3666. // CHECK-ERROR-NEXT:         msr ID_AFR0_EL1, x12
    3667. 

  3667. // CHECK-ERROR-NEXT:             ^
    3668. 

  3668. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3669. 

  3669. // CHECK-ERROR-NEXT:         msr ID_MMFR0_EL1, x12
    3670. 

  3670. // CHECK-ERROR-NEXT:             ^
    3671. 

  3671. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3672. 

  3672. // CHECK-ERROR-NEXT:         msr ID_MMFR1_EL1, x12
    3673. 

  3673. // CHECK-ERROR-NEXT:             ^
    3674. 

  3674. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3675. 

  3675. // CHECK-ERROR-NEXT:         msr ID_MMFR2_EL1, x12
    3676. 

  3676. // CHECK-ERROR-NEXT:             ^
    3677. 

  3677. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3678. 

  3678. // CHECK-ERROR-NEXT:         msr ID_MMFR3_EL1, x12
    3679. 

  3679. // CHECK-ERROR-NEXT:             ^
    3680. 

  3680. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3681. 

  3681. // CHECK-ERROR-NEXT:         msr ID_MMFR4_EL1, x12
    3682. 

  3682. // CHECK-ERROR-NEXT:             ^
    3683. 

  3683. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3684. 

  3684. // CHECK-ERROR-NEXT:         msr ID_MMFR5_EL1, x12
    3685. 

  3685. // CHECK-ERROR-NEXT:             ^
    3686. 

  3686. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3687. 

  3687. // CHECK-ERROR-NEXT:         msr ID_ISAR0_EL1, x12
    3688. 

  3688. // CHECK-ERROR-NEXT:             ^
    3689. 

  3689. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3690. 

  3690. // CHECK-ERROR-NEXT:         msr ID_ISAR1_EL1, x12
    3691. 

  3691. // CHECK-ERROR-NEXT:             ^
    3692. 

  3692. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3693. 

  3693. // CHECK-ERROR-NEXT:         msr ID_ISAR2_EL1, x12
    3694. 

  3694. // CHECK-ERROR-NEXT:             ^
    3695. 

  3695. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3696. 

  3696. // CHECK-ERROR-NEXT:         msr ID_ISAR3_EL1, x12
    3697. 

  3697. // CHECK-ERROR-NEXT:             ^
    3698. 

  3698. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3699. 

  3699. // CHECK-ERROR-NEXT:         msr ID_ISAR4_EL1, x12
    3700. 

  3700. // CHECK-ERROR-NEXT:             ^
    3701. 

  3701. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3702. 

  3702. // CHECK-ERROR-NEXT:         msr ID_ISAR5_EL1, x12
    3703. 

  3703. // CHECK-ERROR-NEXT:             ^
    3704. 

  3704. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3705. 

  3705. // CHECK-ERROR-NEXT:         msr MVFR0_EL1, x12
    3706. 

  3706. // CHECK-ERROR-NEXT:             ^
    3707. 

  3707. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3708. 

  3708. // CHECK-ERROR-NEXT:         msr MVFR1_EL1, x12
    3709. 

  3709. // CHECK-ERROR-NEXT:             ^
    3710. 

  3710. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3711. 

  3711. // CHECK-ERROR-NEXT:         msr MVFR2_EL1, x12
    3712. 

  3712. // CHECK-ERROR-NEXT:             ^
    3713. 

  3713. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3714. 

  3714. // CHECK-ERROR-NEXT:         msr ID_AA64PFR0_EL1, x12
    3715. 

  3715. // CHECK-ERROR-NEXT:             ^
    3716. 

  3716. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3717. 

  3717. // CHECK-ERROR-NEXT:         msr ID_AA64PFR1_EL1, x12
    3718. 

  3718. // CHECK-ERROR-NEXT:             ^
    3719. 

  3719. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3720. 

  3720. // CHECK-ERROR-NEXT:         msr ID_AA64DFR0_EL1, x12
    3721. 

  3721. // CHECK-ERROR-NEXT:             ^
    3722. 

  3722. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3723. 

  3723. // CHECK-ERROR-NEXT:         msr ID_AA64DFR1_EL1, x12
    3724. 

  3724. // CHECK-ERROR-NEXT:             ^
    3725. 

  3725. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3726. 

  3726. // CHECK-ERROR-NEXT:         msr ID_AA64AFR0_EL1, x12
    3727. 

  3727. // CHECK-ERROR-NEXT:             ^
    3728. 

  3728. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3729. 

  3729. // CHECK-ERROR-NEXT:         msr ID_AA64AFR1_EL1, x12
    3730. 

  3730. // CHECK-ERROR-NEXT:             ^
    3731. 

  3731. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3732. 

  3732. // CHECK-ERROR-NEXT:         msr ID_AA64ISAR0_EL1, x12
    3733. 

  3733. // CHECK-ERROR-NEXT:             ^
    3734. 

  3734. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3735. 

  3735. // CHECK-ERROR-NEXT:         msr ID_AA64ISAR1_EL1, x12
    3736. 

  3736. // CHECK-ERROR-NEXT:             ^
    3737. 

  3737. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3738. 

  3738. // CHECK-ERROR-NEXT:         msr ID_AA64MMFR0_EL1, x12
    3739. 

  3739. // CHECK-ERROR-NEXT:             ^
    3740. 

  3740. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3741. 

  3741. // CHECK-ERROR-NEXT:         msr ID_AA64MMFR1_EL1, x12
    3742. 

  3742. // CHECK-ERROR-NEXT:             ^
    3743. 

  3743. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3744. 

  3744. // CHECK-ERROR-NEXT:         msr PMCEID0_EL0, x12
    3745. 

  3745. // CHECK-ERROR-NEXT:             ^
    3746. 

  3746. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3747. 

  3747. // CHECK-ERROR-NEXT:         msr PMCEID1_EL0, x12
    3748. 

  3748. // CHECK-ERROR-NEXT:             ^
    3749. 

  3749. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3750. 

  3750. // CHECK-ERROR-NEXT:         msr RVBAR_EL1, x12
    3751. 

  3751. // CHECK-ERROR-NEXT:             ^
    3752. 

  3752. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3753. 

  3753. // CHECK-ERROR-NEXT:         msr RVBAR_EL2, x12
    3754. 

  3754. // CHECK-ERROR-NEXT:             ^
    3755. 

  3755. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3756. 

  3756. // CHECK-ERROR-NEXT:         msr RVBAR_EL3, x12
    3757. 

  3757. // CHECK-ERROR-NEXT:             ^
    3758. 

  3758. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3759. 

  3759. // CHECK-ERROR-NEXT:         msr ISR_EL1, x12
    3760. 

  3760. // CHECK-ERROR-NEXT:             ^
    3761. 

  3761. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3762. 

  3762. // CHECK-ERROR-NEXT:         msr CNTPCT_EL0, x12
    3763. 

  3763. // CHECK-ERROR-NEXT:             ^
    3764. 

  3764. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3765. 

  3765. // CHECK-ERROR-NEXT:         msr CNTVCT_EL0, x12
    3766. 

  3766. // CHECK-ERROR-NEXT:             ^
    3767. 

  3767. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3768. 

  3768. // CHECK-ERROR-NEXT:         msr PMEVCNTR31_EL0, x12
    3769. 

  3769. // CHECK-ERROR-NEXT:             ^
    3770. 

  3770. // CHECK-ERROR-NEXT: error: expected writable system register or pstate
    3771. 

  3771. // CHECK-ERROR-NEXT:         msr PMEVTYPER31_EL0, x12
    3772. 

  3772. // CHECK-ERROR-NEXT:             ^
    3773. 

  3773. 

  3774.         mrs x9, DBGDTRTX_EL0
    3775. 

  3775.         mrs x9, OSLAR_EL1
    3776. 

  3776.         mrs x9, PMSWINC_EL0
    3777. 

  3777.         mrs x9, PMEVCNTR31_EL0
    3778. 

  3778.         mrs x9, PMEVTYPER31_EL0
    3779. 

  3779. // CHECK-ERROR: error: expected readable system register
    3780. 

  3780. // CHECK-ERROR-NEXT:         mrs x9, DBGDTRTX_EL0
    3781. 

  3781. // CHECK-ERROR-NEXT:                 ^
    3782. 

  3782. // CHECK-ERROR-NEXT: error: expected readable system register
    3783. 

  3783. // CHECK-ERROR-NEXT:         mrs x9, OSLAR_EL1
    3784. 

  3784. // CHECK-ERROR-NEXT:                 ^
    3785. 

  3785. // CHECK-ERROR-NEXT: error: expected readable system register
    3786. 

  3786. // CHECK-ERROR-NEXT:         mrs x9, PMSWINC_EL0
    3787. 

  3787. // CHECK-ERROR-NEXT:                 ^
    3788. 

  3788. // CHECK-ERROR-NEXT: error: expected readable system register
    3789. 

  3789. // CHECK-ERROR-NEXT:         mrs x9, PMEVCNTR31_EL0
    3790. 

  3790. // CHECK-ERROR-NEXT:                 ^
    3791. 

  3791. // CHECK-ERROR-NEXT: error: expected readable system register
    3792. 

  3792. // CHECK-ERROR-NEXT:         mrs x9, PMEVTYPER31_EL0
    3793. 

  3793. // CHECK-ERROR-NEXT:                 ^
    3794. 

  3794. 

  3795. // Now check some invalid generic names
    3796. 

  3796.         mrs x12, s3_8_c11_c13_2
    3797. 

  3797.         mrs x19, s3_2_c15_c16_2
    3798. 

  3798.         mrs x30, s3_2_c15_c1_8
    3799. 

  3799.         mrs x4, s4_7_c15_c15_7
    3800. 

  3800.         mrs x14, s3_7_c16_c15_7
    3801. 

  3801. // CHECK-ERROR-NEXT: error: expected readable system register
    3802. 

  3802. // CHECK-ERROR-NEXT:         mrs x12, s3_8_c11_c13_2
    3803. 

  3803. // CHECK-ERROR-NEXT:                  ^
    3804. 

  3804. // CHECK-ERROR-NEXT: error: expected readable system register
    3805. 

  3805. // CHECK-ERROR-NEXT:         mrs x19, s3_2_c15_c16_2
    3806. 

  3806. // CHECK-ERROR-NEXT:                  ^
    3807. 

  3807. // CHECK-ERROR-NEXT: error: expected readable system register
    3808. 

  3808. // CHECK-ERROR-NEXT:         mrs x30, s3_2_c15_c1_8
    3809. 

  3809. // CHECK-ERROR-NEXT:                  ^
    3810. 

  3810. // CHECK-ERROR-NEXT: error: expected readable system register
    3811. 

  3811. // CHECK-ERROR-NEXT:         mrs x4, s4_7_c15_c15_7
    3812. 

  3812. // CHECK-ERROR-NEXT:                 ^
    3813. 

  3813. // CHECK-ERROR-NEXT: error: expected readable system register
    3814. 

  3814. // CHECK-ERROR-NEXT:         mrs x14, s3_7_c16_c15_7
    3815. 

  3815. // CHECK-ERROR-NEXT:                  ^
    3816. 

  3816. 

  3817. //------------------------------------------------------------------------------
    3818. 

  3818. // Test and branch (immediate)
    3819. 

  3819. //------------------------------------------------------------------------------
    3820. 

  3820. 

  3821.         tbz w3, #-1, addr
    3822. 

  3822.         tbz w3, #32, nowhere
    3823. 

  3823.         tbz x9, #-1, there
    3824. 

  3824.         tbz x20, #64, dont
    3825. 

  3825. // CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
    3826. 

  3826. // CHECK-ERROR-NEXT:     tbz w3, #-1, addr
    3827. 

  3827. // CHECK-ERROR-NEXT:             ^
    3828. 

  3828. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    3829. 

  3829. // CHECK-ERROR-NEXT:        tbz w3, #32, nowhere
    3830. 

  3830. // CHECK-ERROR-NEXT:                ^
    3831. 

  3831. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    3832. 

  3832. // CHECK-ERROR-NEXT:        tbz x9, #-1, there
    3833. 

  3833. // CHECK-ERROR-NEXT:                ^
    3834. 

  3834. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    3835. 

  3835. // CHECK-ERROR-NEXT:        tbz x20, #64, dont
    3836. 

  3836. // CHECK-ERROR-NEXT:                 ^
    3837. 

  3837. 

  3838.         tbnz w3, #-1, addr
    3839. 

  3839.         tbnz w3, #32, nowhere
    3840. 

  3840.         tbnz x9, #-1, there
    3841. 

  3841.         tbnz x20, #64, dont
    3842. 

  3842. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    3843. 

  3843. // CHECK-ERROR-NEXT:        tbnz w3, #-1, addr
    3844. 

  3844. // CHECK-ERROR-NEXT:                 ^
    3845. 

  3845. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 31]
    3846. 

  3846. // CHECK-ERROR-NEXT:        tbnz w3, #32, nowhere
    3847. 

  3847. // CHECK-ERROR-NEXT:                 ^
    3848. 

  3848. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    3849. 

  3849. // CHECK-ERROR-NEXT:        tbnz x9, #-1, there
    3850. 

  3850. // CHECK-ERROR-NEXT:                 ^
    3851. 

  3851. // CHECK-ERROR-NEXT: error: {{expected|immediate must be an}} integer in range [0, 63]
    3852. 

  3852. // CHECK-ERROR-NEXT:        tbnz x20, #64, dont
    3853. 

  3853. 

  3854. //------------------------------------------------------------------------------
    3855. 

  3855. // Unconditional branch (immediate)
    3856. 

  3856. //------------------------------------------------------------------------------
    3857. 

  3857. 

  3858.         b #134217728
    3859. 

  3859.         b #-134217732
    3860. 

  3860.         b #1
    3861. 

  3861. // CHECK-ERROR: error: expected label or encodable integer pc offset
    3862. 

  3862. // CHECK-ERROR-NEXT:         b #134217728
    3863. 

  3863. // CHECK-ERROR-NEXT:           ^
    3864. 

  3864. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    3865. 

  3865. // CHECK-ERROR-NEXT:         b #-134217732
    3866. 

  3866. // CHECK-ERROR-NEXT:           ^
    3867. 

  3867. // CHECK-ERROR-NEXT: error: expected label or encodable integer pc offset
    3868. 

  3868. // CHECK-ERROR-NEXT:         b #1
    3869. 

  3869. // CHECK-ERROR-NEXT:           ^
    3870. 

  3870. 

  3871. //------------------------------------------------------------------------------
    3872. 

  3872. // Unconditional branch (register)
    3873. 

  3873. //------------------------------------------------------------------------------
    3874. 

  3874. 

  3875.         br w2
    3876. 

  3876.         br sp
    3877. 

  3877. // CHECK-ERROR: error: invalid operand for instruction
    3878. 

  3878. // CHECK-ERROR-NEXT:         br w2
    3879. 

  3879. // CHECK-ERROR-NEXT:            ^
    3880. 

  3880. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    3881. 

  3881. // CHECK-ERROR-NEXT:         br sp
    3882. 

  3882. // CHECK-ERROR-NEXT:            ^
    3883. 

  3883. 

  3884.         //// These ones shouldn't allow any registers
    3885. 

  3885.         eret x2
    3886. 

  3886.         drps x2
    3887. 

  3887. // CHECK-ERROR: error: invalid operand for instruction
    3888. 

  3888. // CHECK-ERROR-NEXT:         eret x2
    3889. 

  3889. // CHECK-ERROR-NEXT:              ^
    3890. 

  3890. // CHECK-ERROR-NEXT: error: invalid operand for instruction
    3891. 

  3891. // CHECK-ERROR-NEXT:         drps x2
    3892. 

  3892. // CHECK-ERROR-NEXT:              ^
    3893. 

  3893. 

  3894.