OSDN Git Service

4f2ff6b7c9f62e342aab74945623828787e3c542
[pf3gnuchains/gcc-fork.git] / gcc / config / i386 / predicates.md
1 ;; Predicate definitions for IA-32 and x86-64.
2 ;; Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3 ;;
4 ;; This file is part of GCC.
5 ;;
6 ;; GCC is free software; you can redistribute it and/or modify
7 ;; it under the terms of the GNU General Public License as published by
8 ;; the Free Software Foundation; either version 3, or (at your option)
9 ;; any later version.
10 ;;
11 ;; GCC is distributed in the hope that it will be useful,
12 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 ;; GNU General Public License for more details.
15 ;;
16 ;; You should have received a copy of the GNU General Public License
17 ;; along with GCC; see the file COPYING3.  If not see
18 ;; <http://www.gnu.org/licenses/>.
19
20 ;; Return nonzero if OP is either a i387 or SSE fp register.
21 (define_predicate "any_fp_register_operand"
22   (and (match_code "reg")
23        (match_test "ANY_FP_REGNO_P (REGNO (op))")))
24
25 ;; Return nonzero if OP is an i387 fp register.
26 (define_predicate "fp_register_operand"
27   (and (match_code "reg")
28        (match_test "FP_REGNO_P (REGNO (op))")))
29
30 ;; Return nonzero if OP is a non-fp register_operand.
31 (define_predicate "register_and_not_any_fp_reg_operand"
32   (and (match_code "reg")
33        (not (match_test "ANY_FP_REGNO_P (REGNO (op))"))))
34
35 ;; Return nonzero if OP is a register operand other than an i387 fp register.
36 (define_predicate "register_and_not_fp_reg_operand"
37   (and (match_code "reg")
38        (not (match_test "FP_REGNO_P (REGNO (op))"))))
39
40 ;; True if the operand is an MMX register.
41 (define_predicate "mmx_reg_operand"
42   (and (match_code "reg")
43        (match_test "MMX_REGNO_P (REGNO (op))")))
44
45 ;; True if the operand is a Q_REGS class register.
46 (define_predicate "q_regs_operand"
47   (match_operand 0 "register_operand")
48 {
49   if (GET_CODE (op) == SUBREG)
50     op = SUBREG_REG (op);
51   return ANY_QI_REG_P (op);
52 })
53
54 ;; Match an SI or HImode register for a zero_extract.
55 (define_special_predicate "ext_register_operand"
56   (match_operand 0 "register_operand")
57 {
58   if ((!TARGET_64BIT || GET_MODE (op) != DImode)
59       && GET_MODE (op) != SImode && GET_MODE (op) != HImode)
60     return 0;
61   if (GET_CODE (op) == SUBREG)
62     op = SUBREG_REG (op);
63
64   /* Be careful to accept only registers having upper parts.  */
65   return REGNO (op) > LAST_VIRTUAL_REGISTER || REGNO (op) < 4;
66 })
67
68 ;; Return true if op is the AX register.
69 (define_predicate "ax_reg_operand"
70   (and (match_code "reg")
71        (match_test "REGNO (op) == 0")))
72
73 ;; Return true if op is the flags register.
74 (define_predicate "flags_reg_operand"
75   (and (match_code "reg")
76        (match_test "REGNO (op) == FLAGS_REG")))
77
78 ;; Return true if op is not xmm0 register.
79 (define_predicate "reg_not_xmm0_operand"
80    (and (match_operand 0 "register_operand")
81         (match_test "GET_CODE (op) != REG
82                      || REGNO (op) != FIRST_SSE_REG")))
83
84 ;; As above, but allow nonimmediate operands.
85 (define_predicate "nonimm_not_xmm0_operand"
86    (and (match_operand 0 "nonimmediate_operand")
87         (match_test "GET_CODE (op) != REG
88                      || REGNO (op) != FIRST_SSE_REG")))
89
90 ;; Return 1 if VALUE can be stored in a sign extended immediate field.
91 (define_predicate "x86_64_immediate_operand"
92   (match_code "const_int,symbol_ref,label_ref,const")
93 {
94   if (!TARGET_64BIT)
95     return immediate_operand (op, mode);
96
97   switch (GET_CODE (op))
98     {
99     case CONST_INT:
100       /* CONST_DOUBLES never match, since HOST_BITS_PER_WIDE_INT is known
101          to be at least 32 and this all acceptable constants are
102          represented as CONST_INT.  */
103       if (HOST_BITS_PER_WIDE_INT == 32)
104         return 1;
105       else
106         {
107           HOST_WIDE_INT val = trunc_int_for_mode (INTVAL (op), DImode);
108           return trunc_int_for_mode (val, SImode) == val;
109         }
110       break;
111
112     case SYMBOL_REF:
113       /* For certain code models, the symbolic references are known to fit.
114          in CM_SMALL_PIC model we know it fits if it is local to the shared
115          library.  Don't count TLS SYMBOL_REFs here, since they should fit
116          only if inside of UNSPEC handled below.  */
117       /* TLS symbols are not constant.  */
118       if (SYMBOL_REF_TLS_MODEL (op))
119         return false;
120       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
121               || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
122
123     case LABEL_REF:
124       /* For certain code models, the code is near as well.  */
125       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
126               || ix86_cmodel == CM_KERNEL);
127
128     case CONST:
129       /* We also may accept the offsetted memory references in certain
130          special cases.  */
131       if (GET_CODE (XEXP (op, 0)) == UNSPEC)
132         switch (XINT (XEXP (op, 0), 1))
133           {
134           case UNSPEC_GOTPCREL:
135           case UNSPEC_DTPOFF:
136           case UNSPEC_GOTNTPOFF:
137           case UNSPEC_NTPOFF:
138             return 1;
139           default:
140             break;
141           }
142
143       if (GET_CODE (XEXP (op, 0)) == PLUS)
144         {
145           rtx op1 = XEXP (XEXP (op, 0), 0);
146           rtx op2 = XEXP (XEXP (op, 0), 1);
147           HOST_WIDE_INT offset;
148
149           if (ix86_cmodel == CM_LARGE)
150             return 0;
151           if (!CONST_INT_P (op2))
152             return 0;
153           offset = trunc_int_for_mode (INTVAL (op2), DImode);
154           switch (GET_CODE (op1))
155             {
156             case SYMBOL_REF:
157               /* TLS symbols are not constant.  */
158               if (SYMBOL_REF_TLS_MODEL (op1))
159                 return 0;
160               /* For CM_SMALL assume that latest object is 16MB before
161                  end of 31bits boundary.  We may also accept pretty
162                  large negative constants knowing that all objects are
163                  in the positive half of address space.  */
164               if ((ix86_cmodel == CM_SMALL
165                    || (ix86_cmodel == CM_MEDIUM
166                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
167                   && offset < 16*1024*1024
168                   && trunc_int_for_mode (offset, SImode) == offset)
169                 return 1;
170               /* For CM_KERNEL we know that all object resist in the
171                  negative half of 32bits address space.  We may not
172                  accept negative offsets, since they may be just off
173                  and we may accept pretty large positive ones.  */
174               if (ix86_cmodel == CM_KERNEL
175                   && offset > 0
176                   && trunc_int_for_mode (offset, SImode) == offset)
177                 return 1;
178               break;
179
180             case LABEL_REF:
181               /* These conditions are similar to SYMBOL_REF ones, just the
182                  constraints for code models differ.  */
183               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
184                   && offset < 16*1024*1024
185                   && trunc_int_for_mode (offset, SImode) == offset)
186                 return 1;
187               if (ix86_cmodel == CM_KERNEL
188                   && offset > 0
189                   && trunc_int_for_mode (offset, SImode) == offset)
190                 return 1;
191               break;
192
193             case UNSPEC:
194               switch (XINT (op1, 1))
195                 {
196                 case UNSPEC_DTPOFF:
197                 case UNSPEC_NTPOFF:
198                   if (offset > 0
199                       && trunc_int_for_mode (offset, SImode) == offset)
200                     return 1;
201                 }
202               break;
203
204             default:
205               break;
206             }
207         }
208       break;
209
210       default:
211         gcc_unreachable ();
212     }
213
214   return 0;
215 })
216
217 ;; Return 1 if VALUE can be stored in the zero extended immediate field.
218 (define_predicate "x86_64_zext_immediate_operand"
219   (match_code "const_double,const_int,symbol_ref,label_ref,const")
220 {
221   switch (GET_CODE (op))
222     {
223     case CONST_DOUBLE:
224       if (HOST_BITS_PER_WIDE_INT == 32)
225         return (GET_MODE (op) == VOIDmode && !CONST_DOUBLE_HIGH (op));
226       else
227         return 0;
228
229     case CONST_INT:
230       if (HOST_BITS_PER_WIDE_INT == 32)
231         return INTVAL (op) >= 0;
232       else
233         return !(INTVAL (op) & ~(HOST_WIDE_INT) 0xffffffff);
234
235     case SYMBOL_REF:
236       /* For certain code models, the symbolic references are known to fit.  */
237       /* TLS symbols are not constant.  */
238       if (SYMBOL_REF_TLS_MODEL (op))
239         return false;
240       return (ix86_cmodel == CM_SMALL
241               || (ix86_cmodel == CM_MEDIUM
242                   && !SYMBOL_REF_FAR_ADDR_P (op)));
243
244     case LABEL_REF:
245       /* For certain code models, the code is near as well.  */
246       return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
247
248     case CONST:
249       /* We also may accept the offsetted memory references in certain
250          special cases.  */
251       if (GET_CODE (XEXP (op, 0)) == PLUS)
252         {
253           rtx op1 = XEXP (XEXP (op, 0), 0);
254           rtx op2 = XEXP (XEXP (op, 0), 1);
255
256           if (ix86_cmodel == CM_LARGE)
257             return 0;
258           switch (GET_CODE (op1))
259             {
260             case SYMBOL_REF:
261               /* TLS symbols are not constant.  */
262               if (SYMBOL_REF_TLS_MODEL (op1))
263                 return 0;
264               /* For small code model we may accept pretty large positive
265                  offsets, since one bit is available for free.  Negative
266                  offsets are limited by the size of NULL pointer area
267                  specified by the ABI.  */
268               if ((ix86_cmodel == CM_SMALL
269                    || (ix86_cmodel == CM_MEDIUM
270                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
271                   && CONST_INT_P (op2)
272                   && trunc_int_for_mode (INTVAL (op2), DImode) > -0x10000
273                   && trunc_int_for_mode (INTVAL (op2), SImode) == INTVAL (op2))
274                 return 1;
275               /* ??? For the kernel, we may accept adjustment of
276                  -0x10000000, since we know that it will just convert
277                  negative address space to positive, but perhaps this
278                  is not worthwhile.  */
279               break;
280
281             case LABEL_REF:
282               /* These conditions are similar to SYMBOL_REF ones, just the
283                  constraints for code models differ.  */
284               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
285                   && CONST_INT_P (op2)
286                   && trunc_int_for_mode (INTVAL (op2), DImode) > -0x10000
287                   && trunc_int_for_mode (INTVAL (op2), SImode) == INTVAL (op2))
288                 return 1;
289               break;
290
291             default:
292               return 0;
293             }
294         }
295       break;
296
297     default:
298       gcc_unreachable ();
299     }
300   return 0;
301 })
302
303 ;; Return nonzero if OP is general operand representable on x86_64.
304 (define_predicate "x86_64_general_operand"
305   (if_then_else (match_test "TARGET_64BIT")
306     (ior (match_operand 0 "nonimmediate_operand")
307          (match_operand 0 "x86_64_immediate_operand"))
308     (match_operand 0 "general_operand")))
309
310 ;; Return nonzero if OP is general operand representable on x86_64
311 ;; as either sign extended or zero extended constant.
312 (define_predicate "x86_64_szext_general_operand"
313   (if_then_else (match_test "TARGET_64BIT")
314     (ior (match_operand 0 "nonimmediate_operand")
315          (ior (match_operand 0 "x86_64_immediate_operand")
316               (match_operand 0 "x86_64_zext_immediate_operand")))
317     (match_operand 0 "general_operand")))
318
319 ;; Return nonzero if OP is nonmemory operand representable on x86_64.
320 (define_predicate "x86_64_nonmemory_operand"
321   (if_then_else (match_test "TARGET_64BIT")
322     (ior (match_operand 0 "register_operand")
323          (match_operand 0 "x86_64_immediate_operand"))
324     (match_operand 0 "nonmemory_operand")))
325
326 ;; Return nonzero if OP is nonmemory operand representable on x86_64.
327 (define_predicate "x86_64_szext_nonmemory_operand"
328   (if_then_else (match_test "TARGET_64BIT")
329     (ior (match_operand 0 "register_operand")
330          (ior (match_operand 0 "x86_64_immediate_operand")
331               (match_operand 0 "x86_64_zext_immediate_operand")))
332     (match_operand 0 "nonmemory_operand")))
333
334 ;; Return true when operand is PIC expression that can be computed by lea
335 ;; operation.
336 (define_predicate "pic_32bit_operand"
337   (match_code "const,symbol_ref,label_ref")
338 {
339   if (!flag_pic)
340     return 0;
341   /* Rule out relocations that translate into 64bit constants.  */
342   if (TARGET_64BIT && GET_CODE (op) == CONST)
343     {
344       op = XEXP (op, 0);
345       if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
346         op = XEXP (op, 0);
347       if (GET_CODE (op) == UNSPEC
348           && (XINT (op, 1) == UNSPEC_GOTOFF
349               || XINT (op, 1) == UNSPEC_GOT))
350         return 0;
351     }
352   return symbolic_operand (op, mode);
353 })
354
355
356 ;; Return nonzero if OP is nonmemory operand acceptable by movabs patterns.
357 (define_predicate "x86_64_movabs_operand"
358   (if_then_else (match_test "!TARGET_64BIT || !flag_pic")
359     (match_operand 0 "nonmemory_operand")
360     (ior (match_operand 0 "register_operand")
361          (and (match_operand 0 "const_double_operand")
362               (match_test "GET_MODE_SIZE (mode) <= 8")))))
363
364 ;; Returns nonzero if OP is either a symbol reference or a sum of a symbol
365 ;; reference and a constant.
366 (define_predicate "symbolic_operand"
367   (match_code "symbol_ref,label_ref,const")
368 {
369   switch (GET_CODE (op))
370     {
371     case SYMBOL_REF:
372     case LABEL_REF:
373       return 1;
374
375     case CONST:
376       op = XEXP (op, 0);
377       if (GET_CODE (op) == SYMBOL_REF
378           || GET_CODE (op) == LABEL_REF
379           || (GET_CODE (op) == UNSPEC
380               && (XINT (op, 1) == UNSPEC_GOT
381                   || XINT (op, 1) == UNSPEC_GOTOFF
382                   || XINT (op, 1) == UNSPEC_GOTPCREL)))
383         return 1;
384       if (GET_CODE (op) != PLUS
385           || !CONST_INT_P (XEXP (op, 1)))
386         return 0;
387
388       op = XEXP (op, 0);
389       if (GET_CODE (op) == SYMBOL_REF
390           || GET_CODE (op) == LABEL_REF)
391         return 1;
392       /* Only @GOTOFF gets offsets.  */
393       if (GET_CODE (op) != UNSPEC
394           || XINT (op, 1) != UNSPEC_GOTOFF)
395         return 0;
396
397       op = XVECEXP (op, 0, 0);
398       if (GET_CODE (op) == SYMBOL_REF
399           || GET_CODE (op) == LABEL_REF)
400         return 1;
401       return 0;
402
403     default:
404       gcc_unreachable ();
405     }
406 })
407
408 ;; Return true if the operand contains a @GOT or @GOTOFF reference.
409 (define_predicate "pic_symbolic_operand"
410   (match_code "const")
411 {
412   op = XEXP (op, 0);
413   if (TARGET_64BIT)
414     {
415       if (GET_CODE (op) == UNSPEC
416           && XINT (op, 1) == UNSPEC_GOTPCREL)
417         return 1;
418       if (GET_CODE (op) == PLUS
419           && GET_CODE (XEXP (op, 0)) == UNSPEC
420           && XINT (XEXP (op, 0), 1) == UNSPEC_GOTPCREL)
421         return 1;
422     }
423   else
424     {
425       if (GET_CODE (op) == UNSPEC)
426         return 1;
427       if (GET_CODE (op) != PLUS
428           || !CONST_INT_P (XEXP (op, 1)))
429         return 0;
430       op = XEXP (op, 0);
431       if (GET_CODE (op) == UNSPEC)
432         return 1;
433     }
434   return 0;
435 })
436
437 ;; Return true if OP is a symbolic operand that resolves locally.
438 (define_predicate "local_symbolic_operand"
439   (match_code "const,label_ref,symbol_ref")
440 {
441   if (GET_CODE (op) == CONST
442       && GET_CODE (XEXP (op, 0)) == PLUS
443       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
444     op = XEXP (XEXP (op, 0), 0);
445
446   if (GET_CODE (op) == LABEL_REF)
447     return 1;
448
449   if (GET_CODE (op) != SYMBOL_REF)
450     return 0;
451
452   if (SYMBOL_REF_TLS_MODEL (op) != 0)
453     return 0;
454
455   if (SYMBOL_REF_LOCAL_P (op))
456     return 1;
457
458   /* There is, however, a not insubstantial body of code in the rest of
459      the compiler that assumes it can just stick the results of
460      ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done.  */
461   /* ??? This is a hack.  Should update the body of the compiler to
462      always create a DECL an invoke targetm.encode_section_info.  */
463   if (strncmp (XSTR (op, 0), internal_label_prefix,
464                internal_label_prefix_len) == 0)
465     return 1;
466
467   return 0;
468 })
469
470 ;; Test for a legitimate @GOTOFF operand.
471 ;;
472 ;; VxWorks does not impose a fixed gap between segments; the run-time
473 ;; gap can be different from the object-file gap.  We therefore can't
474 ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
475 ;; same segment as the GOT.  Unfortunately, the flexibility of linker
476 ;; scripts means that we can't be sure of that in general, so assume
477 ;; that @GOTOFF is never valid on VxWorks.
478 (define_predicate "gotoff_operand"
479   (and (match_test "!TARGET_VXWORKS_RTP")
480        (match_operand 0 "local_symbolic_operand")))
481
482 ;; Test for various thread-local symbols.
483 (define_predicate "tls_symbolic_operand"
484   (and (match_code "symbol_ref")
485        (match_test "SYMBOL_REF_TLS_MODEL (op) != 0")))
486
487 (define_predicate "tls_modbase_operand"
488   (and (match_code "symbol_ref")
489        (match_test "op == ix86_tls_module_base ()")))
490
491 (define_predicate "tp_or_register_operand"
492   (ior (match_operand 0 "register_operand")
493        (and (match_code "unspec")
494             (match_test "XINT (op, 1) == UNSPEC_TP"))))
495
496 ;; Test for a pc-relative call operand
497 (define_predicate "constant_call_address_operand"
498   (match_code "symbol_ref")
499 {
500   if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC)
501     return false;
502   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
503     return false;
504   return true;
505 })
506
507 ;; True for any non-virtual or eliminable register.  Used in places where
508 ;; instantiation of such a register may cause the pattern to not be recognized.
509 (define_predicate "register_no_elim_operand"
510   (match_operand 0 "register_operand")
511 {
512   if (GET_CODE (op) == SUBREG)
513     op = SUBREG_REG (op);
514   return !(op == arg_pointer_rtx
515            || op == frame_pointer_rtx
516            || IN_RANGE (REGNO (op),
517                         FIRST_PSEUDO_REGISTER, LAST_VIRTUAL_REGISTER));
518 })
519
520 ;; Similarly, but include the stack pointer.  This is used to prevent esp
521 ;; from being used as an index reg.
522 (define_predicate "index_register_operand"
523   (match_operand 0 "register_operand")
524 {
525   if (GET_CODE (op) == SUBREG)
526     op = SUBREG_REG (op);
527   if (reload_in_progress || reload_completed)
528     return REG_OK_FOR_INDEX_STRICT_P (op);
529   else
530     return REG_OK_FOR_INDEX_NONSTRICT_P (op);
531 })
532
533 ;; Return false if this is any eliminable register.  Otherwise general_operand.
534 (define_predicate "general_no_elim_operand"
535   (if_then_else (match_code "reg,subreg")
536     (match_operand 0 "register_no_elim_operand")
537     (match_operand 0 "general_operand")))
538
539 ;; Return false if this is any eliminable register.  Otherwise
540 ;; register_operand or a constant.
541 (define_predicate "nonmemory_no_elim_operand"
542   (ior (match_operand 0 "register_no_elim_operand")
543        (match_operand 0 "immediate_operand")))
544
545 ;; Test for a valid operand for a call instruction.
546 (define_predicate "call_insn_operand"
547   (ior (match_operand 0 "constant_call_address_operand")
548        (ior (match_operand 0 "register_no_elim_operand")
549             (match_operand 0 "memory_operand"))))
550
551 ;; Similarly, but for tail calls, in which we cannot allow memory references.
552 (define_predicate "sibcall_insn_operand"
553   (ior (match_operand 0 "constant_call_address_operand")
554        (match_operand 0 "register_no_elim_operand")))
555
556 ;; Match exactly zero.
557 (define_predicate "const0_operand"
558   (match_code "const_int,const_double,const_vector")
559 {
560   if (mode == VOIDmode)
561     mode = GET_MODE (op);
562   return op == CONST0_RTX (mode);
563 })
564
565 ;; Match exactly one.
566 (define_predicate "const1_operand"
567   (and (match_code "const_int")
568        (match_test "op == const1_rtx")))
569
570 ;; Match exactly eight.
571 (define_predicate "const8_operand"
572   (and (match_code "const_int")
573        (match_test "INTVAL (op) == 8")))
574
575 ;; Match 2, 4, or 8.  Used for leal multiplicands.
576 (define_predicate "const248_operand"
577   (match_code "const_int")
578 {
579   HOST_WIDE_INT i = INTVAL (op);
580   return i == 2 || i == 4 || i == 8;
581 })
582
583 ;; Match 0 or 1.
584 (define_predicate "const_0_to_1_operand"
585   (and (match_code "const_int")
586        (match_test "op == const0_rtx || op == const1_rtx")))
587
588 ;; Match 0 to 3.
589 (define_predicate "const_0_to_3_operand"
590   (and (match_code "const_int")
591        (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
592
593 ;; Match 0 to 7.
594 (define_predicate "const_0_to_7_operand"
595   (and (match_code "const_int")
596        (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
597
598 ;; Match 0 to 15.
599 (define_predicate "const_0_to_15_operand"
600   (and (match_code "const_int")
601        (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
602
603 ;; Match 0 to 31.
604 (define_predicate "const_0_to_31_operand"
605   (and (match_code "const_int")
606        (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
607
608 ;; Match 0 to 63.
609 (define_predicate "const_0_to_63_operand"
610   (and (match_code "const_int")
611        (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
612
613 ;; Match 0 to 255.
614 (define_predicate "const_0_to_255_operand"
615   (and (match_code "const_int")
616        (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
617
618 ;; Match (0 to 255) * 8
619 (define_predicate "const_0_to_255_mul_8_operand"
620   (match_code "const_int")
621 {
622   unsigned HOST_WIDE_INT val = INTVAL (op);
623   return val <= 255*8 && val % 8 == 0;
624 })
625
626 ;; Return nonzero if OP is CONST_INT >= 1 and <= 31 (a valid operand
627 ;; for shift & compare patterns, as shifting by 0 does not change flags).
628 (define_predicate "const_1_to_31_operand"
629   (and (match_code "const_int")
630        (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
631
632 ;; Match 2 or 3.
633 (define_predicate "const_2_to_3_operand"
634   (and (match_code "const_int")
635        (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
636
637 ;; Match 4 to 7.
638 (define_predicate "const_4_to_7_operand"
639   (and (match_code "const_int")
640        (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
641
642 ;; Match exactly one bit in 2-bit mask.
643 (define_predicate "const_pow2_1_to_2_operand"
644   (and (match_code "const_int")
645        (match_test "INTVAL (op) == 1 || INTVAL (op) == 2")))
646
647 ;; Match exactly one bit in 4-bit mask.
648 (define_predicate "const_pow2_1_to_8_operand"
649   (match_code "const_int")
650 {
651   unsigned int log = exact_log2 (INTVAL (op));
652   return log <= 3;
653 })
654
655 ;; Match exactly one bit in 8-bit mask.
656 (define_predicate "const_pow2_1_to_128_operand"
657   (match_code "const_int")
658 {
659   unsigned int log = exact_log2 (INTVAL (op));
660   return log <= 7;
661 })
662
663 ;; Match exactly one bit in 16-bit mask.
664 (define_predicate "const_pow2_1_to_32768_operand"
665   (match_code "const_int")
666 {
667   unsigned int log = exact_log2 (INTVAL (op));
668   return log <= 15;
669 })
670
671 ;; True if this is a constant appropriate for an increment or decrement.
672 (define_predicate "incdec_operand"
673   (match_code "const_int")
674 {
675   /* On Pentium4, the inc and dec operations causes extra dependency on flag
676      registers, since carry flag is not set.  */
677   if (!TARGET_USE_INCDEC && !optimize_size)
678     return 0;
679   return op == const1_rtx || op == constm1_rtx;
680 })
681
682 ;; True for registers, or 1 or -1.  Used to optimize double-word shifts.
683 (define_predicate "reg_or_pm1_operand"
684   (ior (match_operand 0 "register_operand")
685        (and (match_code "const_int")
686             (match_test "op == const1_rtx || op == constm1_rtx"))))
687
688 ;; True if OP is acceptable as operand of DImode shift expander.
689 (define_predicate "shiftdi_operand"
690   (if_then_else (match_test "TARGET_64BIT")
691     (match_operand 0 "nonimmediate_operand")
692     (match_operand 0 "register_operand")))
693
694 (define_predicate "ashldi_input_operand"
695   (if_then_else (match_test "TARGET_64BIT")
696     (match_operand 0 "nonimmediate_operand")
697     (match_operand 0 "reg_or_pm1_operand")))
698
699 ;; Return true if OP is a vector load from the constant pool with just
700 ;; the first element nonzero.
701 (define_predicate "zero_extended_scalar_load_operand"
702   (match_code "mem")
703 {
704   unsigned n_elts;
705   op = maybe_get_pool_constant (op);
706   if (!op)
707     return 0;
708   if (GET_CODE (op) != CONST_VECTOR)
709     return 0;
710   n_elts =
711     (GET_MODE_SIZE (GET_MODE (op)) /
712      GET_MODE_SIZE (GET_MODE_INNER (GET_MODE (op))));
713   for (n_elts--; n_elts > 0; n_elts--)
714     {
715       rtx elt = CONST_VECTOR_ELT (op, n_elts);
716       if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
717         return 0;
718     }
719   return 1;
720 })
721
722 /* Return true if operand is a vector constant that is all ones. */
723 (define_predicate "vector_all_ones_operand"
724   (match_code "const_vector")
725 {
726   int nunits = GET_MODE_NUNITS (mode);
727
728   if (GET_CODE (op) == CONST_VECTOR
729       && CONST_VECTOR_NUNITS (op) == nunits)
730     {
731       int i;
732       for (i = 0; i < nunits; ++i)
733         {
734           rtx x = CONST_VECTOR_ELT (op, i);
735           if (x != constm1_rtx)
736             return 0;
737         }
738       return 1;
739     }
740
741   return 0;
742 })
743
744 ; Return 1 when OP is operand acceptable for standard SSE move.
745 (define_predicate "vector_move_operand"
746   (ior (match_operand 0 "nonimmediate_operand")
747        (match_operand 0 "const0_operand")))
748
749 ;; Return 1 when OP is nonimmediate or standard SSE constant.
750 (define_predicate "nonimmediate_or_sse_const_operand"
751   (match_operand 0 "general_operand")
752 {
753   if (nonimmediate_operand (op, mode))
754     return 1;
755   if (standard_sse_constant_p (op) > 0)
756     return 1;
757   return 0;
758 })
759
760 ;; Return true if OP is a register or a zero.
761 (define_predicate "reg_or_0_operand"
762   (ior (match_operand 0 "register_operand")
763        (match_operand 0 "const0_operand")))
764
765 ;; Return true if op if a valid address, and does not contain
766 ;; a segment override.
767 (define_special_predicate "no_seg_address_operand"
768   (match_operand 0 "address_operand")
769 {
770   struct ix86_address parts;
771   int ok;
772
773   ok = ix86_decompose_address (op, &parts);
774   gcc_assert (ok);
775   return parts.seg == SEG_DEFAULT;
776 })
777
778 ;; Return nonzero if the rtx is known to be at least 32 bits aligned.
779 (define_predicate "aligned_operand"
780   (match_operand 0 "general_operand")
781 {
782   struct ix86_address parts;
783   int ok;
784
785   /* Registers and immediate operands are always "aligned".  */
786   if (GET_CODE (op) != MEM)
787     return 1;
788
789   /* All patterns using aligned_operand on memory operands ends up
790      in promoting memory operand to 64bit and thus causing memory mismatch.  */
791   if (TARGET_MEMORY_MISMATCH_STALL && !optimize_size)
792     return 0;
793
794   /* Don't even try to do any aligned optimizations with volatiles.  */
795   if (MEM_VOLATILE_P (op))
796     return 0;
797
798   if (MEM_ALIGN (op) >= 32)
799     return 1;
800
801   op = XEXP (op, 0);
802
803   /* Pushes and pops are only valid on the stack pointer.  */
804   if (GET_CODE (op) == PRE_DEC
805       || GET_CODE (op) == POST_INC)
806     return 1;
807
808   /* Decode the address.  */
809   ok = ix86_decompose_address (op, &parts);
810   gcc_assert (ok);
811
812   /* Look for some component that isn't known to be aligned.  */
813   if (parts.index)
814     {
815       if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
816         return 0;
817     }
818   if (parts.base)
819     {
820       if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
821         return 0;
822     }
823   if (parts.disp)
824     {
825       if (!CONST_INT_P (parts.disp)
826           || (INTVAL (parts.disp) & 3) != 0)
827         return 0;
828     }
829
830   /* Didn't find one -- this must be an aligned address.  */
831   return 1;
832 })
833
834 ;; Returns 1 if OP is memory operand with a displacement.
835 (define_predicate "memory_displacement_operand"
836   (match_operand 0 "memory_operand")
837 {
838   struct ix86_address parts;
839   int ok;
840
841   ok = ix86_decompose_address (XEXP (op, 0), &parts);
842   gcc_assert (ok);
843   return parts.disp != NULL_RTX;
844 })
845
846 ;; Returns 1 if OP is memory operand with a displacement only.
847 (define_predicate "memory_displacement_only_operand"
848   (match_operand 0 "memory_operand")
849 {
850   struct ix86_address parts;
851   int ok;
852
853   ok = ix86_decompose_address (XEXP (op, 0), &parts);
854   gcc_assert (ok);
855
856   if (parts.base || parts.index)
857     return 0;
858
859   return parts.disp != NULL_RTX;
860 })
861
862 ;; Returns 1 if OP is memory operand that cannot be represented
863 ;; by the modRM array.
864 (define_predicate "long_memory_operand"
865   (and (match_operand 0 "memory_operand")
866        (match_test "memory_address_length (op) != 0")))
867
868 ;; Return 1 if OP is a comparison operator that can be issued by fcmov.
869 (define_predicate "fcmov_comparison_operator"
870   (match_operand 0 "comparison_operator")
871 {
872   enum machine_mode inmode = GET_MODE (XEXP (op, 0));
873   enum rtx_code code = GET_CODE (op);
874
875   if (inmode == CCFPmode || inmode == CCFPUmode)
876     {
877       enum rtx_code second_code, bypass_code;
878       ix86_fp_comparison_codes (code, &bypass_code, &code, &second_code);
879       if (bypass_code != UNKNOWN || second_code != UNKNOWN)
880         return 0;
881       code = ix86_fp_compare_code_to_integer (code);
882     }
883   /* i387 supports just limited amount of conditional codes.  */
884   switch (code)
885     {
886     case LTU: case GTU: case LEU: case GEU:
887       if (inmode == CCmode || inmode == CCFPmode || inmode == CCFPUmode
888           || inmode == CCCmode)
889         return 1;
890       return 0;
891     case ORDERED: case UNORDERED:
892     case EQ: case NE:
893       return 1;
894     default:
895       return 0;
896     }
897 })
898
899 ;; Return 1 if OP is a comparison that can be used in the CMPSS/CMPPS insns.
900 ;; The first set are supported directly; the second set can't be done with
901 ;; full IEEE support, i.e. NaNs.
902 ;;
903 ;; ??? It would seem that we have a lot of uses of this predicate that pass
904 ;; it the wrong mode.  We got away with this because the old function didn't
905 ;; check the mode at all.  Mirror that for now by calling this a special
906 ;; predicate.
907
908 (define_special_predicate "sse_comparison_operator"
909   (match_code "eq,lt,le,unordered,ne,unge,ungt,ordered"))
910
911 ;; Return 1 if OP is a comparison operator that can be issued by sse predicate
912 ;; generation instructions
913 (define_predicate "sse5_comparison_float_operator"
914   (and (match_test "TARGET_SSE5")
915        (match_code "ne,eq,ge,gt,le,lt,unordered,ordered,uneq,unge,ungt,unle,unlt,ltgt")))
916
917 (define_predicate "ix86_comparison_int_operator"
918   (match_code "ne,eq,ge,gt,le,lt"))
919
920 (define_predicate "ix86_comparison_uns_operator"
921   (match_code "ne,eq,geu,gtu,leu,ltu"))
922
923 (define_predicate "bt_comparison_operator"
924   (match_code "ne,eq"))
925
926 ;; Return 1 if OP is a valid comparison operator in valid mode.
927 (define_predicate "ix86_comparison_operator"
928   (match_operand 0 "comparison_operator")
929 {
930   enum machine_mode inmode = GET_MODE (XEXP (op, 0));
931   enum rtx_code code = GET_CODE (op);
932
933   if (inmode == CCFPmode || inmode == CCFPUmode)
934     {
935       enum rtx_code second_code, bypass_code;
936       ix86_fp_comparison_codes (code, &bypass_code, &code, &second_code);
937       return (bypass_code == UNKNOWN && second_code == UNKNOWN);
938     }
939   switch (code)
940     {
941     case EQ: case NE:
942       return 1;
943     case LT: case GE:
944       if (inmode == CCmode || inmode == CCGCmode
945           || inmode == CCGOCmode || inmode == CCNOmode)
946         return 1;
947       return 0;
948     case LTU: case GTU: case LEU: case GEU:
949       if (inmode == CCmode || inmode == CCCmode)
950         return 1;
951       return 0;
952     case ORDERED: case UNORDERED:
953       if (inmode == CCmode)
954         return 1;
955       return 0;
956     case GT: case LE:
957       if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
958         return 1;
959       return 0;
960     default:
961       return 0;
962     }
963 })
964
965 ;; Return 1 if OP is a valid comparison operator testing carry flag to be set.
966 (define_predicate "ix86_carry_flag_operator"
967   (match_code "ltu,lt,unlt,gtu,gt,ungt,le,unle,ge,unge,ltgt,uneq")
968 {
969   enum machine_mode inmode = GET_MODE (XEXP (op, 0));
970   enum rtx_code code = GET_CODE (op);
971
972   if (!REG_P (XEXP (op, 0))
973       || REGNO (XEXP (op, 0)) != FLAGS_REG
974       || XEXP (op, 1) != const0_rtx)
975     return 0;
976
977   if (inmode == CCFPmode || inmode == CCFPUmode)
978     {
979       enum rtx_code second_code, bypass_code;
980       ix86_fp_comparison_codes (code, &bypass_code, &code, &second_code);
981       if (bypass_code != UNKNOWN || second_code != UNKNOWN)
982         return 0;
983       code = ix86_fp_compare_code_to_integer (code);
984     }
985   else if (inmode == CCCmode)
986    return code == LTU || code == GTU;
987   else if (inmode != CCmode)
988     return 0;
989
990   return code == LTU;
991 })
992
993 ;; Nearly general operand, but accept any const_double, since we wish
994 ;; to be able to drop them into memory rather than have them get pulled
995 ;; into registers.
996 (define_predicate "cmp_fp_expander_operand"
997   (ior (match_code "const_double")
998        (match_operand 0 "general_operand")))
999
1000 ;; Return true if this is a valid binary floating-point operation.
1001 (define_predicate "binary_fp_operator"
1002   (match_code "plus,minus,mult,div"))
1003
1004 ;; Return true if this is a multiply operation.
1005 (define_predicate "mult_operator"
1006   (match_code "mult"))
1007
1008 ;; Return true if this is a division operation.
1009 (define_predicate "div_operator"
1010   (match_code "div"))
1011
1012 ;; Return true if this is a float extend operation.
1013 (define_predicate "float_operator"
1014   (match_code "float"))
1015
1016 ;; Return true for ARITHMETIC_P.
1017 (define_predicate "arith_or_logical_operator"
1018   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
1019                mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
1020
1021 ;; Return 1 if OP is a binary operator that can be promoted to wider mode.
1022 (define_predicate "promotable_binary_operator"
1023   (ior (match_code "plus,and,ior,xor,ashift")
1024        (and (match_code "mult")
1025             (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
1026
1027 ;; To avoid problems when jump re-emits comparisons like testqi_ext_ccno_0,
1028 ;; re-recognize the operand to avoid a copy_to_mode_reg that will fail.
1029 ;;
1030 ;; ??? It seems likely that this will only work because cmpsi is an
1031 ;; expander, and no actual insns use this.
1032
1033 (define_predicate "cmpsi_operand"
1034   (ior (match_operand 0 "nonimmediate_operand")
1035        (and (match_code "and")
1036             (match_code "zero_extract" "0")
1037             (match_code "const_int"    "1")
1038             (match_code "const_int"    "01")
1039             (match_code "const_int"    "02")
1040             (match_test "INTVAL (XEXP (XEXP (op, 0), 1)) == 8")
1041             (match_test "INTVAL (XEXP (XEXP (op, 0), 2)) == 8")
1042        )))
1043
1044 (define_predicate "compare_operator"
1045   (match_code "compare"))
1046
1047 (define_predicate "absneg_operator"
1048   (match_code "abs,neg"))
1049
1050 ;; Return 1 if OP is misaligned memory operand
1051 (define_predicate "misaligned_operand"
1052   (and (match_code "mem")
1053        (match_test "MEM_ALIGN (op) < GET_MODE_ALIGNMENT (mode)")))