OSDN Git Service

6320fd1688bb0a4eeb15fddbe82fb5b48128799d
[pf3gnuchains/gcc-fork.git] / gcc / config / frv / predicates.md
1 ;; Predicate definitions for Frv.
2 ;; Copyright (C) 2005 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 2, 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 COPYING.  If not, write to
18 ;; the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 ;; Boston, MA 02110-1301, USA.
20
21 ;; Return true if operand is a GPR register.
22
23 (define_predicate "integer_register_operand"
24   (match_code "reg,subreg")
25 {
26   if (GET_MODE (op) != mode && mode != VOIDmode)
27     return FALSE;
28
29   if (GET_CODE (op) == SUBREG)
30     {
31       if (GET_CODE (SUBREG_REG (op)) != REG)
32         return register_operand (op, mode);
33
34       op = SUBREG_REG (op);
35     }
36
37   if (GET_CODE (op) != REG)
38     return FALSE;
39
40   return GPR_AP_OR_PSEUDO_P (REGNO (op));
41 })
42
43 ;; Return 1 is OP is a memory operand, or will be turned into one by
44 ;; reload.
45
46 (define_predicate "frv_load_operand"
47   (match_code "reg,subreg,mem")
48 {
49   if (GET_MODE (op) != mode && mode != VOIDmode)
50     return FALSE;
51
52   if (reload_in_progress)
53     {
54       rtx tmp = op;
55       if (GET_CODE (tmp) == SUBREG)
56         tmp = SUBREG_REG (tmp);
57       if (GET_CODE (tmp) == REG
58           && REGNO (tmp) >= FIRST_PSEUDO_REGISTER)
59         op = reg_equiv_memory_loc[REGNO (tmp)];
60     }
61
62   return op && memory_operand (op, mode);
63 })
64
65 ;; Return true if operand is a GPR register.  Do not allow SUBREG's
66 ;; here, in order to prevent a combine bug.
67
68 (define_predicate "gpr_no_subreg_operand"
69   (match_code "reg")
70 {
71   if (GET_MODE (op) != mode && mode != VOIDmode)
72     return FALSE;
73
74   if (GET_CODE (op) != REG)
75     return FALSE;
76
77   return GPR_OR_PSEUDO_P (REGNO (op));
78 })
79
80 ;; Return 1 if operand is a GPR register or a FPR register.
81
82 (define_predicate "gpr_or_fpr_operand"
83   (match_code "reg,subreg")
84 {
85   int regno;
86
87   if (GET_MODE (op) != mode && mode != VOIDmode)
88     return FALSE;
89
90   if (GET_CODE (op) == SUBREG)
91     {
92       if (GET_CODE (SUBREG_REG (op)) != REG)
93         return register_operand (op, mode);
94
95       op = SUBREG_REG (op);
96     }
97
98   if (GET_CODE (op) != REG)
99     return FALSE;
100
101   regno = REGNO (op);
102   if (GPR_P (regno) || FPR_P (regno) || regno >= FIRST_PSEUDO_REGISTER)
103     return TRUE;
104
105   return FALSE;
106 })
107
108 ;; Return 1 if operand is a GPR register or 12 bit signed immediate.
109
110 (define_predicate "gpr_or_int12_operand"
111   (match_code "reg,subreg,const_int,const")
112 {
113   if (GET_CODE (op) == CONST_INT)
114     return IN_RANGE_P (INTVAL (op), -2048, 2047);
115
116   if (got12_operand (op, mode))
117     return true;
118
119   if (GET_MODE (op) != mode && mode != VOIDmode)
120     return FALSE;
121
122   if (GET_CODE (op) == SUBREG)
123     {
124       if (GET_CODE (SUBREG_REG (op)) != REG)
125         return register_operand (op, mode);
126
127       op = SUBREG_REG (op);
128     }
129
130   if (GET_CODE (op) != REG)
131     return FALSE;
132
133   return GPR_OR_PSEUDO_P (REGNO (op));
134 })
135
136 ;; Return 1 if operand is a GPR register, or a FPR register, or a 12
137 ;; bit signed immediate.
138
139 (define_predicate "gpr_fpr_or_int12_operand"
140   (match_code "reg,subreg,const_int")
141 {
142   int regno;
143
144   if (GET_CODE (op) == CONST_INT)
145     return IN_RANGE_P (INTVAL (op), -2048, 2047);
146
147   if (GET_MODE (op) != mode && mode != VOIDmode)
148     return FALSE;
149
150   if (GET_CODE (op) == SUBREG)
151     {
152       if (GET_CODE (SUBREG_REG (op)) != REG)
153         return register_operand (op, mode);
154
155       op = SUBREG_REG (op);
156     }
157
158   if (GET_CODE (op) != REG)
159     return FALSE;
160
161   regno = REGNO (op);
162   if (GPR_P (regno) || FPR_P (regno) || regno >= FIRST_PSEUDO_REGISTER)
163     return TRUE;
164
165   return FALSE;
166 })
167
168 ;; Return 1 if operand is a register or 10 bit signed immediate.
169
170 (define_predicate "gpr_or_int10_operand"
171   (match_code "reg,subreg,const_int")
172 {
173   if (GET_CODE (op) == CONST_INT)
174     return IN_RANGE_P (INTVAL (op), -512, 511);
175
176   if (GET_MODE (op) != mode && mode != VOIDmode)
177     return FALSE;
178
179   if (GET_CODE (op) == SUBREG)
180     {
181       if (GET_CODE (SUBREG_REG (op)) != REG)
182         return register_operand (op, mode);
183
184       op = SUBREG_REG (op);
185     }
186
187   if (GET_CODE (op) != REG)
188     return FALSE;
189
190   return GPR_OR_PSEUDO_P (REGNO (op));
191 })
192
193 ;; Return 1 if operand is a register or an integer immediate.
194
195 (define_predicate "gpr_or_int_operand"
196   (match_code "reg,subreg,const_int")
197 {
198   if (GET_CODE (op) == CONST_INT)
199     return TRUE;
200
201   if (GET_MODE (op) != mode && mode != VOIDmode)
202     return FALSE;
203
204   if (GET_CODE (op) == SUBREG)
205     {
206       if (GET_CODE (SUBREG_REG (op)) != REG)
207         return register_operand (op, mode);
208
209       op = SUBREG_REG (op);
210     }
211
212   if (GET_CODE (op) != REG)
213     return FALSE;
214
215   return GPR_OR_PSEUDO_P (REGNO (op));
216 })
217
218 ;; Return true if operand is something that can be an input for a move
219 ;; operation.
220
221 (define_predicate "move_source_operand"
222   (match_code "reg,subreg,const_int,mem,const_double,const,symbol_ref,label_ref")
223 {
224   rtx subreg;
225   enum rtx_code code;
226
227   switch (GET_CODE (op))
228     {
229     default:
230       break;
231
232     case CONST_INT:
233     case CONST_DOUBLE:
234       return immediate_operand (op, mode);
235
236     case SUBREG:
237       if (GET_MODE (op) != mode && mode != VOIDmode)
238         return FALSE;
239
240       subreg = SUBREG_REG (op);
241       code = GET_CODE (subreg);
242       if (code == MEM)
243         return frv_legitimate_address_p (mode, XEXP (subreg, 0),
244                                          reload_completed, FALSE, FALSE);
245
246       return (code == REG);
247
248     case REG:
249       if (GET_MODE (op) != mode && mode != VOIDmode)
250         return FALSE;
251
252       return TRUE;
253
254     case MEM:
255       return frv_legitimate_memory_operand (op, mode, FALSE);
256     }
257
258   return FALSE;
259 })
260
261 ;; Return true if operand is something that can be an output for a
262 ;; move operation.
263
264 (define_predicate "move_destination_operand"
265   (match_code "reg,subreg,mem")
266 {
267   rtx subreg;
268   enum rtx_code code;
269
270   switch (GET_CODE (op))
271     {
272     default:
273       break;
274
275     case SUBREG:
276       if (GET_MODE (op) != mode && mode != VOIDmode)
277         return FALSE;
278
279       subreg = SUBREG_REG (op);
280       code = GET_CODE (subreg);
281       if (code == MEM)
282         return frv_legitimate_address_p (mode, XEXP (subreg, 0),
283                                          reload_completed, FALSE, FALSE);
284
285       return (code == REG);
286
287     case REG:
288       if (GET_MODE (op) != mode && mode != VOIDmode)
289         return FALSE;
290
291       return TRUE;
292
293     case MEM:
294       return frv_legitimate_memory_operand (op, mode, FALSE);
295     }
296
297   return FALSE;
298 })
299
300 ;; Return true if we the operand is a valid destination for a movcc_fp
301 ;; instruction.  This means rejecting fcc_operands, since we need
302 ;; scratch registers to write to them.
303
304 (define_predicate "movcc_fp_destination_operand"
305   (match_code "reg,subreg,mem")
306 {
307   if (fcc_operand (op, mode))
308     return FALSE;
309
310   return move_destination_operand (op, mode);
311 })
312
313 ;; Return true if operand is something that can be an input for a
314 ;; conditional move operation.
315
316 (define_predicate "condexec_source_operand"
317   (match_code "reg,subreg,const_int,mem,const_double")
318 {
319   rtx subreg;
320   enum rtx_code code;
321
322   switch (GET_CODE (op))
323     {
324     default:
325       break;
326
327     case CONST_INT:
328     case CONST_DOUBLE:
329       return ZERO_P (op);
330
331     case SUBREG:
332       if (GET_MODE (op) != mode && mode != VOIDmode)
333         return FALSE;
334
335       subreg = SUBREG_REG (op);
336       code = GET_CODE (subreg);
337       if (code == MEM)
338         return frv_legitimate_address_p (mode, XEXP (subreg, 0),
339                                          reload_completed, TRUE, FALSE);
340
341       return (code == REG);
342
343     case REG:
344       if (GET_MODE (op) != mode && mode != VOIDmode)
345         return FALSE;
346
347       return TRUE;
348
349     case MEM:
350       return frv_legitimate_memory_operand (op, mode, TRUE);
351     }
352
353   return FALSE;
354 })
355
356 ;; Return true if operand is something that can be an output for a
357 ;; conditional move operation.
358
359 (define_predicate "condexec_dest_operand"
360   (match_code "reg,subreg,mem")
361 {
362   rtx subreg;
363   enum rtx_code code;
364
365   switch (GET_CODE (op))
366     {
367     default:
368       break;
369
370     case SUBREG:
371       if (GET_MODE (op) != mode && mode != VOIDmode)
372         return FALSE;
373
374       subreg = SUBREG_REG (op);
375       code = GET_CODE (subreg);
376       if (code == MEM)
377         return frv_legitimate_address_p (mode, XEXP (subreg, 0),
378                                          reload_completed, TRUE, FALSE);
379
380       return (code == REG);
381
382     case REG:
383       if (GET_MODE (op) != mode && mode != VOIDmode)
384         return FALSE;
385
386       return TRUE;
387
388     case MEM:
389       return frv_legitimate_memory_operand (op, mode, TRUE);
390     }
391
392   return FALSE;
393 })
394
395 ;; Return true if operand is a register of any flavor or a 0 of the
396 ;; appropriate type.
397
398 (define_predicate "reg_or_0_operand"
399   (match_code "reg,subreg,const_int")
400 {
401   switch (GET_CODE (op))
402     {
403     default:
404       break;
405
406     case REG:
407     case SUBREG:
408       if (GET_MODE (op) != mode && mode != VOIDmode)
409         return FALSE;
410
411       return register_operand (op, mode);
412
413     case CONST_INT:
414     case CONST_DOUBLE:
415       return ZERO_P (op);
416     }
417
418   return FALSE;
419 })
420
421 ;; Return true if operand is the link register.
422
423 (define_predicate "lr_operand"
424   (match_code "reg")
425 {
426   if (GET_CODE (op) != REG)
427     return FALSE;
428
429   if (GET_MODE (op) != mode && mode != VOIDmode)
430     return FALSE;
431
432   if (REGNO (op) != LR_REGNO && REGNO (op) < FIRST_PSEUDO_REGISTER)
433     return FALSE;
434
435   return TRUE;
436 })
437
438 ;; Return true if operand is a gpr register or a valid memory operand.
439
440 (define_predicate "gpr_or_memory_operand"
441   (match_code "reg,subreg,mem")
442 {
443   return (integer_register_operand (op, mode)
444           || frv_legitimate_memory_operand (op, mode, FALSE));
445 })
446
447 ;; Return true if operand is a gpr register, a valid memory operand,
448 ;; or a memory operand that can be made valid using an additional gpr
449 ;; register.
450
451 (define_predicate "gpr_or_memory_operand_with_scratch"
452   (match_code "reg,subreg,mem")
453 {
454   rtx addr;
455
456   if (gpr_or_memory_operand (op, mode))
457     return TRUE;
458
459   if (GET_CODE (op) != MEM)
460     return FALSE;
461
462   if (GET_MODE (op) != mode)
463     return FALSE;
464
465   addr = XEXP (op, 0);
466
467   if (GET_CODE (addr) != PLUS)
468     return FALSE;
469       
470   if (!integer_register_operand (XEXP (addr, 0), Pmode))
471     return FALSE;
472
473   if (GET_CODE (XEXP (addr, 1)) != CONST_INT)
474     return FALSE;
475
476   return TRUE;
477 })
478
479 ;; Return true if operand is a fpr register or a valid memory
480 ;; operation.
481
482 (define_predicate "fpr_or_memory_operand"
483   (match_code "reg,subreg,mem")
484 {
485   return (fpr_operand (op, mode)
486           || frv_legitimate_memory_operand (op, mode, FALSE));
487 })
488
489 ;; Return 1 if operand is a 12 bit signed immediate.
490
491 (define_predicate "int12_operand"
492   (match_code "const_int")
493 {
494   if (GET_CODE (op) != CONST_INT)
495     return FALSE;
496
497   return IN_RANGE_P (INTVAL (op), -2048, 2047);
498 })
499
500 ;; Return 1 if operand is an integer constant that takes 2
501 ;; instructions to load up and can be split into sethi/setlo
502 ;; instructions..
503
504 (define_predicate "int_2word_operand"
505   (match_code "const_int,const_double,symbol_ref,label_ref,const")
506 {
507   HOST_WIDE_INT value;
508   REAL_VALUE_TYPE rv;
509   long l;
510
511   switch (GET_CODE (op))
512     {
513     default:
514       break;
515
516     case LABEL_REF:
517       if (TARGET_FDPIC)
518         return FALSE;
519       
520       return (flag_pic == 0);
521
522     case CONST:
523       if (flag_pic || TARGET_FDPIC)
524         return FALSE;
525
526       op = XEXP (op, 0);
527       if (GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT)
528         op = XEXP (op, 0);
529       return GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF;
530
531     case SYMBOL_REF:
532       if (TARGET_FDPIC)
533         return FALSE;
534       
535       /* small data references are already 1 word */
536       return (flag_pic == 0) && (! SYMBOL_REF_SMALL_P (op));
537
538     case CONST_INT:
539       return ! IN_RANGE_P (INTVAL (op), -32768, 32767);
540
541     case CONST_DOUBLE:
542       if (GET_MODE (op) == SFmode)
543         {
544           REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
545           REAL_VALUE_TO_TARGET_SINGLE (rv, l);
546           value = l;
547           return ! IN_RANGE_P (value, -32768, 32767);
548         }
549       else if (GET_MODE (op) == VOIDmode)
550         {
551           value = CONST_DOUBLE_LOW (op);
552           return ! IN_RANGE_P (value, -32768, 32767);
553         }
554       break;
555     }
556
557   return FALSE;
558 })
559
560 ;; Return true if operand is the uClinux PIC register.
561
562 (define_predicate "fdpic_operand"
563   (match_code "reg")
564 {
565   if (!TARGET_FDPIC)
566     return FALSE;
567
568   if (GET_CODE (op) != REG)
569     return FALSE;
570
571   if (GET_MODE (op) != mode && mode != VOIDmode)
572     return FALSE;
573
574   if (REGNO (op) != FDPIC_REGNO && REGNO (op) < FIRST_PSEUDO_REGISTER)
575     return FALSE;
576
577   return TRUE;
578 })
579
580 ;; TODO: Add a comment here.
581
582 (define_predicate "fdpic_fptr_operand"
583   (match_code "reg")
584 {
585   if (GET_MODE (op) != mode && mode != VOIDmode)
586     return FALSE;
587   if (GET_CODE (op) != REG)
588     return FALSE;
589   if (REGNO (op) != FDPIC_FPTR_REGNO && REGNO (op) < FIRST_PSEUDO_REGISTER)
590     return FALSE;
591   return TRUE;
592 })
593
594 ;; An address operand that may use a pair of registers, an addressing
595 ;; mode that we reject in general.
596
597 (define_predicate "ldd_address_operand"
598   (match_code "reg,subreg,plus")
599 {
600   if (GET_MODE (op) != mode && GET_MODE (op) != VOIDmode)
601     return FALSE;
602
603   return frv_legitimate_address_p (DImode, op, reload_completed, FALSE, TRUE);
604 })
605
606 ;; TODO: Add a comment here.
607
608 (define_predicate "got12_operand"
609   (match_code "const")
610 {
611   struct frv_unspec unspec;
612
613   if (frv_const_unspec_p (op, &unspec))
614     switch (unspec.reloc)
615       {
616       case R_FRV_GOT12:
617       case R_FRV_GOTOFF12:
618       case R_FRV_FUNCDESC_GOT12:
619       case R_FRV_FUNCDESC_GOTOFF12:
620       case R_FRV_GPREL12:
621       case R_FRV_TLSMOFF12:
622         return true;
623       }
624   return false;
625 })
626
627 ;; Return true if OP is a valid const-unspec expression.
628
629 (define_predicate "const_unspec_operand"
630   (match_code "const")
631 {
632   struct frv_unspec unspec;
633
634   return frv_const_unspec_p (op, &unspec);
635 })
636
637 ;; Return true if operand is an icc register.
638
639 (define_predicate "icc_operand"
640   (match_code "reg")
641 {
642   int regno;
643
644   if (GET_MODE (op) != mode && mode != VOIDmode)
645     return FALSE;
646
647   if (GET_CODE (op) != REG)
648     return FALSE;
649
650   regno = REGNO (op);
651   return ICC_OR_PSEUDO_P (regno);
652 })
653
654 ;; Return true if operand is an fcc register.
655
656 (define_predicate "fcc_operand"
657   (match_code "reg")
658 {
659   int regno;
660
661   if (GET_MODE (op) != mode && mode != VOIDmode)
662     return FALSE;
663
664   if (GET_CODE (op) != REG)
665     return FALSE;
666
667   regno = REGNO (op);
668   return FCC_OR_PSEUDO_P (regno);
669 })
670
671 ;; Return true if operand is either an fcc or icc register.
672
673 (define_predicate "cc_operand"
674   (match_code "reg")
675 {
676   int regno;
677
678   if (GET_MODE (op) != mode && mode != VOIDmode)
679     return FALSE;
680
681   if (GET_CODE (op) != REG)
682     return FALSE;
683
684   regno = REGNO (op);
685   if (CC_OR_PSEUDO_P (regno))
686     return TRUE;
687
688   return FALSE;
689 })
690
691 ;; Return true if operand is an integer CCR register.
692
693 (define_predicate "icr_operand"
694   (match_code "reg")
695 {
696   int regno;
697
698   if (GET_MODE (op) != mode && mode != VOIDmode)
699     return FALSE;
700
701   if (GET_CODE (op) != REG)
702     return FALSE;
703
704   regno = REGNO (op);
705   return ICR_OR_PSEUDO_P (regno);
706 })
707
708 ;; Return true if operand is an fcc register.
709
710 (define_predicate "fcr_operand"
711   (match_code "reg")
712 {
713   int regno;
714
715   if (GET_MODE (op) != mode && mode != VOIDmode)
716     return FALSE;
717
718   if (GET_CODE (op) != REG)
719     return FALSE;
720
721   regno = REGNO (op);
722   return FCR_OR_PSEUDO_P (regno);
723 })
724
725 ;; Return true if operand is either an fcc or icc register.
726
727 (define_predicate "cr_operand"
728   (match_code "reg")
729 {
730   int regno;
731
732   if (GET_MODE (op) != mode && mode != VOIDmode)
733     return FALSE;
734
735   if (GET_CODE (op) != REG)
736     return FALSE;
737
738   regno = REGNO (op);
739   if (CR_OR_PSEUDO_P (regno))
740     return TRUE;
741
742   return FALSE;
743 })
744
745 ;; Return true if operand is a FPR register.
746
747 (define_predicate "fpr_operand"
748   (match_code "reg,subreg")
749 {
750   if (GET_MODE (op) != mode && mode != VOIDmode)
751     return FALSE;
752
753   if (GET_CODE (op) == SUBREG)
754     {
755       if (GET_CODE (SUBREG_REG (op)) != REG)
756         return register_operand (op, mode);
757
758       op = SUBREG_REG (op);
759     }
760
761   if (GET_CODE (op) != REG)
762     return FALSE;
763
764   return FPR_OR_PSEUDO_P (REGNO (op));
765 })
766
767 ;; Return true if operand is an even GPR or FPR register.
768
769 (define_predicate "even_reg_operand"
770   (match_code "reg,subreg")
771 {
772   int regno;
773
774   if (GET_MODE (op) != mode && mode != VOIDmode)
775     return FALSE;
776
777   if (GET_CODE (op) == SUBREG)
778     {
779       if (GET_CODE (SUBREG_REG (op)) != REG)
780         return register_operand (op, mode);
781
782       op = SUBREG_REG (op);
783     }
784
785   if (GET_CODE (op) != REG)
786     return FALSE;
787
788   regno = REGNO (op);
789   if (regno >= FIRST_PSEUDO_REGISTER)
790     return TRUE;
791
792   if (GPR_P (regno))
793     return (((regno - GPR_FIRST) & 1) == 0);
794
795   if (FPR_P (regno))
796     return (((regno - FPR_FIRST) & 1) == 0);
797
798   return FALSE;
799 })
800
801 ;; Return true if operand is an odd GPR register.
802
803 (define_predicate "odd_reg_operand"
804   (match_code "reg,subreg")
805 {
806   int regno;
807
808   if (GET_MODE (op) != mode && mode != VOIDmode)
809     return FALSE;
810
811   if (GET_CODE (op) == SUBREG)
812     {
813       if (GET_CODE (SUBREG_REG (op)) != REG)
814         return register_operand (op, mode);
815
816       op = SUBREG_REG (op);
817     }
818
819   if (GET_CODE (op) != REG)
820     return FALSE;
821
822   regno = REGNO (op);
823   /* Assume that reload will give us an even register.  */
824   if (regno >= FIRST_PSEUDO_REGISTER)
825     return FALSE;
826
827   if (GPR_P (regno))
828     return (((regno - GPR_FIRST) & 1) != 0);
829
830   if (FPR_P (regno))
831     return (((regno - FPR_FIRST) & 1) != 0);
832
833   return FALSE;
834 })
835
836 ;; Return true if operand is an even GPR register.
837
838 (define_predicate "even_gpr_operand"
839   (match_code "reg,subreg")
840 {
841   int regno;
842
843   if (GET_MODE (op) != mode && mode != VOIDmode)
844     return FALSE;
845
846   if (GET_CODE (op) == SUBREG)
847     {
848       if (GET_CODE (SUBREG_REG (op)) != REG)
849         return register_operand (op, mode);
850
851       op = SUBREG_REG (op);
852     }
853
854   if (GET_CODE (op) != REG)
855     return FALSE;
856
857   regno = REGNO (op);
858   if (regno >= FIRST_PSEUDO_REGISTER)
859     return TRUE;
860
861   if (! GPR_P (regno))
862     return FALSE;
863
864   return (((regno - GPR_FIRST) & 1) == 0);
865 })
866
867 ;; Return true if operand is an odd GPR register.
868
869 (define_predicate "odd_gpr_operand"
870   (match_code "reg,subreg")
871 {
872   int regno;
873
874   if (GET_MODE (op) != mode && mode != VOIDmode)
875     return FALSE;
876
877   if (GET_CODE (op) == SUBREG)
878     {
879       if (GET_CODE (SUBREG_REG (op)) != REG)
880         return register_operand (op, mode);
881
882       op = SUBREG_REG (op);
883     }
884
885   if (GET_CODE (op) != REG)
886     return FALSE;
887
888   regno = REGNO (op);
889   /* Assume that reload will give us an even register.  */
890   if (regno >= FIRST_PSEUDO_REGISTER)
891     return FALSE;
892
893   if (! GPR_P (regno))
894     return FALSE;
895
896   return (((regno - GPR_FIRST) & 1) != 0);
897 })
898
899 ;; Return true if operand is a quad aligned FPR register.
900
901 (define_predicate "quad_fpr_operand"
902   (match_code "reg,subreg")
903 {
904   int regno;
905
906   if (GET_MODE (op) != mode && mode != VOIDmode)
907     return FALSE;
908
909   if (GET_CODE (op) == SUBREG)
910     {
911       if (GET_CODE (SUBREG_REG (op)) != REG)
912         return register_operand (op, mode);
913
914       op = SUBREG_REG (op);
915     }
916
917   if (GET_CODE (op) != REG)
918     return FALSE;
919
920   regno = REGNO (op);
921   if (regno >= FIRST_PSEUDO_REGISTER)
922     return TRUE;
923
924   if (! FPR_P (regno))
925     return FALSE;
926
927   return (((regno - FPR_FIRST) & 3) == 0);
928 })
929
930 ;; Return true if operand is an even FPR register.
931
932 (define_predicate "even_fpr_operand"
933   (match_code "reg,subreg")
934 {
935   int regno;
936
937   if (GET_MODE (op) != mode && mode != VOIDmode)
938     return FALSE;
939
940   if (GET_CODE (op) == SUBREG)
941     {
942       if (GET_CODE (SUBREG_REG (op)) != REG)
943         return register_operand (op, mode);
944
945       op = SUBREG_REG (op);
946     }
947
948   if (GET_CODE (op) != REG)
949     return FALSE;
950
951   regno = REGNO (op);
952   if (regno >= FIRST_PSEUDO_REGISTER)
953     return TRUE;
954
955   if (! FPR_P (regno))
956     return FALSE;
957
958   return (((regno - FPR_FIRST) & 1) == 0);
959 })
960
961 ;; Return true if operand is an odd FPR register.
962
963 (define_predicate "odd_fpr_operand"
964   (match_code "reg,subreg")
965 {
966   int regno;
967
968   if (GET_MODE (op) != mode && mode != VOIDmode)
969     return FALSE;
970
971   if (GET_CODE (op) == SUBREG)
972     {
973       if (GET_CODE (SUBREG_REG (op)) != REG)
974         return register_operand (op, mode);
975
976       op = SUBREG_REG (op);
977     }
978
979   if (GET_CODE (op) != REG)
980     return FALSE;
981
982   regno = REGNO (op);
983   /* Assume that reload will give us an even register.  */
984   if (regno >= FIRST_PSEUDO_REGISTER)
985     return FALSE;
986
987   if (! FPR_P (regno))
988     return FALSE;
989
990   return (((regno - FPR_FIRST) & 1) != 0);
991 })
992
993 ;; Return true if operand is a 2 word memory address that can be
994 ;; loaded in one instruction to load or store.  We assume the stack
995 ;; and frame pointers are suitably aligned, and variables in the small
996 ;; data area.  FIXME -- at some we should recognize other globals and
997 ;; statics. We can't assume that any old pointer is aligned, given
998 ;; that arguments could be passed on an odd word on the stack and the
999 ;; address taken and passed through to another function.
1000
1001 (define_predicate "dbl_memory_one_insn_operand"
1002   (match_code "mem")
1003 {
1004   rtx addr;
1005   rtx addr_reg;
1006
1007   if (! TARGET_DWORD)
1008     return FALSE;
1009
1010   if (GET_CODE (op) != MEM)
1011     return FALSE;
1012
1013   if (mode != VOIDmode && GET_MODE_SIZE (mode) != 2*UNITS_PER_WORD)
1014     return FALSE;
1015
1016   addr = XEXP (op, 0);
1017   if (GET_CODE (addr) == REG)
1018     addr_reg = addr;
1019
1020   else if (GET_CODE (addr) == PLUS)
1021     {
1022       rtx addr0 = XEXP (addr, 0);
1023       rtx addr1 = XEXP (addr, 1);
1024
1025       if (GET_CODE (addr0) != REG)
1026         return FALSE;
1027
1028       if (got12_operand (addr1, VOIDmode))
1029         return TRUE;
1030
1031       if (GET_CODE (addr1) != CONST_INT)
1032         return FALSE;
1033
1034       if ((INTVAL (addr1) & 7) != 0)
1035         return FALSE;
1036
1037       addr_reg = addr0;
1038     }
1039
1040   else
1041     return FALSE;
1042
1043   if (addr_reg == frame_pointer_rtx || addr_reg == stack_pointer_rtx)
1044     return TRUE;
1045
1046   return FALSE;
1047 })
1048
1049 ;; Return true if operand is a 2 word memory address that needs to use
1050 ;; two instructions to load or store.
1051
1052 (define_predicate "dbl_memory_two_insn_operand"
1053   (match_code "mem")
1054 {
1055   if (GET_CODE (op) != MEM)
1056     return FALSE;
1057
1058   if (mode != VOIDmode && GET_MODE_SIZE (mode) != 2*UNITS_PER_WORD)
1059     return FALSE;
1060
1061   if (! TARGET_DWORD)
1062     return TRUE;
1063
1064   return ! dbl_memory_one_insn_operand (op, mode);
1065 })
1066
1067 ;; Return true if operand is a memory reference suitable for a call.
1068
1069 (define_predicate "call_operand"
1070   (match_code "reg,subreg,const_int,const,symbol_ref")
1071 {
1072   if (GET_MODE (op) != mode && mode != VOIDmode && GET_CODE (op) != CONST_INT)
1073     return FALSE;
1074
1075   if (GET_CODE (op) == SYMBOL_REF)
1076     return !TARGET_LONG_CALLS || SYMBOL_REF_LOCAL_P (op);
1077
1078   /* Note this doesn't allow reg+reg or reg+imm12 addressing (which should
1079      never occur anyway), but prevents reload from not handling the case
1080      properly of a call through a pointer on a function that calls
1081      vfork/setjmp, etc. due to the need to flush all of the registers to stack.  */
1082   return gpr_or_int12_operand (op, mode);
1083 })
1084
1085 ;; Return true if operand is a memory reference suitable for a
1086 ;; sibcall.
1087
1088 (define_predicate "sibcall_operand"
1089   (match_code "reg,subreg,const_int,const")
1090 {
1091   if (GET_MODE (op) != mode && mode != VOIDmode && GET_CODE (op) != CONST_INT)
1092     return FALSE;
1093
1094   /* Note this doesn't allow reg+reg or reg+imm12 addressing (which should
1095      never occur anyway), but prevents reload from not handling the case
1096      properly of a call through a pointer on a function that calls
1097      vfork/setjmp, etc. due to the need to flush all of the registers to stack.  */
1098   return gpr_or_int12_operand (op, mode);
1099 })
1100
1101 ;; Return 1 if operand is an integer constant with the bottom 16 bits
1102 ;; clear.
1103
1104 (define_predicate "upper_int16_operand"
1105   (match_code "const_int")
1106 {
1107   if (GET_CODE (op) != CONST_INT)
1108     return FALSE;
1109
1110   return ((INTVAL (op) & 0xffff) == 0);
1111 })
1112
1113 ;; Return 1 if operand is a 16 bit unsigned immediate.
1114
1115 (define_predicate "uint16_operand"
1116   (match_code "const_int")
1117 {
1118   if (GET_CODE (op) != CONST_INT)
1119     return FALSE;
1120
1121   return IN_RANGE_P (INTVAL (op), 0, 0xffff);
1122 })
1123
1124 ;; Returns 1 if OP is either a SYMBOL_REF or a constant.
1125
1126 (define_predicate "symbolic_operand"
1127   (match_code "symbol_ref,const_int")
1128 {
1129   enum rtx_code c = GET_CODE (op);
1130
1131   if (c == CONST)
1132     {
1133       /* Allow (const:SI (plus:SI (symbol_ref) (const_int))).  */
1134       return GET_MODE (op) == SImode
1135         && GET_CODE (XEXP (op, 0)) == PLUS
1136         && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
1137         && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT;
1138     }
1139
1140   return c == SYMBOL_REF || c == CONST_INT;
1141 })
1142
1143 ;; Return true if operator is a kind of relational operator.
1144
1145 (define_predicate "relational_operator"
1146   (match_code "eq,ne,le,lt,ge,gt,leu,ltu,geu,gtu")
1147 {
1148   return (integer_relational_operator (op, mode)
1149           || float_relational_operator (op, mode));
1150 })
1151
1152 ;; Return true if OP is a relational operator suitable for CCmode,
1153 ;; CC_UNSmode or CC_NZmode.
1154
1155 (define_predicate "integer_relational_operator"
1156   (match_code "eq,ne,le,lt,ge,gt,leu,ltu,geu,gtu")
1157 {
1158   if (mode != VOIDmode && mode != GET_MODE (op))
1159     return FALSE;
1160
1161   /* The allowable relations depend on the mode of the ICC register.  */
1162   switch (GET_CODE (op))
1163     {
1164     default:
1165       return FALSE;
1166
1167     case EQ:
1168     case NE:
1169     case LT:
1170     case GE:
1171       return (GET_MODE (XEXP (op, 0)) == CC_NZmode
1172               || GET_MODE (XEXP (op, 0)) == CCmode);
1173
1174     case LE:
1175     case GT:
1176       return GET_MODE (XEXP (op, 0)) == CCmode;
1177
1178     case GTU:
1179     case GEU:
1180     case LTU:
1181     case LEU:
1182       return (GET_MODE (XEXP (op, 0)) == CC_NZmode
1183               || GET_MODE (XEXP (op, 0)) == CC_UNSmode);
1184     }
1185 })
1186
1187 ;; Return true if operator is a floating point relational operator.
1188
1189 (define_predicate "float_relational_operator"
1190   (match_code "eq,ne,le,lt,ge,gt")
1191 {
1192   if (mode != VOIDmode && mode != GET_MODE (op))
1193     return FALSE;
1194
1195   switch (GET_CODE (op))
1196     {
1197     default:
1198       return FALSE;
1199
1200     case EQ: case NE:
1201     case LE: case LT:
1202     case GE: case GT:
1203 #if 0
1204     case UEQ: case UNE:
1205     case ULE: case ULT:
1206     case UGE: case UGT:
1207     case ORDERED:
1208     case UNORDERED:
1209 #endif
1210       return GET_MODE (XEXP (op, 0)) == CC_FPmode;
1211     }
1212 })
1213
1214 ;; Return true if operator is EQ/NE of a conditional execution
1215 ;; register.
1216
1217 (define_predicate "ccr_eqne_operator"
1218   (match_code "eq,ne")
1219 {
1220   enum machine_mode op_mode = GET_MODE (op);
1221   rtx op0;
1222   rtx op1;
1223   int regno;
1224
1225   if (mode != VOIDmode && op_mode != mode)
1226     return FALSE;
1227
1228   switch (GET_CODE (op))
1229     {
1230     default:
1231       return FALSE;
1232
1233     case EQ:
1234     case NE:
1235       break;
1236     }
1237
1238   op1 = XEXP (op, 1);
1239   if (op1 != const0_rtx)
1240     return FALSE;
1241
1242   op0 = XEXP (op, 0);
1243   if (GET_CODE (op0) != REG)
1244     return FALSE;
1245
1246   regno = REGNO (op0);
1247   if (op_mode == CC_CCRmode && CR_OR_PSEUDO_P (regno))
1248     return TRUE;
1249
1250   return FALSE;
1251 })
1252
1253 ;; Return true if operator is a minimum or maximum operator (both
1254 ;; signed and unsigned).
1255
1256 (define_predicate "minmax_operator"
1257   (match_code "smin,smax,umin,umax")
1258 {
1259   if (mode != VOIDmode && mode != GET_MODE (op))
1260     return FALSE;
1261
1262   switch (GET_CODE (op))
1263     {
1264     default:
1265       return FALSE;
1266
1267     case SMIN:
1268     case SMAX:
1269     case UMIN:
1270     case UMAX:
1271       break;
1272     }
1273
1274   if (! integer_register_operand (XEXP (op, 0), mode))
1275     return FALSE;
1276
1277   if (! gpr_or_int10_operand (XEXP (op, 1), mode))
1278     return FALSE;
1279
1280   return TRUE;
1281 })
1282
1283 ;; Return true if operator is an integer binary operator that can
1284 ;; executed conditionally and takes 1 cycle.
1285
1286 (define_predicate "condexec_si_binary_operator"
1287   (match_code "plus,minus,and,ior,xor,ashift,ashiftrt,lshiftrt")
1288 {
1289   enum machine_mode op_mode = GET_MODE (op);
1290
1291   if (mode != VOIDmode && op_mode != mode)
1292     return FALSE;
1293
1294   switch (GET_CODE (op))
1295     {
1296     default:
1297       return FALSE;
1298
1299     case PLUS:
1300     case MINUS:
1301     case AND:
1302     case IOR:
1303     case XOR:
1304     case ASHIFT:
1305     case ASHIFTRT:
1306     case LSHIFTRT:
1307       return TRUE;
1308     }
1309 })
1310
1311 ;; Return true if operator is an integer binary operator that can be
1312 ;; executed conditionally by a media instruction.
1313
1314 (define_predicate "condexec_si_media_operator"
1315   (match_code "and,ior,xor")
1316 {
1317   enum machine_mode op_mode = GET_MODE (op);
1318
1319   if (mode != VOIDmode && op_mode != mode)
1320     return FALSE;
1321
1322   switch (GET_CODE (op))
1323     {
1324     default:
1325       return FALSE;
1326
1327     case AND:
1328     case IOR:
1329     case XOR:
1330       return TRUE;
1331     }
1332 })
1333
1334 ;; Return true if operator is an integer division operator that can
1335 ;; executed conditionally.
1336
1337 (define_predicate "condexec_si_divide_operator"
1338   (match_code "div,udiv")
1339 {
1340   enum machine_mode op_mode = GET_MODE (op);
1341
1342   if (mode != VOIDmode && op_mode != mode)
1343     return FALSE;
1344
1345   switch (GET_CODE (op))
1346     {
1347     default:
1348       return FALSE;
1349
1350     case DIV:
1351     case UDIV:
1352       return TRUE;
1353     }
1354 })
1355
1356 ;; Return true if operator is an integer unary operator that can
1357 ;; executed conditionally.
1358
1359 (define_predicate "condexec_si_unary_operator"
1360   (match_code "not,neg")
1361 {
1362   enum machine_mode op_mode = GET_MODE (op);
1363
1364   if (mode != VOIDmode && op_mode != mode)
1365     return FALSE;
1366
1367   switch (GET_CODE (op))
1368     {
1369     default:
1370       return FALSE;
1371
1372     case NEG:
1373     case NOT:
1374       return TRUE;
1375     }
1376 })
1377
1378 ;; Return true if operator is an addition or subtraction
1379 ;; expression. Such expressions can be evaluated conditionally by
1380 ;; floating-point instructions.
1381
1382 (define_predicate "condexec_sf_add_operator"
1383   (match_code "plus,minus")
1384 {
1385   enum machine_mode op_mode = GET_MODE (op);
1386
1387   if (mode != VOIDmode && op_mode != mode)
1388     return FALSE;
1389
1390   switch (GET_CODE (op))
1391     {
1392     default:
1393       return FALSE;
1394
1395     case PLUS:
1396     case MINUS:
1397       return TRUE;
1398     }
1399 })
1400
1401 ;; Return true if operator is a conversion-type expression that can be
1402 ;; evaluated conditionally by floating-point instructions.
1403
1404 (define_predicate "condexec_sf_conv_operator"
1405   (match_code "abs,neg")
1406 {
1407   enum machine_mode op_mode = GET_MODE (op);
1408
1409   if (mode != VOIDmode && op_mode != mode)
1410     return FALSE;
1411
1412   switch (GET_CODE (op))
1413     {
1414     default:
1415       return FALSE;
1416
1417     case NEG:
1418     case ABS:
1419       return TRUE;
1420     }
1421 })
1422
1423 ;; Return true if OP is an integer binary operator that can be
1424 ;; combined with a (set ... (compare:CC_NZ ...)) pattern.
1425
1426 (define_predicate "intop_compare_operator"
1427   (match_code "plus,minus,and,ior,xor,ashift,ashiftrt,lshiftrt")
1428 {
1429   if (mode != VOIDmode && GET_MODE (op) != mode)
1430     return FALSE;
1431
1432   switch (GET_CODE (op))
1433     {
1434     default:
1435       return FALSE;
1436
1437     case PLUS:
1438     case MINUS:
1439     case AND:
1440     case IOR:
1441     case XOR:
1442     case ASHIFTRT:
1443     case LSHIFTRT:
1444       return GET_MODE (op) == SImode;
1445     }
1446 })
1447
1448 ;; Return 1 if operand is a register or 6 bit signed immediate.
1449
1450 (define_predicate "fpr_or_int6_operand"
1451   (match_code "reg,subreg,const_int")
1452 {
1453   if (GET_CODE (op) == CONST_INT)
1454     return IN_RANGE_P (INTVAL (op), -32, 31);
1455
1456   if (GET_MODE (op) != mode && mode != VOIDmode)
1457     return FALSE;
1458
1459   if (GET_CODE (op) == SUBREG)
1460     {
1461       if (GET_CODE (SUBREG_REG (op)) != REG)
1462         return register_operand (op, mode);
1463
1464       op = SUBREG_REG (op);
1465     }
1466
1467   if (GET_CODE (op) != REG)
1468     return FALSE;
1469
1470   return FPR_OR_PSEUDO_P (REGNO (op));
1471 })
1472
1473 ;; Return 1 if operand is a 6 bit signed immediate.
1474
1475 (define_predicate "int6_operand"
1476   (match_code "const_int")
1477 {
1478   if (GET_CODE (op) != CONST_INT)
1479     return FALSE;
1480
1481   return IN_RANGE_P (INTVAL (op), -32, 31);
1482 })
1483
1484 ;; Return 1 if operand is a 5 bit signed immediate.
1485
1486 (define_predicate "int5_operand"
1487   (match_code "const_int")
1488 {
1489   return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), -16, 15);
1490 })
1491
1492 ;; Return 1 if operand is a 5 bit unsigned immediate.
1493
1494 (define_predicate "uint5_operand"
1495   (match_code "const_int")
1496 {
1497   return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), 0, 31);
1498 })
1499
1500 ;; Return 1 if operand is a 4 bit unsigned immediate.
1501
1502 (define_predicate "uint4_operand"
1503   (match_code "const_int")
1504 {
1505   return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), 0, 15);
1506 })
1507
1508 ;; Return 1 if operand is a 1 bit unsigned immediate (0 or 1).
1509
1510 (define_predicate "uint1_operand"
1511   (match_code "const_int")
1512 {
1513   return GET_CODE (op) == CONST_INT && IN_RANGE_P (INTVAL (op), 0, 1);
1514 })
1515
1516 ;; Return 1 if operand is a valid ACC register number.
1517
1518 (define_predicate "acc_operand"
1519   (match_code "reg,subreg")
1520 {
1521   return ((mode == VOIDmode || mode == GET_MODE (op))
1522           && REG_P (op) && ACC_P (REGNO (op))
1523           && ((REGNO (op) - ACC_FIRST) & ~ACC_MASK) == 0);
1524 })
1525
1526 ;; Return 1 if operand is a valid even ACC register number.
1527
1528 (define_predicate "even_acc_operand"
1529   (match_code "reg,subreg")
1530 {
1531   return acc_operand (op, mode) && ((REGNO (op) - ACC_FIRST) & 1) == 0;
1532 })
1533
1534 ;; Return 1 if operand is zero or four.
1535
1536 (define_predicate "quad_acc_operand"
1537   (match_code "reg,subreg")
1538 {
1539   return acc_operand (op, mode) && ((REGNO (op) - ACC_FIRST) & 3) == 0;
1540 })
1541
1542 ;; Return 1 if operand is a valid ACCG register number.
1543
1544 (define_predicate "accg_operand"
1545   (match_code "reg,subreg")
1546 {
1547   return ((mode == VOIDmode || mode == GET_MODE (op))
1548           && REG_P (op) && ACCG_P (REGNO (op))
1549           && ((REGNO (op) - ACCG_FIRST) & ~ACC_MASK) == 0);
1550 })