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 x0,  [x1]
  94 stg x1,  [x1, #-4096]
  95 stg x2,  [x2, #4080]
  96 stg x3,  [sp, #16]
  97 stg sp,  [sp, #16]
  98
  99 // CHECK: stg x0,  [x1]              // encoding: [0x20,0x08,0x20,0xd9]
 100 // CHECK: stg x1,  [x1, #-4096]      // encoding: [0x21,0x08,0x30,0xd9]
 101 // CHECK: stg x2,  [x2, #4080]       // encoding: [0x42,0xf8,0x2f,0xd9]
 102 // CHECK: stg x3,  [sp, #16]         // encoding: [0xe3,0x1b,0x20,0xd9]
 103 // CHECK: stg sp,  [sp, #16]         // encoding: [0xff,0x1b,0x20,0xd9]
 104
 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 // NOMTE:      instruction requires: mte
 112 // NOMTE-NEXT: stg
 113 // NOMTE:      instruction requires: mte
 114 // NOMTE-NEXT: stg
 115
 116 stzg x0,  [x1]
 117 stzg x1,  [x1, #-4096]
 118 stzg x2,  [x2, #4080]
 119 stzg x3,  [sp, #16]
 120 stzg sp,  [sp, #16]
 121
 122 // CHECK: stzg x0,  [x1]             // encoding: [0x20,0x08,0x60,0xd9]
 123 // CHECK: stzg x1,  [x1, #-4096]     // encoding: [0x21,0x08,0x70,0xd9]
 124 // CHECK: stzg x2,  [x2, #4080]      // encoding: [0x42,0xf8,0x6f,0xd9]
 125 // CHECK: stzg x3,  [sp, #16]        // encoding: [0xe3,0x1b,0x60,0xd9]
 126 // CHECK: stzg sp,  [sp, #16]        // encoding: [0xff,0x1b,0x60,0xd9]
 127
 128 // NOMTE:      instruction requires: mte
 129 // NOMTE-NEXT: stzg
 130 // NOMTE:      instruction requires: mte
 131 // NOMTE-NEXT: stzg
 132 // NOMTE:      instruction requires: mte
 133 // NOMTE-NEXT: stzg
 134 // NOMTE:      instruction requires: mte
 135 // NOMTE-NEXT: stzg
 136 // NOMTE:      instruction requires: mte
 137 // NOMTE-NEXT: stzg
 138
 139 stg x0,  [x1, #-4096]!
 140 stg x1,  [x2, #4080]!
 141 stg x2,  [sp, #16]!
 142 stg sp,  [sp, #16]!
 143
 144 // CHECK: stg x0,  [x1, #-4096]!      // encoding: [0x20,0x0c,0x30,0xd9]
 145 // CHECK: stg x1,  [x2, #4080]!       // encoding: [0x41,0xfc,0x2f,0xd9]
 146 // CHECK: stg x2,  [sp, #16]!         // encoding: [0xe2,0x1f,0x20,0xd9]
 147 // CHECK: stg sp,  [sp, #16]!         // encoding: [0xff,0x1f,0x20,0xd9]
 148
 149 // NOMTE:      instruction requires: mte
 150 // NOMTE-NEXT: stg
 151 // NOMTE:      instruction requires: mte
 152 // NOMTE-NEXT: stg
 153 // NOMTE:      instruction requires: mte
 154 // NOMTE-NEXT: stg
 155 // NOMTE:      instruction requires: mte
 156 // NOMTE-NEXT: stg
 157
 158 stzg x0,  [x1, #-4096]!
 159 stzg x1,  [x2, #4080]!
 160 stzg x2,  [sp, #16]!
 161 stzg sp,  [sp, #16]!
 162
 163 // CHECK: stzg x0,  [x1, #-4096]!     // encoding: [0x20,0x0c,0x70,0xd9]
 164 // CHECK: stzg x1,  [x2, #4080]!      // encoding: [0x41,0xfc,0x6f,0xd9]
 165 // CHECK: stzg x2,  [sp, #16]!        // encoding: [0xe2,0x1f,0x60,0xd9]
 166 // CHECK: stzg sp,  [sp, #16]!        // encoding: [0xff,0x1f,0x60,0xd9]
 167
 168 // NOMTE:      instruction requires: mte
 169 // NOMTE-NEXT: stzg
 170 // NOMTE:      instruction requires: mte
 171 // NOMTE-NEXT: stzg
 172 // NOMTE:      instruction requires: mte
 173 // NOMTE-NEXT: stzg
 174 // NOMTE:      instruction requires: mte
 175 // NOMTE-NEXT: stzg
 176
 177 stg x0,  [x1], #-4096
 178 stg x1,  [x2], #4080
 179 stg x2,  [sp], #16
 180 stg sp,  [sp], #16
 181
 182 // CHECK: stg x0,  [x1], #-4096       // encoding: [0x20,0x04,0x30,0xd9]
 183 // CHECK: stg x1,  [x2], #4080        // encoding: [0x41,0xf4,0x2f,0xd9]
 184 // CHECK: stg x2,  [sp], #16          // encoding: [0xe2,0x17,0x20,0xd9]
 185 // CHECK: stg sp,  [sp], #16          // encoding: [0xff,0x17,0x20,0xd9]
 186
 187 // NOMTE:      instruction requires: mte
 188 // NOMTE-NEXT: stg
 189 // NOMTE:      instruction requires: mte
 190 // NOMTE-NEXT: stg
 191 // NOMTE:      instruction requires: mte
 192 // NOMTE-NEXT: stg
 193 // NOMTE:      instruction requires: mte
 194 // NOMTE-NEXT: stg
 195
 196 stzg x0,  [x1], #-4096
 197 stzg x1,  [x2], #4080
 198 stzg x2,  [sp], #16
 199 stzg sp,  [sp], #16
 200
 201 // CHECK: stzg x0,  [x1], #-4096      // encoding: [0x20,0x04,0x70,0xd9]
 202 // CHECK: stzg x1,  [x2], #4080       // encoding: [0x41,0xf4,0x6f,0xd9]
 203 // CHECK: stzg x2,  [sp], #16         // encoding: [0xe2,0x17,0x60,0xd9]
 204 // CHECK: stzg sp,  [sp], #16         // encoding: [0xff,0x17,0x60,0xd9]
 205
 206 // NOMTE:      instruction requires: mte
 207 // NOMTE-NEXT: stzg
 208 // NOMTE:      instruction requires: mte
 209 // NOMTE-NEXT: stzg
 210 // NOMTE:      instruction requires: mte
 211 // NOMTE-NEXT: stzg
 212 // NOMTE:      instruction requires: mte
 213 // NOMTE-NEXT: stzg
 214
 215 st2g x0,  [x1]
 216 st2g x1,  [x1, #-4096]
 217 st2g x2,  [x2, #4080]
 218 st2g x3,  [sp, #16]
 219 st2g sp,  [sp, #16]
 220
 221 // CHECK: st2g x0,  [x1]              // encoding: [0x20,0x08,0xa0,0xd9]
 222 // CHECK: st2g x1,  [x1, #-4096]      // encoding: [0x21,0x08,0xb0,0xd9]
 223 // CHECK: st2g x2,  [x2, #4080]       // encoding: [0x42,0xf8,0xaf,0xd9]
 224 // CHECK: st2g x3,  [sp, #16]         // encoding: [0xe3,0x1b,0xa0,0xd9]
 225 // CHECK: st2g sp,  [sp, #16]         // encoding: [0xff,0x1b,0xa0,0xd9]
 226
 227 // NOMTE:      instruction requires: mte
 228 // NOMTE-NEXT: st2g
 229 // NOMTE:      instruction requires: mte
 230 // NOMTE-NEXT: st2g
 231 // NOMTE:      instruction requires: mte
 232 // NOMTE-NEXT: st2g
 233 // NOMTE:      instruction requires: mte
 234 // NOMTE-NEXT: st2g
 235 // NOMTE:      instruction requires: mte
 236 // NOMTE-NEXT: st2g
 237
 238 stz2g x0,  [x1]
 239 stz2g x1,  [x1, #-4096]
 240 stz2g x2,  [x2, #4080]
 241 stz2g x3,  [sp, #16]
 242 stz2g sp,  [sp, #16]
 243
 244 // CHECK: stz2g x0,  [x1]             // encoding: [0x20,0x08,0xe0,0xd9]
 245 // CHECK: stz2g x1,  [x1, #-4096]     // encoding: [0x21,0x08,0xf0,0xd9]
 246 // CHECK: stz2g x2,  [x2, #4080]      // encoding: [0x42,0xf8,0xef,0xd9]
 247 // CHECK: stz2g x3,  [sp, #16]        // encoding: [0xe3,0x1b,0xe0,0xd9]
 248 // CHECK: stz2g sp,  [sp, #16]        // encoding: [0xff,0x1b,0xe0,0xd9]
 249
 250 // NOMTE:      instruction requires: mte
 251 // NOMTE-NEXT: stz2g
 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 // NOMTE:      instruction requires: mte
 259 // NOMTE-NEXT: stz2g
 260
 261 st2g x0,  [x1, #-4096]!
 262 st2g x1,  [x2, #4080]!
 263 st2g x2,  [sp, #16]!
 264 st2g sp,  [sp, #16]!
 265
 266 // CHECK: st2g x0,  [x1, #-4096]!     // encoding: [0x20,0x0c,0xb0,0xd9]
 267 // CHECK: st2g x1,  [x2, #4080]!      // encoding: [0x41,0xfc,0xaf,0xd9]
 268 // CHECK: st2g x2,  [sp, #16]!        // encoding: [0xe2,0x1f,0xa0,0xd9]
 269 // CHECK: st2g sp,  [sp, #16]!        // encoding: [0xff,0x1f,0xa0,0xd9]
 270
 271 // NOMTE:      instruction requires: mte
 272 // NOMTE-NEXT: st2g
 273 // NOMTE:      instruction requires: mte
 274 // NOMTE-NEXT: st2g
 275 // NOMTE:      instruction requires: mte
 276 // NOMTE-NEXT: st2g
 277 // NOMTE:      instruction requires: mte
 278 // NOMTE-NEXT: st2g
 279
 280 stz2g x0,  [x1, #-4096]!
 281 stz2g x1,  [x2, #4080]!
 282 stz2g x2,  [sp, #16]!
 283 stz2g sp,  [sp, #16]!
 284
 285 // CHECK: stz2g x0,  [x1, #-4096]!    // encoding: [0x20,0x0c,0xf0,0xd9]
 286 // CHECK: stz2g x1,  [x2, #4080]!     // encoding: [0x41,0xfc,0xef,0xd9]
 287 // CHECK: stz2g x2,  [sp, #16]!       // encoding: [0xe2,0x1f,0xe0,0xd9]
 288 // CHECK: stz2g sp,  [sp, #16]!       // encoding: [0xff,0x1f,0xe0,0xd9]
 289
 290 // NOMTE:      instruction requires: mte
 291 // NOMTE-NEXT: stz2g
 292 // NOMTE:      instruction requires: mte
 293 // NOMTE-NEXT: stz2g
 294 // NOMTE:      instruction requires: mte
 295 // NOMTE-NEXT: stz2g
 296 // NOMTE:      instruction requires: mte
 297 // NOMTE-NEXT: stz2g
 298
 299 st2g x0,  [x1], #-4096
 300 st2g x1,  [x2], #4080
 301 st2g x2,  [sp], #16
 302 st2g sp,  [sp], #16
 303
 304 // CHECK: st2g x0,  [x1], #-4096      // encoding: [0x20,0x04,0xb0,0xd9]
 305 // CHECK: st2g x1,  [x2], #4080       // encoding: [0x41,0xf4,0xaf,0xd9]
 306 // CHECK: st2g x2,  [sp], #16         // encoding: [0xe2,0x17,0xa0,0xd9]
 307 // CHECK: st2g sp,  [sp], #16         // encoding: [0xff,0x17,0xa0,0xd9]
 308
 309 // NOMTE:      instruction requires: mte
 310 // NOMTE-NEXT: st2g
 311 // NOMTE:      instruction requires: mte
 312 // NOMTE-NEXT: st2g
 313 // NOMTE:      instruction requires: mte
 314 // NOMTE-NEXT: st2g
 315 // NOMTE:      instruction requires: mte
 316 // NOMTE-NEXT: st2g
 317
 318 stz2g x0,  [x1], #-4096
 319 stz2g x1,  [x2], #4080
 320 stz2g x2,  [sp], #16
 321 stz2g sp,  [sp], #16
 322
 323 // CHECK: stz2g x0,  [x1], #-4096     // encoding: [0x20,0x04,0xf0,0xd9]
 324 // CHECK: stz2g x1,  [x2], #4080      // encoding: [0x41,0xf4,0xef,0xd9]
 325 // CHECK: stz2g x2,  [sp], #16        // encoding: [0xe2,0x17,0xe0,0xd9]
 326 // CHECK: stz2g sp,  [sp], #16        // encoding: [0xff,0x17,0xe0,0xd9]
 327
 328 // NOMTE:      instruction requires: mte
 329 // NOMTE-NEXT: stz2g
 330 // NOMTE:      instruction requires: mte
 331 // NOMTE-NEXT: stz2g
 332 // NOMTE:      instruction requires: mte
 333 // NOMTE-NEXT: stz2g
 334 // NOMTE:      instruction requires: mte
 335 // NOMTE-NEXT: stz2g
 336
 337 stgp x0, x1, [x2]
 338 stgp x0, x1, [x2, #-1024]
 339 stgp x0, x1, [x2, #1008]
 340 stgp x0, x1, [sp, #16]
 341 stgp xzr, x1, [x2, #16]
 342 stgp x0, xzr, [x2, #16]
 343
 344 // CHECK: stgp x0, x1, [x2]           // encoding: [0x40,0x04,0x00,0x69]
 345 // CHECK: stgp x0, x1, [x2, #-1024]   // encoding: [0x40,0x04,0x20,0x69]
 346 // CHECK: stgp x0, x1, [x2, #1008]    // encoding: [0x40,0x84,0x1f,0x69]
 347 // CHECK: stgp x0, x1, [sp, #16]      // encoding: [0xe0,0x87,0x00,0x69]
 348 // CHECK: stgp xzr, x1, [x2, #16]     // encoding: [0x5f,0x84,0x00,0x69]
 349 // CHECK: stgp x0, xzr, [x2, #16]     // encoding: [0x40,0xfc,0x00,0x69]
 350
 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 // NOMTE:      instruction requires: mte
 358 // NOMTE-NEXT: stgp
 359
 360 stgp x0, x1, [x2, #-1024]!
 361 stgp x0, x1, [x2, #1008]!
 362 stgp x0, x1, [sp, #16]!
 363 stgp xzr, x1, [x2, #16]!
 364 stgp x0, xzr, [x2, #16]!
 365
 366 // CHECK: stgp x0, x1, [x2, #-1024]!   // encoding: [0x40,0x04,0xa0,0x69]
 367 // CHECK: stgp x0, x1, [x2, #1008]!    // encoding: [0x40,0x84,0x9f,0x69]
 368 // CHECK: stgp x0, x1, [sp, #16]!      // encoding: [0xe0,0x87,0x80,0x69]
 369 // CHECK: stgp xzr, x1, [x2, #16]!     // encoding: [0x5f,0x84,0x80,0x69]
 370 // CHECK: stgp x0, xzr, [x2, #16]!     // encoding: [0x40,0xfc,0x80,0x69]
 371
 372 // NOMTE:      instruction requires: mte
 373 // NOMTE-NEXT: stgp
 374 // NOMTE:      instruction requires: mte
 375 // NOMTE-NEXT: stgp
 376 // NOMTE:      instruction requires: mte
 377 // NOMTE-NEXT: stgp
 378 // NOMTE:      instruction requires: mte
 379 // NOMTE-NEXT: stgp
 380 // NOMTE:      instruction requires: mte
 381 // NOMTE-NEXT: stgp
 382
 383 stgp x0, x1, [x2], #-1024
 384 stgp x0, x1, [x2], #1008
 385 stgp x0, x1, [sp], #16
 386 stgp xzr, x1, [x2], #16
 387 stgp x0, xzr, [x2], #16
 388
 389 // CHECK: stgp x0, x1, [x2], #-1024    // encoding: [0x40,0x04,0xa0,0x68]
 390 // CHECK: stgp x0, x1, [x2], #1008     // encoding: [0x40,0x84,0x9f,0x68]
 391 // CHECK: stgp x0, x1, [sp], #16       // encoding: [0xe0,0x87,0x80,0x68]
 392 // CHECK: stgp xzr, x1, [x2], #16      // encoding: [0x5f,0x84,0x80,0x68]
 393 // CHECK: stgp x0, xzr, [x2], #16      // encoding: [0x40,0xfc,0x80,0x68]
 394
 395 // NOMTE:      instruction requires: mte
 396 // NOMTE-NEXT: stgp
 397 // NOMTE:      instruction requires: mte
 398 // NOMTE-NEXT: stgp
 399 // NOMTE:      instruction requires: mte
 400 // NOMTE-NEXT: stgp
 401 // NOMTE:      instruction requires: mte
 402 // NOMTE-NEXT: stgp
 403 // NOMTE:      instruction requires: mte
 404 // NOMTE-NEXT: stgp
 405
 406 dc igvac, x0
 407 dc igsw, x1
 408 dc cgsw, x2
 409 dc cigsw, x3
 410 dc cgvac, x4
 411 dc cgvap, x5
 412 dc cgvadp, x6
 413 dc cigvac, x7
 414 dc gva, x8
 415 dc igdvac, x9
 416 dc igdsw, x10
 417 dc cgdsw, x11
 418 dc cigdsw, x12
 419 dc cgdvac, x13
 420 dc cgdvap, x14
 421 dc cgdvadp, x15
 422 dc cigdvac, x16
 423 dc gzva, x17
 424
 425 // CHECK: dc igvac, x0          // encoding: [0x60,0x76,0x08,0xd5]
 426 // CHECK: dc igsw, x1           // encoding: [0x81,0x76,0x08,0xd5]
 427 // CHECK: dc cgsw, x2           // encoding: [0x82,0x7a,0x08,0xd5]
 428 // CHECK: dc cigsw, x3          // encoding: [0x83,0x7e,0x08,0xd5]
 429 // CHECK: dc cgvac, x4          // encoding: [0x64,0x7a,0x0b,0xd5]
 430 // CHECK: dc cgvap, x5          // encoding: [0x65,0x7c,0x0b,0xd5]
 431 // CHECK: dc cgvadp, x6         // encoding: [0x66,0x7d,0x0b,0xd5]
 432 // CHECK: dc cigvac, x7         // encoding: [0x67,0x7e,0x0b,0xd5]
 433 // CHECK: dc gva, x8            // encoding: [0x68,0x74,0x0b,0xd5]
 434 // CHECK: dc igdvac, x9         // encoding: [0xa9,0x76,0x08,0xd5]
 435 // CHECK: dc igdsw, x10         // encoding: [0xca,0x76,0x08,0xd5]
 436 // CHECK: dc cgdsw, x11         // encoding: [0xcb,0x7a,0x08,0xd5]
 437 // CHECK: dc cigdsw, x12        // encoding: [0xcc,0x7e,0x08,0xd5]
 438 // CHECK: dc cgdvac, x13        // encoding: [0xad,0x7a,0x0b,0xd5]
 439 // CHECK: dc cgdvap, x14        // encoding: [0xae,0x7c,0x0b,0xd5]
 440 // CHECK: dc cgdvadp, x15       // encoding: [0xaf,0x7d,0x0b,0xd5]
 441 // CHECK: dc cigdvac, x16       // encoding: [0xb0,0x7e,0x0b,0xd5]
 442 // CHECK: dc gzva, x17          // encoding: [0x91,0x74,0x0b,0xd5]
 443
 444 // NOMTE: DC IGVAC requires mte
 445 // NOMTE: DC IGSW requires mte
 446 // NOMTE: DC CGSW requires mte
 447 // NOMTE: DC CIGSW requires mte
 448 // NOMTE: DC CGVAC requires mte
 449 // NOMTE: DC CGVAP requires mte
 450 // NOMTE: DC CGVADP requires mte
 451 // NOMTE: DC CIGVAC requires mte
 452 // NOMTE: DC GVA requires mte
 453 // NOMTE: DC IGDVAC requires mte
 454 // NOMTE: DC IGDSW requires mte
 455 // NOMTE: DC CGDSW requires mte
 456 // NOMTE: DC CIGDSW requires mte
 457 // NOMTE: DC CGDVAC requires mte
 458 // NOMTE: DC CGDVAP requires mte
 459 // NOMTE: DC CGDVADP requires mte
 460 // NOMTE: DC CIGDVAC requires mte
 461 // NOMTE: DC GZVA requires mte
 462
 463 mrs x0, tco
 464 mrs x1, gcr_el1
 465 mrs x2, rgsr_el1
 466 mrs x3, tfsr_el1
 467 mrs x4, tfsr_el2
 468 mrs x5, tfsr_el3
 469 mrs x6, tfsr_el12
 470 mrs x7, tfsre0_el1
 471 mrs x7, gmid_el1
 472
 473 // CHECK: mrs x0, TCO           // encoding: [0xe0,0x42,0x3b,0xd5]
 474 // CHECK: mrs x1, GCR_EL1       // encoding: [0xc1,0x10,0x38,0xd5]
 475 // CHECK: mrs x2, RGSR_EL1      // encoding: [0xa2,0x10,0x38,0xd5]
 476 // CHECK: mrs x3, TFSR_EL1      // encoding: [0x03,0x56,0x38,0xd5]
 477 // CHECK: mrs x4, TFSR_EL2      // encoding: [0x04,0x56,0x3c,0xd5]
 478 // CHECK: mrs x5, TFSR_EL3      // encoding: [0x05,0x56,0x3e,0xd5]
 479 // CHECK: mrs x6, TFSR_EL12     // encoding: [0x06,0x56,0x3d,0xd5]
 480 // CHECK: mrs x7, TFSRE0_EL1    // encoding: [0x27,0x56,0x38,0xd5]
 481 // CHECK: mrs x7, GMID_EL1      // encoding: [0x87,0x00,0x39,0xd5]
 482
 483 // NOMTE: expected readable system register
 484 // NOMTE-NEXT: tco
 485 // NOMTE: expected readable system register
 486 // NOMTE-NEXT: gcr_el1
 487 // NOMTE: expected readable system register
 488 // NOMTE-NEXT: rgsr_el1
 489 // NOMTE: expected readable system register
 490 // NOMTE-NEXT: tfsr_el1
 491 // NOMTE: expected readable system register
 492 // NOMTE-NEXT: tfsr_el2
 493 // NOMTE: expected readable system register
 494 // NOMTE-NEXT: tfsr_el3
 495 // NOMTE: expected readable system register
 496 // NOMTE-NEXT: tfsr_el12
 497 // NOMTE: expected readable system register
 498 // NOMTE-NEXT: tfsre0_el1
 499 // NOMTE: expected readable system register
 500 // NOMTE-NEXT: gmid_el1
 501
 502 msr tco, #0
 503
 504 // CHECK: msr TCO, #0           // encoding: [0x9f,0x40,0x03,0xd5]
 505
 506 // NOMTE: expected writable system register or pstate
 507 // NOMTE-NEXT: tco
 508
 509 msr tco, x0
 510 msr gcr_el1, x1
 511 msr rgsr_el1, x2
 512 msr tfsr_el1, x3
 513 msr tfsr_el2, x4
 514 msr tfsr_el3, x5
 515 msr tfsr_el12, x6
 516 msr tfsre0_el1, x7
 517
 518 // CHECK: msr TCO, x0           // encoding: [0xe0,0x42,0x1b,0xd5]
 519 // CHECK: msr GCR_EL1, x1       // encoding: [0xc1,0x10,0x18,0xd5]
 520 // CHECK: msr RGSR_EL1, x2      // encoding: [0xa2,0x10,0x18,0xd5]
 521 // CHECK: msr TFSR_EL1, x3      // encoding: [0x03,0x56,0x18,0xd5]
 522 // CHECK: msr TFSR_EL2, x4      // encoding: [0x04,0x56,0x1c,0xd5]
 523 // CHECK: msr TFSR_EL3, x5      // encoding: [0x05,0x56,0x1e,0xd5]
 524 // CHECK: msr TFSR_EL12, x6     // encoding: [0x06,0x56,0x1d,0xd5]
 525 // CHECK: msr TFSRE0_EL1, x7    // encoding: [0x27,0x56,0x18,0xd5]
 526
 527 // NOMTE: expected writable system register or pstate
 528 // NOMTE-NEXT: tco
 529 // NOMTE: expected writable system register or pstate
 530 // NOMTE-NEXT: gcr_el1
 531 // NOMTE: expected writable system register or pstate
 532 // NOMTE-NEXT: rgsr_el1
 533 // NOMTE: expected writable system register or pstate
 534 // NOMTE-NEXT: tfsr_el1
 535 // NOMTE: expected writable system register or pstate
 536 // NOMTE-NEXT: tfsr_el2
 537 // NOMTE: expected writable system register or pstate
 538 // NOMTE-NEXT: tfsr_el3
 539 // NOMTE: expected writable system register or pstate
 540 // NOMTE-NEXT: tfsr_el12
 541 // NOMTE: expected writable system register or pstate
 542 // NOMTE-NEXT: tfsre0_el1
 543
 544 subp  x0, x1, x2
 545 subp  x0, sp, sp
 546 subps x0, x1, x2
 547 subps x0, sp, sp
 548
 549 // CHECK: subp  x0, x1, x2  // encoding: [0x20,0x00,0xc2,0x9a]
 550 // CHECK: subp  x0, sp, sp  // encoding: [0xe0,0x03,0xdf,0x9a]
 551 // CHECK: subps x0, x1, x2  // encoding: [0x20,0x00,0xc2,0xba]
 552 // CHECK: subps x0, sp, sp  // encoding: [0xe0,0x03,0xdf,0xba]
 553
 554 // NOMTE: instruction requires: mte
 555 // NOMTE: instruction requires: mte
 556 // NOMTE: instruction requires: mte
 557
 558 subps xzr, x0, x1
 559 cmpp  x0, x1
 560 subps xzr, sp, sp
 561 cmpp  sp, sp
 562
 563 // CHECK: subps xzr, x0, x1 // encoding: [0x1f,0x00,0xc1,0xba]
 564 // CHECK: subps xzr, x0, x1 // encoding: [0x1f,0x00,0xc1,0xba]
 565 // CHECK: subps xzr, sp, sp // encoding: [0xff,0x03,0xdf,0xba]
 566 // CHECK: subps xzr, sp, sp // encoding: [0xff,0x03,0xdf,0xba]
 567
 568 // NOMTE: instruction requires: mte
 569 // NOMTE: instruction requires: mte
 570 // NOMTE: instruction requires: mte
 571 // NOMTE: instruction requires: mte
 572
 573 ldg X0, [X1, #0]
 574 ldg X2, [sp, #-4096]
 575 ldg x3, [x4, #4080]
 576
 577 // CHECK: ldg x0, [x1]         // encoding: [0x20,0x00,0x60,0xd9]
 578 // CHECK: ldg x2, [sp, #-4096] // encoding: [0xe2,0x03,0x70,0xd9]
 579 // CHECK: ldg x3, [x4, #4080]  // encoding: [0x83,0xf0,0x6f,0xd9]
 580
 581 // NOMTE: instruction requires: mte
 582 // NOMTE: instruction requires: mte
 583 // NOMTE: instruction requires: mte
 584
 585 ldgm x0, [x1]
 586 ldgm x1, [sp]
 587 ldgm xzr, [x2]
 588
 589 // CHECK: ldgm x0, [x1]  // encoding: [0x20,0x00,0xe0,0xd9]
 590 // CHECK: ldgm x1, [sp]  // encoding: [0xe1,0x03,0xe0,0xd9]
 591 // CHECK: ldgm xzr, [x2] // encoding: [0x5f,0x00,0xe0,0xd9]
 592
 593 // NOMTE: instruction requires: mte
 594 // NOMTE: instruction requires: mte
 595 // NOMTE: instruction requires: mte
 596
 597 stgm x0, [x1]
 598 stgm x1, [sp]
 599 stgm xzr, [x2]
 600
 601 // CHECK: stgm x0, [x1]  // encoding: [0x20,0x00,0xa0,0xd9]
 602 // CHECK: stgm x1, [sp]  // encoding: [0xe1,0x03,0xa0,0xd9]
 603 // CHECK: stgm xzr, [x2] // encoding: [0x5f,0x00,0xa0,0xd9]
 604
 605 // NOMTE: instruction requires: mte
 606 // NOMTE: instruction requires: mte
 607 // NOMTE: instruction requires: mte
 608
 609 stzgm x0, [x1]
 610 stzgm x1, [sp]
 611 stzgm xzr, [x2]
 612
 613 // CHECK: stzgm x0, [x1]  // encoding: [0x20,0x00,0x20,0xd9]
 614 // CHECK: stzgm x1, [sp]  // encoding: [0xe1,0x03,0x20,0xd9]
 615 // CHECK: stzgm xzr, [x2] // encoding: [0x5f,0x00,0x20,0xd9]
 616
 617 // NOMTE: instruction requires: mte
 618 // NOMTE: instruction requires: mte
 619 // NOMTE: instruction requires: mte