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 // These instructions are generated by if conversion.  The old value of R1
 684 // is added as an implicit use.
 685 class CondUnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
 686                    RegisterOperand cls2>
 687   : InstRRF<opcode, (outs cls1:$R1), (ins cls2:$R2, cond4:$valid, cond4:$R3),
 688             mnemonic#"r$R3\t$R1, $R2", []>,
 689     Requires<[FeatureLoadStoreOnCond]>;
 690
 691 // Like CondUnaryRRF, but used for the raw assembly form.  The condition-code
 692 // mask is the third operand rather than being part of the mnemonic.
 693 class AsmCondUnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
 694                       RegisterOperand cls2>
 695   : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2, uimm8zx4:$R3),
 696             mnemonic#"r\t$R1, $R2, $R3", []>,
 697     Requires<[FeatureLoadStoreOnCond]> {
 698   let Constraints = "$R1 = $R1src";
 699   let DisableEncoding = "$R1src";
 700 }
 701
 702 // Like CondUnaryRRF, but with a fixed CC mask.
 703 class FixedCondUnaryRRF<string mnemonic, bits<16> opcode, RegisterOperand cls1,
 704                         RegisterOperand cls2, bits<4> ccmask>
 705   : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
 706             mnemonic#"\t$R1, $R2", []>,
 707     Requires<[FeatureLoadStoreOnCond]> {
 708   let Constraints = "$R1 = $R1src";
 709   let DisableEncoding = "$R1src";
 710   let R3 = ccmask;
 711 }
 712
 713 class UnaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 714               RegisterOperand cls, Immediate imm>
 715   : InstRI<opcode, (outs cls:$R1), (ins imm:$I2),
 716            mnemonic#"\t$R1, $I2",
 717            [(set cls:$R1, (operator imm:$I2))]>;
 718
 719 class UnaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 720                RegisterOperand cls, Immediate imm>
 721   : InstRIL<opcode, (outs cls:$R1), (ins imm:$I2),
 722             mnemonic#"\t$R1, $I2",
 723             [(set cls:$R1, (operator imm:$I2))]>;
 724
 725 class UnaryRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 726                  RegisterOperand cls>
 727   : InstRIL<opcode, (outs cls:$R1), (ins pcrel32:$I2),
 728             mnemonic#"\t$R1, $I2",
 729             [(set cls:$R1, (operator pcrel32:$I2))]> {
 730   let mayLoad = 1;
 731   // We want PC-relative addresses to be tried ahead of BD and BDX addresses.
 732   // However, BDXs have two extra operands and are therefore 6 units more
 733   // complex.
 734   let AddedComplexity = 7;
 735 }
 736
 737 class CondUnaryRSY<string mnemonic, bits<16> opcode,
 738                    SDPatternOperator operator, RegisterOperand cls,
 739                    bits<5> bytes, AddressingMode mode = bdaddr20only>
 740   : InstRSY<opcode, (outs cls:$R1),
 741             (ins cls:$R1src, mode:$BD2, cond4:$valid, cond4:$R3),
 742             mnemonic#"$R3\t$R1, $BD2",
 743             [(set cls:$R1,
 744                   (z_select_ccmask (load bdaddr20only:$BD2), cls:$R1src,
 745                                    cond4:$valid, cond4:$R3))]>,
 746     Requires<[FeatureLoadStoreOnCond]> {
 747   let Constraints = "$R1 = $R1src";
 748   let DisableEncoding = "$R1src";
 749   let mayLoad = 1;
 750   let AccessBytes = bytes;
 751 }
 752
 753 // Like CondUnaryRSY, but used for the raw assembly form.  The condition-code
 754 // mask is the third operand rather than being part of the mnemonic.
 755 class AsmCondUnaryRSY<string mnemonic, bits<16> opcode,
 756                       RegisterOperand cls, bits<5> bytes,
 757                       AddressingMode mode = bdaddr20only>
 758   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2, uimm8zx4:$R3),
 759             mnemonic#"\t$R1, $BD2, $R3", []>,
 760     Requires<[FeatureLoadStoreOnCond]> {
 761   let mayLoad = 1;
 762   let AccessBytes = bytes;
 763   let Constraints = "$R1 = $R1src";
 764   let DisableEncoding = "$R1src";
 765 }
 766
 767 // Like CondUnaryRSY, but with a fixed CC mask.
 768 class FixedCondUnaryRSY<string mnemonic, bits<16> opcode,
 769                         RegisterOperand cls, bits<4> ccmask, bits<5> bytes,
 770                         AddressingMode mode = bdaddr20only>
 771   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2),
 772             mnemonic#"\t$R1, $BD2", []>,
 773     Requires<[FeatureLoadStoreOnCond]> {
 774   let Constraints = "$R1 = $R1src";
 775   let DisableEncoding = "$R1src";
 776   let R3 = ccmask;
 777   let mayLoad = 1;
 778   let AccessBytes = bytes;
 779 }
 780
 781 class UnaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 782               RegisterOperand cls, bits<5> bytes,
 783               AddressingMode mode = bdxaddr12only>
 784   : InstRX<opcode, (outs cls:$R1), (ins mode:$XBD2),
 785            mnemonic#"\t$R1, $XBD2",
 786            [(set cls:$R1, (operator mode:$XBD2))]> {
 787   let OpKey = mnemonic ## cls;
 788   let OpType = "mem";
 789   let mayLoad = 1;
 790   let AccessBytes = bytes;
 791 }
 792
 793 class UnaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 794                RegisterOperand cls, bits<5> bytes>
 795   : InstRXE<opcode, (outs cls:$R1), (ins bdxaddr12only:$XBD2),
 796             mnemonic#"\t$R1, $XBD2",
 797             [(set cls:$R1, (operator bdxaddr12only:$XBD2))]> {
 798   let OpKey = mnemonic ## cls;
 799   let OpType = "mem";
 800   let mayLoad = 1;
 801   let AccessBytes = bytes;
 802 }
 803
 804 class UnaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 805                RegisterOperand cls, bits<5> bytes,
 806                AddressingMode mode = bdxaddr20only>
 807   : InstRXY<opcode, (outs cls:$R1), (ins mode:$XBD2),
 808             mnemonic#"\t$R1, $XBD2",
 809             [(set cls:$R1, (operator mode:$XBD2))]> {
 810   let OpKey = mnemonic ## cls;
 811   let OpType = "mem";
 812   let mayLoad = 1;
 813   let AccessBytes = bytes;
 814 }
 815
 816 multiclass UnaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
 817                        SDPatternOperator operator, RegisterOperand cls,
 818                        bits<5> bytes> {
 819   let DispKey = mnemonic ## #cls in {
 820     let DispSize = "12" in
 821       def "" : UnaryRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
 822     let DispSize = "20" in
 823       def Y  : UnaryRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
 824                         bdxaddr20pair>;
 825   }
 826 }
 827
 828 class BinaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 829                RegisterOperand cls1, RegisterOperand cls2>
 830   : InstRR<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
 831            mnemonic#"r\t$R1, $R2",
 832            [(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
 833   let OpKey = mnemonic ## cls1;
 834   let OpType = "reg";
 835   let Constraints = "$R1 = $R1src";
 836   let DisableEncoding = "$R1src";
 837 }
 838
 839 class BinaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 840                 RegisterOperand cls1, RegisterOperand cls2>
 841   : InstRRE<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
 842             mnemonic#"r\t$R1, $R2",
 843             [(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
 844   let OpKey = mnemonic ## cls1;
 845   let OpType = "reg";
 846   let Constraints = "$R1 = $R1src";
 847   let DisableEncoding = "$R1src";
 848 }
 849
 850 class BinaryRRF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 851                 RegisterOperand cls1, RegisterOperand cls2>
 852   : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R3, cls2:$R2),
 853             mnemonic#"r\t$R1, $R3, $R2",
 854             [(set cls1:$R1, (operator cls1:$R3, cls2:$R2))]> {
 855   let OpKey = mnemonic ## cls1;
 856   let OpType = "reg";
 857 }
 858
 859 class BinaryRRFK<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 860                  RegisterOperand cls1, RegisterOperand cls2>
 861   : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R2, cls2:$R3),
 862             mnemonic#"rk\t$R1, $R2, $R3",
 863             [(set cls1:$R1, (operator cls1:$R2, cls2:$R3))]>;
 864
 865 multiclass BinaryRRAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
 866                         SDPatternOperator operator, RegisterOperand cls1,
 867                         RegisterOperand cls2> {
 868   let NumOpsKey = mnemonic in {
 869     let NumOpsValue = "3" in
 870       def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
 871               Requires<[FeatureDistinctOps]>;
 872     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
 873       def "" : BinaryRR<mnemonic, opcode1, operator, cls1, cls2>;
 874   }
 875 }
 876
 877 multiclass BinaryRREAndK<string mnemonic, bits<16> opcode1, bits<16> opcode2,
 878                          SDPatternOperator operator, RegisterOperand cls1,
 879                          RegisterOperand cls2> {
 880   let NumOpsKey = mnemonic in {
 881     let NumOpsValue = "3" in
 882       def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
 883               Requires<[FeatureDistinctOps]>;
 884     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
 885       def "" : BinaryRRE<mnemonic, opcode1, operator, cls1, cls2>;
 886   }
 887 }
 888
 889 class BinaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 890                RegisterOperand cls, Immediate imm>
 891   : InstRI<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
 892            mnemonic#"\t$R1, $I2",
 893            [(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
 894   let Constraints = "$R1 = $R1src";
 895   let DisableEncoding = "$R1src";
 896 }
 897
 898 class BinaryRIE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 899                 RegisterOperand cls, Immediate imm>
 900   : InstRIEd<opcode, (outs cls:$R1), (ins cls:$R3, imm:$I2),
 901              mnemonic#"\t$R1, $R3, $I2",
 902              [(set cls:$R1, (operator cls:$R3, imm:$I2))]>;
 903
 904 multiclass BinaryRIAndK<string mnemonic, bits<12> opcode1, bits<16> opcode2,
 905                         SDPatternOperator operator, RegisterOperand cls,
 906                         Immediate imm> {
 907   let NumOpsKey = mnemonic in {
 908     let NumOpsValue = "3" in
 909       def K : BinaryRIE<mnemonic##"k", opcode2, null_frag, cls, imm>,
 910               Requires<[FeatureDistinctOps]>;
 911     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
 912       def "" : BinaryRI<mnemonic, opcode1, operator, cls, imm>;
 913   }
 914 }
 915
 916 class BinaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
 917                 RegisterOperand cls, Immediate imm>
 918   : InstRIL<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
 919             mnemonic#"\t$R1, $I2",
 920             [(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
 921   let Constraints = "$R1 = $R1src";
 922   let DisableEncoding = "$R1src";
 923 }
 924
 925 class BinaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 926                RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
 927                AddressingMode mode = bdxaddr12only>
 928   : InstRX<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
 929            mnemonic#"\t$R1, $XBD2",
 930            [(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
 931   let OpKey = mnemonic ## cls;
 932   let OpType = "mem";
 933   let Constraints = "$R1 = $R1src";
 934   let DisableEncoding = "$R1src";
 935   let mayLoad = 1;
 936   let AccessBytes = bytes;
 937 }
 938
 939 class BinaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 940                   RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
 941   : InstRXE<opcode, (outs cls:$R1), (ins cls:$R1src, bdxaddr12only:$XBD2),
 942             mnemonic#"\t$R1, $XBD2",
 943             [(set cls:$R1, (operator cls:$R1src,
 944                                      (load bdxaddr12only:$XBD2)))]> {
 945   let OpKey = mnemonic ## cls;
 946   let OpType = "mem";
 947   let Constraints = "$R1 = $R1src";
 948   let DisableEncoding = "$R1src";
 949   let mayLoad = 1;
 950   let AccessBytes = bytes;
 951 }
 952
 953 class BinaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 954                 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
 955                 AddressingMode mode = bdxaddr20only>
 956   : InstRXY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
 957             mnemonic#"\t$R1, $XBD2",
 958             [(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
 959   let OpKey = mnemonic ## cls;
 960   let OpType = "mem";
 961   let Constraints = "$R1 = $R1src";
 962   let DisableEncoding = "$R1src";
 963   let mayLoad = 1;
 964   let AccessBytes = bytes;
 965 }
 966
 967 multiclass BinaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
 968                         SDPatternOperator operator, RegisterOperand cls,
 969                         SDPatternOperator load, bits<5> bytes> {
 970   let DispKey = mnemonic ## #cls in {
 971     let DispSize = "12" in
 972       def "" : BinaryRX<mnemonic, rxOpcode, operator, cls, load, bytes,
 973                         bdxaddr12pair>;
 974     let DispSize = "20" in
 975       def Y  : BinaryRXY<mnemonic#"y", rxyOpcode, operator, cls, load, bytes,
 976                          bdxaddr20pair>;
 977   }
 978 }
 979
 980 class BinarySI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
 981                Operand imm, AddressingMode mode = bdaddr12only>
 982   : InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
 983            mnemonic#"\t$BD1, $I2",
 984            [(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
 985   let mayLoad = 1;
 986   let mayStore = 1;
 987 }
 988
 989 class BinarySIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
 990                 Operand imm, AddressingMode mode = bdaddr20only>
 991   : InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
 992             mnemonic#"\t$BD1, $I2",
 993             [(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
 994   let mayLoad = 1;
 995   let mayStore = 1;
 996 }
 997
 998 multiclass BinarySIPair<string mnemonic, bits<8> siOpcode,
 999                         bits<16> siyOpcode, SDPatternOperator operator,
1000                         Operand imm> {
1001   let DispKey = mnemonic ## #cls in {
1002     let DispSize = "12" in
1003       def "" : BinarySI<mnemonic, siOpcode, operator, imm, bdaddr12pair>;
1004     let DispSize = "20" in
1005       def Y  : BinarySIY<mnemonic#"y", siyOpcode, operator, imm, bdaddr20pair>;
1006   }
1007 }
1008
1009 class ShiftRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1010               RegisterOperand cls>
1011   : InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, shift12only:$BD2),
1012            mnemonic#"\t$R1, $BD2",
1013            [(set cls:$R1, (operator cls:$R1src, shift12only:$BD2))]> {
1014   let R3 = 0;
1015   let Constraints = "$R1 = $R1src";
1016   let DisableEncoding = "$R1src";
1017 }
1018
1019 class ShiftRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1020                RegisterOperand cls>
1021   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R3, shift20only:$BD2),
1022             mnemonic#"\t$R1, $R3, $BD2",
1023             [(set cls:$R1, (operator cls:$R3, shift20only:$BD2))]>;
1024
1025 multiclass ShiftRSAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
1026                        SDPatternOperator operator, RegisterOperand cls> {
1027   let NumOpsKey = mnemonic in {
1028     let NumOpsValue = "3" in
1029       def K  : ShiftRSY<mnemonic##"k", opcode2, null_frag, cls>,
1030                Requires<[FeatureDistinctOps]>;
1031     let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
1032       def "" : ShiftRS<mnemonic, opcode1, operator, cls>;
1033   }
1034 }
1035
1036 class CompareRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1037                 RegisterOperand cls1, RegisterOperand cls2>
1038   : InstRR<opcode, (outs), (ins cls1:$R1, cls2:$R2),
1039            mnemonic#"r\t$R1, $R2",
1040            [(operator cls1:$R1, cls2:$R2)]> {
1041   let OpKey = mnemonic ## cls1;
1042   let OpType = "reg";
1043   let isCompare = 1;
1044 }
1045
1046 class CompareRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1047                  RegisterOperand cls1, RegisterOperand cls2>
1048   : InstRRE<opcode, (outs), (ins cls1:$R1, cls2:$R2),
1049             mnemonic#"r\t$R1, $R2",
1050             [(operator cls1:$R1, cls2:$R2)]> {
1051   let OpKey = mnemonic ## cls1;
1052   let OpType = "reg";
1053   let isCompare = 1;
1054 }
1055
1056 class CompareRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1057                 RegisterOperand cls, Immediate imm>
1058   : InstRI<opcode, (outs), (ins cls:$R1, imm:$I2),
1059            mnemonic#"\t$R1, $I2",
1060            [(operator cls:$R1, imm:$I2)]> {
1061   let isCompare = 1;
1062 }
1063
1064 class CompareRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1065                  RegisterOperand cls, Immediate imm>
1066   : InstRIL<opcode, (outs), (ins cls:$R1, imm:$I2),
1067             mnemonic#"\t$R1, $I2",
1068             [(operator cls:$R1, imm:$I2)]> {
1069   let isCompare = 1;
1070 }
1071
1072 class CompareRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1073                    RegisterOperand cls, SDPatternOperator load>
1074   : InstRIL<opcode, (outs), (ins cls:$R1, pcrel32:$I2),
1075             mnemonic#"\t$R1, $I2",
1076             [(operator cls:$R1, (load pcrel32:$I2))]> {
1077   let isCompare = 1;
1078   let mayLoad = 1;
1079   // We want PC-relative addresses to be tried ahead of BD and BDX addresses.
1080   // However, BDXs have two extra operands and are therefore 6 units more
1081   // complex.
1082   let AddedComplexity = 7;
1083 }
1084
1085 class CompareRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1086                 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
1087                 AddressingMode mode = bdxaddr12only>
1088   : InstRX<opcode, (outs), (ins cls:$R1, mode:$XBD2),
1089            mnemonic#"\t$R1, $XBD2",
1090            [(operator cls:$R1, (load mode:$XBD2))]> {
1091   let OpKey = mnemonic ## cls;
1092   let OpType = "mem";
1093   let isCompare = 1;
1094   let mayLoad = 1;
1095   let AccessBytes = bytes;
1096 }
1097
1098 class CompareRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1099                  RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
1100   : InstRXE<opcode, (outs), (ins cls:$R1, bdxaddr12only:$XBD2),
1101             mnemonic#"\t$R1, $XBD2",
1102             [(operator cls:$R1, (load bdxaddr12only:$XBD2))]> {
1103   let OpKey = mnemonic ## cls;
1104   let OpType = "mem";
1105   let isCompare = 1;
1106   let mayLoad = 1;
1107   let AccessBytes = bytes;
1108 }
1109
1110 class CompareRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1111                  RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
1112                  AddressingMode mode = bdxaddr20only>
1113   : InstRXY<opcode, (outs), (ins cls:$R1, mode:$XBD2),
1114             mnemonic#"\t$R1, $XBD2",
1115             [(operator cls:$R1, (load mode:$XBD2))]> {
1116   let OpKey = mnemonic ## cls;
1117   let OpType = "mem";
1118   let isCompare = 1;
1119   let mayLoad = 1;
1120   let AccessBytes = bytes;
1121 }
1122
1123 multiclass CompareRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
1124                          SDPatternOperator operator, RegisterOperand cls,
1125                          SDPatternOperator load, bits<5> bytes> {
1126   let DispKey = mnemonic ## #cls in {
1127     let DispSize = "12" in
1128       def "" : CompareRX<mnemonic, rxOpcode, operator, cls,
1129                          load, bytes, bdxaddr12pair>;
1130     let DispSize = "20" in
1131       def Y  : CompareRXY<mnemonic#"y", rxyOpcode, operator, cls,
1132                           load, bytes, bdxaddr20pair>;
1133   }
1134 }
1135
1136 class CompareSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1137                 SDPatternOperator load, Immediate imm,
1138                 AddressingMode mode = bdaddr12only>
1139   : InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
1140            mnemonic#"\t$BD1, $I2",
1141            [(operator (load mode:$BD1), imm:$I2)]> {
1142   let isCompare = 1;
1143   let mayLoad = 1;
1144 }
1145
1146 class CompareSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1147                  SDPatternOperator load, Immediate imm>
1148   : InstSIL<opcode, (outs), (ins bdaddr12only:$BD1, imm:$I2),
1149             mnemonic#"\t$BD1, $I2",
1150             [(operator (load bdaddr12only:$BD1), imm:$I2)]> {
1151   let isCompare = 1;
1152   let mayLoad = 1;
1153 }
1154
1155 class CompareSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1156                  SDPatternOperator load, Immediate imm,
1157                  AddressingMode mode = bdaddr20only>
1158   : InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
1159             mnemonic#"\t$BD1, $I2",
1160             [(operator (load mode:$BD1), imm:$I2)]> {
1161   let isCompare = 1;
1162   let mayLoad = 1;
1163 }
1164
1165 multiclass CompareSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
1166                          SDPatternOperator operator, SDPatternOperator load,
1167                          Immediate imm> {
1168   let DispKey = mnemonic in {
1169     let DispSize = "12" in
1170       def "" : CompareSI<mnemonic, siOpcode, operator, load, imm, bdaddr12pair>;
1171     let DispSize = "20" in
1172       def Y  : CompareSIY<mnemonic#"y", siyOpcode, operator, load, imm,
1173                           bdaddr20pair>;
1174   }
1175 }
1176
1177 class TernaryRRD<string mnemonic, bits<16> opcode,
1178                  SDPatternOperator operator, RegisterOperand cls>
1179   : InstRRD<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, cls:$R2),
1180             mnemonic#"r\t$R1, $R3, $R2",
1181             [(set cls:$R1, (operator cls:$R1src, cls:$R3, cls:$R2))]> {
1182   let OpKey = mnemonic ## cls;
1183   let OpType = "reg";
1184   let Constraints = "$R1 = $R1src";
1185   let DisableEncoding = "$R1src";
1186 }
1187
1188 class TernaryRXF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1189                  RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
1190   : InstRXF<opcode, (outs cls:$R1),
1191             (ins cls:$R1src, cls:$R3, bdxaddr12only:$XBD2),
1192             mnemonic#"\t$R1, $R3, $XBD2",
1193             [(set cls:$R1, (operator cls:$R1src, cls:$R3,
1194                                      (load bdxaddr12only:$XBD2)))]> {
1195   let OpKey = mnemonic ## cls;
1196   let OpType = "mem";
1197   let Constraints = "$R1 = $R1src";
1198   let DisableEncoding = "$R1src";
1199   let mayLoad = 1;
1200   let AccessBytes = bytes;
1201 }
1202
1203 class CmpSwapRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1204                 RegisterOperand cls, AddressingMode mode = bdaddr12only>
1205   : InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
1206            mnemonic#"\t$R1, $R3, $BD2",
1207            [(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
1208   let Constraints = "$R1 = $R1src";
1209   let DisableEncoding = "$R1src";
1210   let mayLoad = 1;
1211   let mayStore = 1;
1212 }
1213
1214 class CmpSwapRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1215                  RegisterOperand cls, AddressingMode mode = bdaddr20only>
1216   : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
1217             mnemonic#"\t$R1, $R3, $BD2",
1218             [(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
1219   let Constraints = "$R1 = $R1src";
1220   let DisableEncoding = "$R1src";
1221   let mayLoad = 1;
1222   let mayStore = 1;
1223 }
1224
1225 multiclass CmpSwapRSPair<string mnemonic, bits<8> rsOpcode, bits<16> rsyOpcode,
1226                          SDPatternOperator operator, RegisterOperand cls> {
1227   let DispKey = mnemonic ## #cls in {
1228     let DispSize = "12" in
1229       def "" : CmpSwapRS<mnemonic, rsOpcode, operator, cls, bdaddr12pair>;
1230     let DispSize = "20" in
1231       def Y  : CmpSwapRSY<mnemonic#"y", rsyOpcode, operator, cls, bdaddr20pair>;
1232   }
1233 }
1234
1235 class RotateSelectRIEf<string mnemonic, bits<16> opcode, RegisterOperand cls1,
1236                        RegisterOperand cls2>
1237   : InstRIEf<opcode, (outs cls1:$R1),
1238              (ins cls1:$R1src, cls2:$R2, uimm8:$I3, uimm8:$I4, uimm8zx6:$I5),
1239              mnemonic#"\t$R1, $R2, $I3, $I4, $I5", []> {
1240   let Constraints = "$R1 = $R1src";
1241   let DisableEncoding = "$R1src";
1242 }
1243
1244 //===----------------------------------------------------------------------===//
1245 // Pseudo instructions
1246 //===----------------------------------------------------------------------===//
1247 //
1248 // Convenience instructions that get lowered to real instructions
1249 // by either SystemZTargetLowering::EmitInstrWithCustomInserter()
1250 // or SystemZInstrInfo::expandPostRAPseudo().
1251 //
1252 //===----------------------------------------------------------------------===//
1253
1254 class Pseudo<dag outs, dag ins, list<dag> pattern>
1255   : InstSystemZ<0, outs, ins, "", pattern> {
1256   let isPseudo = 1;
1257   let isCodeGenOnly = 1;
1258 }
1259
1260 // Implements "$dst = $cc & (8 >> CC) ? $src1 : $src2", where CC is
1261 // the value of the PSW's 2-bit condition code field.
1262 class SelectWrapper<RegisterOperand cls>
1263   : Pseudo<(outs cls:$dst),
1264            (ins cls:$src1, cls:$src2, uimm8zx4:$valid, uimm8zx4:$cc),
1265            [(set cls:$dst, (z_select_ccmask cls:$src1, cls:$src2,
1266                                             uimm8zx4:$valid, uimm8zx4:$cc))]> {
1267   let usesCustomInserter = 1;
1268   // Although the instructions used by these nodes do not in themselves
1269   // change CC, the insertion requires new blocks, and CC cannot be live
1270   // across them.
1271   let Defs = [CC];
1272   let Uses = [CC];
1273 }
1274
1275 // Stores $new to $addr if $cc is true ("" case) or false (Inv case).
1276 multiclass CondStores<RegisterOperand cls, SDPatternOperator store,
1277                       SDPatternOperator load, AddressingMode mode> {
1278   let Defs = [CC], Uses = [CC], usesCustomInserter = 1 in {
1279     def "" : Pseudo<(outs),
1280                     (ins cls:$new, mode:$addr, uimm8zx4:$valid, uimm8zx4:$cc),
1281                     [(store (z_select_ccmask cls:$new, (load mode:$addr),
1282                                              uimm8zx4:$valid, uimm8zx4:$cc),
1283                             mode:$addr)]>;
1284     def Inv : Pseudo<(outs),
1285                      (ins cls:$new, mode:$addr, uimm8zx4:$valid, uimm8zx4:$cc),
1286                      [(store (z_select_ccmask (load mode:$addr), cls:$new,
1287                                               uimm8zx4:$valid, uimm8zx4:$cc),
1288                               mode:$addr)]>;
1289   }
1290 }
1291
1292 // OPERATOR is ATOMIC_SWAP or an ATOMIC_LOAD_* operation.  PAT and OPERAND
1293 // describe the second (non-memory) operand.
1294 class AtomicLoadBinary<SDPatternOperator operator, RegisterOperand cls,
1295                        dag pat, DAGOperand operand>
1296   : Pseudo<(outs cls:$dst), (ins bdaddr20only:$ptr, operand:$src2),
1297            [(set cls:$dst, (operator bdaddr20only:$ptr, pat))]> {
1298   let Defs = [CC];
1299   let Has20BitOffset = 1;
1300   let mayLoad = 1;
1301   let mayStore = 1;
1302   let usesCustomInserter = 1;
1303 }
1304
1305 // Specializations of AtomicLoadWBinary.
1306 class AtomicLoadBinaryReg32<SDPatternOperator operator>
1307   : AtomicLoadBinary<operator, GR32, (i32 GR32:$src2), GR32>;
1308 class AtomicLoadBinaryImm32<SDPatternOperator operator, Immediate imm>
1309   : AtomicLoadBinary<operator, GR32, (i32 imm:$src2), imm>;
1310 class AtomicLoadBinaryReg64<SDPatternOperator operator>
1311   : AtomicLoadBinary<operator, GR64, (i64 GR64:$src2), GR64>;
1312 class AtomicLoadBinaryImm64<SDPatternOperator operator, Immediate imm>
1313   : AtomicLoadBinary<operator, GR64, (i64 imm:$src2), imm>;
1314
1315 // OPERATOR is ATOMIC_SWAPW or an ATOMIC_LOADW_* operation.  PAT and OPERAND
1316 // describe the second (non-memory) operand.
1317 class AtomicLoadWBinary<SDPatternOperator operator, dag pat,
1318                         DAGOperand operand>
1319   : Pseudo<(outs GR32:$dst),
1320            (ins bdaddr20only:$ptr, operand:$src2, ADDR32:$bitshift,
1321                 ADDR32:$negbitshift, uimm32:$bitsize),
1322            [(set GR32:$dst, (operator bdaddr20only:$ptr, pat, ADDR32:$bitshift,
1323                                       ADDR32:$negbitshift, uimm32:$bitsize))]> {
1324   let Defs = [CC];
1325   let Has20BitOffset = 1;
1326   let mayLoad = 1;
1327   let mayStore = 1;
1328   let usesCustomInserter = 1;
1329 }
1330
1331 // Specializations of AtomicLoadWBinary.
1332 class AtomicLoadWBinaryReg<SDPatternOperator operator>
1333   : AtomicLoadWBinary<operator, (i32 GR32:$src2), GR32>;
1334 class AtomicLoadWBinaryImm<SDPatternOperator operator, Immediate imm>
1335   : AtomicLoadWBinary<operator, (i32 imm:$src2), imm>;