OSDN Git Service

2009-09-29 Steve Ellcey <sje@cup.hp.com>
[pf3gnuchains/gcc-fork.git] / gcc / config / ia64 / predicates.md
1 ;; Predicate definitions for IA-64.
2 ;; Copyright (C) 2004, 2005, 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 ;; True if OP is a valid operand for the MEM of a CALL insn.
21 (define_predicate "call_operand"
22   (ior (match_code "symbol_ref")
23        (match_operand 0 "register_operand")))
24
25 ;; True if OP refers to any kind of symbol.
26 ;; For roughly the same reasons that pmode_register_operand exists, this
27 ;; predicate ignores its mode argument.
28 (define_special_predicate "symbolic_operand" 
29    (match_code "symbol_ref,const,label_ref"))
30
31 ;; True if OP is a SYMBOL_REF which refers to a function.
32 (define_predicate "function_operand"
33   (and (match_code "symbol_ref")
34        (match_test "SYMBOL_REF_FUNCTION_P (op)")))
35
36 ;; True if OP refers to a symbol in the sdata section.
37 (define_predicate "sdata_symbolic_operand" 
38   (match_code "symbol_ref,const")
39 {
40   HOST_WIDE_INT offset = 0, size = 0;
41
42   switch (GET_CODE (op))
43     {
44     case CONST:
45       op = XEXP (op, 0);
46       if (GET_CODE (op) != PLUS
47           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
48           || GET_CODE (XEXP (op, 1)) != CONST_INT)
49         return false;
50       offset = INTVAL (XEXP (op, 1));
51       op = XEXP (op, 0);
52       /* FALLTHRU */
53
54     case SYMBOL_REF:
55       if (CONSTANT_POOL_ADDRESS_P (op))
56         {
57           size = GET_MODE_SIZE (get_pool_mode (op));
58           if (size > ia64_section_threshold)
59             return false;
60         }
61       else
62         {
63           tree t;
64
65           if (!SYMBOL_REF_LOCAL_P (op) || !SYMBOL_REF_SMALL_P (op))
66             return false;
67
68           /* Note that in addition to DECLs, we can get various forms
69              of constants here.  */
70           t = SYMBOL_REF_DECL (op);
71           if (DECL_P (t))
72             t = DECL_SIZE_UNIT (t);
73           else
74             t = TYPE_SIZE_UNIT (TREE_TYPE (t));
75           if (t && host_integerp (t, 0))
76             {
77               size = tree_low_cst (t, 0);
78               if (size < 0)
79                 size = 0;
80             }
81         }
82
83       /* Deny the stupid user trick of addressing outside the object.  Such
84          things quickly result in GPREL22 relocation overflows.  Of course,
85          they're also highly undefined.  From a pure pedant's point of view
86          they deserve a slap on the wrist (such as provided by a relocation
87          overflow), but that just leads to bugzilla noise.  */
88       return (offset >= 0 && offset <= size);
89
90     default:
91       gcc_unreachable ();
92     }
93 })
94
95 ;; True if OP refers to a symbol in the small address area.
96 (define_predicate "small_addr_symbolic_operand" 
97   (match_code "symbol_ref,const")
98 {
99   switch (GET_CODE (op))
100     {
101     case CONST:
102       op = XEXP (op, 0);
103       if (GET_CODE (op) != PLUS
104           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
105           || GET_CODE (XEXP (op, 1)) != CONST_INT)
106         return false;
107       op = XEXP (op, 0);
108       /* FALLTHRU */
109
110     case SYMBOL_REF:
111       return SYMBOL_REF_SMALL_ADDR_P (op);
112
113     default:
114       gcc_unreachable ();
115     }
116 })
117
118 ;; True if OP refers to a symbol with which we may use any offset.
119 (define_predicate "any_offset_symbol_operand"
120   (match_code "symbol_ref")
121 {
122   if (TARGET_NO_PIC || TARGET_AUTO_PIC)
123     return true;
124   if (SYMBOL_REF_SMALL_ADDR_P (op))
125     return true;
126   if (SYMBOL_REF_FUNCTION_P (op))
127     return false;
128   if (sdata_symbolic_operand (op, mode))
129     return true;
130   return false;
131 })
132
133 ;; True if OP refers to a symbol with which we may use 14-bit aligned offsets.
134 ;; False if OP refers to a symbol with which we may not use any offset at any
135 ;; time.
136 (define_predicate "aligned_offset_symbol_operand"
137   (and (match_code "symbol_ref")
138        (match_test "! SYMBOL_REF_FUNCTION_P (op)")))
139
140 ;; True if OP refers to a symbol, and is appropriate for a GOT load.
141 (define_predicate "got_symbolic_operand" 
142   (match_operand 0 "symbolic_operand" "")
143 {
144   HOST_WIDE_INT addend = 0;
145
146   switch (GET_CODE (op))
147     {
148     case LABEL_REF:
149       return true;
150
151     case CONST:
152       /* Accept only (plus (symbol_ref) (const_int)).  */
153       op = XEXP (op, 0);
154       if (GET_CODE (op) != PLUS
155           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
156           || GET_CODE (XEXP (op, 1)) != CONST_INT)
157         return false;
158
159       addend = INTVAL (XEXP (op, 1));
160       op = XEXP (op, 0);
161       /* FALLTHRU */
162
163     case SYMBOL_REF:
164       /* These symbols shouldn't be used with got loads.  */
165       if (SYMBOL_REF_SMALL_ADDR_P (op))
166         return false;
167       if (SYMBOL_REF_TLS_MODEL (op) != 0)
168         return false;
169
170       if (any_offset_symbol_operand (op, mode))
171         return true;
172
173       /* The low 14 bits of the constant have been forced to zero
174          so that we do not use up so many GOT entries.  Prevent cse
175          from undoing this.  */
176       if (aligned_offset_symbol_operand (op, mode))
177         return (addend & 0x3fff) == 0;
178
179       return addend == 0;
180
181     default:
182       gcc_unreachable ();
183     }
184 })
185
186 ;; Return true if OP is a valid thread local storage symbolic operand.
187 (define_predicate "tls_symbolic_operand"
188   (match_code "symbol_ref,const")
189 {
190   switch (GET_CODE (op))
191     {
192     case SYMBOL_REF:
193       return SYMBOL_REF_TLS_MODEL (op) != 0;
194
195     case CONST:
196       op = XEXP (op, 0);
197       if (GET_CODE (op) != PLUS
198           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
199           || GET_CODE (XEXP (op, 1)) != CONST_INT)
200         return false;
201
202       /* We only allow certain offsets for certain tls models.  */
203       switch (SYMBOL_REF_TLS_MODEL (XEXP (op, 0)))
204         {
205         case TLS_MODEL_GLOBAL_DYNAMIC:
206         case TLS_MODEL_LOCAL_DYNAMIC:
207           return false;
208
209         case TLS_MODEL_INITIAL_EXEC:
210           return (INTVAL (XEXP (op, 1)) & 0x3fff) == 0;
211
212         case TLS_MODEL_LOCAL_EXEC:
213           return true;
214
215         default:
216           return false;
217         }
218
219     default:
220       gcc_unreachable ();
221     }
222 })
223
224 ;; Return true if OP is a local-dynamic thread local storage symbolic operand.
225 (define_predicate "ld_tls_symbolic_operand"
226   (and (match_code "symbol_ref")
227        (match_test "SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_DYNAMIC")))
228
229 ;; Return true if OP is an initial-exec thread local storage symbolic operand.
230 (define_predicate "ie_tls_symbolic_operand"
231   (match_code "symbol_ref,const")
232 {
233   switch (GET_CODE (op))
234     {
235     case CONST:
236       op = XEXP (op, 0);
237       if (GET_CODE (op) != PLUS
238           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
239           || GET_CODE (XEXP (op, 1)) != CONST_INT
240           || (INTVAL (XEXP (op, 1)) & 0x3fff) != 0)
241         return false;
242       op = XEXP (op, 0);
243       /* FALLTHRU */
244
245     case SYMBOL_REF:
246       return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_INITIAL_EXEC;
247
248     default:
249       gcc_unreachable ();
250     }
251 })
252
253 ;; Return true if OP is a local-exec thread local storage symbolic operand.
254 (define_predicate "le_tls_symbolic_operand"
255   (match_code "symbol_ref,const")
256 {
257   switch (GET_CODE (op))
258     {
259     case CONST:
260       op = XEXP (op, 0);
261       if (GET_CODE (op) != PLUS
262           || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
263           || GET_CODE (XEXP (op, 1)) != CONST_INT)
264         return false;
265       op = XEXP (op, 0);
266       /* FALLTHRU */
267
268     case SYMBOL_REF:
269       return SYMBOL_REF_TLS_MODEL (op) == TLS_MODEL_LOCAL_EXEC;
270
271     default:
272       gcc_unreachable ();
273     }
274 })
275
276 ;; Like nonimmediate_operand, but don't allow MEMs that try to use a
277 ;; POST_MODIFY with a REG as displacement.
278 (define_predicate "destination_operand"
279   (and (match_operand 0 "nonimmediate_operand")
280        (match_test "GET_CODE (op) != MEM
281                     || GET_CODE (XEXP (op, 0)) != POST_MODIFY
282                     || GET_CODE (XEXP (XEXP (XEXP (op, 0), 1), 1)) != REG")))
283
284 ;; Like destination_operand, but don't allow any post-increments.
285 (define_predicate "not_postinc_destination_operand"
286   (and (match_operand 0 "nonimmediate_operand")
287        (match_test "GET_CODE (op) != MEM
288         || GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
289
290 ;; Like memory_operand, but don't allow post-increments.
291 (define_predicate "not_postinc_memory_operand"
292   (and (match_operand 0 "memory_operand")
293        (match_test "GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
294
295 ;; True if OP is a general operand, with some restrictions on symbols.
296 (define_predicate "move_operand"
297   (match_operand 0 "general_operand")
298 {
299   switch (GET_CODE (op))
300     {
301     case CONST:
302       {
303         HOST_WIDE_INT addend;
304
305         /* Accept only (plus (symbol_ref) (const_int)).  */
306         op = XEXP (op, 0);
307         if (GET_CODE (op) != PLUS
308             || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
309             || GET_CODE (XEXP (op, 1)) != CONST_INT)
310           return false;
311
312         addend = INTVAL (XEXP (op, 1));
313         op = XEXP (op, 0);
314
315         /* After reload, we want to allow any offset whatsoever.  This
316            allows reload the opportunity to avoid spilling addresses to
317            the stack, and instead simply substitute in the value from a
318            REG_EQUIV.  We'll split this up again when splitting the insn.  */
319         if (reload_in_progress || reload_completed)
320           return true;
321
322         /* Some symbol types we allow to use with any offset.  */
323         if (any_offset_symbol_operand (op, mode))
324           return true;
325
326         /* Some symbol types we allow offsets with the low 14 bits of the
327            constant forced to zero so that we do not use up so many GOT
328            entries.  We want to prevent cse from undoing this.  */
329         if (aligned_offset_symbol_operand (op, mode))
330           return (addend & 0x3fff) == 0;
331
332         /* The remaining symbol types may never be used with an offset.  */
333         return false;
334       }
335
336     default:
337       return true;
338     }
339 })
340
341 ;; Like move_operand but don't allow post-increments.
342 (define_predicate "not_postinc_move_operand"
343   (and (match_operand 0 "move_operand")
344        (match_test "GET_CODE (op) != MEM
345         || GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != RTX_AUTOINC")))
346
347 ;; True if OP is a register operand that is (or could be) a GR reg.
348 (define_predicate "gr_register_operand"
349   (match_operand 0 "register_operand")
350 {
351   unsigned int regno;
352   if (GET_CODE (op) == SUBREG)
353     op = SUBREG_REG (op);
354
355   regno = REGNO (op);
356   return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno));
357 })
358
359 ;; True if OP is a register operand that is (or could be) an FR reg.
360 (define_predicate "fr_register_operand"
361   (match_operand 0 "register_operand")
362 {
363   unsigned int regno;
364   if (GET_CODE (op) == SUBREG)
365     op = SUBREG_REG (op);
366
367   regno = REGNO (op);
368   return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno));
369 })
370
371 ;; True if OP is a register operand that is (or could be) a GR/FR reg.
372 (define_predicate "grfr_register_operand"
373   (match_operand 0 "register_operand")
374 {
375   unsigned int regno;
376   if (GET_CODE (op) == SUBREG)
377     op = SUBREG_REG (op);
378
379   regno = REGNO (op);
380   return (regno >= FIRST_PSEUDO_REGISTER
381           || GENERAL_REGNO_P (regno)
382           || FR_REGNO_P (regno));
383 })
384
385 ;; True if OP is a nonimmediate operand that is (or could be) a GR reg.
386 (define_predicate "gr_nonimmediate_operand"
387   (match_operand 0 "nonimmediate_operand")
388 {
389   unsigned int regno;
390
391   if (GET_CODE (op) == MEM)
392     return true;
393   if (GET_CODE (op) == SUBREG)
394     op = SUBREG_REG (op);
395
396   regno = REGNO (op);
397   return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno));
398 })
399
400 ;; True if OP is a nonimmediate operand that is (or could be) a FR reg.
401 (define_predicate "fr_nonimmediate_operand"
402   (match_operand 0 "nonimmediate_operand")
403 {
404   unsigned int regno;
405
406   if (GET_CODE (op) == MEM)
407     return true;
408   if (GET_CODE (op) == SUBREG)
409     op = SUBREG_REG (op);
410
411   regno = REGNO (op);
412   return (regno >= FIRST_PSEUDO_REGISTER || FR_REGNO_P (regno));
413 })
414
415 ;; True if OP is a nonimmediate operand that is (or could be) a GR/FR reg.
416 (define_predicate "grfr_nonimmediate_operand"
417   (match_operand 0 "nonimmediate_operand")
418 {
419   unsigned int regno;
420
421   if (GET_CODE (op) == MEM)
422     return true;
423   if (GET_CODE (op) == SUBREG)
424     op = SUBREG_REG (op);
425
426   regno = REGNO (op);
427   return (regno >= FIRST_PSEUDO_REGISTER
428           || GENERAL_REGNO_P (regno)
429           || FR_REGNO_P (regno));
430 })
431
432 ;; True if OP is a GR register operand, or zero.
433 (define_predicate "gr_reg_or_0_operand"
434   (ior (match_operand 0 "gr_register_operand")
435        (and (match_code "const_int,const_double,const_vector")
436             (match_test "op == CONST0_RTX (GET_MODE (op))"))))
437
438 ;; True if OP is a GR register operand, or a 5-bit immediate operand.
439 (define_predicate "gr_reg_or_5bit_operand"
440   (ior (match_operand 0 "gr_register_operand")
441        (and (match_code "const_int")
442             (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32"))))
443
444 ;; True if OP is a GR register operand, or a 6-bit immediate operand.
445 (define_predicate "gr_reg_or_6bit_operand"
446   (ior (match_operand 0 "gr_register_operand")
447        (and (match_code "const_int")
448             (match_test "satisfies_constraint_M (op)"))))
449
450 ;; True if OP is a GR register operand, or an 8-bit immediate operand.
451 (define_predicate "gr_reg_or_8bit_operand"
452   (ior (match_operand 0 "gr_register_operand")
453        (and (match_code "const_int")
454             (match_test "satisfies_constraint_K (op)"))))
455
456 ;; True if OP is a GR/FR register operand, or an 8-bit immediate operand.
457 (define_predicate "grfr_reg_or_8bit_operand"
458   (ior (match_operand 0 "grfr_register_operand")
459        (and (match_code "const_int")
460             (match_test "satisfies_constraint_K (op)"))))
461
462 ;; True if OP is a register operand, or an 8-bit adjusted immediate operand.
463 (define_predicate "gr_reg_or_8bit_adjusted_operand"
464   (ior (match_operand 0 "gr_register_operand")
465        (and (match_code "const_int")
466             (match_test "satisfies_constraint_L (op)"))))
467
468 ;; True if OP is a register operand, or is valid for both an 8-bit
469 ;; immediate and an 8-bit adjusted immediate operand.  This is necessary
470 ;; because when we emit a compare, we don't know what the condition will be,
471 ;; so we need the union of the immediates accepted by GT and LT.
472 (define_predicate "gr_reg_or_8bit_and_adjusted_operand"
473   (ior (match_operand 0 "gr_register_operand")
474        (and (match_code "const_int")
475             (match_test "satisfies_constraint_K (op)
476                          && satisfies_constraint_L (op)"))))
477
478 ;; True if OP is a register operand, or a 14-bit immediate operand.
479 (define_predicate "gr_reg_or_14bit_operand"
480   (ior (match_operand 0 "gr_register_operand")
481        (and (match_code "const_int")
482             (match_test "satisfies_constraint_I (op)"))))
483
484 ;;  True if OP is a register operand, or a 22-bit immediate operand.
485 (define_predicate "gr_reg_or_22bit_operand"
486   (ior (match_operand 0 "gr_register_operand")
487        (and (match_code "const_int")
488             (match_test "satisfies_constraint_J (op)"))))
489
490 ;; True if OP is a 7-bit immediate operand.
491 (define_predicate "dshift_count_operand"
492   (and (match_code "const_int")
493        (match_test "INTVAL (op) >= 0 && INTVAL (op) < 128")))
494
495 ;; True if OP is a 6-bit immediate operand.
496 (define_predicate "shift_count_operand"
497   (and (match_code "const_int")
498        (match_test "satisfies_constraint_M (op)")))
499
500 ;; True if OP-1 is a 6-bit immediate operand, used in extr instruction.
501 (define_predicate "extr_len_operand"
502   (and (match_code "const_int")
503        (match_test "satisfies_constraint_M (GEN_INT (INTVAL (op) - 1))")))
504
505 ;; True if OP is a 5-bit immediate operand.
506 (define_predicate "shift_32bit_count_operand"
507    (and (match_code "const_int")
508         (match_test "INTVAL (op) >= 0 && INTVAL (op) < 32")))
509
510 ;; True if OP is one of the immediate values 2, 4, 8, or 16.
511 (define_predicate "shladd_operand"
512   (and (match_code "const_int")
513        (match_test "INTVAL (op) == 2 || INTVAL (op) == 4 ||
514                     INTVAL (op) == 8 || INTVAL (op) == 16")))
515
516 ;; True if OP is one of the immediate values 1, 2, 3, or 4.
517 (define_predicate "shladd_log2_operand"
518   (and (match_code "const_int")
519        (match_test "INTVAL (op) >= 1 && INTVAL (op) <= 4")))
520
521 ;; True if OP is one of the immediate values  -16, -8, -4, -1, 1, 4, 8, 16.
522 (define_predicate "fetchadd_operand"
523   (and (match_code "const_int")
524        (match_test "INTVAL (op) == -16 || INTVAL (op) == -8 ||
525                     INTVAL (op) == -4  || INTVAL (op) == -1 ||
526                     INTVAL (op) == 1   || INTVAL (op) == 4  ||
527                     INTVAL (op) == 8   || INTVAL (op) == 16")))
528
529 ;; True if OP is 0..3.
530 (define_predicate "const_int_2bit_operand"
531   (and (match_code "const_int")
532         (match_test "INTVAL (op) >= 0 && INTVAL (op) <= 3")))
533
534 ;; True if OP is a floating-point constant zero, one, or a register.
535 (define_predicate "fr_reg_or_fp01_operand"
536   (ior (match_operand 0 "fr_register_operand")
537        (and (match_code "const_double")
538             (match_test "satisfies_constraint_G (op)"))))
539
540 ;; Like fr_reg_or_fp01_operand, but don't allow any SUBREGs.
541 (define_predicate "xfreg_or_fp01_operand"
542   (and (match_operand 0 "fr_reg_or_fp01_operand")
543        (not (match_code "subreg"))))
544
545 ;; True if OP is a constant zero, or a register.
546 (define_predicate "fr_reg_or_0_operand"
547   (ior (match_operand 0 "fr_register_operand")
548        (and (match_code "const_double,const_vector")
549             (match_test "op == CONST0_RTX (GET_MODE (op))"))))
550
551 ;; Return 1 if OP is a valid comparison operator for "cbranch" instructions.
552 (define_predicate "ia64_cbranch_operator"
553   (ior (match_operand 0 "ordered_comparison_operator")
554        (match_code "ordered,unordered")))
555
556 ;; True if this is a comparison operator, which accepts a normal 8-bit
557 ;; signed immediate operand.
558 (define_predicate "normal_comparison_operator"
559   (match_code "eq,ne,gt,le,gtu,leu"))
560
561 ;; True if this is a comparison operator, which accepts an adjusted 8-bit
562 ;; signed immediate operand.
563 (define_predicate "adjusted_comparison_operator"
564   (match_code "lt,ge,ltu,geu"))
565
566 ;; True if this is a signed inequality operator.
567 (define_predicate "signed_inequality_operator"
568   (match_code "ge,gt,le,lt"))
569
570 ;; True if this operator is valid for predication.
571 (define_predicate "predicate_operator"
572   (match_code "eq,ne"))
573
574 ;; True if this operator can be used in a conditional operation.
575 (define_predicate "condop_operator"
576   (match_code "plus,minus,ior,xor,and"))
577
578 ;; These three are hardware registers that can only be addressed in
579 ;; DImode.  It's not strictly necessary to test mode == DImode here,
580 ;; but it makes decent insurance against someone writing a
581 ;; match_operand wrong.
582
583 ;; True if this is the ar.lc register.
584 (define_predicate "ar_lc_reg_operand"
585   (and (match_code "reg")
586        (match_test "mode == DImode && REGNO (op) == AR_LC_REGNUM")))
587
588 ;; True if this is the ar.ccv register.
589 (define_predicate "ar_ccv_reg_operand"
590   (and (match_code "reg")
591        (match_test "mode == DImode && REGNO (op) == AR_CCV_REGNUM")))
592
593 ;; True if this is the ar.pfs register.
594 (define_predicate "ar_pfs_reg_operand"
595   (and (match_code "reg")
596        (match_test "mode == DImode && REGNO (op) == AR_PFS_REGNUM")))
597
598 ;; True if OP is valid as a base register in a reg + offset address.
599 ;; ??? Should I copy the flag_omit_frame_pointer and cse_not_expected
600 ;; checks from pa.c basereg_operand as well?  Seems to be OK without them
601 ;; in test runs.
602 (define_predicate "basereg_operand"
603   (match_operand 0 "register_operand")
604 {
605   return REG_P (op) && REG_POINTER (op);
606 })
607