OSDN Git Service

* config/m32c/cond.md (cbranch<mode>4): Defer splitting until after reload.
[pf3gnuchains/gcc-fork.git] / gcc / config / m32c / predicates.md
1 ;; Machine Descriptions for R8C/M16C/M32C
2 ;; Copyright (C) 2005
3 ;; Free Software Foundation, Inc.
4 ;; Contributed by Red Hat.
5 ;;
6 ;; This file is part of GCC.
7 ;;
8 ;; GCC is free software; you can redistribute it and/or modify it
9 ;; under the terms of the GNU General Public License as published
10 ;; by the Free Software Foundation; either version 2, or (at your
11 ;; option) any later version.
12 ;;
13 ;; GCC is distributed in the hope that it will be useful, but WITHOUT
14 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16 ;; License for more details.
17 ;;
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with GCC; see the file COPYING.  If not, write to the Free
20 ;; Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 ;; 02110-1301, USA.
22
23 ;; Predicates
24
25 ; TRUE for any valid operand.  We do this because general_operand
26 ; refuses to match volatile memory refs.
27
28 (define_predicate "m32c_any_operand"
29   (ior (match_operand 0 "general_operand")
30        (match_operand 1 "memory_operand")))
31
32 ; Likewise for nonimmediate_operand.
33
34 (define_predicate "m32c_nonimmediate_operand"
35   (ior (match_operand 0 "nonimmediate_operand")
36        (match_operand 1 "memory_operand")))
37
38 ; TRUE if the operand is a pseudo-register.
39 (define_predicate "m32c_pseudo"
40   (ior (and (match_code "reg")
41             (match_test "REGNO(op) >= FIRST_PSEUDO_REGISTER"))
42        (and (match_code "subreg")
43             (and (match_test "GET_CODE (XEXP (op, 0)) == REG")
44                  (match_test "REGNO(XEXP (op,0)) >= FIRST_PSEUDO_REGISTER")))))
45        
46
47 ; Returning true causes many predicates to NOT match.  We allow
48 ; subregs for type changing, but not for size changing.
49 (define_predicate "m32c_wide_subreg"
50   (and (match_code "subreg")
51        (not (match_operand 0 "m32c_pseudo")))
52   {
53     unsigned int sizeo = GET_MODE_SIZE (GET_MODE (op));
54     unsigned int sizei = GET_MODE_SIZE (GET_MODE (XEXP (op, 0)));
55     sizeo = (sizeo + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
56     sizei = (sizei + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
57     return sizeo != sizei;
58   })
59
60 ; TRUE for r0 through r3, or a pseudo that reload could put in r0
61 ; through r3 (likewise for the next couple too)
62 (define_predicate "r0123_operand"
63   (ior (match_operand 0 "m32c_pseudo" "")
64        (and (match_code "reg")
65             (match_test "REGNO(op) <= R3_REGNO"))))
66
67 ; TRUE for r0
68 (define_predicate "m32c_r0_operand"
69   (ior (match_operand 0 "m32c_pseudo" "")
70        (and (match_code "reg")
71             (match_test "REGNO(op) == R0_REGNO"))))
72
73 ; TRUE for r1
74 (define_predicate "m32c_r1_operand"
75   (ior (match_operand 0 "m32c_pseudo" "")
76        (and (match_code "reg")
77             (match_test "REGNO(op) == R1_REGNO"))))
78
79 ; TRUE for HL_CLASS (r0 or r1)
80 (define_predicate "m32c_hl_operand"
81   (ior (match_operand 0 "m32c_pseudo" "")
82        (and (match_code "reg")
83             (match_test "REGNO(op) == R0_REGNO || REGNO(op) == R1_REGNO"))))
84
85
86 ; TRUE for r2
87 (define_predicate "m32c_r2_operand"
88   (ior (match_operand 0 "m32c_pseudo" "")
89        (and (match_code "reg")
90             (match_test "REGNO(op) == R2_REGNO"))))
91
92 ; TRUE for r3
93 (define_predicate "m32c_r3_operand"
94   (ior (match_operand 0 "m32c_pseudo" "")
95        (and (match_code "reg")
96             (match_test "REGNO(op) == R3_REGNO"))))
97
98 ; TRUE for any general operand except r2.
99 (define_predicate "m32c_notr2_operand"
100   (and (match_operand 0 "general_operand")
101        (ior (not (match_code "reg"))
102             (match_test "REGNO(op) != R2_REGNO"))))
103
104 ; TRUE for the stack pointer.
105 (define_predicate "m32c_sp_operand"
106   (ior (match_operand 0 "m32c_pseudo" "")
107        (and (match_code "reg")
108             (match_test "REGNO(op) == SP_REGNO"))))
109
110 ; TRUE for control registers.
111 (define_predicate "cr_operand"
112   (match_code "reg")
113   "return (REGNO (op) >= SB_REGNO
114            && REGNO (op) <= FLG_REGNO);")
115
116 ; TRUE for $a0 or $a1.
117 (define_predicate "a_operand"
118   (and (match_code "reg")
119        (match_test "REGNO (op) == A0_REGNO || REGNO (op) == A1_REGNO")))
120
121 ; TRUE for $a0 or $a1 or a pseudo
122 (define_predicate "ap_operand"
123   (ior (match_operand 0 "m32c_pseudo" "")
124        (and (match_code "reg")
125             (match_test "REGNO (op) == A0_REGNO || REGNO (op) == A1_REGNO"))))
126
127 ; TRUE for r0 through r3, or a0 or a1.
128 (define_predicate "ra_operand"
129   (and (and (match_operand 0 "register_operand" "")
130             (not (match_operand 1 "cr_operand" "")))
131        (not (match_operand 2 "m32c_wide_subreg" ""))))
132
133 ; Likewise, plus TRUE for memory references.
134 (define_predicate "mra_operand"
135   (and (and (match_operand 0 "nonimmediate_operand" "")
136             (not (match_operand 1 "cr_operand" "")))
137        (not (match_operand 2 "m32c_wide_subreg" ""))))
138
139 ; Likewise, plus TRUE for subregs.
140 (define_predicate "mras_operand"
141   (and (match_operand 0 "nonimmediate_operand" "")
142        (not (match_operand 1 "cr_operand" ""))))
143
144 ; As above, but no push/pop operations
145 (define_predicate "mra_nopp_operand"
146   (match_operand 0 "mra_operand" "")
147 {
148   if (GET_CODE (op) == MEM
149       && (GET_CODE (XEXP (op, 0)) == PRE_DEC
150           || (GET_CODE (XEXP (op, 0)) == POST_INC)))
151     return 0;
152   return 1;
153 })
154
155 ; TRUE for memory, r0..r3, a0..a1, or immediates.
156 (define_predicate "mrai_operand"
157   (and (and (match_operand 0 "m32c_any_operand" "")
158             (not (match_operand 1 "cr_operand" "")))
159        (not (match_operand 2 "m32c_wide_subreg" ""))))
160
161 ; Likewise, plus true for subregs.
162 (define_predicate "mrasi_operand"
163   (and (match_operand 0 "general_operand" "")
164        (not (match_operand 1 "cr_operand" ""))))
165
166 ; TRUE for r0..r3 or memory.
167 (define_predicate "mr_operand"
168   (and (match_operand 0 "mra_operand" "")
169        (not (match_operand 1 "a_operand" ""))))
170
171 ; TRUE for a0..a1 or memory.
172 (define_predicate "ma_operand"
173   (ior (match_operand 0 "a_operand" "")
174        (match_operand 1 "memory_operand" "")))
175
176 ; TRUE for memory operands that are not indexed
177 (define_predicate "memsym_operand"
178   (and (match_operand 0 "memory_operand" "")
179        (match_test "m32c_extra_constraint_p (op, 'S', \"Si\")")))
180
181 ; TRUE for memory operands with small integer addresses
182 (define_predicate "memimmed_operand"
183   (and (match_operand 0 "memory_operand" "")
184        (match_test "m32c_extra_constraint_p (op, 'S', \"Sp\")")))
185
186 ; TRUE for r1h.  This is complicated since r1h isn't a register GCC
187 ; normally knows about.
188 (define_predicate "r1h_operand"
189   (match_code "zero_extract")
190   {
191     rtx reg = XEXP (op, 0);
192     rtx size = XEXP (op, 1);
193     rtx pos = XEXP (op, 2);
194     return (GET_CODE (reg) == REG
195             && REGNO (reg) == R1_REGNO
196             && GET_CODE (size) == CONST_INT
197             && INTVAL (size) == 8
198             && GET_CODE (pos) == CONST_INT
199             && INTVAL (pos) == 8);
200   })
201
202 ; TRUE if we can shift by this amount.  Constant shift counts have a
203 ; limited range.
204 (define_predicate "shiftcount_operand"
205   (ior (match_operand 0 "mra_operand" "")
206        (and (match_operand 2 "const_int_operand" "")
207             (match_test "-8 <= INTVAL (op) && INTVAL (op) && INTVAL (op) <= 8"))))
208 (define_predicate "longshiftcount_operand"
209   (ior (match_operand 0 "mra_operand" "")
210        (and (match_operand 2 "const_int_operand" "")
211             (match_test "-32 <= INTVAL (op) && INTVAL (op) && INTVAL (op) <= 32"))))
212
213 ; TRUE for r0..r3, a0..a1, or sp.
214 (define_predicate "mra_or_sp_operand"
215   (and (ior (match_operand 0 "mra_operand")
216             (match_operand 1 "m32c_sp_operand"))
217        (not (match_operand 2 "m32c_wide_subreg" ""))))
218
219
220 ; TRUE for r2 or r3.
221 (define_predicate "m32c_r2r3_operand"
222   (ior (and (match_code "reg")
223             (ior (match_test "REGNO(op) == R2_REGNO")
224                  (match_test "REGNO(op) == R3_REGNO")))
225        (and (match_code "subreg")
226             (match_test "GET_CODE (XEXP (op, 0)) == REG && (REGNO (XEXP (op, 0)) == R2_REGNO || REGNO (XEXP (op, 0)) == R3_REGNO)"))))
227
228 ; Likewise, plus TRUE for a0..a1.
229 (define_predicate "m32c_r2r3a_operand"
230   (ior (match_operand 0 "m32c_r2r3_operand" "")
231        (match_operand 0 "a_operand" "")))
232
233 ; These two are only for movqi - no subreg limit
234 (define_predicate "mra_qi_operand"
235   (and (and (match_operand 0 "m32c_nonimmediate_operand" "")
236             (not (match_operand 1 "cr_operand" "")))
237        (not (match_operand 1 "m32c_r2r3a_operand" ""))))
238
239 (define_predicate "mrai_qi_operand"
240   (and (and (match_operand 0 "m32c_any_operand" "")
241             (not (match_operand 1 "cr_operand" "")))
242        (not (match_operand 1 "m32c_r2r3a_operand" ""))))
243
244 (define_predicate "a_qi_operand"
245   (ior (match_operand 0 "m32c_pseudo" "")
246        (match_operand 1 "a_operand" "")))
247
248 ; TRUE for comparisons we support.
249 (define_predicate "m32c_cmp_operator"
250   (match_code "eq,ne,gt,gtu,lt,ltu,ge,geu,le,leu"))
251
252 (define_predicate "m32c_eqne_operator"
253   (match_code "eq,ne"))
254
255 ; TRUE for mem0
256 (define_predicate "m32c_mem0_operand"
257   (ior (match_operand 0 "m32c_pseudo" "")
258        (and (match_code "reg")
259             (match_test "REGNO(op) == MEM0_REGNO"))))
260
261 ; TRUE for things the call patterns can return.
262 (define_predicate "m32c_return_operand"
263   (ior (match_operand 0 "m32c_r0_operand")
264        (ior (match_operand 0 "m32c_mem0_operand")
265             (match_code "parallel"))))
266
267 ; TRUE for constants we can multiply pointers by
268 (define_predicate "m32c_psi_scale"
269   (and (match_operand 0 "const_int_operand")
270        (match_test "m32c_const_ok_for_constraint_p(INTVAL(op), 'I', \"Ilb\")")))
271
272 ; TRUE for one bit set (bit) or clear (mask) out of N bits.
273
274 (define_predicate "m32c_1bit8_operand"
275   (and (match_operand 0 "const_int_operand")
276        (match_test "m32c_const_ok_for_constraint_p(INTVAL(op), 'I', \"Ilb\")")))
277
278 (define_predicate "m32c_1bit16_operand"
279   (and (match_operand 0 "const_int_operand")
280        (match_test "m32c_const_ok_for_constraint_p(INTVAL(op), 'I', \"Ilw\")")))
281
282 (define_predicate "m32c_1mask8_operand"
283   (and (match_operand 0 "const_int_operand")
284        (match_test "m32c_const_ok_for_constraint_p(INTVAL(op), 'I', \"Imb\")")))
285
286 (define_predicate "m32c_1mask16_operand"
287   (and (match_operand 0 "const_int_operand")
288        (match_test "m32c_const_ok_for_constraint_p(INTVAL(op), 'I', \"Imw\")")))