1 //===- HexagonImmediates.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 // From IA64's InstrInfo file
11 def s32Imm : Operand<i32> {
12 // For now, we use a generic print function for all operands.
13 let PrintMethod = "printImmOperand";
16 // f32Ext type is used to identify constant extended floating point
17 // Immediate operands.
18 def f32Ext : Operand<f32> {
19 let PrintMethod = "printImmOperand";
22 def s16Imm : Operand<i32> {
23 let PrintMethod = "printImmOperand";
26 def s12Imm : Operand<i32> {
27 // For now, we use a generic print function for all operands.
28 let PrintMethod = "printImmOperand";
31 def s11Imm : Operand<i32> {
32 // For now, we use a generic print function for all operands.
33 let PrintMethod = "printImmOperand";
36 def s11_0Imm : Operand<i32> {
37 // For now, we use a generic print function for all operands.
38 let PrintMethod = "printImmOperand";
41 def s11_1Imm : Operand<i32> {
42 // For now, we use a generic print function for all operands.
43 let PrintMethod = "printImmOperand";
46 def s11_2Imm : Operand<i32> {
47 // For now, we use a generic print function for all operands.
48 let PrintMethod = "printImmOperand";
51 def s11_3Imm : Operand<i32> {
52 // For now, we use a generic print function for all operands.
53 let PrintMethod = "printImmOperand";
56 def s10Imm : Operand<i32> {
57 // For now, we use a generic print function for all operands.
58 let PrintMethod = "printImmOperand";
61 def s9Imm : Operand<i32> {
62 // For now, we use a generic print function for all operands.
63 let PrintMethod = "printImmOperand";
66 def s8Imm : Operand<i32> {
67 // For now, we use a generic print function for all operands.
68 let PrintMethod = "printImmOperand";
71 def s8Imm64 : Operand<i64> {
72 // For now, we use a generic print function for all operands.
73 let PrintMethod = "printImmOperand";
76 def s6Imm : Operand<i32> {
77 // For now, we use a generic print function for all operands.
78 let PrintMethod = "printImmOperand";
81 def s4Imm : Operand<i32> {
82 // For now, we use a generic print function for all operands.
83 let PrintMethod = "printImmOperand";
86 def s4_0Imm : Operand<i32> {
87 // For now, we use a generic print function for all operands.
88 let PrintMethod = "printImmOperand";
91 def s4_1Imm : Operand<i32> {
92 // For now, we use a generic print function for all operands.
93 let PrintMethod = "printImmOperand";
96 def s4_2Imm : Operand<i32> {
97 // For now, we use a generic print function for all operands.
98 let PrintMethod = "printImmOperand";
101 def s4_3Imm : Operand<i32> {
102 // For now, we use a generic print function for all operands.
103 let PrintMethod = "printImmOperand";
106 def u64Imm : Operand<i64> {
107 // For now, we use a generic print function for all operands.
108 let PrintMethod = "printImmOperand";
111 def u32Imm : Operand<i32> {
112 // For now, we use a generic print function for all operands.
113 let PrintMethod = "printImmOperand";
116 def u16Imm : Operand<i32> {
117 // For now, we use a generic print function for all operands.
118 let PrintMethod = "printImmOperand";
121 def u16_0Imm : Operand<i32> {
122 // For now, we use a generic print function for all operands.
123 let PrintMethod = "printImmOperand";
126 def u16_1Imm : Operand<i32> {
127 // For now, we use a generic print function for all operands.
128 let PrintMethod = "printImmOperand";
131 def u16_2Imm : Operand<i32> {
132 // For now, we use a generic print function for all operands.
133 let PrintMethod = "printImmOperand";
136 def u11_3Imm : Operand<i32> {
137 // For now, we use a generic print function for all operands.
138 let PrintMethod = "printImmOperand";
141 def u10Imm : Operand<i32> {
142 // For now, we use a generic print function for all operands.
143 let PrintMethod = "printImmOperand";
146 def u9Imm : Operand<i32> {
147 // For now, we use a generic print function for all operands.
148 let PrintMethod = "printImmOperand";
151 def u8Imm : Operand<i32> {
152 // For now, we use a generic print function for all operands.
153 let PrintMethod = "printImmOperand";
156 def u7Imm : Operand<i32> {
157 // For now, we use a generic print function for all operands.
158 let PrintMethod = "printImmOperand";
161 def u6Imm : Operand<i32> {
162 // For now, we use a generic print function for all operands.
163 let PrintMethod = "printImmOperand";
166 def u6_0Imm : Operand<i32> {
167 // For now, we use a generic print function for all operands.
168 let PrintMethod = "printImmOperand";
171 def u6_1Imm : Operand<i32> {
172 // For now, we use a generic print function for all operands.
173 let PrintMethod = "printImmOperand";
176 def u6_2Imm : Operand<i32> {
177 // For now, we use a generic print function for all operands.
178 let PrintMethod = "printImmOperand";
181 def u6_3Imm : Operand<i32> {
182 // For now, we use a generic print function for all operands.
183 let PrintMethod = "printImmOperand";
186 def u5Imm : Operand<i32> {
187 // For now, we use a generic print function for all operands.
188 let PrintMethod = "printImmOperand";
191 def u4Imm : Operand<i32> {
192 // For now, we use a generic print function for all operands.
193 let PrintMethod = "printImmOperand";
196 def u3Imm : Operand<i32> {
197 // For now, we use a generic print function for all operands.
198 let PrintMethod = "printImmOperand";
201 def u2Imm : Operand<i32> {
202 // For now, we use a generic print function for all operands.
203 let PrintMethod = "printImmOperand";
206 def u1Imm : Operand<i32> {
207 // For now, we use a generic print function for all operands.
208 let PrintMethod = "printImmOperand";
211 def n8Imm : Operand<i32> {
212 // For now, we use a generic print function for all operands.
213 let PrintMethod = "printImmOperand";
216 def m6Imm : Operand<i32> {
217 // For now, we use a generic print function for all operands.
218 let PrintMethod = "printImmOperand";
221 def nOneImm : Operand<i32> {
222 // For now, we use a generic print function for all operands.
223 let PrintMethod = "printNOneImmOperand";
227 // Immediate predicates
229 def s32ImmPred : PatLeaf<(i32 imm), [{
230 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
232 int64_t v = (int64_t)N->getSExtValue();
236 def s32_24ImmPred : PatLeaf<(i32 imm), [{
237 // s32_24ImmPred predicate - True if the immediate fits in a 32-bit sign
238 // extended field that is a multiple of 0x1000000.
239 int64_t v = (int64_t)N->getSExtValue();
240 return isShiftedInt<32,24>(v);
243 def s32_16s8ImmPred : PatLeaf<(i32 imm), [{
244 // s32_16s8ImmPred predicate - True if the immediate fits in a 32-bit sign
245 // extended field that is a multiple of 0x10000.
246 int64_t v = (int64_t)N->getSExtValue();
247 return isShiftedInt<24,16>(v);
250 def s16ImmPred : PatLeaf<(i32 imm), [{
251 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
253 int64_t v = (int64_t)N->getSExtValue();
258 def s13ImmPred : PatLeaf<(i32 imm), [{
259 // immS13 predicate - True if the immediate fits in a 13-bit sign extended
261 int64_t v = (int64_t)N->getSExtValue();
266 def s12ImmPred : PatLeaf<(i32 imm), [{
267 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
269 int64_t v = (int64_t)N->getSExtValue();
273 def s11_0ImmPred : PatLeaf<(i32 imm), [{
274 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
276 int64_t v = (int64_t)N->getSExtValue();
281 def s11_1ImmPred : PatLeaf<(i32 imm), [{
282 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
284 int64_t v = (int64_t)N->getSExtValue();
285 return isShiftedInt<11,1>(v);
289 def s11_2ImmPred : PatLeaf<(i32 imm), [{
290 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
292 int64_t v = (int64_t)N->getSExtValue();
293 return isShiftedInt<11,2>(v);
297 def s11_3ImmPred : PatLeaf<(i32 imm), [{
298 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
300 int64_t v = (int64_t)N->getSExtValue();
301 return isShiftedInt<11,3>(v);
305 def s10ImmPred : PatLeaf<(i32 imm), [{
306 // s10ImmPred predicate - True if the immediate fits in a 10-bit sign extended
308 int64_t v = (int64_t)N->getSExtValue();
313 def s9ImmPred : PatLeaf<(i32 imm), [{
314 // s9ImmPred predicate - True if the immediate fits in a 9-bit sign extended
316 int64_t v = (int64_t)N->getSExtValue();
321 def s8ImmPred : PatLeaf<(i32 imm), [{
322 // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended
324 int64_t v = (int64_t)N->getSExtValue();
329 def s8Imm64Pred : PatLeaf<(i64 imm), [{
330 // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended
332 int64_t v = (int64_t)N->getSExtValue();
337 def s6ImmPred : PatLeaf<(i32 imm), [{
338 // s6ImmPred predicate - True if the immediate fits in a 6-bit sign extended
340 int64_t v = (int64_t)N->getSExtValue();
345 def s4_0ImmPred : PatLeaf<(i32 imm), [{
346 // s4_0ImmPred predicate - True if the immediate fits in a 4-bit sign extended
348 int64_t v = (int64_t)N->getSExtValue();
353 def s4_1ImmPred : PatLeaf<(i32 imm), [{
354 // s4_1ImmPred predicate - True if the immediate fits in a 4-bit sign extended
356 int64_t v = (int64_t)N->getSExtValue();
357 return isShiftedInt<4,1>(v);
361 def s4_2ImmPred : PatLeaf<(i32 imm), [{
362 // s4_2ImmPred predicate - True if the immediate fits in a 4-bit sign extended
363 // field that is a multiple of 4.
364 int64_t v = (int64_t)N->getSExtValue();
365 return isShiftedInt<4,2>(v);
369 def s4_3ImmPred : PatLeaf<(i32 imm), [{
370 // s4_3ImmPred predicate - True if the immediate fits in a 4-bit sign extended
371 // field that is a multiple of 8.
372 int64_t v = (int64_t)N->getSExtValue();
373 return isShiftedInt<4,3>(v);
377 def u64ImmPred : PatLeaf<(i64 imm), [{
378 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
380 // Adding "N ||" to supress gcc unused warning.
384 def u32ImmPred : PatLeaf<(i32 imm), [{
385 // immS16 predicate - True if the immediate fits in a 16-bit sign extended
387 int64_t v = (int64_t)N->getSExtValue();
388 return isUInt<32>(v);
391 def u16ImmPred : PatLeaf<(i32 imm), [{
392 // u16ImmPred predicate - True if the immediate fits in a 16-bit unsigned
394 int64_t v = (int64_t)N->getSExtValue();
395 return isUInt<16>(v);
398 def u16_s8ImmPred : PatLeaf<(i32 imm), [{
399 // u16_s8ImmPred predicate - True if the immediate fits in a 16-bit sign
400 // extended s8 field.
401 int64_t v = (int64_t)N->getSExtValue();
402 return isShiftedUInt<16,8>(v);
405 def u9ImmPred : PatLeaf<(i32 imm), [{
406 // u9ImmPred predicate - True if the immediate fits in a 9-bit unsigned
408 int64_t v = (int64_t)N->getSExtValue();
413 def u8ImmPred : PatLeaf<(i32 imm), [{
414 // u8ImmPred predicate - True if the immediate fits in a 8-bit unsigned
416 int64_t v = (int64_t)N->getSExtValue();
420 def u7ImmPred : PatLeaf<(i32 imm), [{
421 // u7ImmPred predicate - True if the immediate fits in a 8-bit unsigned
423 int64_t v = (int64_t)N->getSExtValue();
428 def u6ImmPred : PatLeaf<(i32 imm), [{
429 // u6ImmPred predicate - True if the immediate fits in a 6-bit unsigned
431 int64_t v = (int64_t)N->getSExtValue();
435 def u6_0ImmPred : PatLeaf<(i32 imm), [{
436 // u6_0ImmPred predicate - True if the immediate fits in a 6-bit unsigned
437 // field. Same as u6ImmPred.
438 int64_t v = (int64_t)N->getSExtValue();
442 def u6_1ImmPred : PatLeaf<(i32 imm), [{
443 // u6_1ImmPred predicate - True if the immediate fits in a 6-bit unsigned
444 // field that is 1 bit alinged - multiple of 2.
445 int64_t v = (int64_t)N->getSExtValue();
446 return isShiftedUInt<6,1>(v);
449 def u6_2ImmPred : PatLeaf<(i32 imm), [{
450 // u6_2ImmPred predicate - True if the immediate fits in a 6-bit unsigned
451 // field that is 2 bits alinged - multiple of 4.
452 int64_t v = (int64_t)N->getSExtValue();
453 return isShiftedUInt<6,2>(v);
456 def u6_3ImmPred : PatLeaf<(i32 imm), [{
457 // u6_3ImmPred predicate - True if the immediate fits in a 6-bit unsigned
458 // field that is 3 bits alinged - multiple of 8.
459 int64_t v = (int64_t)N->getSExtValue();
460 return isShiftedUInt<6,3>(v);
463 def u5ImmPred : PatLeaf<(i32 imm), [{
464 // u5ImmPred predicate - True if the immediate fits in a 5-bit unsigned
466 int64_t v = (int64_t)N->getSExtValue();
471 def u3ImmPred : PatLeaf<(i32 imm), [{
472 // u3ImmPred predicate - True if the immediate fits in a 3-bit unsigned
474 int64_t v = (int64_t)N->getSExtValue();
479 def u2ImmPred : PatLeaf<(i32 imm), [{
480 // u2ImmPred predicate - True if the immediate fits in a 2-bit unsigned
482 int64_t v = (int64_t)N->getSExtValue();
487 def u1ImmPred : PatLeaf<(i1 imm), [{
488 // u1ImmPred predicate - True if the immediate fits in a 1-bit unsigned
490 int64_t v = (int64_t)N->getSExtValue();
494 def m6ImmPred : PatLeaf<(i32 imm), [{
495 // m6ImmPred predicate - True if the immediate is negative and fits in
496 // a 6-bit negative number.
497 int64_t v = (int64_t)N->getSExtValue();
501 //InN means negative integers in [-(2^N - 1), 0]
502 def n8ImmPred : PatLeaf<(i32 imm), [{
503 // n8ImmPred predicate - True if the immediate fits in a 8-bit signed
505 int64_t v = (int64_t)N->getSExtValue();
506 return (-255 <= v && v <= 0);
509 def nOneImmPred : PatLeaf<(i32 imm), [{
510 // nOneImmPred predicate - True if the immediate is -1.
511 int64_t v = (int64_t)N->getSExtValue();
515 // Operand types for constant extendable operands
516 def s16Ext : Operand<i32> {
517 let PrintMethod = "printExtOperand";
520 def s12Ext : Operand<i32> {
521 let PrintMethod = "printExtOperand";
524 def s10Ext : Operand<i32> {
525 let PrintMethod = "printExtOperand";
528 def s9Ext : Operand<i32> {
529 let PrintMethod = "printExtOperand";
532 def s8Ext : Operand<i32> {
533 let PrintMethod = "printExtOperand";
536 def s6Ext : Operand<i32> {
537 let PrintMethod = "printExtOperand";
540 def s11_0Ext : Operand<i32> {
541 let PrintMethod = "printExtOperand";
544 def s11_1Ext : Operand<i32> {
545 let PrintMethod = "printExtOperand";
548 def s11_2Ext : Operand<i32> {
549 let PrintMethod = "printExtOperand";
552 def s11_3Ext : Operand<i32> {
553 let PrintMethod = "printExtOperand";
556 def u6Ext : Operand<i32> {
557 let PrintMethod = "printExtOperand";
560 def u7Ext : Operand<i32> {
561 let PrintMethod = "printExtOperand";
564 def u8Ext : Operand<i32> {
565 let PrintMethod = "printExtOperand";
568 def u9Ext : Operand<i32> {
569 let PrintMethod = "printExtOperand";
572 def u10Ext : Operand<i32> {
573 let PrintMethod = "printExtOperand";
576 def u6_0Ext : Operand<i32> {
577 let PrintMethod = "printExtOperand";
580 def u6_1Ext : Operand<i32> {
581 let PrintMethod = "printExtOperand";
584 def u6_2Ext : Operand<i32> {
585 let PrintMethod = "printExtOperand";
588 def u6_3Ext : Operand<i32> {
589 let PrintMethod = "printExtOperand";
592 // Predicates for constant extendable operands
593 def s16ExtPred : PatLeaf<(i32 imm), [{
594 int64_t v = (int64_t)N->getSExtValue();
595 if (!Subtarget.hasV4TOps())
596 // Return true if the immediate can fit in a 16-bit sign extended field.
602 // Return true if extending this immediate is profitable and the value
603 // can fit in a 32-bit signed field.
604 if (isConstExtProfitable(Node) && isInt<32>(v))
611 def s10ExtPred : PatLeaf<(i32 imm), [{
612 int64_t v = (int64_t)N->getSExtValue();
613 if (!Subtarget.hasV4TOps())
614 // Return true if the immediate can fit in a 10-bit sign extended field.
620 // Return true if extending this immediate is profitable and the value
621 // can fit in a 32-bit signed field.
622 if (isConstExtProfitable(Node) && isInt<32>(v))
629 def s9ExtPred : PatLeaf<(i32 imm), [{
630 int64_t v = (int64_t)N->getSExtValue();
631 if (!Subtarget.hasV4TOps())
632 // Return true if the immediate can fit in a 9-bit sign extended field.
638 // Return true if extending this immediate is profitable and the value
639 // can fit in a 32-bit unsigned field.
640 if (isConstExtProfitable(Node) && isInt<32>(v))
647 def s8ExtPred : PatLeaf<(i32 imm), [{
648 int64_t v = (int64_t)N->getSExtValue();
649 if (!Subtarget.hasV4TOps())
650 // Return true if the immediate can fit in a 8-bit sign extended field.
656 // Return true if extending this immediate is profitable and the value
657 // can fit in a 32-bit signed field.
658 if (isConstExtProfitable(Node) && isInt<32>(v))
665 def s8_16ExtPred : PatLeaf<(i32 imm), [{
666 int64_t v = (int64_t)N->getSExtValue();
667 if (!Subtarget.hasV4TOps())
668 // Return true if the immediate fits in a 8-bit sign extended field.
674 // Return true if extending this immediate is profitable and the value
675 // can't fit in a 16-bit signed field. This is required to avoid
676 // unnecessary constant extenders.
677 if (isConstExtProfitable(Node) && !isInt<16>(v))
684 def s6ExtPred : PatLeaf<(i32 imm), [{
685 int64_t v = (int64_t)N->getSExtValue();
686 if (!Subtarget.hasV4TOps())
687 // Return true if the immediate can fit in a 6-bit sign extended field.
693 // Return true if extending this immediate is profitable and the value
694 // can fit in a 32-bit unsigned field.
695 if (isConstExtProfitable(Node) && isInt<32>(v))
702 def s6_16ExtPred : PatLeaf<(i32 imm), [{
703 int64_t v = (int64_t)N->getSExtValue();
704 if (!Subtarget.hasV4TOps())
705 // Return true if the immediate fits in a 6-bit sign extended field.
711 // Return true if extending this immediate is profitable and the value
712 // can't fit in a 16-bit signed field. This is required to avoid
713 // unnecessary constant extenders.
714 if (isConstExtProfitable(Node) && !isInt<16>(v))
721 def s6_10ExtPred : PatLeaf<(i32 imm), [{
722 int64_t v = (int64_t)N->getSExtValue();
723 if (!Subtarget.hasV4TOps())
724 // Return true if the immediate can fit in a 6-bit sign extended field.
730 // Return true if extending this immediate is profitable and the value
731 // can't fit in a 10-bit signed field. This is required to avoid
732 // unnecessary constant extenders.
733 if (isConstExtProfitable(Node) && !isInt<10>(v))
740 def s11_0ExtPred : PatLeaf<(i32 imm), [{
741 int64_t v = (int64_t)N->getSExtValue();
742 if (!Subtarget.hasV4TOps())
743 // Return true if the immediate can fit in a 11-bit sign extended field.
744 return isShiftedInt<11,0>(v);
749 // Return true if extending this immediate is profitable and the value
750 // can fit in a 32-bit signed field.
751 if (isConstExtProfitable(Node) && isInt<32>(v))
758 def s11_1ExtPred : PatLeaf<(i32 imm), [{
759 int64_t v = (int64_t)N->getSExtValue();
760 if (!Subtarget.hasV4TOps())
761 // Return true if the immediate can fit in a 12-bit sign extended field and
762 // is 2 byte aligned.
763 return isShiftedInt<11,1>(v);
766 return isShiftedInt<11,1>(v);
768 // Return true if extending this immediate is profitable and the low 1 bit
769 // is zero (2-byte aligned).
770 if (isConstExtProfitable(Node) && isInt<32>(v) && ((v % 2) == 0))
777 def s11_2ExtPred : PatLeaf<(i32 imm), [{
778 int64_t v = (int64_t)N->getSExtValue();
779 if (!Subtarget.hasV4TOps())
780 // Return true if the immediate can fit in a 13-bit sign extended field and
781 // is 4-byte aligned.
782 return isShiftedInt<11,2>(v);
785 return isShiftedInt<11,2>(v);
787 // Return true if extending this immediate is profitable and the low 2-bits
788 // are zero (4-byte aligned).
789 if (isConstExtProfitable(Node) && isInt<32>(v) && ((v % 4) == 0))
796 def s11_3ExtPred : PatLeaf<(i32 imm), [{
797 int64_t v = (int64_t)N->getSExtValue();
798 if (!Subtarget.hasV4TOps())
799 // Return true if the immediate can fit in a 14-bit sign extended field and
800 // is 8-byte aligned.
801 return isShiftedInt<11,3>(v);
804 return isShiftedInt<11,3>(v);
806 // Return true if extending this immediate is profitable and the low 3-bits
807 // are zero (8-byte aligned).
808 if (isConstExtProfitable(Node) && isInt<32>(v) && ((v % 8) == 0))
815 def u6ExtPred : PatLeaf<(i32 imm), [{
816 int64_t v = (int64_t)N->getSExtValue();
817 if (!Subtarget.hasV4TOps())
818 // Return true if the immediate can fit in a 6-bit unsigned field.
824 // Return true if extending this immediate is profitable and the value
825 // can fit in a 32-bit unsigned field.
826 if (isConstExtProfitable(Node) && isUInt<32>(v))
833 def u7ExtPred : PatLeaf<(i32 imm), [{
834 int64_t v = (int64_t)N->getSExtValue();
835 if (!Subtarget.hasV4TOps())
836 // Return true if the immediate can fit in a 7-bit unsigned field.
842 // Return true if extending this immediate is profitable and the value
843 // can fit in a 32-bit unsigned field.
844 if (isConstExtProfitable(Node) && isUInt<32>(v))
851 def u8ExtPred : PatLeaf<(i32 imm), [{
852 int64_t v = (int64_t)N->getSExtValue();
853 if (!Subtarget.hasV4TOps())
854 // Return true if the immediate can fit in a 8-bit unsigned field.
860 // Return true if extending this immediate is profitable and the value
861 // can fit in a 32-bit unsigned field.
862 if (isConstExtProfitable(Node) && isUInt<32>(v))
869 def u9ExtPred : PatLeaf<(i32 imm), [{
870 int64_t v = (int64_t)N->getSExtValue();
871 if (!Subtarget.hasV4TOps())
872 // Return true if the immediate can fit in a 9-bit unsigned field.
878 // Return true if extending this immediate is profitable and the value
879 // can fit in a 32-bit unsigned field.
880 if (isConstExtProfitable(Node) && isUInt<32>(v))
887 def u6_2ExtPred : PatLeaf<(i32 imm), [{
888 int64_t v = (int64_t)N->getSExtValue();
889 if (!Subtarget.hasV4TOps())
890 // Return true if the immediate can fit in a 8-bit unsigned field and
891 // is 4-byte aligned.
892 return isShiftedUInt<6,2>(v);
895 return isShiftedUInt<6,2>(v);
897 // Return true if extending this immediate is profitable and the value
898 // can fit in a 32-bit unsigned field.
899 if (isConstExtProfitable(Node) && isUInt<32>(v) && ((v % 4) == 0))
906 def u6_3ExtPred : PatLeaf<(i32 imm), [{
907 int64_t v = (int64_t)N->getSExtValue();
908 if (!Subtarget.hasV4TOps())
909 // Return true if the immediate can fit in a 9-bit unsigned field and
910 // is 8-byte aligned.
911 return isShiftedUInt<6,3>(v);
914 return isShiftedUInt<6,3>(v);
916 // Return true if extending this immediate is profitable and the value
917 // can fit in a 32-bit unsigned field.
918 if (isConstExtProfitable(Node) && isUInt<32>(v) && ((v % 8) == 0))