OSDN Git Service

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