1 //===- HexagonOperands.td - Hexagon immediate processing -*- tablegen -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illnois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Immediate operands.
12 let PrintMethod = "printImmOperand" in {
13 // f32Ext type is used to identify constant extended floating point immediates.
14 def f32Ext : Operand<f32>;
15 def s32Imm : Operand<i32>;
16 def s26_6Imm : Operand<i32>;
17 def s16Imm : Operand<i32>;
18 def s12Imm : Operand<i32>;
19 def s11Imm : Operand<i32>;
20 def s11_0Imm : Operand<i32>;
21 def s11_1Imm : Operand<i32>;
22 def s11_2Imm : Operand<i32>;
23 def s11_3Imm : Operand<i32>;
24 def s10Imm : Operand<i32>;
25 def s9Imm : Operand<i32>;
26 def m9Imm : Operand<i32>;
27 def s8Imm : Operand<i32>;
28 def s8Imm64 : Operand<i64>;
29 def s6Imm : Operand<i32>;
30 def s4Imm : Operand<i32>;
31 def s4_0Imm : Operand<i32>;
32 def s4_1Imm : Operand<i32>;
33 def s4_2Imm : Operand<i32>;
34 def s4_3Imm : Operand<i32>;
35 def u64Imm : Operand<i64>;
36 def u32Imm : Operand<i32>;
37 def u26_6Imm : Operand<i32>;
38 def u16Imm : Operand<i32>;
39 def u16_0Imm : Operand<i32>;
40 def u16_1Imm : Operand<i32>;
41 def u16_2Imm : Operand<i32>;
42 def u16_3Imm : Operand<i32>;
43 def u11_3Imm : Operand<i32>;
44 def u10Imm : Operand<i32>;
45 def u9Imm : Operand<i32>;
46 def u8Imm : Operand<i32>;
47 def u7Imm : Operand<i32>;
48 def u6Imm : Operand<i32>;
49 def u6_0Imm : Operand<i32>;
50 def u6_1Imm : Operand<i32>;
51 def u6_2Imm : Operand<i32>;
52 def u6_3Imm : Operand<i32>;
53 def u5Imm : Operand<i32>;
54 def u4Imm : Operand<i32>;
55 def u3Imm : Operand<i32>;
56 def u2Imm : Operand<i32>;
57 def u1Imm : Operand<i32>;
58 def n8Imm : Operand<i32>;
59 def m6Imm : Operand<i32>;
62 let PrintMethod = "printNOneImmOperand" in
63 def nOneImm : Operand<i32>;
66 // Immediate predicates
68 def s32ImmPred : PatLeaf<(i32 imm), [{
69 // s32ImmPred predicate - True if the immediate fits in a 32-bit sign extended
71 int64_t v = (int64_t)N->getSExtValue();
75 def s32_24ImmPred : PatLeaf<(i32 imm), [{
76 // s32_24ImmPred predicate - True if the immediate fits in a 32-bit sign
77 // extended field that is a multiple of 0x1000000.
78 int64_t v = (int64_t)N->getSExtValue();
79 return isShiftedInt<32,24>(v);
82 def s32_16s8ImmPred : PatLeaf<(i32 imm), [{
83 // s32_16s8ImmPred predicate - True if the immediate fits in a 32-bit sign
84 // extended field that is a multiple of 0x10000.
85 int64_t v = (int64_t)N->getSExtValue();
86 return isShiftedInt<24,16>(v);
89 def s26_6ImmPred : PatLeaf<(i32 imm), [{
90 // s26_6ImmPred predicate - True if the immediate fits in a 32-bit
91 // sign extended field.
92 int64_t v = (int64_t)N->getSExtValue();
93 return isShiftedInt<26,6>(v);
97 def s16ImmPred : PatLeaf<(i32 imm), [{
98 // s16ImmPred predicate - True if the immediate fits in a 16-bit sign extended
100 int64_t v = (int64_t)N->getSExtValue();
105 def s13ImmPred : PatLeaf<(i32 imm), [{
106 // s13ImmPred predicate - True if the immediate fits in a 13-bit sign extended
108 int64_t v = (int64_t)N->getSExtValue();
113 def s12ImmPred : PatLeaf<(i32 imm), [{
114 // s12ImmPred predicate - True if the immediate fits in a 12-bit
115 // sign extended field.
116 int64_t v = (int64_t)N->getSExtValue();
120 def s11_0ImmPred : PatLeaf<(i32 imm), [{
121 // s11_0ImmPred predicate - True if the immediate fits in a 11-bit
122 // sign extended field.
123 int64_t v = (int64_t)N->getSExtValue();
128 def s11_1ImmPred : PatLeaf<(i32 imm), [{
129 // s11_1ImmPred predicate - True if the immediate fits in a 12-bit
130 // sign extended field and is a multiple of 2.
131 int64_t v = (int64_t)N->getSExtValue();
132 return isShiftedInt<11,1>(v);
136 def s11_2ImmPred : PatLeaf<(i32 imm), [{
137 // s11_2ImmPred predicate - True if the immediate fits in a 13-bit
138 // sign extended field and is a multiple of 4.
139 int64_t v = (int64_t)N->getSExtValue();
140 return isShiftedInt<11,2>(v);
144 def s11_3ImmPred : PatLeaf<(i32 imm), [{
145 // s11_3ImmPred predicate - True if the immediate fits in a 14-bit
146 // sign extended field and is a multiple of 8.
147 int64_t v = (int64_t)N->getSExtValue();
148 return isShiftedInt<11,3>(v);
152 def s10ImmPred : PatLeaf<(i32 imm), [{
153 // s10ImmPred predicate - True if the immediate fits in a 10-bit sign extended
155 int64_t v = (int64_t)N->getSExtValue();
160 def s9ImmPred : PatLeaf<(i32 imm), [{
161 // s9ImmPred predicate - True if the immediate fits in a 9-bit sign extended
163 int64_t v = (int64_t)N->getSExtValue();
167 def m9ImmPred : PatLeaf<(i32 imm), [{
168 // m9ImmPred predicate - True if the immediate fits in a 9-bit magnitude
169 // field. The range of m9 is -255 to 255.
170 int64_t v = (int64_t)N->getSExtValue();
171 return isInt<9>(v) && (v != -256);
174 def s8ImmPred : PatLeaf<(i32 imm), [{
175 // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended
177 int64_t v = (int64_t)N->getSExtValue();
182 def s8Imm64Pred : PatLeaf<(i64 imm), [{
183 // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended
185 int64_t v = (int64_t)N->getSExtValue();
190 def s6ImmPred : PatLeaf<(i32 imm), [{
191 // s6ImmPred predicate - True if the immediate fits in a 6-bit sign extended
193 int64_t v = (int64_t)N->getSExtValue();
198 def s4_0ImmPred : PatLeaf<(i32 imm), [{
199 // s4_0ImmPred predicate - True if the immediate fits in a 4-bit sign extended
201 int64_t v = (int64_t)N->getSExtValue();
206 def s4_1ImmPred : PatLeaf<(i32 imm), [{
207 // s4_1ImmPred predicate - True if the immediate fits in a 4-bit sign extended
209 int64_t v = (int64_t)N->getSExtValue();
210 return isShiftedInt<4,1>(v);
214 def s4_2ImmPred : PatLeaf<(i32 imm), [{
215 // s4_2ImmPred predicate - True if the immediate fits in a 4-bit sign extended
216 // field that is a multiple of 4.
217 int64_t v = (int64_t)N->getSExtValue();
218 return isShiftedInt<4,2>(v);
222 def s4_3ImmPred : PatLeaf<(i32 imm), [{
223 // s4_3ImmPred predicate - True if the immediate fits in a 4-bit sign extended
224 // field that is a multiple of 8.
225 int64_t v = (int64_t)N->getSExtValue();
226 return isShiftedInt<4,3>(v);
230 def u64ImmPred : PatLeaf<(i64 imm), [{
231 // Adding "N ||" to suppress gcc unused warning.
235 def u32ImmPred : PatLeaf<(i32 imm), [{
236 // u32ImmPred predicate - True if the immediate fits in a 32-bit field.
237 int64_t v = (int64_t)N->getSExtValue();
238 return isUInt<32>(v);
241 def u26_6ImmPred : PatLeaf<(i32 imm), [{
242 // u26_6ImmPred - True if the immediate fits in a 32-bit field and
243 // is a multiple of 64.
244 int64_t v = (int64_t)N->getSExtValue();
245 return isShiftedUInt<26,6>(v);
248 def u16ImmPred : PatLeaf<(i32 imm), [{
249 // u16ImmPred predicate - True if the immediate fits in a 16-bit unsigned
251 int64_t v = (int64_t)N->getSExtValue();
252 return isUInt<16>(v);
255 def u16_s8ImmPred : PatLeaf<(i32 imm), [{
256 // u16_s8ImmPred predicate - True if the immediate fits in a 16-bit sign
257 // extended s8 field.
258 int64_t v = (int64_t)N->getSExtValue();
259 return isShiftedUInt<16,8>(v);
262 def u16_0ImmPred : PatLeaf<(i32 imm), [{
263 // True if the immediate fits in a 16-bit unsigned field.
264 int64_t v = (int64_t)N->getSExtValue();
265 return isUInt<16>(v);
268 def u11_3ImmPred : PatLeaf<(i32 imm), [{
269 // True if the immediate fits in a 14-bit unsigned field, and the lowest
271 int64_t v = (int64_t)N->getSExtValue();
272 return isShiftedUInt<11,3>(v);
275 def u9ImmPred : PatLeaf<(i32 imm), [{
276 // u9ImmPred predicate - True if the immediate fits in a 9-bit unsigned
278 int64_t v = (int64_t)N->getSExtValue();
283 def u8ImmPred : PatLeaf<(i32 imm), [{
284 // u8ImmPred predicate - True if the immediate fits in a 8-bit unsigned
286 int64_t v = (int64_t)N->getSExtValue();
290 def u7StrictPosImmPred : ImmLeaf<i32, [{
291 // u7StrictPosImmPred predicate - True if the immediate fits in an 7-bit
292 // unsigned field and is strictly greater than 0.
293 return isUInt<7>(Imm) && Imm > 0;
296 def u7ImmPred : PatLeaf<(i32 imm), [{
297 // u7ImmPred predicate - True if the immediate fits in a 7-bit unsigned
299 int64_t v = (int64_t)N->getSExtValue();
304 def u6ImmPred : PatLeaf<(i32 imm), [{
305 // u6ImmPred predicate - True if the immediate fits in a 6-bit unsigned
307 int64_t v = (int64_t)N->getSExtValue();
311 def u6_0ImmPred : PatLeaf<(i32 imm), [{
312 // u6_0ImmPred predicate - True if the immediate fits in a 6-bit unsigned
313 // field. Same as u6ImmPred.
314 int64_t v = (int64_t)N->getSExtValue();
318 def u6_1ImmPred : PatLeaf<(i32 imm), [{
319 // u6_1ImmPred predicate - True if the immediate fits in a 7-bit unsigned
320 // field that is 1 bit alinged - multiple of 2.
321 int64_t v = (int64_t)N->getSExtValue();
322 return isShiftedUInt<6,1>(v);
325 def u6_2ImmPred : PatLeaf<(i32 imm), [{
326 // u6_2ImmPred predicate - True if the immediate fits in a 8-bit unsigned
327 // field that is 2 bits alinged - multiple of 4.
328 int64_t v = (int64_t)N->getSExtValue();
329 return isShiftedUInt<6,2>(v);
332 def u6_3ImmPred : PatLeaf<(i32 imm), [{
333 // u6_3ImmPred predicate - True if the immediate fits in a 9-bit unsigned
334 // field that is 3 bits alinged - multiple of 8.
335 int64_t v = (int64_t)N->getSExtValue();
336 return isShiftedUInt<6,3>(v);
339 def u5ImmPred : PatLeaf<(i32 imm), [{
340 // u5ImmPred predicate - True if the immediate fits in a 5-bit unsigned
342 int64_t v = (int64_t)N->getSExtValue();
346 def u4ImmPred : PatLeaf<(i32 imm), [{
347 // u4ImmPred predicate - True if the immediate fits in a 4-bit unsigned
349 int64_t v = (int64_t)N->getSExtValue();
353 def u3ImmPred : PatLeaf<(i32 imm), [{
354 // u3ImmPred predicate - True if the immediate fits in a 3-bit unsigned
356 int64_t v = (int64_t)N->getSExtValue();
361 def u2ImmPred : PatLeaf<(i32 imm), [{
362 // u2ImmPred predicate - True if the immediate fits in a 2-bit unsigned
364 int64_t v = (int64_t)N->getSExtValue();
369 def u1ImmPred : PatLeaf<(i1 imm), [{
370 // u1ImmPred predicate - True if the immediate fits in a 1-bit unsigned
372 int64_t v = (int64_t)N->getSExtValue();
376 def m5BImmPred : PatLeaf<(i32 imm), [{
377 // m5BImmPred predicate - True if the (char) number is in range -1 .. -31
378 // and will fit in a 5 bit field when made positive, for use in memops.
379 // this is specific to the zero extending of a negative by CombineInstr
380 int8_t v = (int8_t)N->getSExtValue();
381 return (-31 <= v && v <= -1);
384 def m5HImmPred : PatLeaf<(i32 imm), [{
385 // m5HImmPred predicate - True if the (short) number is in range -1 .. -31
386 // and will fit in a 5 bit field when made positive, for use in memops.
387 // this is specific to the zero extending of a negative by CombineInstr
388 int16_t v = (int16_t)N->getSExtValue();
389 return (-31 <= v && v <= -1);
392 def m5ImmPred : PatLeaf<(i32 imm), [{
393 // m5ImmPred predicate - True if the number is in range -1 .. -31
394 // and will fit in a 5 bit field when made positive, for use in memops.
395 int64_t v = (int64_t)N->getSExtValue();
396 return (-31 <= v && v <= -1);
399 //InN means negative integers in [-(2^N - 1), 0]
400 def n8ImmPred : PatLeaf<(i32 imm), [{
401 // n8ImmPred predicate - True if the immediate fits in a 8-bit signed
403 int64_t v = (int64_t)N->getSExtValue();
404 return (-255 <= v && v <= 0);
407 def nOneImmPred : PatLeaf<(i32 imm), [{
408 // nOneImmPred predicate - True if the immediate is -1.
409 int64_t v = (int64_t)N->getSExtValue();
413 def Set5ImmPred : PatLeaf<(i32 imm), [{
414 // Set5ImmPred predicate - True if the number is in the series of values.
415 // [ 2^0, 2^1, ... 2^31 ]
416 // For use in setbit immediate.
417 uint32_t v = (int32_t)N->getSExtValue();
418 // Constrain to 32 bits, and then check for single bit.
419 return ImmIsSingleBit(v);
422 def Clr5ImmPred : PatLeaf<(i32 imm), [{
423 // Clr5ImmPred predicate - True if the number is in the series of
424 // bit negated values.
425 // [ 2^0, 2^1, ... 2^31 ]
426 // For use in clrbit immediate.
427 // Note: we are bit NOTing the value.
428 uint32_t v = ~ (int32_t)N->getSExtValue();
429 // Constrain to 32 bits, and then check for single bit.
430 return ImmIsSingleBit(v);
433 def SetClr5ImmPred : PatLeaf<(i32 imm), [{
434 // SetClr5ImmPred predicate - True if the immediate is in range 0..31.
435 int32_t v = (int32_t)N->getSExtValue();
436 return (v >= 0 && v <= 31);
439 def Set4ImmPred : PatLeaf<(i32 imm), [{
440 // Set4ImmPred predicate - True if the number is in the series of values:
441 // [ 2^0, 2^1, ... 2^15 ].
442 // For use in setbit immediate.
443 uint16_t v = (int16_t)N->getSExtValue();
444 // Constrain to 16 bits, and then check for single bit.
445 return ImmIsSingleBit(v);
448 def Clr4ImmPred : PatLeaf<(i32 imm), [{
449 // Clr4ImmPred predicate - True if the number is in the series of
450 // bit negated values:
451 // [ 2^0, 2^1, ... 2^15 ].
452 // For use in setbit and clrbit immediate.
453 uint16_t v = ~ (int16_t)N->getSExtValue();
454 // Constrain to 16 bits, and then check for single bit.
455 return ImmIsSingleBit(v);
458 def SetClr4ImmPred : PatLeaf<(i32 imm), [{
459 // SetClr4ImmPred predicate - True if the immediate is in the range 0..15.
460 int16_t v = (int16_t)N->getSExtValue();
461 return (v >= 0 && v <= 15);
464 def Set3ImmPred : PatLeaf<(i32 imm), [{
465 // Set3ImmPred predicate - True if the number is in the series of values:
466 // [ 2^0, 2^1, ... 2^7 ].
467 // For use in setbit immediate.
468 uint8_t v = (int8_t)N->getSExtValue();
469 // Constrain to 8 bits, and then check for single bit.
470 return ImmIsSingleBit(v);
473 def Clr3ImmPred : PatLeaf<(i32 imm), [{
474 // Clr3ImmPred predicate - True if the number is in the series of
475 // bit negated values:
476 // [ 2^0, 2^1, ... 2^7 ].
477 // For use in setbit and clrbit immediate.
478 uint8_t v = ~ (int8_t)N->getSExtValue();
479 // Constrain to 8 bits, and then check for single bit.
480 return ImmIsSingleBit(v);
483 def SetClr3ImmPred : PatLeaf<(i32 imm), [{
484 // SetClr3ImmPred predicate - True if the immediate is in the range 0..7.
485 int8_t v = (int8_t)N->getSExtValue();
486 return (v >= 0 && v <= 7);
490 // Extendable immediate operands.
492 let PrintMethod = "printExtOperand" in {
493 def s16Ext : Operand<i32>;
494 def s12Ext : Operand<i32>;
495 def s10Ext : Operand<i32>;
496 def s9Ext : Operand<i32>;
497 def s8Ext : Operand<i32>;
498 def s6Ext : Operand<i32>;
499 def s11_0Ext : Operand<i32>;
500 def s11_1Ext : Operand<i32>;
501 def s11_2Ext : Operand<i32>;
502 def s11_3Ext : Operand<i32>;
503 def u6Ext : Operand<i32>;
504 def u7Ext : Operand<i32>;
505 def u8Ext : Operand<i32>;
506 def u9Ext : Operand<i32>;
507 def u10Ext : Operand<i32>;
508 def u6_0Ext : Operand<i32>;
509 def u6_1Ext : Operand<i32>;
510 def u6_2Ext : Operand<i32>;
511 def u6_3Ext : Operand<i32>;
514 let PrintMethod = "printImmOperand" in
515 def u0AlwaysExt : Operand<i32>;
517 // Predicates for constant extendable operands
518 def s16ExtPred : PatLeaf<(i32 imm), [{
519 int64_t v = (int64_t)N->getSExtValue();
520 if (!Subtarget.hasV4TOps())
521 // Return true if the immediate can fit in a 16-bit sign extended field.
527 // Return true if extending this immediate is profitable and the value
528 // can fit in a 32-bit signed field.
529 return isConstExtProfitable(Node) && isInt<32>(v);
533 def s10ExtPred : PatLeaf<(i32 imm), [{
534 int64_t v = (int64_t)N->getSExtValue();
535 if (!Subtarget.hasV4TOps())
536 // Return true if the immediate can fit in a 10-bit sign extended field.
542 // Return true if extending this immediate is profitable and the value
543 // can fit in a 32-bit signed field.
544 return isConstExtProfitable(Node) && isInt<32>(v);
548 def s9ExtPred : PatLeaf<(i32 imm), [{
549 int64_t v = (int64_t)N->getSExtValue();
550 if (!Subtarget.hasV4TOps())
551 // Return true if the immediate can fit in a 9-bit sign extended field.
557 // Return true if extending this immediate is profitable and the value
558 // can fit in a 32-bit unsigned field.
559 return isConstExtProfitable(Node) && isInt<32>(v);
563 def s8ExtPred : PatLeaf<(i32 imm), [{
564 int64_t v = (int64_t)N->getSExtValue();
565 if (!Subtarget.hasV4TOps())
566 // Return true if the immediate can fit in a 8-bit sign extended field.
572 // Return true if extending this immediate is profitable and the value
573 // can fit in a 32-bit signed field.
574 return isConstExtProfitable(Node) && isInt<32>(v);
578 def s8_16ExtPred : PatLeaf<(i32 imm), [{
579 int64_t v = (int64_t)N->getSExtValue();
580 if (!Subtarget.hasV4TOps())
581 // Return true if the immediate fits in a 8-bit sign extended field.
587 // Return true if extending this immediate is profitable and the value
588 // can't fit in a 16-bit signed field. This is required to avoid
589 // unnecessary constant extenders.
590 return isConstExtProfitable(Node) && !isInt<16>(v);
594 def s6ExtPred : PatLeaf<(i32 imm), [{
595 int64_t v = (int64_t)N->getSExtValue();
596 if (!Subtarget.hasV4TOps())
597 // Return true if the immediate can fit in a 6-bit sign extended field.
603 // Return true if extending this immediate is profitable and the value
604 // can fit in a 32-bit unsigned field.
605 return isConstExtProfitable(Node) && isInt<32>(v);
609 def s6_16ExtPred : PatLeaf<(i32 imm), [{
610 int64_t v = (int64_t)N->getSExtValue();
611 if (!Subtarget.hasV4TOps())
612 // Return true if the immediate fits in a 6-bit sign extended field.
618 // Return true if extending this immediate is profitable and the value
619 // can't fit in a 16-bit signed field. This is required to avoid
620 // unnecessary constant extenders.
621 return isConstExtProfitable(Node) && !isInt<16>(v);
625 def s6_10ExtPred : PatLeaf<(i32 imm), [{
626 int64_t v = (int64_t)N->getSExtValue();
627 if (!Subtarget.hasV4TOps())
628 // Return true if the immediate can fit in a 6-bit sign extended field.
634 // Return true if extending this immediate is profitable and the value
635 // can't fit in a 10-bit signed field. This is required to avoid
636 // unnecessary constant extenders.
637 return isConstExtProfitable(Node) && !isInt<10>(v);
641 def s11_0ExtPred : PatLeaf<(i32 imm), [{
642 int64_t v = (int64_t)N->getSExtValue();
643 if (!Subtarget.hasV4TOps())
644 // Return true if the immediate can fit in a 11-bit sign extended field.
645 return isShiftedInt<11,0>(v);
650 // Return true if extending this immediate is profitable and the value
651 // can fit in a 32-bit signed field.
652 return isConstExtProfitable(Node) && isInt<32>(v);
656 def s11_1ExtPred : PatLeaf<(i32 imm), [{
657 int64_t v = (int64_t)N->getSExtValue();
658 if (!Subtarget.hasV4TOps())
659 // Return true if the immediate can fit in a 12-bit sign extended field and
660 // is 2 byte aligned.
661 return isShiftedInt<11,1>(v);
664 return isShiftedInt<11,1>(v);
666 // Return true if extending this immediate is profitable and the low 1 bit
667 // is zero (2-byte aligned).
668 return isConstExtProfitable(Node) && isInt<32>(v) && ((v % 2) == 0);
672 def s11_2ExtPred : PatLeaf<(i32 imm), [{
673 int64_t v = (int64_t)N->getSExtValue();
674 if (!Subtarget.hasV4TOps())
675 // Return true if the immediate can fit in a 13-bit sign extended field and
676 // is 4-byte aligned.
677 return isShiftedInt<11,2>(v);
680 return isShiftedInt<11,2>(v);
682 // Return true if extending this immediate is profitable and the low 2-bits
683 // are zero (4-byte aligned).
684 return isConstExtProfitable(Node) && isInt<32>(v) && ((v % 4) == 0);
688 def s11_3ExtPred : PatLeaf<(i32 imm), [{
689 int64_t v = (int64_t)N->getSExtValue();
690 if (!Subtarget.hasV4TOps())
691 // Return true if the immediate can fit in a 14-bit sign extended field and
692 // is 8-byte aligned.
693 return isShiftedInt<11,3>(v);
696 return isShiftedInt<11,3>(v);
698 // Return true if extending this immediate is profitable and the low 3-bits
699 // are zero (8-byte aligned).
700 return isConstExtProfitable(Node) && isInt<32>(v) && ((v % 8) == 0);
704 def u0AlwaysExtPred : PatLeaf<(i32 imm), [{
705 // Predicate for an unsigned 32-bit value that always needs to be extended.
706 if (Subtarget.hasV4TOps()) {
707 if (isConstExtProfitable(Node)) {
708 int64_t v = (int64_t)N->getSExtValue();
709 return isUInt<32>(v);
715 def u6ExtPred : PatLeaf<(i32 imm), [{
716 int64_t v = (int64_t)N->getSExtValue();
717 if (!Subtarget.hasV4TOps())
718 // Return true if the immediate can fit in a 6-bit unsigned field.
724 // Return true if extending this immediate is profitable and the value
725 // can fit in a 32-bit unsigned field.
726 return isConstExtProfitable(Node) && isUInt<32>(v);
730 def u7ExtPred : PatLeaf<(i32 imm), [{
731 int64_t v = (int64_t)N->getSExtValue();
732 if (!Subtarget.hasV4TOps())
733 // Return true if the immediate can fit in a 7-bit unsigned field.
739 // Return true if extending this immediate is profitable and the value
740 // can fit in a 32-bit unsigned field.
741 return isConstExtProfitable(Node) && isUInt<32>(v);
745 def u8ExtPred : PatLeaf<(i32 imm), [{
746 int64_t v = (int64_t)N->getSExtValue();
747 if (!Subtarget.hasV4TOps())
748 // Return true if the immediate can fit in a 8-bit unsigned field.
754 // Return true if extending this immediate is profitable and the value
755 // can fit in a 32-bit unsigned field.
756 return isConstExtProfitable(Node) && isUInt<32>(v);
760 def u9ExtPred : PatLeaf<(i32 imm), [{
761 int64_t v = (int64_t)N->getSExtValue();
762 if (!Subtarget.hasV4TOps())
763 // Return true if the immediate can fit in a 9-bit unsigned field.
769 // Return true if extending this immediate is profitable and the value
770 // can fit in a 32-bit unsigned field.
771 return isConstExtProfitable(Node) && isUInt<32>(v);
775 def u6_1ExtPred : PatLeaf<(i32 imm), [{
776 int64_t v = (int64_t)N->getSExtValue();
777 if (!Subtarget.hasV4TOps())
778 // Return true if the immediate can fit in a 7-bit unsigned field and
779 // is 2-byte aligned.
780 return isShiftedUInt<6,1>(v);
783 return isShiftedUInt<6,1>(v);
785 // Return true if extending this immediate is profitable and the value
786 // can fit in a 32-bit unsigned field.
787 return isConstExtProfitable(Node) && isUInt<32>(v) && ((v % 2) == 0);
791 def u6_2ExtPred : PatLeaf<(i32 imm), [{
792 int64_t v = (int64_t)N->getSExtValue();
793 if (!Subtarget.hasV4TOps())
794 // Return true if the immediate can fit in a 8-bit unsigned field and
795 // is 4-byte aligned.
796 return isShiftedUInt<6,2>(v);
799 return isShiftedUInt<6,2>(v);
801 // Return true if extending this immediate is profitable and the value
802 // can fit in a 32-bit unsigned field.
803 return isConstExtProfitable(Node) && isUInt<32>(v) && ((v % 4) == 0);
807 def u6_3ExtPred : PatLeaf<(i32 imm), [{
808 int64_t v = (int64_t)N->getSExtValue();
809 if (!Subtarget.hasV4TOps())
810 // Return true if the immediate can fit in a 9-bit unsigned field and
811 // is 8-byte aligned.
812 return isShiftedUInt<6,3>(v);
815 return isShiftedUInt<6,3>(v);
817 // Return true if extending this immediate is profitable and the value
818 // can fit in a 32-bit unsigned field.
819 return isConstExtProfitable(Node) && isUInt<32>(v) && ((v % 8) == 0);
824 // This complex pattern exists only to create a machine instruction operand
825 // of type "frame index". There doesn't seem to be a way to do that directly
827 def AddrFI : ComplexPattern<i32, 1, "SelectAddrFI", [frameindex], []>;
831 def ADDRrr : ComplexPattern<i32, 2, "SelectADDRrr", [], []>;
832 def ADDRri : ComplexPattern<i32, 2, "SelectADDRri", [frameindex], []>;
833 def ADDRriS11_0 : ComplexPattern<i32, 2, "SelectADDRriS11_0", [frameindex], []>;
834 def ADDRriS11_1 : ComplexPattern<i32, 2, "SelectADDRriS11_1", [frameindex], []>;
835 def ADDRriS11_2 : ComplexPattern<i32, 2, "SelectADDRriS11_2", [frameindex], []>;
836 def ADDRriS11_3 : ComplexPattern<i32, 2, "SelectADDRriS11_3", [frameindex], []>;
837 def ADDRriU6_0 : ComplexPattern<i32, 2, "SelectADDRriU6_0", [frameindex], []>;
838 def ADDRriU6_1 : ComplexPattern<i32, 2, "SelectADDRriU6_1", [frameindex], []>;
839 def ADDRriU6_2 : ComplexPattern<i32, 2, "SelectADDRriU6_2", [frameindex], []>;
843 def MEMrr : Operand<i32> {
844 let PrintMethod = "printMEMrrOperand";
845 let MIOperandInfo = (ops IntRegs, IntRegs);
848 def MEMri : Operand<i32> {
849 let PrintMethod = "printMEMriOperand";
850 let MIOperandInfo = (ops IntRegs, IntRegs);
853 def MEMri_s11_2 : Operand<i32>,
854 ComplexPattern<i32, 2, "SelectMEMriS11_2", []> {
855 let PrintMethod = "printMEMriOperand";
856 let MIOperandInfo = (ops IntRegs, s11Imm);
859 def FrameIndex : Operand<i32> {
860 let PrintMethod = "printFrameIndexOperand";
861 let MIOperandInfo = (ops IntRegs, s11Imm);
864 let PrintMethod = "printGlobalOperand" in {
865 def globaladdress : Operand<i32>;
866 def globaladdressExt : Operand<i32>;
869 let PrintMethod = "printJumpTable" in
870 def jumptablebase : Operand<i32>;
872 def brtarget : Operand<OtherVT>;
873 def brtargetExt : Operand<OtherVT>;
874 def calltarget : Operand<i32>;
876 def bblabel : Operand<i32>;
877 def bbl : SDNode<"ISD::BasicBlock", SDTPtrLeaf , [], "BasicBlockSDNode">;
879 def symbolHi32 : Operand<i32> {
880 let PrintMethod = "printSymbolHi";
882 def symbolLo32 : Operand<i32> {
883 let PrintMethod = "printSymbolLo";
886 // Return true if for a 32 to 64-bit sign-extended load.
887 def is_sext_i32 : PatLeaf<(i64 DoubleRegs:$src1), [{
888 LoadSDNode *LD = dyn_cast<LoadSDNode>(N);
891 return LD->getExtensionType() == ISD::SEXTLOAD &&
892 LD->getMemoryVT().getScalarType() == MVT::i32;