1 //=====- SystemZOperands.td - SystemZ Operands defs ---------*- tblgen-*-=====//
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 // This file describes the various SystemZ instruction operands.
12 //===----------------------------------------------------------------------===//
14 //===----------------------------------------------------------------------===//
15 // Instruction Pattern Stuff.
16 //===----------------------------------------------------------------------===//
18 // SystemZ specific condition code. These correspond to CondCode in
19 // SystemZ.h. They must be kept in synch.
20 def SYSTEMZ_COND_E : PatLeaf<(i8 0)>;
21 def SYSTEMZ_COND_NE : PatLeaf<(i8 1)>;
22 def SYSTEMZ_COND_H : PatLeaf<(i8 2)>;
23 def SYSTEMZ_COND_L : PatLeaf<(i8 3)>;
24 def SYSTEMZ_COND_HE : PatLeaf<(i8 4)>;
25 def SYSTEMZ_COND_LE : PatLeaf<(i8 5)>;
27 def LL16 : SDNodeXForm<imm, [{
28 // Transformation function: return low 16 bits.
29 return getI16Imm(N->getZExtValue() & 0x000000000000FFFFULL);
32 def LH16 : SDNodeXForm<imm, [{
33 // Transformation function: return bits 16-31.
34 return getI16Imm((N->getZExtValue() & 0x00000000FFFF0000ULL) >> 16);
37 def HL16 : SDNodeXForm<imm, [{
38 // Transformation function: return bits 32-47.
39 return getI16Imm((N->getZExtValue() & 0x0000FFFF00000000ULL) >> 32);
42 def HH16 : SDNodeXForm<imm, [{
43 // Transformation function: return bits 48-63.
44 return getI16Imm((N->getZExtValue() & 0xFFFF000000000000ULL) >> 48);
47 def LO32 : SDNodeXForm<imm, [{
48 // Transformation function: return low 32 bits.
49 return getI32Imm(N->getZExtValue() & 0x00000000FFFFFFFFULL);
52 def HI32 : SDNodeXForm<imm, [{
53 // Transformation function: return bits 32-63.
54 return getI32Imm(N->getZExtValue() >> 32);
57 def i32ll16 : PatLeaf<(i32 imm), [{
58 // i32ll16 predicate - true if the 32-bit immediate has only rightmost 16
60 return ((N->getZExtValue() & 0x000000000000FFFFULL) == N->getZExtValue());
63 def i32lh16 : PatLeaf<(i32 imm), [{
64 // i32lh16 predicate - true if the 32-bit immediate has only bits 16-31 set.
65 return ((N->getZExtValue() & 0x00000000FFFF0000ULL) == N->getZExtValue());
68 def i32ll16c : PatLeaf<(i32 imm), [{
69 // i32ll16c predicate - true if the 32-bit immediate has all bits 16-31 set.
70 return ((N->getZExtValue() | 0x00000000FFFF0000ULL) == N->getZExtValue());
73 def i32lh16c : PatLeaf<(i32 imm), [{
74 // i32lh16c predicate - true if the 32-bit immediate has all rightmost 16
76 return ((N->getZExtValue() | 0x000000000000FFFFULL) == N->getZExtValue());
79 def i64ll16 : PatLeaf<(i64 imm), [{
80 // i64ll16 predicate - true if the 64-bit immediate has only rightmost 16
82 return ((N->getZExtValue() & 0x000000000000FFFFULL) == N->getZExtValue());
85 def i64lh16 : PatLeaf<(i64 imm), [{
86 // i64lh16 predicate - true if the 64-bit immediate has only bits 16-31 set.
87 return ((N->getZExtValue() & 0x00000000FFFF0000ULL) == N->getZExtValue());
90 def i64hl16 : PatLeaf<(i64 imm), [{
91 // i64hl16 predicate - true if the 64-bit immediate has only bits 32-47 set.
92 return ((N->getZExtValue() & 0x0000FFFF00000000ULL) == N->getZExtValue());
95 def i64hh16 : PatLeaf<(i64 imm), [{
96 // i64hh16 predicate - true if the 64-bit immediate has only bits 48-63 set.
97 return ((N->getZExtValue() & 0xFFFF000000000000ULL) == N->getZExtValue());
100 def i64ll16c : PatLeaf<(i64 imm), [{
101 // i64ll16c predicate - true if the 64-bit immediate has only rightmost 16
103 return ((N->getZExtValue() | 0xFFFFFFFFFFFF0000ULL) == N->getZExtValue());
106 def i64lh16c : PatLeaf<(i64 imm), [{
107 // i64lh16c predicate - true if the 64-bit immediate has only bits 16-31 set.
108 return ((N->getZExtValue() | 0xFFFFFFFF0000FFFFULL) == N->getZExtValue());
111 def i64hl16c : PatLeaf<(i64 imm), [{
112 // i64hl16c predicate - true if the 64-bit immediate has only bits 32-47 set.
113 return ((N->getZExtValue() | 0xFFFF0000FFFFFFFFULL) == N->getZExtValue());
116 def i64hh16c : PatLeaf<(i64 imm), [{
117 // i64hh16c predicate - true if the 64-bit immediate has only bits 48-63 set.
118 return ((N->getZExtValue() | 0x0000FFFFFFFFFFFFULL) == N->getZExtValue());
121 def immSExt16 : PatLeaf<(imm), [{
122 // immSExt16 predicate - true if the immediate fits in a 16-bit sign extended
124 if (N->getValueType(0) == MVT::i64) {
125 uint64_t val = N->getZExtValue();
126 return ((int64_t)val == (int16_t)val);
127 } else if (N->getValueType(0) == MVT::i32) {
128 uint32_t val = N->getZExtValue();
129 return ((int32_t)val == (int16_t)val);
135 def immSExt32 : PatLeaf<(i64 imm), [{
136 // immSExt32 predicate - true if the immediate fits in a 32-bit sign extended
138 uint64_t val = N->getZExtValue();
139 return ((int64_t)val == (int32_t)val);
142 def i64lo32 : PatLeaf<(i64 imm), [{
143 // i64lo32 predicate - true if the 64-bit immediate has only rightmost 32
145 return ((N->getZExtValue() & 0x00000000FFFFFFFFULL) == N->getZExtValue());
148 def i64hi32 : PatLeaf<(i64 imm), [{
149 // i64hi32 predicate - true if the 64-bit immediate has only bits 32-63 set.
150 return ((N->getZExtValue() & 0xFFFFFFFF00000000ULL) == N->getZExtValue());
153 def i64lo32c : PatLeaf<(i64 imm), [{
154 // i64lo32 predicate - true if the 64-bit immediate has only rightmost 32
156 return ((N->getZExtValue() | 0xFFFFFFFF00000000ULL) == N->getZExtValue());
159 def i64hi32c : PatLeaf<(i64 imm), [{
160 // i64hi32 predicate - true if the 64-bit immediate has only bits 32-63 set.
161 return ((N->getZExtValue() | 0x00000000FFFFFFFFULL) == N->getZExtValue());
164 def i32immSExt8 : PatLeaf<(i32 imm), [{
165 // i32immSExt8 predicate - True if the 32-bit immediate fits in a 8-bit
166 // sign extended field.
167 return (int32_t)N->getZExtValue() == (int8_t)N->getZExtValue();
170 def i32immSExt16 : PatLeaf<(i32 imm), [{
171 // i32immSExt16 predicate - True if the 32-bit immediate fits in a 16-bit
172 // sign extended field.
173 return (int32_t)N->getZExtValue() == (int16_t)N->getZExtValue();
176 def i64immSExt32 : PatLeaf<(i64 imm), [{
177 // i64immSExt32 predicate - True if the 64-bit immediate fits in a 32-bit
178 // sign extended field.
179 return (int64_t)N->getZExtValue() == (int32_t)N->getZExtValue();
182 def i64immZExt32 : PatLeaf<(i64 imm), [{
183 // i64immZExt32 predicate - True if the 64-bit immediate fits in a 32-bit
184 // zero extended field.
185 return (uint64_t)N->getZExtValue() == (uint32_t)N->getZExtValue();
189 def extloadi32i8 : PatFrag<(ops node:$ptr), (i32 (extloadi8 node:$ptr))>;
190 def extloadi32i16 : PatFrag<(ops node:$ptr), (i32 (extloadi16 node:$ptr))>;
191 def extloadi64i8 : PatFrag<(ops node:$ptr), (i64 (extloadi8 node:$ptr))>;
192 def extloadi64i16 : PatFrag<(ops node:$ptr), (i64 (extloadi16 node:$ptr))>;
193 def extloadi64i32 : PatFrag<(ops node:$ptr), (i64 (extloadi32 node:$ptr))>;
195 def sextloadi32i8 : PatFrag<(ops node:$ptr), (i32 (sextloadi8 node:$ptr))>;
196 def sextloadi32i16 : PatFrag<(ops node:$ptr), (i32 (sextloadi16 node:$ptr))>;
197 def sextloadi64i8 : PatFrag<(ops node:$ptr), (i64 (sextloadi8 node:$ptr))>;
198 def sextloadi64i16 : PatFrag<(ops node:$ptr), (i64 (sextloadi16 node:$ptr))>;
199 def sextloadi64i32 : PatFrag<(ops node:$ptr), (i64 (sextloadi32 node:$ptr))>;
201 def zextloadi32i8 : PatFrag<(ops node:$ptr), (i32 (zextloadi8 node:$ptr))>;
202 def zextloadi32i16 : PatFrag<(ops node:$ptr), (i32 (zextloadi16 node:$ptr))>;
203 def zextloadi64i8 : PatFrag<(ops node:$ptr), (i64 (zextloadi8 node:$ptr))>;
204 def zextloadi64i16 : PatFrag<(ops node:$ptr), (i64 (zextloadi16 node:$ptr))>;
205 def zextloadi64i32 : PatFrag<(ops node:$ptr), (i64 (zextloadi32 node:$ptr))>;
207 // A couple of more descriptive operand definitions.
208 // 32-bits but only 8 bits are significant.
209 def i32i8imm : Operand<i32>;
210 // 32-bits but only 16 bits are significant.
211 def i32i16imm : Operand<i32>;
212 // 64-bits but only 32 bits are significant.
213 def i64i32imm : Operand<i64>;
214 // Branch targets have OtherVT type.
215 def brtarget : Operand<OtherVT>;
218 def u12imm : Operand<i32> {
219 let PrintMethod = "printU12ImmOperand";
221 def u12imm64 : Operand<i64> {
222 let PrintMethod = "printU12ImmOperand";
226 def s16imm : Operand<i32> {
227 let PrintMethod = "printS16ImmOperand";
229 def s16imm64 : Operand<i64> {
230 let PrintMethod = "printS16ImmOperand";
233 def s20imm : Operand<i32> {
234 let PrintMethod = "printS20ImmOperand";
236 def s20imm64 : Operand<i64> {
237 let PrintMethod = "printS20ImmOperand";
240 def s32imm : Operand<i32> {
241 let PrintMethod = "printS32ImmOperand";
243 def s32imm64 : Operand<i64> {
244 let PrintMethod = "printS32ImmOperand";
247 def imm_pcrel : Operand<i64> {
248 let PrintMethod = "printPCRelImmOperand";
251 //===----------------------------------------------------------------------===//
252 // SystemZ Operand Definitions.
253 //===----------------------------------------------------------------------===//
257 // riaddr := reg + imm
258 def riaddr32 : Operand<i64>,
259 ComplexPattern<i64, 2, "SelectAddrRI12Only", []> {
260 let PrintMethod = "printRIAddrOperand";
261 let MIOperandInfo = (ops ADDR64:$base, u12imm:$disp);
264 def riaddr12 : Operand<i64>,
265 ComplexPattern<i64, 2, "SelectAddrRI12", []> {
266 let PrintMethod = "printRIAddrOperand";
267 let MIOperandInfo = (ops ADDR64:$base, u12imm64:$disp);
270 def riaddr : Operand<i64>,
271 ComplexPattern<i64, 2, "SelectAddrRI", []> {
272 let PrintMethod = "printRIAddrOperand";
273 let MIOperandInfo = (ops ADDR64:$base, s20imm64:$disp);
276 //===----------------------------------------------------------------------===//
278 // rriaddr := reg + reg + imm
279 def rriaddr12 : Operand<i64>,
280 ComplexPattern<i64, 3, "SelectAddrRRI12", [], []> {
281 let PrintMethod = "printRRIAddrOperand";
282 let MIOperandInfo = (ops ADDR64:$base, u12imm64:$disp, ADDR64:$index);
284 def rriaddr : Operand<i64>,
285 ComplexPattern<i64, 3, "SelectAddrRRI20", [], []> {
286 let PrintMethod = "printRRIAddrOperand";
287 let MIOperandInfo = (ops ADDR64:$base, s20imm64:$disp, ADDR64:$index);
289 def laaddr : Operand<i64>,
290 ComplexPattern<i64, 3, "SelectLAAddr", [add, sub, or, frameindex], []> {
291 let PrintMethod = "printRRIAddrOperand";
292 let MIOperandInfo = (ops ADDR64:$base, s20imm64:$disp, ADDR64:$index);