contrib/llvm/lib/Target/SystemZ/SystemZInstrSystem.td

   1 //==- SystemZInstrSystem.td - SystemZ system instructions -*- tblgen-*-----==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // The instructions in this file implement SystemZ system-level instructions.
  11 // Most of these instructions are privileged or semi-privileged.  They are
  12 // not used for code generation, but are provided for use with the assembler
  13 // and disassembler only.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 //===----------------------------------------------------------------------===//
  18 // Program-Status Word Instructions.
  19 //===----------------------------------------------------------------------===//
  20
  21 // Extract PSW.
  22 let hasSideEffects = 1, Uses = [CC] in
  23   def EPSW : InherentDualRRE<"epsw", 0xB98D, GR32>;
  24
  25 // Load PSW (extended).
  26 let hasSideEffects = 1, Defs = [CC], mayLoad = 1 in {
  27   def LPSW : SideEffectUnaryS<"lpsw", 0x8200, null_frag, 8>;
  28   def LPSWE : SideEffectUnaryS<"lpswe", 0xB2B2, null_frag, 16>;
  29 }
  30
  31 // Insert PSW key.
  32 let Uses = [R2L], Defs = [R2L] in
  33   def IPK : SideEffectInherentS<"ipk", 0xB20B, null_frag>;
  34
  35 // Set PSW key from address.
  36 let hasSideEffects = 1 in
  37   def SPKA : SideEffectAddressS<"spka", 0xB20A, null_frag>;
  38
  39 // Set system mask.
  40 let hasSideEffects = 1, mayLoad = 1 in
  41   def SSM : SideEffectUnaryS<"ssm", 0x8000, null_frag, 1>;
  42
  43 // Store then AND/OR system mask.
  44 let hasSideEffects = 1 in {
  45   def STNSM : StoreSI<"stnsm", 0xAC, null_frag, imm32zx8>;
  46   def STOSM : StoreSI<"stosm", 0xAD, null_frag, imm32zx8>;
  47 }
  48
  49 // Insert address space control.
  50 let hasSideEffects = 1 in
  51   def IAC : InherentRRE<"iac", 0xB224, GR32, null_frag>;
  52
  53 // Set address space control (fast).
  54 let hasSideEffects = 1 in {
  55   def SAC : SideEffectAddressS<"sac", 0xB219, null_frag>;
  56   def SACF : SideEffectAddressS<"sacf", 0xB279, null_frag>;
  57 }
  58
  59 //===----------------------------------------------------------------------===//
  60 // Control Register Instructions.
  61 //===----------------------------------------------------------------------===//
  62
  63 // Load control.
  64 def LCTL : LoadMultipleRS<"lctl", 0xB7, CR64>;
  65 def LCTLG : LoadMultipleRSY<"lctlg", 0xEB2F, CR64>;
  66
  67 // Store control.
  68 def STCTL : StoreMultipleRS<"stctl", 0xB6, CR64>;
  69 def STCTG : StoreMultipleRSY<"stctg", 0xEB25, CR64>;
  70
  71 // Extract primary ASN (and instance).
  72 let hasSideEffects = 1 in {
  73   def EPAR : InherentRRE<"epar", 0xB226, GR32, null_frag>;
  74   def EPAIR : InherentRRE<"epair", 0xB99A, GR64, null_frag>;
  75 }
  76
  77 // Extract secondary ASN (and instance).
  78 let hasSideEffects = 1 in {
  79   def ESAR : InherentRRE<"esar", 0xB227, GR32, null_frag>;
  80   def ESAIR : InherentRRE<"esair", 0xB99B, GR64, null_frag>;
  81 }
  82
  83 // Set secondary ASN (and instance).
  84 let hasSideEffects = 1 in {
  85   def SSAR : SideEffectUnaryRRE<"ssar", 0xB225, GR32, null_frag>;
  86   def SSAIR : SideEffectUnaryRRE<"ssair", 0xB99F, GR64, null_frag>;
  87 }
  88
  89 // Extract and set extended authority.
  90 let hasSideEffects = 1 in
  91   def ESEA : UnaryTiedRRE<"esea", 0xB99D, GR32>;
  92
  93 //===----------------------------------------------------------------------===//
  94 // Prefix-Register Instructions.
  95 //===----------------------------------------------------------------------===//
  96
  97 // Set prefix.
  98 let hasSideEffects = 1 in
  99   def SPX : SideEffectUnaryS<"spx", 0xB210, null_frag, 4>;
 100
 101 // Store prefix.
 102 let hasSideEffects = 1 in
 103   def STPX : StoreInherentS<"stpx", 0xB211, null_frag, 4>;
 104
 105 //===----------------------------------------------------------------------===//
 106 // Storage-Key and Real Memory Instructions.
 107 //===----------------------------------------------------------------------===//
 108
 109 // Insert storage key extended.
 110 let hasSideEffects = 1 in
 111   def ISKE : BinaryRRE<"iske", 0xB229, null_frag, GR32, GR64>;
 112
 113 // Insert virtual storage key.
 114 let hasSideEffects = 1 in
 115   def IVSK : BinaryRRE<"ivsk", 0xB223, null_frag, GR32, GR64>;
 116
 117 // Set storage key extended.
 118 let hasSideEffects = 1, Defs = [CC] in
 119   defm SSKE : SideEffectTernaryRRFcOpt<"sske", 0xB22B, GR32, GR64>;
 120
 121 // Reset reference bit extended.
 122 let hasSideEffects = 1, Defs = [CC] in
 123   def RRBE : SideEffectBinaryRRE<"rrbe", 0xB22A, GR32, GR64>;
 124
 125 // Reset reference bits multiple.
 126 let Predicates = [FeatureResetReferenceBitsMultiple], hasSideEffects = 1 in
 127   def RRBM : UnaryRRE<"rrbm", 0xB9AE, null_frag, GR64, GR64>;
 128
 129 // Perform frame management function.
 130 let hasSideEffects = 1 in
 131   def PFMF : SideEffectBinaryMemRRE<"pfmf", 0xB9AF, GR32, GR64>;
 132
 133 // Test block.
 134 let hasSideEffects = 1, mayStore = 1, Uses = [R0D], Defs = [R0D, CC] in
 135   def TB : SideEffectBinaryRRE<"tb", 0xB22C, GR64, GR64>;
 136
 137 // Page in / out.
 138 let mayLoad = 1, mayStore = 1, Defs = [CC] in {
 139   def PGIN : SideEffectBinaryRRE<"pgin", 0xB22E, GR64, GR64>;
 140   def PGOUT : SideEffectBinaryRRE<"pgout", 0xB22F, GR64, GR64>;
 141 }
 142
 143 //===----------------------------------------------------------------------===//
 144 // Dynamic-Address-Translation Instructions.
 145 //===----------------------------------------------------------------------===//
 146
 147 // Invalidate page table entry.
 148 let hasSideEffects = 1 in
 149   defm IPTE : SideEffectQuaternaryRRFaOptOpt<"ipte", 0xB221, GR64, GR32, GR32>;
 150
 151 // Invalidate DAT table entry.
 152 let hasSideEffects = 1 in
 153   defm IDTE : SideEffectQuaternaryRRFbOpt<"idte", 0xB98E, GR64, GR64, GR64>;
 154
 155 // Compare and replace DAT table entry.
 156 let Predicates = [FeatureEnhancedDAT2], hasSideEffects = 1, Defs = [CC] in
 157   defm CRDTE : SideEffectQuaternaryRRFbOpt<"crdte", 0xB98F, GR128, GR128, GR64>;
 158
 159 // Purge TLB.
 160 let hasSideEffects = 1 in
 161   def PTLB : SideEffectInherentS<"ptlb", 0xB20D, null_frag>;
 162
 163 // Compare and swap and purge.
 164 let hasSideEffects = 1, Defs = [CC] in {
 165   def CSP : CmpSwapRRE<"csp", 0xB250, GR128, GR64>;
 166   def CSPG : CmpSwapRRE<"cspg", 0xB98A, GR128, GR64>;
 167 }
 168
 169 // Load page-table-entry address.
 170 let hasSideEffects = 1, Defs = [CC] in
 171   def LPTEA : TernaryRRFb<"lptea", 0xB9AA, GR64, GR64, GR64>;
 172
 173 // Load real address.
 174 let hasSideEffects = 1, Defs = [CC] in {
 175   defm LRA : LoadAddressRXPair<"lra", 0xB1, 0xE313, null_frag>;
 176   def LRAG : LoadAddressRXY<"lrag", 0xE303, null_frag, laaddr20pair>;
 177 }
 178
 179 // Store real address.
 180 def STRAG : StoreSSE<"strag", 0xE502>;
 181
 182 // Load using real address.
 183 let mayLoad = 1 in {
 184  def LURA : UnaryRRE<"lura", 0xB24B, null_frag, GR32, GR64>;
 185  def LURAG : UnaryRRE<"lurag", 0xB905, null_frag, GR64, GR64>;
 186 }
 187
 188 // Store using real address.
 189 let mayStore = 1 in {
 190  def STURA : SideEffectBinaryRRE<"stura", 0xB246, GR32, GR64>;
 191  def STURG : SideEffectBinaryRRE<"sturg", 0xB925, GR64, GR64>;
 192 }
 193
 194 // Test protection.
 195 let hasSideEffects = 1, Defs = [CC] in
 196   def TPROT : SideEffectBinarySSE<"tprot", 0xE501>;
 197
 198 //===----------------------------------------------------------------------===//
 199 // Memory-move Instructions.
 200 //===----------------------------------------------------------------------===//
 201
 202 // Move with key.
 203 let mayLoad = 1, mayStore = 1, Defs = [CC] in
 204   def MVCK : MemoryBinarySSd<"mvck", 0xD9, GR64>;
 205
 206 // Move to primary / secondary.
 207 let mayLoad = 1, mayStore = 1, Defs = [CC] in {
 208   def MVCP : MemoryBinarySSd<"mvcp", 0xDA, GR64>;
 209   def MVCS : MemoryBinarySSd<"mvcs", 0xDB, GR64>;
 210 }
 211
 212 // Move with source / destination key.
 213 let mayLoad = 1, mayStore = 1, Uses = [R0L, R1L] in {
 214   def MVCSK : SideEffectBinarySSE<"mvcsk", 0xE50E>;
 215   def MVCDK : SideEffectBinarySSE<"mvcdk", 0xE50F>;
 216 }
 217
 218 // Move with optional specifications.
 219 let mayLoad = 1, mayStore = 1, Uses = [R0L] in
 220   def MVCOS : SideEffectTernarySSF<"mvcos", 0xC80, GR64>;
 221
 222 // Move page.
 223 let mayLoad = 1, mayStore = 1, Uses = [R0L], Defs = [CC] in
 224   def MVPG : SideEffectBinaryRRE<"mvpg", 0xB254, GR64, GR64>;
 225
 226 //===----------------------------------------------------------------------===//
 227 // Address-Space Instructions.
 228 //===----------------------------------------------------------------------===//
 229
 230 // Load address space parameters.
 231 let hasSideEffects = 1, Defs = [CC] in
 232   def LASP : SideEffectBinarySSE<"lasp", 0xE500>;
 233
 234 // Purge ALB.
 235 let hasSideEffects = 1 in
 236   def PALB : SideEffectInherentRRE<"palb", 0xB248>;
 237
 238 // Program call.
 239 let hasSideEffects = 1 in
 240   def PC : SideEffectAddressS<"pc", 0xB218, null_frag>;
 241
 242 // Program return.
 243 let hasSideEffects = 1, Defs = [CC] in
 244   def PR : SideEffectInherentE<"pr", 0x0101>;
 245
 246 // Program transfer (with instance).
 247 let hasSideEffects = 1 in {
 248   def PT : SideEffectBinaryRRE<"pt", 0xB228, GR32, GR64>;
 249   def PTI : SideEffectBinaryRRE<"pti", 0xB99E, GR64, GR64>;
 250 }
 251
 252 // Resume program.
 253 let hasSideEffects = 1, Defs = [CC] in
 254   def RP : SideEffectAddressS<"rp", 0xB277, null_frag>;
 255
 256 // Branch in subspace group.
 257 let hasSideEffects = 1 in
 258   def BSG : UnaryRRE<"bsg", 0xB258, null_frag, GR64, GR64>;
 259
 260 // Branch and set authority.
 261 let hasSideEffects = 1 in
 262   def BSA : UnaryRRE<"bsa", 0xB25A, null_frag, GR64, GR64>;
 263
 264 // Test access.
 265 let Defs = [CC] in
 266   def TAR : SideEffectBinaryRRE<"tar", 0xB24C, AR32, GR32>;
 267
 268 //===----------------------------------------------------------------------===//
 269 // Linkage-Stack Instructions.
 270 //===----------------------------------------------------------------------===//
 271
 272 // Branch and stack.
 273 let hasSideEffects = 1 in
 274   def BAKR : SideEffectBinaryRRE<"bakr", 0xB240, GR64, GR64>;
 275
 276 // Extract stacked registers.
 277 let hasSideEffects = 1 in {
 278   def EREG : SideEffectBinaryRRE<"ereg", 0xB249, GR32, GR32>;
 279   def EREGG : SideEffectBinaryRRE<"eregg", 0xB90E, GR64, GR64>;
 280 }
 281
 282 // Extract stacked state.
 283 let hasSideEffects = 1, Defs = [CC] in
 284   def ESTA : UnaryRRE<"esta", 0xB24A, null_frag, GR128, GR32>;
 285
 286 // Modify stacked state.
 287 let hasSideEffects = 1 in
 288   def MSTA : SideEffectUnaryRRE<"msta", 0xB247, GR128, null_frag>;
 289
 290 //===----------------------------------------------------------------------===//
 291 // Time-Related Instructions.
 292 //===----------------------------------------------------------------------===//
 293
 294 // Perform timing facility function.
 295 let hasSideEffects = 1, mayLoad = 1, Uses = [R0L, R1D], Defs = [CC] in
 296   def PTFF : SideEffectInherentE<"ptff", 0x0104>;
 297
 298 // Set clock.
 299 let hasSideEffects = 1, Defs = [CC] in
 300   def SCK : SideEffectUnaryS<"sck", 0xB204, null_frag, 8>;
 301
 302 // Set clock programmable field.
 303 let hasSideEffects = 1, Uses = [R0L] in
 304   def SCKPF : SideEffectInherentE<"sckpf", 0x0107>;
 305
 306 // Set clock comparator.
 307 let hasSideEffects = 1 in
 308   def SCKC : SideEffectUnaryS<"sckc", 0xB206, null_frag, 8>;
 309
 310 // Set CPU timer.
 311 let hasSideEffects = 1 in
 312   def SPT : SideEffectUnaryS<"spt", 0xB208, null_frag, 8>;
 313
 314 // Store clock (fast / extended).
 315 let hasSideEffects = 1, Defs = [CC] in {
 316   def STCK  : StoreInherentS<"stck",  0xB205, null_frag, 8>;
 317   def STCKF : StoreInherentS<"stckf", 0xB27C, null_frag, 8>;
 318   def STCKE : StoreInherentS<"stcke", 0xB278, null_frag, 16>;
 319 }
 320
 321 // Store clock comparator.
 322 let hasSideEffects = 1 in
 323   def STCKC : StoreInherentS<"stckc", 0xB207, null_frag, 8>;
 324
 325 // Store CPU timer.
 326 let hasSideEffects = 1 in
 327   def STPT : StoreInherentS<"stpt", 0xB209, null_frag, 8>;
 328
 329 //===----------------------------------------------------------------------===//
 330 // CPU-Related Instructions.
 331 //===----------------------------------------------------------------------===//
 332
 333 // Store CPU address.
 334 let hasSideEffects = 1 in
 335   def STAP : StoreInherentS<"stap", 0xB212, null_frag, 2>;
 336
 337 // Store CPU ID.
 338 let hasSideEffects = 1 in
 339   def STIDP : StoreInherentS<"stidp", 0xB202, null_frag, 8>;
 340
 341 // Store system information.
 342 let hasSideEffects = 1, Uses = [R0L, R1L], Defs = [R0L, CC] in
 343   def STSI : StoreInherentS<"stsi", 0xB27D, null_frag, 0>;
 344
 345 // Store facility list.
 346 let hasSideEffects = 1 in
 347   def STFL : StoreInherentS<"stfl", 0xB2B1, null_frag, 4>;
 348
 349 // Store facility list extended.
 350 let hasSideEffects = 1, Uses = [R0D], Defs = [R0D, CC] in
 351   def STFLE : StoreInherentS<"stfle", 0xB2B0, null_frag, 0>;
 352
 353 // Extract CPU attribute.
 354 let hasSideEffects = 1 in
 355   def ECAG : BinaryRSY<"ecag", 0xEB4C, null_frag, GR64>;
 356
 357 // Extract CPU time.
 358 let hasSideEffects = 1, mayLoad = 1, Defs = [R0D, R1D] in
 359   def ECTG : SideEffectTernarySSF<"ectg", 0xC81, GR64>;
 360
 361 // Perform topology function.
 362 let hasSideEffects = 1 in
 363   def PTF : UnaryTiedRRE<"ptf", 0xB9A2, GR64>;
 364
 365 // Perform cryptographic key management operation.
 366 let Predicates = [FeatureMessageSecurityAssist3],
 367     hasSideEffects = 1, Uses = [R0L, R1D] in
 368   def PCKMO : SideEffectInherentRRE<"pckmo", 0xB928>;
 369
 370 //===----------------------------------------------------------------------===//
 371 // Miscellaneous Instructions.
 372 //===----------------------------------------------------------------------===//
 373
 374 // Supervisor call.
 375 let hasSideEffects = 1, isCall = 1, Defs = [CC] in
 376   def SVC : SideEffectUnaryI<"svc", 0x0A, imm32zx8>;
 377
 378 // Monitor call.
 379 let hasSideEffects = 1, isCall = 1 in
 380   def MC : SideEffectBinarySI<"mc", 0xAF, imm32zx8>;
 381
 382 // Diagnose.
 383 let hasSideEffects = 1, isCall = 1 in
 384   def DIAG : SideEffectTernaryRS<"diag", 0x83, GR32, GR32>;
 385
 386 // Trace.
 387 let hasSideEffects = 1, mayLoad = 1 in {
 388   def TRACE : SideEffectTernaryRS<"trace", 0x99, GR32, GR32>;
 389   def TRACG : SideEffectTernaryRSY<"tracg", 0xEB0F, GR64, GR64>;
 390 }
 391
 392 // Trap.
 393 let hasSideEffects = 1 in {
 394   def TRAP2 : SideEffectInherentE<"trap2", 0x01FF>;
 395   def TRAP4 : SideEffectAddressS<"trap4", 0xB2FF, null_frag>;
 396 }
 397
 398 // Signal processor.
 399 let hasSideEffects = 1, Defs = [CC] in
 400   def SIGP : SideEffectTernaryRS<"sigp", 0xAE, GR64, GR64>;
 401
 402 // Signal adapter.
 403 let hasSideEffects = 1, Uses = [R0D, R1D, R2D, R3D], Defs = [CC] in
 404   def SIGA : SideEffectAddressS<"siga", 0xB274, null_frag>;
 405
 406 // Start interpretive execution.
 407 let hasSideEffects = 1, Defs = [CC] in
 408   def SIE : SideEffectUnaryS<"sie", 0xB214, null_frag, 0>;
 409
 410 //===----------------------------------------------------------------------===//
 411 // CPU-Measurement Facility Instructions (SA23-2260).
 412 //===----------------------------------------------------------------------===//
 413
 414 // Load program parameter
 415 let hasSideEffects = 1 in
 416   def LPP : SideEffectUnaryS<"lpp", 0xB280, null_frag, 8>;
 417
 418 // Extract coprocessor-group address.
 419 let hasSideEffects = 1, Defs = [CC] in
 420   def ECPGA : UnaryRRE<"ecpga", 0xB2ED, null_frag, GR32, GR64>;
 421
 422 // Extract CPU counter.
 423 let hasSideEffects = 1, Defs = [CC] in
 424   def ECCTR : UnaryRRE<"ecctr", 0xB2E4, null_frag, GR64, GR64>;
 425
 426 // Extract peripheral counter.
 427 let hasSideEffects = 1, Defs = [CC] in
 428   def EPCTR : UnaryRRE<"epctr", 0xB2E5, null_frag, GR64, GR64>;
 429
 430 // Load CPU-counter-set controls.
 431 let hasSideEffects = 1, Defs = [CC] in
 432   def LCCTL : SideEffectUnaryS<"lcctl", 0xB284, null_frag, 8>;
 433
 434 // Load peripheral-counter-set controls.
 435 let hasSideEffects = 1, Defs = [CC] in
 436   def LPCTL : SideEffectUnaryS<"lpctl", 0xB285, null_frag, 8>;
 437
 438 // Load sampling controls.
 439 let hasSideEffects = 1, Defs = [CC] in
 440   def LSCTL : SideEffectUnaryS<"lsctl", 0xB287, null_frag, 0>;
 441
 442 // Query sampling information.
 443 let hasSideEffects = 1 in
 444   def QSI : StoreInherentS<"qsi", 0xB286, null_frag, 0>;
 445
 446 // Query counter information.
 447 let hasSideEffects = 1 in
 448   def QCTRI : StoreInherentS<"qctri", 0xB28E, null_frag, 0>;
 449
 450 // Set CPU counter.
 451 let hasSideEffects = 1, Defs = [CC] in
 452   def SCCTR : SideEffectBinaryRRE<"scctr", 0xB2E0, GR64, GR64>;
 453
 454 // Set peripheral counter.
 455 let hasSideEffects = 1, Defs = [CC] in
 456   def SPCTR : SideEffectBinaryRRE<"spctr", 0xB2E1, GR64, GR64>;
 457
 458 //===----------------------------------------------------------------------===//
 459 // I/O Instructions (Principles of Operation, Chapter 14).
 460 //===----------------------------------------------------------------------===//
 461
 462 // Clear subchannel.
 463 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 464   def CSCH : SideEffectInherentS<"csch", 0xB230, null_frag>;
 465
 466 // Halt subchannel.
 467 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 468   def HSCH : SideEffectInherentS<"hsch", 0xB231, null_frag>;
 469
 470 // Modify subchannel.
 471 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 472   def MSCH : SideEffectUnaryS<"msch", 0xB232, null_frag, 0>;
 473
 474 // Resume subchannel.
 475 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 476   def RSCH : SideEffectInherentS<"rsch", 0xB238, null_frag>;
 477
 478 // Start subchannel.
 479 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 480   def SSCH : SideEffectUnaryS<"ssch", 0xB233, null_frag, 0>;
 481
 482 // Store subchannel.
 483 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 484   def STSCH : StoreInherentS<"stsch", 0xB234, null_frag, 0>;
 485
 486 // Test subchannel.
 487 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 488   def TSCH : StoreInherentS<"tsch", 0xB235, null_frag, 0>;
 489
 490 // Cancel subchannel.
 491 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 492   def XSCH : SideEffectInherentS<"xsch", 0xB276, null_frag>;
 493
 494 // Reset channel path.
 495 let hasSideEffects = 1, Uses = [R1L], Defs = [CC] in
 496   def RCHP : SideEffectInherentS<"rchp", 0xB23B, null_frag>;
 497
 498 // Set channel monitor.
 499 let hasSideEffects = 1, mayLoad = 1, Uses = [R1L, R2D] in
 500   def SCHM : SideEffectInherentS<"schm", 0xB23C, null_frag>;
 501
 502 // Store channel path status.
 503 let hasSideEffects = 1 in
 504   def STCPS : StoreInherentS<"stcps", 0xB23A, null_frag, 0>;
 505
 506 // Store channel report word.
 507 let hasSideEffects = 1, Defs = [CC] in
 508   def STCRW : StoreInherentS<"stcrw", 0xB239, null_frag, 0>;
 509
 510 // Test pending interruption.
 511 let hasSideEffects = 1, Defs = [CC] in
 512   def TPI : StoreInherentS<"tpi", 0xB236, null_frag, 0>;
 513
 514 // Set address limit.
 515 let hasSideEffects = 1, Uses = [R1L] in
 516   def SAL : SideEffectInherentS<"sal", 0xB237, null_frag>;
 517