test/MC/AArch64/armv8.5a-mte.s

   1 // RUN:     llvm-mc -triple aarch64 -show-encoding -mattr=+mte   < %s      | FileCheck %s
   2 // RUN: not llvm-mc -triple aarch64 -show-encoding -mattr=+v8.5a < %s 2>&1 | FileCheck %s --check-prefix=NOMTE
   3 // RUN: not llvm-mc -triple aarch64 -show-encoding -mattr=-mte   < %s 2>&1 | FileCheck %s --check-prefix=NOMTE
   4
   5 irg x0, x1
   6 irg sp, x1
   7 irg x0, sp
   8 irg x0, x1, x2
   9 irg sp, x1, x2
  10
  11 // CHECK: irg x0, x1            // encoding: [0x20,0x10,0xdf,0x9a]
  12 // CHECK: irg sp, x1            // encoding: [0x3f,0x10,0xdf,0x9a]
  13 // CHECK: irg x0, sp            // encoding: [0xe0,0x13,0xdf,0x9a]
  14 // CHECK: irg x0, x1, x2        // encoding: [0x20,0x10,0xc2,0x9a]
  15 // CHECK: irg sp, x1, x2        // encoding: [0x3f,0x10,0xc2,0x9a]
  16
  17 // NOMTE:      instruction requires: mte
  18 // NOMTE-NEXT: irg x0, x1
  19 // NOMTE:      instruction requires: mte
  20 // NOMTE-NEXT: irg sp, x1
  21 // NOMTE:      instruction requires: mte
  22 // NOMTE-NEXT: irg x0, sp
  23 // NOMTE:      instruction requires: mte
  24 // NOMTE-NEXT: irg x0, x1, x2
  25 // NOMTE:      instruction requires: mte
  26 // NOMTE-NEXT: irg sp, x1, x2
  27
  28 addg x0, x1, #0, #1
  29 addg sp, x2, #32, #3
  30 addg x0, sp, #64, #5
  31 addg x3, x4, #1008, #6
  32 addg x5, x6, #112, #15
  33
  34 subg x0, x1, #0, #1
  35 subg sp, x2, #32, #3
  36 subg x0, sp, #64, #5
  37 subg x3, x4, #1008, #6
  38 subg x5, x6, #112, #15
  39
  40 // CHECK: addg x0, x1, #0, #1   // encoding: [0x20,0x04,0x80,0x91]
  41 // CHECK: addg sp, x2, #32, #3   // encoding: [0x5f,0x0c,0x82,0x91]
  42 // CHECK: addg x0, sp, #64, #5   // encoding: [0xe0,0x17,0x84,0x91]
  43 // CHECK: addg x3, x4, #1008, #6  // encoding: [0x83,0x18,0xbf,0x91]
  44 // CHECK: addg x5, x6, #112, #15  // encoding: [0xc5,0x3c,0x87,0x91]
  45
  46 // CHECK: subg x0, x1, #0, #1   // encoding: [0x20,0x04,0x80,0xd1]
  47 // CHECK: subg sp, x2, #32, #3   // encoding: [0x5f,0x0c,0x82,0xd1]
  48 // CHECK: subg x0, sp, #64, #5   // encoding: [0xe0,0x17,0x84,0xd1]
  49 // CHECK: subg x3, x4, #1008, #6  // encoding: [0x83,0x18,0xbf,0xd1]
  50 // CHECK: subg x5, x6, #112, #15  // encoding: [0xc5,0x3c,0x87,0xd1]
  51
  52 // NOMTE:      instruction requires: mte
  53 // NOMTE-NEXT: addg x0, x1, #0, #1
  54 // NOMTE:      instruction requires: mte
  55 // NOMTE-NEXT: addg sp, x2, #32, #3
  56 // NOMTE:      instruction requires: mte
  57 // NOMTE-NEXT: addg x0, sp, #64, #5
  58 // NOMTE:      instruction requires: mte
  59 // NOMTE-NEXT: addg x3, x4, #1008, #6
  60 // NOMTE:      instruction requires: mte
  61 // NOMTE-NEXT: addg x5, x6, #112, #15
  62
  63 // NOMTE:      instruction requires: mte
  64 // NOMTE-NEXT: subg x0, x1, #0, #1
  65 // NOMTE:      instruction requires: mte
  66 // NOMTE-NEXT: subg sp, x2, #32, #3
  67 // NOMTE:      instruction requires: mte
  68 // NOMTE-NEXT: subg x0, sp, #64, #5
  69 // NOMTE:      instruction requires: mte
  70 // NOMTE-NEXT: subg x3, x4, #1008, #6
  71 // NOMTE:      instruction requires: mte
  72 // NOMTE-NEXT: subg x5, x6, #112, #15
  73
  74 gmi x0, x1, x2
  75 gmi x3, sp, x4
  76 gmi xzr, x0, x30
  77 gmi x30, x0, xzr
  78
  79 // CHECK: gmi x0, x1, x2        // encoding: [0x20,0x14,0xc2,0x9a]
  80 // CHECK: gmi x3, sp, x4        // encoding: [0xe3,0x17,0xc4,0x9a]
  81 // CHECK: gmi xzr, x0, x30      // encoding: [0x1f,0x14,0xde,0x9a]
  82 // CHECK: gmi x30, x0, xzr      // encoding: [0x1e,0x14,0xdf,0x9a]
  83
  84 // NOMTE:      instruction requires: mte
  85 // NOMTE-NEXT: gmi x0, x1, x2
  86 // NOMTE:      instruction requires: mte
  87 // NOMTE-NEXT: gmi x3, sp, x4
  88 // NOMTE:      instruction requires: mte
  89 // NOMTE-NEXT: gmi xzr, x0, x30
  90 // NOMTE:      instruction requires: mte
  91 // NOMTE-NEXT: gmi x30, x0, xzr
  92
  93 stg [x1]
  94 stg [x1, #-4096]
  95 stg [x2, #4080]
  96 stg [sp, #16]
  97
  98 // CHECK: stg [x1]              // encoding: [0x3f,0x08,0x20,0xd9]
  99 // CHECK: stg [x1, #-4096]      // encoding: [0x3f,0x08,0x30,0xd9]
 100 // CHECK: stg [x2, #4080]       // encoding: [0x5f,0xf8,0x2f,0xd9]
 101 // CHECK: stg [sp, #16]         // encoding: [0xff,0x1b,0x20,0xd9]
 102
 103 // NOMTE:      instruction requires: mte
 104 // NOMTE-NEXT: stg
 105 // NOMTE:      instruction requires: mte
 106 // NOMTE-NEXT: stg
 107 // NOMTE:      instruction requires: mte
 108 // NOMTE-NEXT: stg
 109 // NOMTE:      instruction requires: mte
 110 // NOMTE-NEXT: stg
 111
 112 stzg [x1]
 113 stzg [x1, #-4096]
 114 stzg [x2, #4080]
 115 stzg [sp, #16]
 116
 117 // CHECK: stzg [x1]             // encoding: [0x3f,0x08,0x60,0xd9]
 118 // CHECK: stzg [x1, #-4096]     // encoding: [0x3f,0x08,0x70,0xd9]
 119 // CHECK: stzg [x2, #4080]      // encoding: [0x5f,0xf8,0x6f,0xd9]
 120 // CHECK: stzg [sp, #16]        // encoding: [0xff,0x1b,0x60,0xd9]
 121
 122 // NOMTE:      instruction requires: mte
 123 // NOMTE-NEXT: stzg
 124 // NOMTE:      instruction requires: mte
 125 // NOMTE-NEXT: stzg
 126 // NOMTE:      instruction requires: mte
 127 // NOMTE-NEXT: stzg
 128 // NOMTE:      instruction requires: mte
 129 // NOMTE-NEXT: stzg
 130
 131 stg [x1, #-4096]!
 132 stg [x2, #4080]!
 133 stg [sp, #16]!
 134
 135 // CHECK: stg [x1, #-4096]!      // encoding: [0x3f,0x0c,0x30,0xd9]
 136 // CHECK: stg [x2, #4080]!       // encoding: [0x5f,0xfc,0x2f,0xd9]
 137 // CHECK: stg [sp, #16]!         // encoding: [0xff,0x1f,0x20,0xd9]
 138
 139 // NOMTE:      instruction requires: mte
 140 // NOMTE-NEXT: stg
 141 // NOMTE:      instruction requires: mte
 142 // NOMTE-NEXT: stg
 143 // NOMTE:      instruction requires: mte
 144 // NOMTE-NEXT: stg
 145
 146 stzg [x1, #-4096]!
 147 stzg [x2, #4080]!
 148 stzg [sp, #16]!
 149
 150 // CHECK: stzg [x1, #-4096]!     // encoding: [0x3f,0x0c,0x70,0xd9]
 151 // CHECK: stzg [x2, #4080]!      // encoding: [0x5f,0xfc,0x6f,0xd9]
 152 // CHECK: stzg [sp, #16]!        // encoding: [0xff,0x1f,0x60,0xd9]
 153
 154 // NOMTE:      instruction requires: mte
 155 // NOMTE-NEXT: stzg
 156 // NOMTE:      instruction requires: mte
 157 // NOMTE-NEXT: stzg
 158 // NOMTE:      instruction requires: mte
 159 // NOMTE-NEXT: stzg
 160
 161 stg [x1], #-4096
 162 stg [x2], #4080
 163 stg [sp], #16
 164
 165 // CHECK: stg [x1], #-4096       // encoding: [0x3f,0x04,0x30,0xd9]
 166 // CHECK: stg [x2], #4080        // encoding: [0x5f,0xf4,0x2f,0xd9]
 167 // CHECK: stg [sp], #16          // encoding: [0xff,0x17,0x20,0xd9]
 168
 169 // NOMTE:      instruction requires: mte
 170 // NOMTE-NEXT: stg
 171 // NOMTE:      instruction requires: mte
 172 // NOMTE-NEXT: stg
 173 // NOMTE:      instruction requires: mte
 174 // NOMTE-NEXT: stg
 175
 176 stzg [x1], #-4096
 177 stzg [x2], #4080
 178 stzg [sp], #16
 179
 180 // CHECK: stzg [x1], #-4096      // encoding: [0x3f,0x04,0x70,0xd9]
 181 // CHECK: stzg [x2], #4080       // encoding: [0x5f,0xf4,0x6f,0xd9]
 182 // CHECK: stzg [sp], #16         // encoding: [0xff,0x17,0x60,0xd9]
 183
 184 // NOMTE:      instruction requires: mte
 185 // NOMTE-NEXT: stzg
 186 // NOMTE:      instruction requires: mte
 187 // NOMTE-NEXT: stzg
 188 // NOMTE:      instruction requires: mte
 189 // NOMTE-NEXT: stzg
 190
 191 st2g [x1]
 192 st2g [x1, #-4096]
 193 st2g [x2, #4080]
 194 st2g [sp, #16]
 195
 196 // CHECK: st2g [x1]              // encoding: [0x3f,0x08,0xa0,0xd9]
 197 // CHECK: st2g [x1, #-4096]      // encoding: [0x3f,0x08,0xb0,0xd9]
 198 // CHECK: st2g [x2, #4080]       // encoding: [0x5f,0xf8,0xaf,0xd9]
 199 // CHECK: st2g [sp, #16]         // encoding: [0xff,0x1b,0xa0,0xd9]
 200
 201 // NOMTE:      instruction requires: mte
 202 // NOMTE-NEXT: st2g
 203 // NOMTE:      instruction requires: mte
 204 // NOMTE-NEXT: st2g
 205 // NOMTE:      instruction requires: mte
 206 // NOMTE-NEXT: st2g
 207 // NOMTE:      instruction requires: mte
 208 // NOMTE-NEXT: st2g
 209
 210 stz2g [x1]
 211 stz2g [x1, #-4096]
 212 stz2g [x2, #4080]
 213 stz2g [sp, #16]
 214
 215 // CHECK: stz2g [x1]             // encoding: [0x3f,0x08,0xe0,0xd9]
 216 // CHECK: stz2g [x1, #-4096]     // encoding: [0x3f,0x08,0xf0,0xd9]
 217 // CHECK: stz2g [x2, #4080]      // encoding: [0x5f,0xf8,0xef,0xd9]
 218 // CHECK: stz2g [sp, #16]        // encoding: [0xff,0x1b,0xe0,0xd9]
 219
 220 // NOMTE:      instruction requires: mte
 221 // NOMTE-NEXT: stz2g
 222 // NOMTE:      instruction requires: mte
 223 // NOMTE-NEXT: stz2g
 224 // NOMTE:      instruction requires: mte
 225 // NOMTE-NEXT: stz2g
 226 // NOMTE:      instruction requires: mte
 227 // NOMTE-NEXT: stz2g
 228
 229 st2g [x1, #-4096]!
 230 st2g [x2, #4080]!
 231 st2g [sp, #16]!
 232
 233 // CHECK: st2g [x1, #-4096]!     // encoding: [0x3f,0x0c,0xb0,0xd9]
 234 // CHECK: st2g [x2, #4080]!      // encoding: [0x5f,0xfc,0xaf,0xd9]
 235 // CHECK: st2g [sp, #16]!        // encoding: [0xff,0x1f,0xa0,0xd9]
 236
 237 // NOMTE:      instruction requires: mte
 238 // NOMTE-NEXT: st2g
 239 // NOMTE:      instruction requires: mte
 240 // NOMTE-NEXT: st2g
 241 // NOMTE:      instruction requires: mte
 242 // NOMTE-NEXT: st2g
 243
 244 stz2g [x1, #-4096]!
 245 stz2g [x2, #4080]!
 246 stz2g [sp, #16]!
 247
 248 // CHECK: stz2g [x1, #-4096]!    // encoding: [0x3f,0x0c,0xf0,0xd9]
 249 // CHECK: stz2g [x2, #4080]!     // encoding: [0x5f,0xfc,0xef,0xd9]
 250 // CHECK: stz2g [sp, #16]!       // encoding: [0xff,0x1f,0xe0,0xd9]
 251
 252 // NOMTE:      instruction requires: mte
 253 // NOMTE-NEXT: stz2g
 254 // NOMTE:      instruction requires: mte
 255 // NOMTE-NEXT: stz2g
 256 // NOMTE:      instruction requires: mte
 257 // NOMTE-NEXT: stz2g
 258
 259 st2g [x1], #-4096
 260 st2g [x2], #4080
 261 st2g [sp], #16
 262
 263 // CHECK: st2g [x1], #-4096      // encoding: [0x3f,0x04,0xb0,0xd9]
 264 // CHECK: st2g [x2], #4080       // encoding: [0x5f,0xf4,0xaf,0xd9]
 265 // CHECK: st2g [sp], #16         // encoding: [0xff,0x17,0xa0,0xd9]
 266
 267 // NOMTE:      instruction requires: mte
 268 // NOMTE-NEXT: st2g
 269 // NOMTE:      instruction requires: mte
 270 // NOMTE-NEXT: st2g
 271 // NOMTE:      instruction requires: mte
 272 // NOMTE-NEXT: st2g
 273
 274 stz2g [x1], #-4096
 275 stz2g [x2], #4080
 276 stz2g [sp], #16
 277
 278 // CHECK: stz2g [x1], #-4096     // encoding: [0x3f,0x04,0xf0,0xd9]
 279 // CHECK: stz2g [x2], #4080      // encoding: [0x5f,0xf4,0xef,0xd9]
 280 // CHECK: stz2g [sp], #16        // encoding: [0xff,0x17,0xe0,0xd9]
 281
 282 // NOMTE:      instruction requires: mte
 283 // NOMTE-NEXT: stz2g
 284 // NOMTE:      instruction requires: mte
 285 // NOMTE-NEXT: stz2g
 286 // NOMTE:      instruction requires: mte
 287 // NOMTE-NEXT: stz2g
 288
 289 stgp x0, x1, [x2]
 290 stgp x0, x1, [x2, #-1024]
 291 stgp x0, x1, [x2, #1008]
 292 stgp x0, x1, [sp, #16]
 293 stgp xzr, x1, [x2, #16]
 294 stgp x0, xzr, [x2, #16]
 295
 296 // CHECK: stgp x0, x1, [x2]           // encoding: [0x40,0x04,0x00,0x69]
 297 // CHECK: stgp x0, x1, [x2, #-1024]   // encoding: [0x40,0x04,0x20,0x69]
 298 // CHECK: stgp x0, x1, [x2, #1008]    // encoding: [0x40,0x84,0x1f,0x69]
 299 // CHECK: stgp x0, x1, [sp, #16]      // encoding: [0xe0,0x87,0x00,0x69]
 300 // CHECK: stgp xzr, x1, [x2, #16]     // encoding: [0x5f,0x84,0x00,0x69]
 301 // CHECK: stgp x0, xzr, [x2, #16]     // encoding: [0x40,0xfc,0x00,0x69]
 302
 303 // NOMTE:      instruction requires: mte
 304 // NOMTE-NEXT: stgp
 305 // NOMTE:      instruction requires: mte
 306 // NOMTE-NEXT: stgp
 307 // NOMTE:      instruction requires: mte
 308 // NOMTE-NEXT: stgp
 309 // NOMTE:      instruction requires: mte
 310 // NOMTE-NEXT: stgp
 311
 312 stgp x0, x1, [x2, #-1024]!
 313 stgp x0, x1, [x2, #1008]!
 314 stgp x0, x1, [sp, #16]!
 315 stgp xzr, x1, [x2, #16]!
 316 stgp x0, xzr, [x2, #16]!
 317
 318 // CHECK: stgp x0, x1, [x2, #-1024]!   // encoding: [0x40,0x04,0xa0,0x69]
 319 // CHECK: stgp x0, x1, [x2, #1008]!    // encoding: [0x40,0x84,0x9f,0x69]
 320 // CHECK: stgp x0, x1, [sp, #16]!      // encoding: [0xe0,0x87,0x80,0x69]
 321 // CHECK: stgp xzr, x1, [x2, #16]!     // encoding: [0x5f,0x84,0x80,0x69]
 322 // CHECK: stgp x0, xzr, [x2, #16]!     // encoding: [0x40,0xfc,0x80,0x69]
 323
 324 // NOMTE:      instruction requires: mte
 325 // NOMTE-NEXT: stgp
 326 // NOMTE:      instruction requires: mte
 327 // NOMTE-NEXT: stgp
 328 // NOMTE:      instruction requires: mte
 329 // NOMTE-NEXT: stgp
 330 // NOMTE:      instruction requires: mte
 331 // NOMTE-NEXT: stgp
 332 // NOMTE:      instruction requires: mte
 333 // NOMTE-NEXT: stgp
 334
 335 stgp x0, x1, [x2], #-1024
 336 stgp x0, x1, [x2], #1008
 337 stgp x0, x1, [sp], #16
 338 stgp xzr, x1, [x2], #16
 339 stgp x0, xzr, [x2], #16
 340
 341 // CHECK: stgp x0, x1, [x2], #-1024    // encoding: [0x40,0x04,0xa0,0x68]
 342 // CHECK: stgp x0, x1, [x2], #1008     // encoding: [0x40,0x84,0x9f,0x68]
 343 // CHECK: stgp x0, x1, [sp], #16       // encoding: [0xe0,0x87,0x80,0x68]
 344 // CHECK: stgp xzr, x1, [x2], #16      // encoding: [0x5f,0x84,0x80,0x68]
 345 // CHECK: stgp x0, xzr, [x2], #16      // encoding: [0x40,0xfc,0x80,0x68]
 346
 347 // NOMTE:      instruction requires: mte
 348 // NOMTE-NEXT: stgp
 349 // NOMTE:      instruction requires: mte
 350 // NOMTE-NEXT: stgp
 351 // NOMTE:      instruction requires: mte
 352 // NOMTE-NEXT: stgp
 353 // NOMTE:      instruction requires: mte
 354 // NOMTE-NEXT: stgp
 355 // NOMTE:      instruction requires: mte
 356 // NOMTE-NEXT: stgp
 357
 358 dc igvac, x0
 359 dc igsw, x1
 360 dc cgsw, x2
 361 dc cigsw, x3
 362 dc cgvac, x4
 363 dc cgvap, x5
 364 dc cgvadp, x6
 365 dc cigvac, x7
 366 dc gva, x8
 367 dc igdvac, x9
 368 dc igdsw, x10
 369 dc cgdsw, x11
 370 dc cigdsw, x12
 371 dc cgdvac, x13
 372 dc cgdvap, x14
 373 dc cgdvadp, x15
 374 dc cigdvac, x16
 375 dc gzva, x17
 376
 377 // CHECK: dc igvac, x0          // encoding: [0x60,0x76,0x08,0xd5]
 378 // CHECK: dc igsw, x1           // encoding: [0x81,0x76,0x08,0xd5]
 379 // CHECK: dc cgsw, x2           // encoding: [0x82,0x7a,0x08,0xd5]
 380 // CHECK: dc cigsw, x3          // encoding: [0x83,0x7e,0x08,0xd5]
 381 // CHECK: dc cgvac, x4          // encoding: [0x64,0x7a,0x0b,0xd5]
 382 // CHECK: dc cgvap, x5          // encoding: [0x65,0x7c,0x0b,0xd5]
 383 // CHECK: dc cgvadp, x6         // encoding: [0x66,0x7d,0x0b,0xd5]
 384 // CHECK: dc cigvac, x7         // encoding: [0x67,0x7e,0x0b,0xd5]
 385 // CHECK: dc gva, x8            // encoding: [0x68,0x74,0x0b,0xd5]
 386 // CHECK: dc igdvac, x9         // encoding: [0xa9,0x76,0x08,0xd5]
 387 // CHECK: dc igdsw, x10         // encoding: [0xca,0x76,0x08,0xd5]
 388 // CHECK: dc cgdsw, x11         // encoding: [0xcb,0x7a,0x08,0xd5]
 389 // CHECK: dc cigdsw, x12        // encoding: [0xcc,0x7e,0x08,0xd5]
 390 // CHECK: dc cgdvac, x13        // encoding: [0xad,0x7a,0x0b,0xd5]
 391 // CHECK: dc cgdvap, x14        // encoding: [0xae,0x7c,0x0b,0xd5]
 392 // CHECK: dc cgdvadp, x15       // encoding: [0xaf,0x7d,0x0b,0xd5]
 393 // CHECK: dc cigdvac, x16       // encoding: [0xb0,0x7e,0x0b,0xd5]
 394 // CHECK: dc gzva, x17          // encoding: [0x91,0x74,0x0b,0xd5]
 395
 396 // NOMTE: DC IGVAC requires mte
 397 // NOMTE: DC IGSW requires mte
 398 // NOMTE: DC CGSW requires mte
 399 // NOMTE: DC CIGSW requires mte
 400 // NOMTE: DC CGVAC requires mte
 401 // NOMTE: DC CGVAP requires mte
 402 // NOMTE: DC CGVADP requires mte
 403 // NOMTE: DC CIGVAC requires mte
 404 // NOMTE: DC GVA requires mte
 405 // NOMTE: DC IGDVAC requires mte
 406 // NOMTE: DC IGDSW requires mte
 407 // NOMTE: DC CGDSW requires mte
 408 // NOMTE: DC CIGDSW requires mte
 409 // NOMTE: DC CGDVAC requires mte
 410 // NOMTE: DC CGDVAP requires mte
 411 // NOMTE: DC CGDVADP requires mte
 412 // NOMTE: DC CIGDVAC requires mte
 413 // NOMTE: DC GZVA requires mte
 414
 415 mrs x0, tco
 416 mrs x1, gcr_el1
 417 mrs x2, rgsr_el1
 418 mrs x3, tfsr_el1
 419 mrs x4, tfsr_el2
 420 mrs x5, tfsr_el3
 421 mrs x6, tfsr_el12
 422 mrs x7, tfsre0_el1
 423
 424 // CHECK: mrs x0, TCO           // encoding: [0xe0,0x42,0x3b,0xd5]
 425 // CHECK: mrs x1, GCR_EL1       // encoding: [0xc1,0x10,0x38,0xd5]
 426 // CHECK: mrs x2, RGSR_EL1      // encoding: [0xa2,0x10,0x38,0xd5]
 427 // CHECK: mrs x3, TFSR_EL1      // encoding: [0x03,0x65,0x38,0xd5]
 428 // CHECK: mrs x4, TFSR_EL2      // encoding: [0x04,0x65,0x3c,0xd5]
 429 // CHECK: mrs x5, TFSR_EL3      // encoding: [0x05,0x66,0x3e,0xd5]
 430 // CHECK: mrs x6, TFSR_EL12     // encoding: [0x06,0x66,0x3d,0xd5]
 431 // CHECK: mrs x7, TFSRE0_EL1    // encoding: [0x27,0x66,0x38,0xd5]
 432
 433 // NOMTE: expected readable system register
 434 // NOMTE-NEXT: tco
 435 // NOMTE: expected readable system register
 436 // NOMTE-NEXT: gcr_el1
 437 // NOMTE: expected readable system register
 438 // NOMTE-NEXT: rgsr_el1
 439 // NOMTE: expected readable system register
 440 // NOMTE-NEXT: tfsr_el1
 441 // NOMTE: expected readable system register
 442 // NOMTE-NEXT: tfsr_el2
 443 // NOMTE: expected readable system register
 444 // NOMTE-NEXT: tfsr_el3
 445 // NOMTE: expected readable system register
 446 // NOMTE-NEXT: tfsr_el12
 447 // NOMTE: expected readable system register
 448 // NOMTE-NEXT: tfsre0_el1
 449
 450 msr tco, #0
 451
 452 // CHECK: msr TCO, #0           // encoding: [0x9f,0x40,0x03,0xd5]
 453
 454 // NOMTE: expected writable system register or pstate
 455 // NOMTE-NEXT: tco
 456
 457 msr tco, x0
 458 msr gcr_el1, x1
 459 msr rgsr_el1, x2
 460 msr tfsr_el1, x3
 461 msr tfsr_el2, x4
 462 msr tfsr_el3, x5
 463 msr tfsr_el12, x6
 464 msr tfsre0_el1, x7
 465
 466 // CHECK: msr TCO, x0           // encoding: [0xe0,0x42,0x1b,0xd5]
 467 // CHECK: msr GCR_EL1, x1       // encoding: [0xc1,0x10,0x18,0xd5]
 468 // CHECK: msr RGSR_EL1, x2      // encoding: [0xa2,0x10,0x18,0xd5]
 469 // CHECK: msr TFSR_EL1, x3      // encoding: [0x03,0x65,0x18,0xd5]
 470 // CHECK: msr TFSR_EL2, x4      // encoding: [0x04,0x65,0x1c,0xd5]
 471 // CHECK: msr TFSR_EL3, x5      // encoding: [0x05,0x66,0x1e,0xd5]
 472 // CHECK: msr TFSR_EL12, x6     // encoding: [0x06,0x66,0x1d,0xd5]
 473 // CHECK: msr TFSRE0_EL1, x7    // encoding: [0x27,0x66,0x18,0xd5]
 474
 475 // NOMTE: expected writable system register or pstate
 476 // NOMTE-NEXT: tco
 477 // NOMTE: expected writable system register or pstate
 478 // NOMTE-NEXT: gcr_el1
 479 // NOMTE: expected writable system register or pstate
 480 // NOMTE-NEXT: rgsr_el1
 481 // NOMTE: expected writable system register or pstate
 482 // NOMTE-NEXT: tfsr_el1
 483 // NOMTE: expected writable system register or pstate
 484 // NOMTE-NEXT: tfsr_el2
 485 // NOMTE: expected writable system register or pstate
 486 // NOMTE-NEXT: tfsr_el3
 487 // NOMTE: expected writable system register or pstate
 488 // NOMTE-NEXT: tfsr_el12
 489 // NOMTE: expected writable system register or pstate
 490 // NOMTE-NEXT: tfsre0_el1
 491
 492 subp  x0, x1, x2
 493 subp  x0, sp, sp
 494 subps x0, x1, x2
 495 subps x0, sp, sp
 496
 497 // CHECK: subp  x0, x1, x2  // encoding: [0x20,0x00,0xc2,0x9a]
 498 // CHECK: subp  x0, sp, sp  // encoding: [0xe0,0x03,0xdf,0x9a]
 499 // CHECK: subps x0, x1, x2  // encoding: [0x20,0x00,0xc2,0xba]
 500 // CHECK: subps x0, sp, sp  // encoding: [0xe0,0x03,0xdf,0xba]
 501
 502 // NOMTE: instruction requires: mte
 503 // NOMTE: instruction requires: mte
 504 // NOMTE: instruction requires: mte
 505
 506 subps xzr, x0, x1
 507 cmpp  x0, x1
 508 subps xzr, sp, sp
 509 cmpp  sp, sp
 510
 511 // CHECK: subps xzr, x0, x1 // encoding: [0x1f,0x00,0xc1,0xba]
 512 // CHECK: subps xzr, x0, x1 // encoding: [0x1f,0x00,0xc1,0xba]
 513 // CHECK: subps xzr, sp, sp // encoding: [0xff,0x03,0xdf,0xba]
 514 // CHECK: subps xzr, sp, sp // encoding: [0xff,0x03,0xdf,0xba]
 515
 516 // NOMTE: instruction requires: mte
 517 // NOMTE: instruction requires: mte
 518 // NOMTE: instruction requires: mte
 519 // NOMTE: instruction requires: mte
 520
 521 ldg X0, [X1, #0]
 522 ldg X2, [sp, #-4096]
 523 ldg x3, [x4, #4080]
 524
 525 // CHECK: ldg x0, [x1]         // encoding: [0x20,0x00,0x60,0xd9]
 526 // CHECK: ldg x2, [sp, #-4096] // encoding: [0xe2,0x03,0x70,0xd9]
 527 // CHECK: ldg x3, [x4, #4080]  // encoding: [0x83,0xf0,0x6f,0xd9]
 528
 529 // NOMTE: instruction requires: mte
 530 // NOMTE: instruction requires: mte
 531 // NOMTE: instruction requires: mte
 532
 533 ldgv x0, [x1]!
 534 ldgv x1, [sp]!
 535 ldgv xzr, [x2]!
 536
 537 // CHECK: ldgv x0, [x1]!  // encoding: [0x20,0x00,0xe0,0xd9]
 538 // CHECK: ldgv x1, [sp]!  // encoding: [0xe1,0x03,0xe0,0xd9]
 539 // CHECK: ldgv xzr, [x2]! // encoding: [0x5f,0x00,0xe0,0xd9]
 540
 541 // NOMTE: instruction requires: mte
 542 // NOMTE: instruction requires: mte
 543
 544 stgv x0, [x1]!
 545 stgv x1, [sp]!
 546 stgv xzr, [x2]!
 547
 548 // CHECK: stgv x0, [x1]!  // encoding: [0x20,0x00,0xa0,0xd9]
 549 // CHECK: stgv x1, [sp]!  // encoding: [0xe1,0x03,0xa0,0xd9]
 550 // CHECK: stgv xzr, [x2]! // encoding: [0x5f,0x00,0xa0,0xd9]
 551
 552 // NOMTE: instruction requires: mte
 553 // NOMTE: instruction requires: mte