OSDN Git Service

e4e3805845f210d6460e3e4c7c529f47b28a1cf9
[pf3gnuchains/gcc-fork.git] / gcc / config / mips / predicates.md
1 ;; Predicate definitions for MIPS.
2 ;; Copyright (C) 2004 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 (define_predicate "const_uns_arith_operand"
22   (and (match_code "const_int")
23        (match_test "SMALL_OPERAND_UNSIGNED (INTVAL (op))")))
24
25 (define_predicate "uns_arith_operand"
26   (ior (match_operand 0 "const_uns_arith_operand")
27        (match_operand 0 "register_operand")))
28
29 (define_predicate "const_arith_operand"
30   (and (match_code "const_int")
31        (match_test "SMALL_OPERAND (INTVAL (op))")))
32
33 (define_predicate "arith_operand"
34   (ior (match_operand 0 "const_arith_operand")
35        (match_operand 0 "register_operand")))
36
37 (define_predicate "const_uimm6_operand"
38   (and (match_code "const_int")
39        (match_test "UIMM6_OPERAND (INTVAL (op))")))
40
41 (define_predicate "const_imm10_operand"
42   (and (match_code "const_int")
43        (match_test "IMM10_OPERAND (INTVAL (op))")))
44
45 (define_predicate "reg_imm10_operand"
46   (ior (match_operand 0 "const_imm10_operand")
47        (match_operand 0 "register_operand")))
48
49 (define_predicate "sle_operand"
50   (and (match_code "const_int")
51        (match_test "SMALL_OPERAND (INTVAL (op) + 1)")))
52
53 (define_predicate "sleu_operand"
54   (and (match_operand 0 "sle_operand")
55        (match_test "INTVAL (op) + 1 != 0")))
56
57 (define_predicate "const_0_operand"
58   (and (match_code "const_int,const_double,const_vector")
59        (match_test "op == CONST0_RTX (GET_MODE (op))")))
60
61 (define_predicate "reg_or_0_operand"
62   (ior (and (match_operand 0 "const_0_operand")
63             (match_test "!TARGET_MIPS16"))
64        (match_operand 0 "register_operand")))
65
66 (define_predicate "const_1_operand"
67   (and (match_code "const_int,const_double,const_vector")
68        (match_test "op == CONST1_RTX (GET_MODE (op))")))
69
70 (define_predicate "reg_or_1_operand"
71   (ior (match_operand 0 "const_1_operand")
72        (match_operand 0 "register_operand")))
73
74 ;; This is used for indexing into vectors, and hence only accepts const_int.
75 (define_predicate "const_0_or_1_operand"
76   (and (match_code "const_int")
77        (ior (match_test "op == CONST0_RTX (GET_MODE (op))")
78             (match_test "op == CONST1_RTX (GET_MODE (op))"))))
79
80 (define_predicate "fpr_operand"
81   (and (match_code "reg")
82        (match_test "FP_REG_P (REGNO (op))")))
83
84 (define_predicate "lo_operand"
85   (and (match_code "reg")
86        (match_test "REGNO (op) == LO_REGNUM")))
87
88 (define_predicate "fcc_reload_operand"
89   (and (match_code "reg,subreg")
90        (match_test "ST_REG_P (true_regnum (op))")))
91
92 (define_special_predicate "pc_or_label_operand"
93   (match_code "pc,label_ref"))
94
95 (define_predicate "const_call_insn_operand"
96   (match_code "const,symbol_ref,label_ref")
97 {
98   enum mips_symbol_type symbol_type;
99
100   if (!mips_symbolic_constant_p (op, &symbol_type))
101     return false;
102
103   switch (symbol_type)
104     {
105     case SYMBOL_GENERAL:
106       /* If -mlong-calls, force all calls to use register addressing.  */
107       return !TARGET_LONG_CALLS;
108
109     case SYMBOL_GOT_GLOBAL:
110       /* Without explicit relocs, there is no special syntax for
111          loading the address of a call destination into a register.
112          Using "la $25,foo; jal $25" would prevent the lazy binding
113          of "foo", so keep the address of global symbols with the
114          jal macro.  */
115       return !TARGET_EXPLICIT_RELOCS;
116
117     default:
118       return false;
119     }
120 })
121
122 (define_predicate "call_insn_operand"
123   (ior (match_operand 0 "const_call_insn_operand")
124        (match_operand 0 "register_operand")))
125
126 (define_predicate "move_operand"
127   (match_operand 0 "general_operand")
128 {
129   switch (GET_CODE (op))
130     {
131     case CONST_INT:
132       /* When generating mips16 code, LEGITIMATE_CONSTANT_P rejects
133          CONST_INTs that can't be loaded using simple insns.  */
134       if (TARGET_MIPS16)
135         return true;
136
137       /* When generating 32-bit code, allow DImode move_operands to
138          match arbitrary constants.  We split them after reload.  */
139       if (!TARGET_64BIT && mode == DImode)
140         return true;
141
142       /* Otherwise check whether the constant can be loaded in a single
143          instruction.  */
144       return LUI_INT (op) || SMALL_INT (op) || SMALL_INT_UNSIGNED (op);
145
146     case CONST:
147     case SYMBOL_REF:
148     case LABEL_REF:
149       return CONST_GP_P (op) || mips_atomic_symbolic_constant_p (op);
150
151     default:
152       return true;
153     }
154 })
155
156 (define_predicate "consttable_operand"
157   (match_test "CONSTANT_P (op)"))
158
159 (define_predicate "symbolic_operand"
160   (match_code "const,symbol_ref,label_ref")
161 {
162   enum mips_symbol_type type;
163   return mips_symbolic_constant_p (op, &type);
164 })
165
166 (define_predicate "general_symbolic_operand"
167   (match_code "const,symbol_ref,label_ref")
168 {
169   enum mips_symbol_type type;
170   return mips_symbolic_constant_p (op, &type) && type == SYMBOL_GENERAL;
171 })
172
173 (define_predicate "global_got_operand"
174   (match_code "const,symbol_ref,label_ref")
175 {
176   enum mips_symbol_type type;
177   return mips_symbolic_constant_p (op, &type) && type == SYMBOL_GOT_GLOBAL;
178 })
179
180 (define_predicate "local_got_operand"
181   (match_code "const,symbol_ref,label_ref")
182 {
183   enum mips_symbol_type type;
184   return mips_symbolic_constant_p (op, &type) && type == SYMBOL_GOT_LOCAL;
185 })
186
187 (define_predicate "stack_operand"
188   (and (match_code "mem")
189        (match_test "mips_stack_address_p (XEXP (op, 0), GET_MODE (op))")))
190
191 (define_predicate "macc_msac_operand"
192   (ior (and (match_code "plus") (match_test "ISA_HAS_MACC"))
193        (and (match_code "minus") (match_test "ISA_HAS_MSAC")))
194 {
195   rtx mult = XEXP (op, GET_CODE (op) == PLUS ? 0 : 1);
196   rtx accum = XEXP (op, GET_CODE (op) == PLUS ? 1 : 0);
197   return (GET_CODE (mult) == MULT
198           && REG_P (XEXP (mult, 0))
199           && REG_P (XEXP (mult, 1))
200           && REG_P (accum));
201 })
202
203
204 (define_predicate "equality_operator"
205   (match_code "eq,ne"))
206
207 (define_predicate "extend_operator"
208   (match_code "zero_extend,sign_extend"))
209
210 (define_predicate "trap_comparison_operator"
211   (match_code "eq,ne,lt,ltu,ge,geu"))
212
213
214 (define_predicate "small_data_pattern"
215   (and (match_code "set,parallel,unspec,unspec_volatile,prefetch")
216        (match_test "mips_small_data_pattern_p (op)")))