1 //==- SystemZInstrFormats.td - SystemZ Instruction Formats --*- tablegen -*-==//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 //===----------------------------------------------------------------------===//
11 // Basic SystemZ instruction definition
12 //===----------------------------------------------------------------------===//
14 class InstSystemZ<int size, dag outs, dag ins, string asmstr,
15 list<dag> pattern> : Instruction {
16 let Namespace = "SystemZ";
18 dag OutOperandList = outs;
19 dag InOperandList = ins;
21 let Pattern = pattern;
22 let AsmString = asmstr;
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"
29 string DispSize = "none";
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>.
35 string OpType = "none";
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";
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;
47 // True if this instruction is a simple D(X,B) store of a register
48 // (with no truncation).
49 bit SimpleBDXStore = 0;
51 // True if this instruction has a 20-bit displacement field.
52 bit Has20BitOffset = 0;
54 // True if addresses in this instruction have an index register.
57 // True if this is a 128-bit pseudo instruction that combines two 64-bit
61 // The access size of all memory operands in bytes, or 0 if not known.
62 bits<5> AccessBytes = 0;
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;
72 //===----------------------------------------------------------------------===//
73 // Mappings between instructions
74 //===----------------------------------------------------------------------===//
76 // Return the version of an instruction that has an unsigned 12-bit
78 def getDisp12Opcode : InstrMapping {
79 let FilterClass = "InstSystemZ";
80 let RowFields = ["DispKey"];
81 let ColFields = ["DispSize"];
83 let ValueCols = [["12"]];
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"];
92 let ValueCols = [["20"]];
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"]];
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"];
110 let ValueCols = [["3"]];
113 //===----------------------------------------------------------------------===//
114 // Instruction formats
115 //===----------------------------------------------------------------------===//
117 // Formats are specified using operand field declarations of the form:
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
124 // bits<4> Xn : index register for address operand n
125 // bits<4> Mn : mode value for operand n
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.
131 //===----------------------------------------------------------------------===//
133 class InstRI<bits<12> op, dag outs, dag ins, string asmstr, list<dag> pattern>
134 : InstSystemZ<4, outs, ins, asmstr, pattern> {
136 field bits<32> SoftFail = 0;
141 let Inst{31-24} = op{11-4};
142 let Inst{23-20} = R1;
143 let Inst{19-16} = op{3-0};
147 class InstRIEb<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
148 : InstSystemZ<6, outs, ins, asmstr, pattern> {
150 field bits<48> SoftFail = 0;
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;
163 let Inst{7-0} = op{7-0};
166 class InstRIEc<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
167 : InstSystemZ<6, outs, ins, asmstr, pattern> {
169 field bits<48> SoftFail = 0;
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;
181 let Inst{7-0} = op{7-0};
184 class InstRIEd<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
185 : InstSystemZ<6, outs, ins, asmstr, pattern> {
187 field bits<48> SoftFail = 0;
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;
198 let Inst{7-0} = op{7-0};
201 class InstRIEf<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
202 : InstSystemZ<6, outs, ins, asmstr, pattern> {
204 field bits<48> SoftFail = 0;
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;
218 let Inst{7-0} = op{7-0};
221 class InstRIL<bits<12> op, dag outs, dag ins, string asmstr, list<dag> pattern>
222 : InstSystemZ<6, outs, ins, asmstr, pattern> {
224 field bits<48> SoftFail = 0;
229 let Inst{47-40} = op{11-4};
230 let Inst{39-36} = R1;
231 let Inst{35-32} = op{3-0};
235 class InstRR<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
236 : InstSystemZ<2, outs, ins, asmstr, pattern> {
238 field bits<16> SoftFail = 0;
248 class InstRRD<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
249 : InstSystemZ<4, outs, ins, asmstr, pattern> {
251 field bits<32> SoftFail = 0;
257 let Inst{31-16} = op;
258 let Inst{15-12} = R1;
264 class InstRRE<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
265 : InstSystemZ<4, outs, ins, asmstr, pattern> {
267 field bits<32> SoftFail = 0;
272 let Inst{31-16} = op;
278 class InstRRF<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
279 : InstSystemZ<4, outs, ins, asmstr, pattern> {
281 field bits<32> SoftFail = 0;
287 let Inst{31-16} = op;
288 let Inst{15-12} = R3;
294 class InstRX<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
295 : InstSystemZ<4, outs, ins, asmstr, pattern> {
297 field bits<32> SoftFail = 0;
302 let Inst{31-24} = op;
303 let Inst{23-20} = R1;
304 let Inst{19-0} = XBD2;
309 class InstRXE<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
310 : InstSystemZ<6, outs, ins, asmstr, pattern> {
312 field bits<48> SoftFail = 0;
317 let Inst{47-40} = op{15-8};
318 let Inst{39-36} = R1;
319 let Inst{35-16} = XBD2;
321 let Inst{7-0} = op{7-0};
326 class InstRXF<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
327 : InstSystemZ<6, outs, ins, asmstr, pattern> {
329 field bits<48> SoftFail = 0;
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;
340 let Inst{7-0} = op{7-0};
345 class InstRXY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
346 : InstSystemZ<6, outs, ins, asmstr, pattern> {
348 field bits<48> SoftFail = 0;
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};
358 let Has20BitOffset = 1;
362 class InstRS<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
363 : InstSystemZ<4, outs, ins, asmstr, pattern> {
365 field bits<32> SoftFail = 0;
371 let Inst{31-24} = op;
372 let Inst{23-20} = R1;
373 let Inst{19-16} = R3;
374 let Inst{15-0} = BD2;
377 class InstRSY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
378 : InstSystemZ<6, outs, ins, asmstr, pattern> {
380 field bits<48> SoftFail = 0;
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};
392 let Has20BitOffset = 1;
395 class InstSI<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
396 : InstSystemZ<4, outs, ins, asmstr, pattern> {
398 field bits<32> SoftFail = 0;
403 let Inst{31-24} = op;
404 let Inst{23-16} = I2;
405 let Inst{15-0} = BD1;
408 class InstSIL<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
409 : InstSystemZ<6, outs, ins, asmstr, pattern> {
411 field bits<48> SoftFail = 0;
416 let Inst{47-32} = op;
417 let Inst{31-16} = BD1;
421 class InstSIY<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
422 : InstSystemZ<6, outs, ins, asmstr, pattern> {
424 field bits<48> SoftFail = 0;
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};
434 let Has20BitOffset = 1;
437 class InstSS<bits<8> op, dag outs, dag ins, string asmstr, list<dag> pattern>
438 : InstSystemZ<6, outs, ins, asmstr, pattern> {
440 field bits<48> SoftFail = 0;
445 let Inst{47-40} = op;
446 let Inst{39-16} = BDL1;
447 let Inst{15-0} = BD2;
450 //===----------------------------------------------------------------------===//
451 // Instruction definitions with semantics
452 //===----------------------------------------------------------------------===//
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:
461 // One register output operand and no input operands.
464 // One register or immediate input operand and one address input operand.
465 // The instruction stores the first operand to the address.
467 // This category is used for both pure and truncating stores.
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.
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.
482 // One register output operand and one input operand. The input
483 // operand may be a register, immediate or memory.
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.
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).
496 // Two input operands. The first operand is always a register,
497 // the second may be a register, immediate or memory.
500 // One register output operand and three register input operands.
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.
508 // One output operand and five input operands. The first two operands
509 // are registers and the other three are immediates.
511 // The format determines which input operands are tied to output operands,
512 // and also determines the shape of any address operand.
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
519 //===----------------------------------------------------------------------===//
521 class InherentRRE<string mnemonic, bits<16> opcode, RegisterOperand cls,
523 : InstRRE<opcode, (outs cls:$R1), (ins),
525 [(set cls:$R1, src)]> {
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", []> {
535 class StoreRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
537 : InstRIL<opcode, (outs), (ins cls:$R1, pcrel32:$I2),
538 mnemonic#"\t$R1, $I2",
539 [(operator cls:$R1, pcrel32:$I2)]> {
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
544 let AddedComplexity = 7;
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;
556 let AccessBytes = bytes;
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;
568 let AccessBytes = bytes;
571 multiclass StoreRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
572 SDPatternOperator operator, RegisterOperand cls,
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,
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", []> {
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)]> {
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)]> {
605 class StoreSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
607 : InstSIL<opcode, (outs), (ins bdaddr12only:$BD1, imm:$I2),
608 mnemonic#"\t$BD1, $I2",
609 [(operator imm:$I2, bdaddr12only:$BD1)]> {
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>;
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]> {
630 let AccessBytes = bytes;
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]> {
642 let AccessBytes = bytes;
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]> {
653 let AccessBytes = bytes;
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;
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;
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;
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:$R3),
688 mnemonic#"r$R3\t$R1, $R2", []>,
689 Requires<[FeatureLoadStoreOnCond]>;
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";
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";
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))]>;
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))]>;
725 class UnaryRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
727 : InstRIL<opcode, (outs cls:$R1), (ins pcrel32:$I2),
728 mnemonic#"\t$R1, $I2",
729 [(set cls:$R1, (operator pcrel32:$I2))]> {
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
734 let AddedComplexity = 7;
737 class CondUnaryRSY<string mnemonic, bits<16> opcode,
738 RegisterOperand cls, bits<5> bytes,
739 AddressingMode mode = bdaddr20only>
740 : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2, cond4:$R3),
741 mnemonic#"$R3\t$R1, $BD2", []>,
742 Requires<[FeatureLoadStoreOnCond]> {
743 let Constraints = "$R1 = $R1src";
744 let DisableEncoding = "$R1src";
746 let AccessBytes = bytes;
749 // Like CondUnaryRSY, but used for the raw assembly form. The condition-code
750 // mask is the third operand rather than being part of the mnemonic.
751 class AsmCondUnaryRSY<string mnemonic, bits<16> opcode,
752 RegisterOperand cls, bits<5> bytes,
753 AddressingMode mode = bdaddr20only>
754 : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2, uimm8zx4:$R3),
755 mnemonic#"\t$R1, $BD2, $R3", []>,
756 Requires<[FeatureLoadStoreOnCond]> {
758 let AccessBytes = bytes;
759 let Constraints = "$R1 = $R1src";
760 let DisableEncoding = "$R1src";
763 // Like CondUnaryRSY, but with a fixed CC mask.
764 class FixedCondUnaryRSY<string mnemonic, bits<16> opcode,
765 RegisterOperand cls, bits<4> ccmask, bits<5> bytes,
766 AddressingMode mode = bdaddr20only>
767 : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$BD2),
768 mnemonic#"\t$R1, $BD2", []>,
769 Requires<[FeatureLoadStoreOnCond]> {
770 let Constraints = "$R1 = $R1src";
771 let DisableEncoding = "$R1src";
774 let AccessBytes = bytes;
777 class UnaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
778 RegisterOperand cls, bits<5> bytes,
779 AddressingMode mode = bdxaddr12only>
780 : InstRX<opcode, (outs cls:$R1), (ins mode:$XBD2),
781 mnemonic#"\t$R1, $XBD2",
782 [(set cls:$R1, (operator mode:$XBD2))]> {
783 let OpKey = mnemonic ## cls;
786 let AccessBytes = bytes;
789 class UnaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
790 RegisterOperand cls, bits<5> bytes>
791 : InstRXE<opcode, (outs cls:$R1), (ins bdxaddr12only:$XBD2),
792 mnemonic#"\t$R1, $XBD2",
793 [(set cls:$R1, (operator bdxaddr12only:$XBD2))]> {
794 let OpKey = mnemonic ## cls;
797 let AccessBytes = bytes;
800 class UnaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
801 RegisterOperand cls, bits<5> bytes,
802 AddressingMode mode = bdxaddr20only>
803 : InstRXY<opcode, (outs cls:$R1), (ins mode:$XBD2),
804 mnemonic#"\t$R1, $XBD2",
805 [(set cls:$R1, (operator mode:$XBD2))]> {
806 let OpKey = mnemonic ## cls;
809 let AccessBytes = bytes;
812 multiclass UnaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
813 SDPatternOperator operator, RegisterOperand cls,
815 let DispKey = mnemonic ## #cls in {
816 let DispSize = "12" in
817 def "" : UnaryRX<mnemonic, rxOpcode, operator, cls, bytes, bdxaddr12pair>;
818 let DispSize = "20" in
819 def Y : UnaryRXY<mnemonic#"y", rxyOpcode, operator, cls, bytes,
824 class BinaryRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
825 RegisterOperand cls1, RegisterOperand cls2>
826 : InstRR<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
827 mnemonic#"r\t$R1, $R2",
828 [(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
829 let OpKey = mnemonic ## cls1;
831 let Constraints = "$R1 = $R1src";
832 let DisableEncoding = "$R1src";
835 class BinaryRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
836 RegisterOperand cls1, RegisterOperand cls2>
837 : InstRRE<opcode, (outs cls1:$R1), (ins cls1:$R1src, cls2:$R2),
838 mnemonic#"r\t$R1, $R2",
839 [(set cls1:$R1, (operator cls1:$R1src, cls2:$R2))]> {
840 let OpKey = mnemonic ## cls1;
842 let Constraints = "$R1 = $R1src";
843 let DisableEncoding = "$R1src";
846 class BinaryRRF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
847 RegisterOperand cls1, RegisterOperand cls2>
848 : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R3, cls2:$R2),
849 mnemonic#"r\t$R1, $R3, $R2",
850 [(set cls1:$R1, (operator cls1:$R3, cls2:$R2))]> {
851 let OpKey = mnemonic ## cls1;
855 class BinaryRRFK<string mnemonic, bits<16> opcode, SDPatternOperator operator,
856 RegisterOperand cls1, RegisterOperand cls2>
857 : InstRRF<opcode, (outs cls1:$R1), (ins cls1:$R2, cls2:$R3),
858 mnemonic#"rk\t$R1, $R2, $R3",
859 [(set cls1:$R1, (operator cls1:$R2, cls2:$R3))]>;
861 multiclass BinaryRRAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
862 SDPatternOperator operator, RegisterOperand cls1,
863 RegisterOperand cls2> {
864 let NumOpsKey = mnemonic in {
865 let NumOpsValue = "3" in
866 def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
867 Requires<[FeatureDistinctOps]>;
868 let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
869 def "" : BinaryRR<mnemonic, opcode1, operator, cls1, cls2>;
873 multiclass BinaryRREAndK<string mnemonic, bits<16> opcode1, bits<16> opcode2,
874 SDPatternOperator operator, RegisterOperand cls1,
875 RegisterOperand cls2> {
876 let NumOpsKey = mnemonic in {
877 let NumOpsValue = "3" in
878 def K : BinaryRRFK<mnemonic, opcode2, null_frag, cls1, cls2>,
879 Requires<[FeatureDistinctOps]>;
880 let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
881 def "" : BinaryRRE<mnemonic, opcode1, operator, cls1, cls2>;
885 class BinaryRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
886 RegisterOperand cls, Immediate imm>
887 : InstRI<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
888 mnemonic#"\t$R1, $I2",
889 [(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
890 let Constraints = "$R1 = $R1src";
891 let DisableEncoding = "$R1src";
894 class BinaryRIE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
895 RegisterOperand cls, Immediate imm>
896 : InstRIEd<opcode, (outs cls:$R1), (ins cls:$R3, imm:$I2),
897 mnemonic#"\t$R1, $R3, $I2",
898 [(set cls:$R1, (operator cls:$R3, imm:$I2))]>;
900 multiclass BinaryRIAndK<string mnemonic, bits<12> opcode1, bits<16> opcode2,
901 SDPatternOperator operator, RegisterOperand cls,
903 let NumOpsKey = mnemonic in {
904 let NumOpsValue = "3" in
905 def K : BinaryRIE<mnemonic##"k", opcode2, null_frag, cls, imm>,
906 Requires<[FeatureDistinctOps]>;
907 let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
908 def "" : BinaryRI<mnemonic, opcode1, operator, cls, imm>;
912 class BinaryRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
913 RegisterOperand cls, Immediate imm>
914 : InstRIL<opcode, (outs cls:$R1), (ins cls:$R1src, imm:$I2),
915 mnemonic#"\t$R1, $I2",
916 [(set cls:$R1, (operator cls:$R1src, imm:$I2))]> {
917 let Constraints = "$R1 = $R1src";
918 let DisableEncoding = "$R1src";
921 class BinaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
922 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
923 AddressingMode mode = bdxaddr12only>
924 : InstRX<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
925 mnemonic#"\t$R1, $XBD2",
926 [(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
927 let OpKey = mnemonic ## cls;
929 let Constraints = "$R1 = $R1src";
930 let DisableEncoding = "$R1src";
932 let AccessBytes = bytes;
935 class BinaryRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
936 RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
937 : InstRXE<opcode, (outs cls:$R1), (ins cls:$R1src, bdxaddr12only:$XBD2),
938 mnemonic#"\t$R1, $XBD2",
939 [(set cls:$R1, (operator cls:$R1src,
940 (load bdxaddr12only:$XBD2)))]> {
941 let OpKey = mnemonic ## cls;
943 let Constraints = "$R1 = $R1src";
944 let DisableEncoding = "$R1src";
946 let AccessBytes = bytes;
949 class BinaryRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
950 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
951 AddressingMode mode = bdxaddr20only>
952 : InstRXY<opcode, (outs cls:$R1), (ins cls:$R1src, mode:$XBD2),
953 mnemonic#"\t$R1, $XBD2",
954 [(set cls:$R1, (operator cls:$R1src, (load mode:$XBD2)))]> {
955 let OpKey = mnemonic ## cls;
957 let Constraints = "$R1 = $R1src";
958 let DisableEncoding = "$R1src";
960 let AccessBytes = bytes;
963 multiclass BinaryRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
964 SDPatternOperator operator, RegisterOperand cls,
965 SDPatternOperator load, bits<5> bytes> {
966 let DispKey = mnemonic ## #cls in {
967 let DispSize = "12" in
968 def "" : BinaryRX<mnemonic, rxOpcode, operator, cls, load, bytes,
970 let DispSize = "20" in
971 def Y : BinaryRXY<mnemonic#"y", rxyOpcode, operator, cls, load, bytes,
976 class BinarySI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
977 Operand imm, AddressingMode mode = bdaddr12only>
978 : InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
979 mnemonic#"\t$BD1, $I2",
980 [(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
985 class BinarySIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
986 Operand imm, AddressingMode mode = bdaddr20only>
987 : InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
988 mnemonic#"\t$BD1, $I2",
989 [(store (operator (load mode:$BD1), imm:$I2), mode:$BD1)]> {
994 multiclass BinarySIPair<string mnemonic, bits<8> siOpcode,
995 bits<16> siyOpcode, SDPatternOperator operator,
997 let DispKey = mnemonic ## #cls in {
998 let DispSize = "12" in
999 def "" : BinarySI<mnemonic, siOpcode, operator, imm, bdaddr12pair>;
1000 let DispSize = "20" in
1001 def Y : BinarySIY<mnemonic#"y", siyOpcode, operator, imm, bdaddr20pair>;
1005 class ShiftRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1006 RegisterOperand cls>
1007 : InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, shift12only:$BD2),
1008 mnemonic#"\t$R1, $BD2",
1009 [(set cls:$R1, (operator cls:$R1src, shift12only:$BD2))]> {
1011 let Constraints = "$R1 = $R1src";
1012 let DisableEncoding = "$R1src";
1015 class ShiftRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1016 RegisterOperand cls>
1017 : InstRSY<opcode, (outs cls:$R1), (ins cls:$R3, shift20only:$BD2),
1018 mnemonic#"\t$R1, $R3, $BD2",
1019 [(set cls:$R1, (operator cls:$R3, shift20only:$BD2))]>;
1021 multiclass ShiftRSAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
1022 SDPatternOperator operator, RegisterOperand cls> {
1023 let NumOpsKey = mnemonic in {
1024 let NumOpsValue = "3" in
1025 def K : ShiftRSY<mnemonic##"k", opcode2, null_frag, cls>,
1026 Requires<[FeatureDistinctOps]>;
1027 let NumOpsValue = "2", isConvertibleToThreeAddress = 1 in
1028 def "" : ShiftRS<mnemonic, opcode1, operator, cls>;
1032 class CompareRR<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1033 RegisterOperand cls1, RegisterOperand cls2>
1034 : InstRR<opcode, (outs), (ins cls1:$R1, cls2:$R2),
1035 mnemonic#"r\t$R1, $R2",
1036 [(operator cls1:$R1, cls2:$R2)]> {
1037 let OpKey = mnemonic ## cls1;
1042 class CompareRRE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1043 RegisterOperand cls1, RegisterOperand cls2>
1044 : InstRRE<opcode, (outs), (ins cls1:$R1, cls2:$R2),
1045 mnemonic#"r\t$R1, $R2",
1046 [(operator cls1:$R1, cls2:$R2)]> {
1047 let OpKey = mnemonic ## cls1;
1052 class CompareRI<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1053 RegisterOperand cls, Immediate imm>
1054 : InstRI<opcode, (outs), (ins cls:$R1, imm:$I2),
1055 mnemonic#"\t$R1, $I2",
1056 [(operator cls:$R1, imm:$I2)]> {
1060 class CompareRIL<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1061 RegisterOperand cls, Immediate imm>
1062 : InstRIL<opcode, (outs), (ins cls:$R1, imm:$I2),
1063 mnemonic#"\t$R1, $I2",
1064 [(operator cls:$R1, imm:$I2)]> {
1068 class CompareRILPC<string mnemonic, bits<12> opcode, SDPatternOperator operator,
1069 RegisterOperand cls, SDPatternOperator load>
1070 : InstRIL<opcode, (outs), (ins cls:$R1, pcrel32:$I2),
1071 mnemonic#"\t$R1, $I2",
1072 [(operator cls:$R1, (load pcrel32:$I2))]> {
1075 // We want PC-relative addresses to be tried ahead of BD and BDX addresses.
1076 // However, BDXs have two extra operands and are therefore 6 units more
1078 let AddedComplexity = 7;
1081 class CompareRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1082 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
1083 AddressingMode mode = bdxaddr12only>
1084 : InstRX<opcode, (outs), (ins cls:$R1, mode:$XBD2),
1085 mnemonic#"\t$R1, $XBD2",
1086 [(operator cls:$R1, (load mode:$XBD2))]> {
1087 let OpKey = mnemonic ## cls;
1091 let AccessBytes = bytes;
1094 class CompareRXE<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1095 RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
1096 : InstRXE<opcode, (outs), (ins cls:$R1, bdxaddr12only:$XBD2),
1097 mnemonic#"\t$R1, $XBD2",
1098 [(operator cls:$R1, (load bdxaddr12only:$XBD2))]> {
1099 let OpKey = mnemonic ## cls;
1103 let AccessBytes = bytes;
1106 class CompareRXY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1107 RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
1108 AddressingMode mode = bdxaddr20only>
1109 : InstRXY<opcode, (outs), (ins cls:$R1, mode:$XBD2),
1110 mnemonic#"\t$R1, $XBD2",
1111 [(operator cls:$R1, (load mode:$XBD2))]> {
1112 let OpKey = mnemonic ## cls;
1116 let AccessBytes = bytes;
1119 multiclass CompareRXPair<string mnemonic, bits<8> rxOpcode, bits<16> rxyOpcode,
1120 SDPatternOperator operator, RegisterOperand cls,
1121 SDPatternOperator load, bits<5> bytes> {
1122 let DispKey = mnemonic ## #cls in {
1123 let DispSize = "12" in
1124 def "" : CompareRX<mnemonic, rxOpcode, operator, cls,
1125 load, bytes, bdxaddr12pair>;
1126 let DispSize = "20" in
1127 def Y : CompareRXY<mnemonic#"y", rxyOpcode, operator, cls,
1128 load, bytes, bdxaddr20pair>;
1132 class CompareSI<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1133 SDPatternOperator load, Immediate imm,
1134 AddressingMode mode = bdaddr12only>
1135 : InstSI<opcode, (outs), (ins mode:$BD1, imm:$I2),
1136 mnemonic#"\t$BD1, $I2",
1137 [(operator (load mode:$BD1), imm:$I2)]> {
1142 class CompareSIL<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1143 SDPatternOperator load, Immediate imm>
1144 : InstSIL<opcode, (outs), (ins bdaddr12only:$BD1, imm:$I2),
1145 mnemonic#"\t$BD1, $I2",
1146 [(operator (load bdaddr12only:$BD1), imm:$I2)]> {
1151 class CompareSIY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1152 SDPatternOperator load, Immediate imm,
1153 AddressingMode mode = bdaddr20only>
1154 : InstSIY<opcode, (outs), (ins mode:$BD1, imm:$I2),
1155 mnemonic#"\t$BD1, $I2",
1156 [(operator (load mode:$BD1), imm:$I2)]> {
1161 multiclass CompareSIPair<string mnemonic, bits<8> siOpcode, bits<16> siyOpcode,
1162 SDPatternOperator operator, SDPatternOperator load,
1164 let DispKey = mnemonic in {
1165 let DispSize = "12" in
1166 def "" : CompareSI<mnemonic, siOpcode, operator, load, imm, bdaddr12pair>;
1167 let DispSize = "20" in
1168 def Y : CompareSIY<mnemonic#"y", siyOpcode, operator, load, imm,
1173 class TernaryRRD<string mnemonic, bits<16> opcode,
1174 SDPatternOperator operator, RegisterOperand cls>
1175 : InstRRD<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, cls:$R2),
1176 mnemonic#"r\t$R1, $R3, $R2",
1177 [(set cls:$R1, (operator cls:$R1src, cls:$R3, cls:$R2))]> {
1178 let OpKey = mnemonic ## cls;
1180 let Constraints = "$R1 = $R1src";
1181 let DisableEncoding = "$R1src";
1184 class TernaryRXF<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1185 RegisterOperand cls, SDPatternOperator load, bits<5> bytes>
1186 : InstRXF<opcode, (outs cls:$R1),
1187 (ins cls:$R1src, cls:$R3, bdxaddr12only:$XBD2),
1188 mnemonic#"\t$R1, $R3, $XBD2",
1189 [(set cls:$R1, (operator cls:$R1src, cls:$R3,
1190 (load bdxaddr12only:$XBD2)))]> {
1191 let OpKey = mnemonic ## cls;
1193 let Constraints = "$R1 = $R1src";
1194 let DisableEncoding = "$R1src";
1196 let AccessBytes = bytes;
1199 class CmpSwapRS<string mnemonic, bits<8> opcode, SDPatternOperator operator,
1200 RegisterOperand cls, AddressingMode mode = bdaddr12only>
1201 : InstRS<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
1202 mnemonic#"\t$R1, $R3, $BD2",
1203 [(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
1204 let Constraints = "$R1 = $R1src";
1205 let DisableEncoding = "$R1src";
1210 class CmpSwapRSY<string mnemonic, bits<16> opcode, SDPatternOperator operator,
1211 RegisterOperand cls, AddressingMode mode = bdaddr20only>
1212 : InstRSY<opcode, (outs cls:$R1), (ins cls:$R1src, cls:$R3, mode:$BD2),
1213 mnemonic#"\t$R1, $R3, $BD2",
1214 [(set cls:$R1, (operator mode:$BD2, cls:$R1src, cls:$R3))]> {
1215 let Constraints = "$R1 = $R1src";
1216 let DisableEncoding = "$R1src";
1221 multiclass CmpSwapRSPair<string mnemonic, bits<8> rsOpcode, bits<16> rsyOpcode,
1222 SDPatternOperator operator, RegisterOperand cls> {
1223 let DispKey = mnemonic ## #cls in {
1224 let DispSize = "12" in
1225 def "" : CmpSwapRS<mnemonic, rsOpcode, operator, cls, bdaddr12pair>;
1226 let DispSize = "20" in
1227 def Y : CmpSwapRSY<mnemonic#"y", rsyOpcode, operator, cls, bdaddr20pair>;
1231 class RotateSelectRIEf<string mnemonic, bits<16> opcode, RegisterOperand cls1,
1232 RegisterOperand cls2>
1233 : InstRIEf<opcode, (outs cls1:$R1),
1234 (ins cls1:$R1src, cls2:$R2, uimm8:$I3, uimm8:$I4, uimm8zx6:$I5),
1235 mnemonic#"\t$R1, $R2, $I3, $I4, $I5", []> {
1236 let Constraints = "$R1 = $R1src";
1237 let DisableEncoding = "$R1src";
1240 //===----------------------------------------------------------------------===//
1241 // Pseudo instructions
1242 //===----------------------------------------------------------------------===//
1244 // Convenience instructions that get lowered to real instructions
1245 // by either SystemZTargetLowering::EmitInstrWithCustomInserter()
1246 // or SystemZInstrInfo::expandPostRAPseudo().
1248 //===----------------------------------------------------------------------===//
1250 class Pseudo<dag outs, dag ins, list<dag> pattern>
1251 : InstSystemZ<0, outs, ins, "", pattern> {
1253 let isCodeGenOnly = 1;
1256 // Implements "$dst = $cc & (8 >> CC) ? $src1 : $src2", where CC is
1257 // the value of the PSW's 2-bit condition code field.
1258 class SelectWrapper<RegisterOperand cls>
1259 : Pseudo<(outs cls:$dst), (ins cls:$src1, cls:$src2, i8imm:$cc),
1260 [(set cls:$dst, (z_select_ccmask cls:$src1, cls:$src2, imm:$cc))]> {
1261 let usesCustomInserter = 1;
1262 // Although the instructions used by these nodes do not in themselves
1263 // change CC, the insertion requires new blocks, and CC cannot be live
1269 // Stores $new to $addr if $cc is true ("" case) or false (Inv case).
1270 multiclass CondStores<RegisterOperand cls, SDPatternOperator store,
1271 SDPatternOperator load, AddressingMode mode> {
1272 let Defs = [CC], Uses = [CC], usesCustomInserter = 1 in {
1273 def "" : Pseudo<(outs), (ins cls:$new, mode:$addr, uimm8zx4:$cc),
1274 [(store (z_select_ccmask cls:$new, (load mode:$addr),
1275 uimm8zx4:$cc), mode:$addr)]>;
1276 def Inv : Pseudo<(outs), (ins cls:$new, mode:$addr, uimm8zx4:$cc),
1277 [(store (z_select_ccmask (load mode:$addr), cls:$new,
1278 uimm8zx4:$cc), mode:$addr)]>;
1282 // OPERATOR is ATOMIC_SWAP or an ATOMIC_LOAD_* operation. PAT and OPERAND
1283 // describe the second (non-memory) operand.
1284 class AtomicLoadBinary<SDPatternOperator operator, RegisterOperand cls,
1285 dag pat, DAGOperand operand>
1286 : Pseudo<(outs cls:$dst), (ins bdaddr20only:$ptr, operand:$src2),
1287 [(set cls:$dst, (operator bdaddr20only:$ptr, pat))]> {
1289 let Has20BitOffset = 1;
1292 let usesCustomInserter = 1;
1295 // Specializations of AtomicLoadWBinary.
1296 class AtomicLoadBinaryReg32<SDPatternOperator operator>
1297 : AtomicLoadBinary<operator, GR32, (i32 GR32:$src2), GR32>;
1298 class AtomicLoadBinaryImm32<SDPatternOperator operator, Immediate imm>
1299 : AtomicLoadBinary<operator, GR32, (i32 imm:$src2), imm>;
1300 class AtomicLoadBinaryReg64<SDPatternOperator operator>
1301 : AtomicLoadBinary<operator, GR64, (i64 GR64:$src2), GR64>;
1302 class AtomicLoadBinaryImm64<SDPatternOperator operator, Immediate imm>
1303 : AtomicLoadBinary<operator, GR64, (i64 imm:$src2), imm>;
1305 // OPERATOR is ATOMIC_SWAPW or an ATOMIC_LOADW_* operation. PAT and OPERAND
1306 // describe the second (non-memory) operand.
1307 class AtomicLoadWBinary<SDPatternOperator operator, dag pat,
1309 : Pseudo<(outs GR32:$dst),
1310 (ins bdaddr20only:$ptr, operand:$src2, ADDR32:$bitshift,
1311 ADDR32:$negbitshift, uimm32:$bitsize),
1312 [(set GR32:$dst, (operator bdaddr20only:$ptr, pat, ADDR32:$bitshift,
1313 ADDR32:$negbitshift, uimm32:$bitsize))]> {
1315 let Has20BitOffset = 1;
1318 let usesCustomInserter = 1;
1321 // Specializations of AtomicLoadWBinary.
1322 class AtomicLoadWBinaryReg<SDPatternOperator operator>
1323 : AtomicLoadWBinary<operator, (i32 GR32:$src2), GR32>;
1324 class AtomicLoadWBinaryImm<SDPatternOperator operator, Immediate imm>
1325 : AtomicLoadWBinary<operator, (i32 imm:$src2), imm>;