lib/Target/SystemZ/SystemZInstrFormats.td

   1 //==- SystemZInstrFormats.td - SystemZ Instruction Formats --*- tablegen -*-==//
   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 //===----------------------------------------------------------------------===//
  11 // Basic SystemZ instruction definition
  12 //===----------------------------------------------------------------------===//
  13
  14 class InstSystemZ<int size, dag outs, dag ins, string asmstr,
  15                   list<dag> pattern> : Instruction {
  16   let Namespace = "SystemZ";
  17
  18   dag OutOperandList = outs;
  19   dag InOperandList = ins;
  20   let Size = size;
  21   let Pattern = pattern;
  22   let AsmString = asmstr;
  23
  24   // Some instructions come in pairs, one having a 12-bit displacement
  25   // and the other having a 20-bit displacement.  Both instructions in
  26   // the pair have the same DispKey and their DispSizes are "12" and "20"
  27   // respectively.
  28   string DispKey = "";
  29   string DispSize = "none";
  30
  31   // Many register-based <INSN>R instructions have a memory-based <INSN>
  32   // counterpart.  OpKey uniquely identifies <INSN>, while OpType is
  33   // "reg" for <INSN>R and "mem" for <INSN>.
  34   string OpKey = "";
  35   string OpType = "none";
  36
  37   // Many distinct-operands instructions have older 2-operand equivalents.
  38   // NumOpsKey uniquely identifies one of these 2-operand and 3-operand pairs,
  39   // with NumOpsValue being "2" or "3" as appropriate.
  40   string NumOpsKey = "";
  41   string NumOpsValue = "none";
  42
  43   // True if this instruction is a simple D(X,B) load of a register
  44   // (with no sign or zero extension).
  45   bit SimpleBDXLoad = 0;
  46
  47   // True if this instruction is a simple D(X,B) store of a register
  48   // (with no truncation).
  49   bit SimpleBDXStore = 0;
  50
  51   // True if this instruction has a 20-bit displacement field.
  52   bit Has20BitOffset = 0;
  53
  54   // True if addresses in this instruction have an index register.
  55   bit HasIndex = 0;
  56
  57   // True if this is a 128-bit pseudo instruction that combines two 64-bit
  58   // operations.
  59   bit Is128Bit = 0;
  60
  61   // The access size of all memory operands in bytes, or 0 if not known.
  62   bits<5> AccessBytes = 0;
  63
  64   let TSFlags{0} = SimpleBDXLoad;
  65   let TSFlags{1} = SimpleBDXStore;
  66   let TSFlags{2} = Has20BitOffset;
  67   let TSFlags{3} = HasIndex;
  68   let TSFlags{4} = Is128Bit;
  69   let TSFlags{9-5} = AccessBytes;
  70 }
  71
  72 //===----------------------------------------------------------------------===//
  73 // Mappings between instructions
  74 //===----------------------------------------------------------------------===//
  75
  76 // Return the version of an instruction that has an unsigned 12-bit
  77 // displacement.
  78 def getDisp12Opcode : InstrMapping {
  79   let FilterClass = "InstSystemZ";
  80   let RowFields = ["DispKey"];
  81   let ColFields = ["DispSize"];
  82   let KeyCol = ["20"];
  83   let ValueCols = [["12"]];
  84 }
  85
  86 // Return the version of an instruction that has a signed 20-bit displacement.
  87 def getDisp20Opcode : InstrMapping {
  88   let FilterClass = "InstSystemZ";
  89   let RowFields = ["DispKey"];
  90   let ColFields = ["DispSize"];
  91   let KeyCol = ["12"];
  92   let ValueCols = [["20"]];
  93 }
  94
  95 // Return the memory form of a register instruction.
  96 def getMemOpcode : InstrMapping {
  97   let FilterClass = "InstSystemZ";
  98   let RowFields = ["OpKey"];
  99   let ColFields = ["OpType"];
 100   let KeyCol = ["reg"];
 101   let ValueCols = [["mem"]];
 102 }
 103
 104 // Return the 3-operand form of a 2-operand instruction.
 105 def getThreeOperandOpcode : InstrMapping {
 106   let FilterClass = "InstSystemZ";
 107   let RowFields = ["NumOpsKey"];
 108   let ColFields = ["NumOpsValue"];
 109   let KeyCol = ["2"];
 110   let ValueCols = [["3"]];
 111 }
 112
 113 //===----------------------------------------------------------------------===//
 114 // Instruction formats
 115 //===----------------------------------------------------------------------===//
 116 //
 117 // Formats are specified using operand field declarations of the form:
 118 //
 119 //   bits<4> Rn   : register input or output for operand n
 120 //   bits<m> In   : immediate value of width m for operand n
 121 //   bits<4> BDn  : address operand n, which has a base and a displacement
 122 //   bits<m> XBDn : address operand n, which has an index, a base and a
 123 //                  displacement
 124 //   bits<4> Xn   : index register for address operand n
 125 //   bits<4> Mn   : mode value for operand n
 126 //
 127 // The operand numbers ("n" in the list above) follow the architecture manual.
 128 // Assembly operands sometimes have a different order; in particular, R3 often
 129 // is often written between operands 1 and 2.
 130 //
 131 //===----------------------------------------------------------------------===//
 132
 133 class InstRI<bits<12> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 134   : InstSystemZ<4, outs, ins, asmstr, pattern> {
 135   field bits<32> Inst;
 136   field bits<32> SoftFail = 0;
 137
 138   bits<4> R1;
 139   bits<16> I2;
 140
 141   let Inst{31-24} = op{11-4};
 142   let Inst{23-20} = R1;
 143   let Inst{19-16} = op{3-0};
 144   let Inst{15-0}  = I2;
 145 }
 146
 147 class InstRIEb<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 148   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 149   field bits<48> Inst;
 150   field bits<48> SoftFail = 0;
 151
 152   bits<4> R1;
 153   bits<4> R2;
 154   bits<4> M3;
 155   bits<16> RI4;
 156
 157   let Inst{47-40} = op{15-8};
 158   let Inst{39-36} = R1;
 159   let Inst{35-32} = R2;
 160   let Inst{31-16} = RI4;
 161   let Inst{15-12} = M3;
 162   let Inst{11-8}  = 0;
 163   let Inst{7-0}   = op{7-0};
 164 }
 165
 166 class InstRIEc<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 167   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 168   field bits<48> Inst;
 169   field bits<48> SoftFail = 0;
 170
 171   bits<4> R1;
 172   bits<8> I2;
 173   bits<4> M3;
 174   bits<16> RI4;
 175
 176   let Inst{47-40} = op{15-8};
 177   let Inst{39-36} = R1;
 178   let Inst{35-32} = M3;
 179   let Inst{31-16} = RI4;
 180   let Inst{15-8}  = I2;
 181   let Inst{7-0}   = op{7-0};
 182 }
 183
 184 class InstRIEd<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 185   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 186   field bits<48> Inst;
 187   field bits<48> SoftFail = 0;
 188
 189   bits<4> R1;
 190   bits<4> R3;
 191   bits<16> I2;
 192
 193   let Inst{47-40} = op{15-8};
 194   let Inst{39-36} = R1;
 195   let Inst{35-32} = R3;
 196   let Inst{31-16} = I2;
 197   let Inst{15-8}  = 0;
 198   let Inst{7-0}   = op{7-0};
 199 }
 200
 201 class InstRIEf<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 202   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 203   field bits<48> Inst;
 204   field bits<48> SoftFail = 0;
 205
 206   bits<4> R1;
 207   bits<4> R2;
 208   bits<8> I3;
 209   bits<8> I4;
 210   bits<8> I5;
 211
 212   let Inst{47-40} = op{15-8};
 213   let Inst{39-36} = R1;
 214   let Inst{35-32} = R2;
 215   let Inst{31-24} = I3;
 216   let Inst{23-16} = I4;
 217   let Inst{15-8}  = I5;
 218   let Inst{7-0}   = op{7-0};
 219 }
 220
 221 class InstRIL<bits<12> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 222   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 223   field bits<48> Inst;
 224   field bits<48> SoftFail = 0;
 225
 226   bits<4> R1;
 227   bits<32> I2;
 228
 229   let Inst{47-40} = op{11-4};
 230   let Inst{39-36} = R1;
 231   let Inst{35-32} = op{3-0};
 232   let Inst{31-0}  = I2;
 233 }
 234
 235 class InstRR<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 236   : InstSystemZ<2, outs, ins, asmstr, pattern> {
 237   field bits<16> Inst;
 238   field bits<16> SoftFail = 0;
 239
 240   bits<4> R1;
 241   bits<4> R2;
 242
 243   let Inst{15-8} = op;
 244   let Inst{7-4}  = R1;
 245   let Inst{3-0}  = R2;
 246 }
 247
 248 class InstRRD<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 249   : InstSystemZ<4, outs, ins, asmstr, pattern> {
 250   field bits<32> Inst;
 251   field bits<32> SoftFail = 0;
 252
 253   bits<4> R1;
 254   bits<4> R3;
 255   bits<4> R2;
 256
 257   let Inst{31-16} = op;
 258   let Inst{15-12} = R1;
 259   let Inst{11-8}  = 0;
 260   let Inst{7-4}   = R3;
 261   let Inst{3-0}   = R2;
 262 }
 263
 264 class InstRRE<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 265   : InstSystemZ<4, outs, ins, asmstr, pattern> {
 266   field bits<32> Inst;
 267   field bits<32> SoftFail = 0;
 268
 269   bits<4> R1;
 270   bits<4> R2;
 271
 272   let Inst{31-16} = op;
 273   let Inst{15-8}  = 0;
 274   let Inst{7-4}   = R1;
 275   let Inst{3-0}   = R2;
 276 }
 277
 278 class InstRRF<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 279   : InstSystemZ<4, outs, ins, asmstr, pattern> {
 280   field bits<32> Inst;
 281   field bits<32> SoftFail = 0;
 282
 283   bits<4> R1;
 284   bits<4> R2;
 285   bits<4> R3;
 286
 287   let Inst{31-16} = op;
 288   let Inst{15-12} = R3;
 289   let Inst{11-8}  = 0;
 290   let Inst{7-4}   = R1;
 291   let Inst{3-0}   = R2;
 292 }
 293
 294 class InstRX<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 295   : InstSystemZ<4, outs, ins, asmstr, pattern> {
 296   field bits<32> Inst;
 297   field bits<32> SoftFail = 0;
 298
 299   bits<4> R1;
 300   bits<20> XBD2;
 301
 302   let Inst{31-24} = op;
 303   let Inst{23-20} = R1;
 304   let Inst{19-0}  = XBD2;
 305
 306   let HasIndex = 1;
 307 }
 308
 309 class InstRXE<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 310   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 311   field bits<48> Inst;
 312   field bits<48> SoftFail = 0;
 313
 314   bits<4> R1;
 315   bits<20> XBD2;
 316
 317   let Inst{47-40} = op{15-8};
 318   let Inst{39-36} = R1;
 319   let Inst{35-16} = XBD2;
 320   let Inst{15-8}  = 0;
 321   let Inst{7-0}   = op{7-0};
 322
 323   let HasIndex = 1;
 324 }
 325
 326 class InstRXF<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 327   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 328   field bits<48> Inst;
 329   field bits<48> SoftFail = 0;
 330
 331   bits<4> R1;
 332   bits<4> R3;
 333   bits<20> XBD2;
 334
 335   let Inst{47-40} = op{15-8};
 336   let Inst{39-36} = R3;
 337   let Inst{35-16} = XBD2;
 338   let Inst{15-12} = R1;
 339   let Inst{11-8}  = 0;
 340   let Inst{7-0}   = op{7-0};
 341
 342   let HasIndex = 1;
 343 }
 344
 345 class InstRXY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 346   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 347   field bits<48> Inst;
 348   field bits<48> SoftFail = 0;
 349
 350   bits<4> R1;
 351   bits<28> XBD2;
 352
 353   let Inst{47-40} = op{15-8};
 354   let Inst{39-36} = R1;
 355   let Inst{35-8}  = XBD2;
 356   let Inst{7-0}   = op{7-0};
 357
 358   let Has20BitOffset = 1;
 359   let HasIndex = 1;
 360 }
 361
 362 class InstRS<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 363   : InstSystemZ<4, outs, ins, asmstr, pattern> {
 364   field bits<32> Inst;
 365   field bits<32> SoftFail = 0;
 366
 367   bits<4> R1;
 368   bits<4> R3;
 369   bits<16> BD2;
 370
 371   let Inst{31-24} = op;
 372   let Inst{23-20} = R1;
 373   let Inst{19-16} = R3;
 374   let Inst{15-0}  = BD2;
 375 }
 376
 377 class InstRSY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 378   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 379   field bits<48> Inst;
 380   field bits<48> SoftFail = 0;
 381
 382   bits<4> R1;
 383   bits<4> R3;
 384   bits<24> BD2;
 385
 386   let Inst{47-40} = op{15-8};
 387   let Inst{39-36} = R1;
 388   let Inst{35-32} = R3;
 389   let Inst{31-8}  = BD2;
 390   let Inst{7-0}   = op{7-0};
 391
 392   let Has20BitOffset = 1;
 393 }
 394
 395 class InstSI<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 396   : InstSystemZ<4, outs, ins, asmstr, pattern> {
 397   field bits<32> Inst;
 398   field bits<32> SoftFail = 0;
 399
 400   bits<16> BD1;
 401   bits<8> I2;
 402
 403   let Inst{31-24} = op;
 404   let Inst{23-16} = I2;
 405   let Inst{15-0}  = BD1;
 406 }
 407
 408 class InstSIL<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 409   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 410   field bits<48> Inst;
 411   field bits<48> SoftFail = 0;
 412
 413   bits<16> BD1;
 414   bits<16> I2;
 415
 416   let Inst{47-32} = op;
 417   let Inst{31-16} = BD1;
 418   let Inst{15-0}  = I2;
 419 }
 420
 421 class InstSIY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 422   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 423   field bits<48> Inst;
 424   field bits<48> SoftFail = 0;
 425
 426   bits<24> BD1;
 427   bits<8> I2;
 428
 429   let Inst{47-40} = op{15-8};
 430   let Inst{39-32} = I2;
 431   let Inst{31-8}  = BD1;
 432   let Inst{7-0}   = op{7-0};
 433
 434   let Has20BitOffset = 1;
 435 }
 436
 437 class InstSS<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
 438   : InstSystemZ<6, outs, ins, asmstr, pattern> {
 439   field bits<48> Inst;
 440   field bits<48> SoftFail = 0;
 441
 442   bits<24> BDL1;
 443   bits<16> BD2;
 444
 445   let Inst{47-40} = op;
 446   let Inst{39-16} = BDL1;
 447   let Inst{15-0}  = BD2;
 448 }
 449
 450 //===----------------------------------------------------------------------===//
 451 // Instruction definitions with semantics
 452 //===----------------------------------------------------------------------===//
 453 //
 454 // These classes have the form [Cond]<Category><Format>, where <Format> is one
 455 // of the formats defined above and where <Category> describes the inputs
 456 // and outputs.  "Cond" is used if the instruction is conditional,
 457 // in which case the 4-bit condition-code mask is added as a final operand.
 458 // <Category> can be one of:
 459 //
 460 //   Inherent:
 461 //     One register output operand and no input operands.
 462 //
 463 //   Store:
 464 //     One register or immediate input operand and one address input operand.
 465 //     The instruction stores the first operand to the address.
 466 //
 467 //     This category is used for both pure and truncating stores.
 468 //
 469 //   LoadMultiple:
 470 //     One address input operand and two explicit output operands.
 471 //     The instruction loads a range of registers from the address,
 472 //     with the explicit operands giving the first and last register
 473 //     to load.  Other loaded registers are added as implicit definitions.
 474 //
 475 //   StoreMultiple:
 476 //     Two explicit input register operands and an address operand.
 477 //     The instruction stores a range of registers to the address,
 478 //     with the explicit operands giving the first and last register
 479 //     to store.  Other stored registers are added as implicit uses.
 480 //
 481 //   Unary:
 482 //     One register output operand and one input operand.  The input
 483 //     operand may be a register, immediate or memory.
 484 //
 485 //   Binary:
 486 //     One register output operand and two input operands.  The first
 487 //     input operand is always a register and he second may be a register,
 488 //     immediate or memory.
 489 //
 490 //   Shift:
 491 //     One register output operand and two input operands.  The first
 492 //     input operand is a register and the second has the same form as
 493 //     an address (although it isn't actually used to address memory).
 494 //
 495 //   Compare:
 496 //     Two input operands.  The first operand is always a register,
 497 //     the second may be a register, immediate or memory.
 498 //
 499 //   Ternary:
 500 //     One register output operand and three register input operands.
 501 //
 502 //   CmpSwap:
 503 //     One output operand and three input operands.  The first two
 504 //     operands are registers and the third is an address.  The instruction
 505 //     both reads from and writes to the address.
 506 //
 507 //   RotateSelect:
 508 //     One output operand and five input operands.  The first two operands
 509 //     are registers and the other three are immediates.
 510 //
 511 // The format determines which input operands are tied to output operands,
 512 // and also determines the shape of any address operand.
 513 //
 514 // Multiclasses of the form <Category><Format>Pair define two instructions,
 515 // one with <Category><Format> and one with <Category><Format>Y.  The name
 516 // of the first instruction has no suffix, the name of the second has
 517 // an extra "y".
 518 //
 519 //===----------------------------------------------------------------------===//
 520
 521 class InherentRRE<string mnemonic, bits<16> opcode, RegisterOperand cls,
 522                   dag src>
 523   : InstRRE<opcode, (outs cls:$R1), (ins),
 524             mnemonic#"r\t$R1",
 525             [(set cls:$R1, src)]> {
 526   let R2 = 0;
 527 }
 528
 529 class LoadMultipleRSY<string mnemonic, bits<16> opcode, RegisterOperand cls>
 530   : InstRSY<opcode, (outs cls:$R1, cls:$R3), (ins bdaddr20only:$BD2),
 531             mnemonic#"\t$R1, $R3, $BD2", []> {
 532   let mayLoad = 1;
 533 }
 534
 535 class StoreRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 536                  RegisterOperand cls>
 537   : InstRIL<opcode, (outs), (ins cls:$R1, pcrel32:$I2),
 538             mnemonic#"\t$R1, $I2",
 539             [(operator cls:$R1, pcrel32:$I2)]> {
 540   let mayStore = 1;
 541   // We want PC-relative addresses to be tried ahead of BD and BDX addresses.
 542   // However, BDXs have two extra operands and are therefore 6 units more
 543   // complex.
 544   let AddedComplexity = 7;
 545 }
 546
 547 class StoreRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 548               RegisterOperand cls, bits<5> bytes,
 549               AddressingMode mode = bdxaddr12only>
 550   : InstRX<opcode, (outs), (ins cls:$R1, mode:$XBD2),
 551            mnemonic#"\t$R1, $XBD2",
 552            [(operator cls:$R1, mode:$XBD2)]> {
 553   let OpKey = mnemonic ## cls;
 554   let OpType = "mem";
 555   let mayStore = 1;
 556   let AccessBytes = bytes;
 557 }
 558
 559 class StoreRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 560                RegisterOperand cls, bits<5> bytes,
 561                AddressingMode mode = bdxaddr20only>
 562   : InstRXY<opcode, (outs), (ins cls:$R1, mode:$XBD2),
 563             mnemonic#"\t$R1, $XBD2",
 564             [(operator cls:$R1, mode:$XBD2)]> {
 565   let OpKey = mnemonic ## cls;
 566   let OpType = "mem";
 567   let mayStore = 1;
 568   let AccessBytes = bytes;
 569 }
 570
 571 multiclass StoreRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
 572                        SDPatternOperator operator, RegisterOperand cls,
 573                        bits<5> bytes> {
 574   let DispKey = mnemonic ## #cls in {
 575     let DispSize = "12" in
 576       def "" : StoreRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
 577     let DispSize = "20" in
 578       def Y  : StoreRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
 579                         bdxaddr20pair>;
 580   }
 581 }
 582
 583 class StoreMultipleRSY<string mnemonic, bits<16> opcode, RegisterOperand cls>
 584   : InstRSY<opcode, (outs), (ins cls:$R1, cls:$R3, bdaddr20only:$BD2),
 585             mnemonic#"\t$R1, $R3, $BD2", []> {
 586   let mayStore = 1;
 587 }
 588
 589 class StoreSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 590               Immediate imm, AddressingMode mode = bdaddr12only>
 591   : InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
 592            mnemonic#"\t$BD1, $I2",
 593            [(operator imm:$I2, mode:$BD1)]> {
 594   let mayStore = 1;
 595 }
 596
 597 class StoreSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 598                Immediate imm, AddressingMode mode = bdaddr20only>
 599   : InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
 600             mnemonic#"\t$BD1, $I2",
 601             [(operator imm:$I2, mode:$BD1)]> {
 602   let mayStore = 1;
 603 }
 604
 605 class StoreSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 606                Immediate imm>
 607   : InstSIL<opcode, (outs), (ins bdaddr12only:$BD1, imm:$I2),
 608             mnemonic#"\t$BD1, $I2",
 609             [(operator imm:$I2, bdaddr12only:$BD1)]> {
 610   let mayStore = 1;
 611 }
 612
 613 multiclass StoreSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
 614                        SDPatternOperator operator, Immediate imm> {
 615   let DispKey = mnemonic in {
 616     let DispSize = "12" in
 617       def "" : StoreSI<mnemonic, siOpcode, operator, imm, bdaddr12pair>;
 618     let DispSize = "20" in
 619       def Y  : StoreSIY<mnemonic#"y", siyOpcode, operator, imm, bdaddr20pair>;
 620   }
 621 }
 622
 623 class CondStoreRSY<string mnemonic, bits<16> opcode,
 624                    RegisterOperand cls, bits<5> bytes,
 625                    AddressingMode mode = bdaddr20only>
 626   : InstRSY<opcode, (outs), (ins cls:$R1, mode:$BD2, cond4:$R3),
 627             mnemonic#"$R3\t$R1, $BD2", []>,
 628     Requires<[FeatureLoadStoreOnCond]> {
 629   let mayStore = 1;
 630   let AccessBytes = bytes;
 631 }
 632
 633 // Like CondStoreRSY, but used for the raw assembly form.  The condition-code
 634 // mask is the third operand rather than being part of the mnemonic.
 635 class AsmCondStoreRSY<string mnemonic, bits<16> opcode,
 636                       RegisterOperand cls, bits<5> bytes,
 637                       AddressingMode mode = bdaddr20only>
 638   : InstRSY<opcode, (outs), (ins cls:$R1, mode:$BD2, uimm8zx4:$R3),
 639             mnemonic#"\t$R1, $BD2, $R3", []>,
 640     Requires<[FeatureLoadStoreOnCond]> {
 641   let mayStore = 1;
 642   let AccessBytes = bytes;
 643 }
 644
 645 // Like CondStoreRSY, but with a fixed CC mask.
 646 class FixedCondStoreRSY<string mnemonic, bits<16> opcode,
 647                         RegisterOperand cls, bits<4> ccmask, bits<5> bytes,
 648                         AddressingMode mode = bdaddr20only>
 649   : InstRSY<opcode, (outs), (ins cls:$R1, mode:$BD2),
 650             mnemonic#"\t$R1, $BD2", []>,
 651     Requires<[FeatureLoadStoreOnCond]> {
 652   let mayStore = 1;
 653   let AccessBytes = bytes;
 654   let R3 = ccmask;
 655 }
 656
 657 class UnaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 658               RegisterOperand cls1, RegisterOperand cls2>
 659   : InstRR<opcode, (outs cls1:$R1), (ins cls2:$R2),
 660            mnemonic#"r\t$R1, $R2",
 661            [(set cls1:$R1, (operator cls2:$R2))]> {
 662   let OpKey = mnemonic ## cls1;
 663   let OpType = "reg";
 664 }
 665
 666 class UnaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 667                RegisterOperand cls1, RegisterOperand cls2>
 668   : InstRRE<opcode, (outs cls1:$R1), (ins cls2:$R2),
 669             mnemonic#"r\t$R1, $R2",
 670             [(set cls1:$R1, (operator cls2:$R2))]> {
 671   let OpKey = mnemonic ## cls1;
 672   let OpType = "reg";
 673 }
 674
 675 class UnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
 676                RegisterOperand cls2>
 677   : InstRRF<opcode, (outs cls1:$R1), (ins uimm8zx4:$R3, cls2:$R2),
 678             mnemonic#"r\t$R1, $R3, $R2", []> {
 679   let OpKey = mnemonic ## cls1;
 680   let OpType = "reg";
 681 }
 682
 683 class UnaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 684               RegisterOperand cls, Immediate imm>
 685   : InstRI<opcode, (outs cls:$R1), (ins imm:$I2),
 686            mnemonic#"\t$R1, $I2",
 687            [(set cls:$R1, (operator imm:$I2))]>;
 688
 689 class UnaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 690                RegisterOperand cls, Immediate imm>
 691   : InstRIL<opcode, (outs cls:$R1), (ins imm:$I2),
 692             mnemonic#"\t$R1, $I2",
 693             [(set cls:$R1, (operator imm:$I2))]>;
 694
 695 class UnaryRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 696                  RegisterOperand cls>
 697   : InstRIL<opcode, (outs cls:$R1), (ins pcrel32:$I2),
 698             mnemonic#"\t$R1, $I2",
 699             [(set cls:$R1, (operator pcrel32:$I2))]> {
 700   let mayLoad = 1;
 701   // We want PC-relative addresses to be tried ahead of BD and BDX addresses.
 702   // However, BDXs have two extra operands and are therefore 6 units more
 703   // complex.
 704   let AddedComplexity = 7;
 705 }
 706
 707 class CondUnaryRSY<string mnemonic, bits<16> opcode,
 708                    RegisterOperand cls, bits<5> bytes,
 709                    AddressingMode mode = bdaddr20only>
 710   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2, cond4:$R3),
 711             mnemonic#"$R3\t$R1, $BD2", []>,
 712     Requires<[FeatureLoadStoreOnCond]> {
 713   let Constraints = "$R1 = $R1src";
 714   let DisableEncoding = "$R1src";
 715   let mayLoad = 1;
 716   let AccessBytes = bytes;
 717 }
 718
 719 // Like CondUnaryRSY, but used for the raw assembly form.  The condition-code
 720 // mask is the third operand rather than being part of the mnemonic.
 721 class AsmCondUnaryRSY<string mnemonic, bits<16> opcode,
 722                       RegisterOperand cls, bits<5> bytes,
 723                       AddressingMode mode = bdaddr20only>
 724   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2, uimm8zx4:$R3),
 725             mnemonic#"\t$R1, $BD2, $R3", []>,
 726     Requires<[FeatureLoadStoreOnCond]> {
 727   let mayLoad = 1;
 728   let AccessBytes = bytes;
 729   let Constraints = "$R1 = $R1src";
 730   let DisableEncoding = "$R1src";
 731 }
 732
 733 // Like CondUnaryRSY, but with a fixed CC mask.
 734 class FixedCondUnaryRSY<string mnemonic, bits<16> opcode,
 735                         RegisterOperand cls, bits<4> ccmask, bits<5> bytes,
 736                         AddressingMode mode = bdaddr20only>
 737   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2),
 738             mnemonic#"\t$R1, $BD2", []>,
 739     Requires<[FeatureLoadStoreOnCond]> {
 740   let Constraints = "$R1 = $R1src";
 741   let DisableEncoding = "$R1src";
 742   let R3 = ccmask;
 743   let mayLoad = 1;
 744   let AccessBytes = bytes;
 745 }
 746
 747 class UnaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 748               RegisterOperand cls, bits<5> bytes,
 749               AddressingMode mode = bdxaddr12only>
 750   : InstRX<opcode, (outs cls:$R1), (ins mode:$XBD2),
 751            mnemonic#"\t$R1, $XBD2",
 752            [(set cls:$R1, (operator mode:$XBD2))]> {
 753   let OpKey = mnemonic ## cls;
 754   let OpType = "mem";
 755   let mayLoad = 1;
 756   let AccessBytes = bytes;
 757 }
 758
 759 class UnaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 760                RegisterOperand cls, bits<5> bytes>
 761   : InstRXE<opcode, (outs cls:$R1), (ins bdxaddr12only:$XBD2),
 762             mnemonic#"\t$R1, $XBD2",
 763             [(set cls:$R1, (operator bdxaddr12only:$XBD2))]> {
 764   let OpKey = mnemonic ## cls;
 765   let OpType = "mem";
 766   let mayLoad = 1;
 767   let AccessBytes = bytes;
 768 }
 769
 770 class UnaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 771                RegisterOperand cls, bits<5> bytes,
 772                AddressingMode mode = bdxaddr20only>
 773   : InstRXY<opcode, (outs cls:$R1), (ins mode:$XBD2),
 774             mnemonic#"\t$R1, $XBD2",
 775             [(set cls:$R1, (operator mode:$XBD2))]> {
 776   let OpKey = mnemonic ## cls;
 777   let OpType = "mem";
 778   let mayLoad = 1;
 779   let AccessBytes = bytes;
 780 }
 781
 782 multiclass UnaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
 783                        SDPatternOperator operator, RegisterOperand cls,
 784                        bits<5> bytes> {
 785   let DispKey = mnemonic ## #cls in {
 786     let DispSize = "12" in
 787       def "" : UnaryRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
 788     let DispSize = "20" in
 789       def Y  : UnaryRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
 790                         bdxaddr20pair>;
 791   }
 792 }
 793
 794 class BinaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 795                RegisterOperand cls1, RegisterOperand cls2>
 796   : InstRR<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
 797            mnemonic#"r\t$R1, $R2",
 798            [(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
 799   let OpKey = mnemonic ## cls1;
 800   let OpType = "reg";
 801   let Constraints = "$R1 = $R1src";
 802   let DisableEncoding = "$R1src";
 803 }
 804
 805 class BinaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 806                 RegisterOperand cls1, RegisterOperand cls2>
 807   : InstRRE<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
 808             mnemonic#"r\t$R1, $R2",
 809             [(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
 810   let OpKey = mnemonic ## cls1;
 811   let OpType = "reg";
 812   let Constraints = "$R1 = $R1src";
 813   let DisableEncoding = "$R1src";
 814 }
 815
 816 class BinaryRRF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 817                 RegisterOperand cls1, RegisterOperand cls2>
 818   : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R3, cls2:$R2),
 819             mnemonic#"r\t$R1, $R3, $R2",
 820             [(set cls1:$R1, (operator cls1:$R3, cls2:$R2))]> {
 821   let OpKey = mnemonic ## cls1;
 822   let OpType = "reg";
 823 }
 824
 825 class BinaryRRFK<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 826                  RegisterOperand cls1, RegisterOperand cls2>
 827   : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R2, cls2:$R3),
 828             mnemonic#"rk\t$R1, $R2, $R3",
 829             [(set cls1:$R1, (operator cls1:$R2, cls2:$R3))]>;
 830
 831 multiclass BinaryRRAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
 832                         SDPatternOperator operator, RegisterOperand cls1,
 833                         RegisterOperand cls2> {
 834   let NumOpsKey = mnemonic in {
 835     let NumOpsValue = "3" in
 836       def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
 837               Requires<[FeatureDistinctOps]>;
 838     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
 839       def "" : BinaryRR<mnemonic, opcode1, operator, cls1, cls2>;
 840   }
 841 }
 842
 843 multiclass BinaryRREAndK<string mnemonic, bits<16> opcode1, bits<16> opcode2,
 844                          SDPatternOperator operator, RegisterOperand cls1,
 845                          RegisterOperand cls2> {
 846   let NumOpsKey = mnemonic in {
 847     let NumOpsValue = "3" in
 848       def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
 849               Requires<[FeatureDistinctOps]>;
 850     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
 851       def "" : BinaryRRE<mnemonic, opcode1, operator, cls1, cls2>;
 852   }
 853 }
 854
 855 class BinaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 856                RegisterOperand cls, Immediate imm>
 857   : InstRI<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
 858            mnemonic#"\t$R1, $I2",
 859            [(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
 860   let Constraints = "$R1 = $R1src";
 861   let DisableEncoding = "$R1src";
 862 }
 863
 864 class BinaryRIE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 865                 RegisterOperand cls, Immediate imm>
 866   : InstRIEd<opcode, (outs cls:$R1), (ins cls:$R3, imm:$I2),
 867              mnemonic#"\t$R1, $R3, $I2",
 868              [(set cls:$R1, (operator cls:$R3, imm:$I2))]>;
 869
 870 multiclass BinaryRIAndK<string mnemonic, bits<12> opcode1, bits<16> opcode2,
 871                         SDPatternOperator operator, RegisterOperand cls,
 872                         Immediate imm> {
 873   let NumOpsKey = mnemonic in {
 874     let NumOpsValue = "3" in
 875       def K : BinaryRIE<mnemonic##"k", opcode2, null_frag, cls, imm>,
 876               Requires<[FeatureDistinctOps]>;
 877     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
 878       def "" : BinaryRI<mnemonic, opcode1, operator, cls, imm>;
 879   }
 880 }
 881
 882 class BinaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 883                 RegisterOperand cls, Immediate imm>
 884   : InstRIL<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
 885             mnemonic#"\t$R1, $I2",
 886             [(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
 887   let Constraints = "$R1 = $R1src";
 888   let DisableEncoding = "$R1src";
 889 }
 890
 891 class BinaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 892                RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
 893                AddressingMode mode = bdxaddr12only>
 894   : InstRX<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
 895            mnemonic#"\t$R1, $XBD2",
 896            [(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
 897   let OpKey = mnemonic ## cls;
 898   let OpType = "mem";
 899   let Constraints = "$R1 = $R1src";
 900   let DisableEncoding = "$R1src";
 901   let mayLoad = 1;
 902   let AccessBytes = bytes;
 903 }
 904
 905 class BinaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 906                   RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
 907   : InstRXE<opcode, (outs cls:$R1), (ins cls:$R1src, bdxaddr12only:$XBD2),
 908             mnemonic#"\t$R1, $XBD2",
 909             [(set cls:$R1, (operator cls:$R1src,
 910                                      (load bdxaddr12only:$XBD2)))]> {
 911   let OpKey = mnemonic ## cls;
 912   let OpType = "mem";
 913   let Constraints = "$R1 = $R1src";
 914   let DisableEncoding = "$R1src";
 915   let mayLoad = 1;
 916   let AccessBytes = bytes;
 917 }
 918
 919 class BinaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 920                 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
 921                 AddressingMode mode = bdxaddr20only>
 922   : InstRXY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
 923             mnemonic#"\t$R1, $XBD2",
 924             [(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
 925   let OpKey = mnemonic ## cls;
 926   let OpType = "mem";
 927   let Constraints = "$R1 = $R1src";
 928   let DisableEncoding = "$R1src";
 929   let mayLoad = 1;
 930   let AccessBytes = bytes;
 931 }
 932
 933 multiclass BinaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
 934                         SDPatternOperator operator, RegisterOperand cls,
 935                         SDPatternOperator load, bits<5> bytes> {
 936   let DispKey = mnemonic ## #cls in {
 937     let DispSize = "12" in
 938       def "" : BinaryRX<mnemonic, rxOpcode, operator, cls, load, bytes,
 939                         bdxaddr12pair>;
 940     let DispSize = "20" in
 941       def Y  : BinaryRXY<mnemonic#"y", rxyOpcode, operator, cls, load, bytes,
 942                          bdxaddr20pair>;
 943   }
 944 }
 945
 946 class BinarySI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 947                Operand imm, AddressingMode mode = bdaddr12only>
 948   : InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
 949            mnemonic#"\t$BD1, $I2",
 950            [(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
 951   let mayLoad = 1;
 952   let mayStore = 1;
 953 }
 954
 955 class BinarySIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 956                 Operand imm, AddressingMode mode = bdaddr20only>
 957   : InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
 958             mnemonic#"\t$BD1, $I2",
 959             [(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
 960   let mayLoad = 1;
 961   let mayStore = 1;
 962 }
 963
 964 multiclass BinarySIPair<string mnemonic, bits<8> siOpcode,
 965                         bits<16> siyOpcode, SDPatternOperator operator,
 966                         Operand imm> {
 967   let DispKey = mnemonic ## #cls in {
 968     let DispSize = "12" in
 969       def "" : BinarySI<mnemonic, siOpcode, operator, imm, bdaddr12pair>;
 970     let DispSize = "20" in
 971       def Y  : BinarySIY<mnemonic#"y", siyOpcode, operator, imm, bdaddr20pair>;
 972   }
 973 }
 974
 975 class ShiftRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 976               RegisterOperand cls>
 977   : InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, shift12only:$BD2),
 978            mnemonic#"\t$R1, $BD2",
 979            [(set cls:$R1, (operator cls:$R1src, shift12only:$BD2))]> {
 980   let R3 = 0;
 981   let Constraints = "$R1 = $R1src";
 982   let DisableEncoding = "$R1src";
 983 }
 984
 985 class ShiftRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 986                RegisterOperand cls>
 987   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R3, shift20only:$BD2),
 988             mnemonic#"\t$R1, $R3, $BD2",
 989             [(set cls:$R1, (operator cls:$R3, shift20only:$BD2))]>;
 990
 991 multiclass ShiftRSAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
 992                        SDPatternOperator operator, RegisterOperand cls> {
 993   let NumOpsKey = mnemonic in {
 994     let NumOpsValue = "3" in
 995       def K  : ShiftRSY<mnemonic##"k", opcode2, null_frag, cls>,
 996                Requires<[FeatureDistinctOps]>;
 997     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
 998       def "" : ShiftRS<mnemonic, opcode1, operator, cls>;
 999   }
1000 }
1001
1002 class CompareRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1003                 RegisterOperand cls1, RegisterOperand cls2>
1004   : InstRR<opcode, (outs), (ins cls1:$R1, cls2:$R2),
1005            mnemonic#"r\t$R1, $R2",
1006            [(operator cls1:$R1, cls2:$R2)]> {
1007   let OpKey = mnemonic ## cls1;
1008   let OpType = "reg";
1009 }
1010
1011 class CompareRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1012                  RegisterOperand cls1, RegisterOperand cls2>
1013   : InstRRE<opcode, (outs), (ins cls1:$R1, cls2:$R2),
1014             mnemonic#"r\t$R1, $R2",
1015             [(operator cls1:$R1, cls2:$R2)]> {
1016   let OpKey = mnemonic ## cls1;
1017   let OpType = "reg";
1018 }
1019
1020 class CompareRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1021                 RegisterOperand cls, Immediate imm>
1022   : InstRI<opcode, (outs), (ins cls:$R1, imm:$I2),
1023            mnemonic#"\t$R1, $I2",
1024            [(operator cls:$R1, imm:$I2)]>;
1025
1026 class CompareRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1027                  RegisterOperand cls, Immediate imm>
1028   : InstRIL<opcode, (outs), (ins cls:$R1, imm:$I2),
1029             mnemonic#"\t$R1, $I2",
1030             [(operator cls:$R1, imm:$I2)]>;
1031
1032 class CompareRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1033                    RegisterOperand cls, SDPatternOperator load>
1034   : InstRIL<opcode, (outs), (ins cls:$R1, pcrel32:$I2),
1035             mnemonic#"\t$R1, $I2",
1036             [(operator cls:$R1, (load pcrel32:$I2))]> {
1037   let mayLoad = 1;
1038   // We want PC-relative addresses to be tried ahead of BD and BDX addresses.
1039   // However, BDXs have two extra operands and are therefore 6 units more
1040   // complex.
1041   let AddedComplexity = 7;
1042 }
1043
1044 class CompareRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1045                 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
1046                 AddressingMode mode = bdxaddr12only>
1047   : InstRX<opcode, (outs), (ins cls:$R1, mode:$XBD2),
1048            mnemonic#"\t$R1, $XBD2",
1049            [(operator cls:$R1, (load mode:$XBD2))]> {
1050   let OpKey = mnemonic ## cls;
1051   let OpType = "mem";
1052   let mayLoad = 1;
1053   let AccessBytes = bytes;
1054 }
1055
1056 class CompareRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1057                  RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
1058   : InstRXE<opcode, (outs), (ins cls:$R1, bdxaddr12only:$XBD2),
1059             mnemonic#"\t$R1, $XBD2",
1060             [(operator cls:$R1, (load bdxaddr12only:$XBD2))]> {
1061   let OpKey = mnemonic ## cls;
1062   let OpType = "mem";
1063   let mayLoad = 1;
1064   let AccessBytes = bytes;
1065 }
1066
1067 class CompareRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1068                  RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
1069                  AddressingMode mode = bdxaddr20only>
1070   : InstRXY<opcode, (outs), (ins cls:$R1, mode:$XBD2),
1071             mnemonic#"\t$R1, $XBD2",
1072             [(operator cls:$R1, (load mode:$XBD2))]> {
1073   let OpKey = mnemonic ## cls;
1074   let OpType = "mem";
1075   let mayLoad = 1;
1076   let AccessBytes = bytes;
1077 }
1078
1079 multiclass CompareRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
1080                          SDPatternOperator operator, RegisterOperand cls,
1081                          SDPatternOperator load, bits<5> bytes> {
1082   let DispKey = mnemonic ## #cls in {
1083     let DispSize = "12" in
1084       def "" : CompareRX<mnemonic, rxOpcode, operator, cls,
1085                          load, bytes, bdxaddr12pair>;
1086     let DispSize = "20" in
1087       def Y  : CompareRXY<mnemonic#"y", rxyOpcode, operator, cls,
1088                           load, bytes, bdxaddr20pair>;
1089   }
1090 }
1091
1092 class CompareSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1093                 SDPatternOperator load, Immediate imm,
1094                 AddressingMode mode = bdaddr12only>
1095   : InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
1096            mnemonic#"\t$BD1, $I2",
1097            [(operator (load mode:$BD1), imm:$I2)]> {
1098   let mayLoad = 1;
1099 }
1100
1101 class CompareSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1102                  SDPatternOperator load, Immediate imm>
1103   : InstSIL<opcode, (outs), (ins bdaddr12only:$BD1, imm:$I2),
1104             mnemonic#"\t$BD1, $I2",
1105             [(operator (load bdaddr12only:$BD1), imm:$I2)]> {
1106   let mayLoad = 1;
1107 }
1108
1109 class CompareSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1110                  SDPatternOperator load, Immediate imm,
1111                  AddressingMode mode = bdaddr20only>
1112   : InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
1113             mnemonic#"\t$BD1, $I2",
1114             [(operator (load mode:$BD1), imm:$I2)]> {
1115   let mayLoad = 1;
1116 }
1117
1118 multiclass CompareSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
1119                          SDPatternOperator operator, SDPatternOperator load,
1120                          Immediate imm> {
1121   let DispKey = mnemonic in {
1122     let DispSize = "12" in
1123       def "" : CompareSI<mnemonic, siOpcode, operator, load, imm, bdaddr12pair>;
1124     let DispSize = "20" in
1125       def Y  : CompareSIY<mnemonic#"y", siyOpcode, operator, load, imm,
1126                           bdaddr20pair>;
1127   }
1128 }
1129
1130 class TernaryRRD<string mnemonic, bits<16> opcode,
1131                  SDPatternOperator operator, RegisterOperand cls>
1132   : InstRRD<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, cls:$R2),
1133             mnemonic#"r\t$R1, $R3, $R2",
1134             [(set cls:$R1, (operator cls:$R1src, cls:$R3, cls:$R2))]> {
1135   let OpKey = mnemonic ## cls;
1136   let OpType = "reg";
1137   let Constraints = "$R1 = $R1src";
1138   let DisableEncoding = "$R1src";
1139 }
1140
1141 class TernaryRXF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1142                  RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
1143   : InstRXF<opcode, (outs cls:$R1),
1144             (ins cls:$R1src, cls:$R3, bdxaddr12only:$XBD2),
1145             mnemonic#"\t$R1, $R3, $XBD2",
1146             [(set cls:$R1, (operator cls:$R1src, cls:$R3,
1147                                      (load bdxaddr12only:$XBD2)))]> {
1148   let OpKey = mnemonic ## cls;
1149   let OpType = "mem";
1150   let Constraints = "$R1 = $R1src";
1151   let DisableEncoding = "$R1src";
1152   let mayLoad = 1;
1153   let AccessBytes = bytes;
1154 }
1155
1156 class CmpSwapRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1157                 RegisterOperand cls, AddressingMode mode = bdaddr12only>
1158   : InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
1159            mnemonic#"\t$R1, $R3, $BD2",
1160            [(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
1161   let Constraints = "$R1 = $R1src";
1162   let DisableEncoding = "$R1src";
1163   let mayLoad = 1;
1164   let mayStore = 1;
1165 }
1166
1167 class CmpSwapRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1168                  RegisterOperand cls, AddressingMode mode = bdaddr20only>
1169   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
1170             mnemonic#"\t$R1, $R3, $BD2",
1171             [(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
1172   let Constraints = "$R1 = $R1src";
1173   let DisableEncoding = "$R1src";
1174   let mayLoad = 1;
1175   let mayStore = 1;
1176 }
1177
1178 multiclass CmpSwapRSPair<string mnemonic, bits<8> rsOpcode, bits<16> rsyOpcode,
1179                          SDPatternOperator operator, RegisterOperand cls> {
1180   let DispKey = mnemonic ## #cls in {
1181     let DispSize = "12" in
1182       def "" : CmpSwapRS<mnemonic, rsOpcode, operator, cls, bdaddr12pair>;
1183     let DispSize = "20" in
1184       def Y  : CmpSwapRSY<mnemonic#"y", rsyOpcode, operator, cls, bdaddr20pair>;
1185   }
1186 }
1187
1188 class RotateSelectRIEf<string mnemonic, bits<16> opcode, RegisterOperand cls1,
1189                        RegisterOperand cls2>
1190   : InstRIEf<opcode, (outs cls1:$R1),
1191              (ins cls1:$R1src, cls2:$R2, uimm8:$I3, uimm8:$I4, uimm8zx6:$I5),
1192              mnemonic#"\t$R1, $R2, $I3, $I4, $I5", []> {
1193   let Constraints = "$R1 = $R1src";
1194   let DisableEncoding = "$R1src";
1195 }
1196
1197 //===----------------------------------------------------------------------===//
1198 // Pseudo instructions
1199 //===----------------------------------------------------------------------===//
1200 //
1201 // Convenience instructions that get lowered to real instructions
1202 // by either SystemZTargetLowering::EmitInstrWithCustomInserter()
1203 // or SystemZInstrInfo::expandPostRAPseudo().
1204 //
1205 //===----------------------------------------------------------------------===//
1206
1207 class Pseudo<dag outs, dag ins, list<dag> pattern>
1208   : InstSystemZ<0, outs, ins, "", pattern> {
1209   let isPseudo = 1;
1210   let isCodeGenOnly = 1;
1211 }
1212
1213 // Implements "$dst = $cc & (8 >> CC) ? $src1 : $src2", where CC is
1214 // the value of the PSW's 2-bit condition code field.
1215 class SelectWrapper<RegisterOperand cls>
1216   : Pseudo<(outs cls:$dst), (ins cls:$src1, cls:$src2, i8imm:$cc),
1217            [(set cls:$dst, (z_select_ccmask cls:$src1, cls:$src2, imm:$cc))]> {
1218   let usesCustomInserter = 1;
1219   // Although the instructions used by these nodes do not in themselves
1220   // change CC, the insertion requires new blocks, and CC cannot be live
1221   // across them.
1222   let Defs = [CC];
1223   let Uses = [CC];
1224 }
1225
1226 // Stores $new to $addr if $cc is true ("" case) or false (Inv case).
1227 multiclass CondStores<RegisterOperand cls, SDPatternOperator store,
1228                       SDPatternOperator load, AddressingMode mode> {
1229   let Defs = [CC], Uses = [CC], usesCustomInserter = 1 in {
1230     def "" : Pseudo<(outs), (ins cls:$new, mode:$addr, uimm8zx4:$cc),
1231                     [(store (z_select_ccmask cls:$new, (load mode:$addr),
1232                                              uimm8zx4:$cc), mode:$addr)]>;
1233     def Inv : Pseudo<(outs), (ins cls:$new, mode:$addr, uimm8zx4:$cc),
1234                      [(store (z_select_ccmask (load mode:$addr), cls:$new,
1235                                               uimm8zx4:$cc), mode:$addr)]>;
1236   }
1237 }
1238
1239 // OPERATOR is ATOMIC_SWAP or an ATOMIC_LOAD_* operation.  PAT and OPERAND
1240 // describe the second (non-memory) operand.
1241 class AtomicLoadBinary<SDPatternOperator operator, RegisterOperand cls,
1242                        dag pat, DAGOperand operand>
1243   : Pseudo<(outs cls:$dst), (ins bdaddr20only:$ptr, operand:$src2),
1244            [(set cls:$dst, (operator bdaddr20only:$ptr, pat))]> {
1245   let Defs = [CC];
1246   let Has20BitOffset = 1;
1247   let mayLoad = 1;
1248   let mayStore = 1;
1249   let usesCustomInserter = 1;
1250 }
1251
1252 // Specializations of AtomicLoadWBinary.
1253 class AtomicLoadBinaryReg32<SDPatternOperator operator>
1254   : AtomicLoadBinary<operator, GR32, (i32 GR32:$src2), GR32>;
1255 class AtomicLoadBinaryImm32<SDPatternOperator operator, Immediate imm>
1256   : AtomicLoadBinary<operator, GR32, (i32 imm:$src2), imm>;
1257 class AtomicLoadBinaryReg64<SDPatternOperator operator>
1258   : AtomicLoadBinary<operator, GR64, (i64 GR64:$src2), GR64>;
1259 class AtomicLoadBinaryImm64<SDPatternOperator operator, Immediate imm>
1260   : AtomicLoadBinary<operator, GR64, (i64 imm:$src2), imm>;
1261
1262 // OPERATOR is ATOMIC_SWAPW or an ATOMIC_LOADW_* operation.  PAT and OPERAND
1263 // describe the second (non-memory) operand.
1264 class AtomicLoadWBinary<SDPatternOperator operator, dag pat,
1265                         DAGOperand operand>
1266   : Pseudo<(outs GR32:$dst),
1267            (ins bdaddr20only:$ptr, operand:$src2, ADDR32:$bitshift,
1268                 ADDR32:$negbitshift, uimm32:$bitsize),
1269            [(set GR32:$dst, (operator bdaddr20only:$ptr, pat, ADDR32:$bitshift,
1270                                       ADDR32:$negbitshift, uimm32:$bitsize))]> {
1271   let Defs = [CC];
1272   let Has20BitOffset = 1;
1273   let mayLoad = 1;
1274   let mayStore = 1;
1275   let usesCustomInserter = 1;
1276 }
1277
1278 // Specializations of AtomicLoadWBinary.
1279 class AtomicLoadWBinaryReg<SDPatternOperator operator>
1280   : AtomicLoadWBinary<operator, (i32 GR32:$src2), GR32>;
1281 class AtomicLoadWBinaryImm<SDPatternOperator operator, Immediate imm>
1282   : AtomicLoadWBinary<operator, (i32 imm:$src2), imm>;