OSDN Git Service

* config/mcore/predicates.md (mcore_general_movesrc_operand): Accept CONSTs.
[pf3gnuchains/gcc-fork.git] / gcc / config / mcore / predicates.md
1 ;; Predicate definitions for Motorola MCore.
2 ;; Copyright (C) 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 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 ;; Nonzero if OP is a normal arithmetic register.
22
23 (define_predicate "mcore_arith_reg_operand"
24   (match_code "reg,subreg")
25 {
26   if (! register_operand (op, mode))
27     return 0;
28
29   if (GET_CODE (op) == SUBREG)
30     op = SUBREG_REG (op);
31
32   if (GET_CODE (op) == REG)
33     return REGNO (op) != CC_REG;
34
35   return 1;
36 })
37
38 ;; Nonzero if OP can be source of a simple move operation.
39
40 (define_predicate "mcore_general_movsrc_operand"
41   (match_code "mem,const_int,reg,subreg,symbol_ref,label_ref,const")
42 {
43   /* Any (MEM LABEL_REF) is OK.  That is a pc-relative load.  */
44   if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == LABEL_REF)
45     return 1;
46
47   return general_operand (op, mode);
48 })
49
50 ;; Nonzero if OP can be destination of a simple move operation.
51
52 (define_predicate "mcore_general_movdst_operand"
53   (match_code "mem,reg,subreg")
54 {
55   if (GET_CODE (op) == REG && REGNO (op) == CC_REG)
56     return 0;
57
58   return general_operand (op, mode);
59 })
60
61 ;; Nonzero if OP should be recognized during reload for an ixh/ixw
62 ;; operand.  See the ixh/ixw patterns.
63
64 (define_predicate "mcore_reload_operand"
65   (match_code "mem,reg,subreg")
66 {
67   if (mcore_arith_reg_operand (op, mode))
68     return 1;
69
70   if (! reload_in_progress)
71     return 0;
72
73   return GET_CODE (op) == MEM;
74 })
75
76 ;; Nonzero if OP is a valid source operand for an arithmetic insn.
77
78 (define_predicate "mcore_arith_J_operand"
79   (match_code "const_int,reg,subreg")
80 {
81   if (register_operand (op, mode))
82     return 1;
83
84   if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_J (INTVAL (op)))
85     return 1;
86
87   return 0;
88 })
89
90 ;; Nonzero if OP is a valid source operand for an arithmetic insn.
91
92 (define_predicate "mcore_arith_K_operand"
93   (match_code "const_int,reg,subreg")
94 {
95   if (register_operand (op, mode))
96     return 1;
97
98   if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_K (INTVAL (op)))
99     return 1;
100
101   return 0;
102 })
103
104 ;; Nonzero if OP is a valid source operand for a shift or rotate insn.
105
106 (define_predicate "mcore_arith_K_operand_not_0"
107   (match_code "const_int,reg,subreg")
108 {
109   if (register_operand (op, mode))
110     return 1;
111
112   if (   GET_CODE (op) == CONST_INT
113       && CONST_OK_FOR_K (INTVAL (op))
114       && INTVAL (op) != 0)
115     return 1;
116
117   return 0;
118 })
119
120 ;; TODO: Add a comment here.
121
122 (define_predicate "mcore_arith_M_operand"
123   (match_code "const_int,reg,subreg")
124 {
125   if (register_operand (op, mode))
126     return 1;
127
128   if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_M (INTVAL (op)))
129     return 1;
130
131   return 0;
132 })
133
134 ;; TODO: Add a comment here.
135
136 (define_predicate "mcore_arith_K_S_operand"
137   (match_code "const_int,reg,subreg")
138 {
139   if (register_operand (op, mode))
140     return 1;
141
142   if (GET_CODE (op) == CONST_INT)
143     {
144       if (CONST_OK_FOR_K (INTVAL (op)) || (mcore_num_zeros (INTVAL (op)) <= 2))
145         return 1;
146     }
147
148   return 0;
149 })
150
151 ;; Nonzero if OP is a valid source operand for a cmov with two consts
152 ;; +/- 1.
153
154 (define_predicate "mcore_arith_O_operand"
155   (match_code "const_int,reg,subreg")
156 {
157   if (register_operand (op, mode))
158     return 1;
159
160   if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_O (INTVAL (op)))
161     return 1;
162
163   return 0;
164 })
165
166 ;; Nonzero if OP is a valid source operand for loading.
167
168 (define_predicate "mcore_arith_imm_operand"
169   (match_code "const_int,reg,subreg")
170 {
171   if (register_operand (op, mode))
172     return 1;
173
174   if (GET_CODE (op) == CONST_INT && const_ok_for_mcore (INTVAL (op)))
175     return 1;
176
177   return 0;
178 })
179
180 ;; TODO: Add a comment here.
181
182 (define_predicate "mcore_arith_any_imm_operand"
183   (match_code "const_int,reg,subreg")
184 {
185   if (register_operand (op, mode))
186     return 1;
187
188   if (GET_CODE (op) == CONST_INT)
189     return 1;
190
191   return 0;
192 })
193
194 ;; Nonzero if OP is a valid source operand for a btsti.
195
196 (define_predicate "mcore_literal_K_operand"
197   (match_code "const_int")
198 {
199   if (GET_CODE (op) == CONST_INT && CONST_OK_FOR_K (INTVAL (op)))
200     return 1;
201
202   return 0;
203 })
204
205 ;; Nonzero if OP is a valid source operand for an add/sub insn.
206
207 (define_predicate "mcore_addsub_operand"
208   (match_code "const_int,reg,subreg")
209 {
210   if (register_operand (op, mode))
211     return 1;
212
213   if (GET_CODE (op) == CONST_INT)
214     {
215       /* The following has been removed because it precludes large constants from being
216          returned as valid source operands for and add/sub insn.  While large
217          constants may not directly be used in an add/sub, they may if first loaded
218          into a register.  Thus, this predicate should indicate that they are valid,
219          and the constraint in mcore.md should control whether an additional load to
220          register is needed. (see mcore.md, addsi). -- DAC 4/2/1998
221       
222       if (CONST_OK_FOR_J (INTVAL (op)) || CONST_OK_FOR_L (INTVAL (op)))
223         return 1;
224
225          However we do still need to check to make sure that the constant is not too
226          big, especially if we are running on a 64-bit OS...  Nickc 8/1/07.  */
227
228       if (trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
229         return 0;
230
231       return 1;
232
233     }
234
235   return 0;
236 })
237
238 ;; Nonzero if OP is a valid source operand for a compare operation.
239
240 (define_predicate "mcore_compare_operand"
241   (match_code "const_int,reg,subreg")
242 {
243   if (register_operand (op, mode))
244     return 1;
245
246   if (GET_CODE (op) == CONST_INT && INTVAL (op) == 0)
247     return 1;
248
249   return 0;
250 })
251
252 ;; Return 1 if OP is a load multiple operation.  It is known to be a
253 ;; PARALLEL and the first section will be tested.
254
255 (define_predicate "mcore_load_multiple_operation"
256   (match_code "parallel")
257 {
258   int count = XVECLEN (op, 0);
259   int dest_regno;
260   rtx src_addr;
261   int i;
262
263   /* Perform a quick check so we don't blow up below.  */
264   if (count <= 1
265       || GET_CODE (XVECEXP (op, 0, 0)) != SET
266       || GET_CODE (SET_DEST (XVECEXP (op, 0, 0))) != REG
267       || GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != MEM)
268     return 0;
269
270   dest_regno = REGNO (SET_DEST (XVECEXP (op, 0, 0)));
271   src_addr = XEXP (SET_SRC (XVECEXP (op, 0, 0)), 0);
272
273   for (i = 1; i < count; i++)
274     {
275       rtx elt = XVECEXP (op, 0, i);
276
277       if (GET_CODE (elt) != SET
278           || GET_CODE (SET_DEST (elt)) != REG
279           || GET_MODE (SET_DEST (elt)) != SImode
280           || REGNO (SET_DEST (elt))    != (unsigned) (dest_regno + i)
281           || GET_CODE (SET_SRC (elt))  != MEM
282           || GET_MODE (SET_SRC (elt))  != SImode
283           || GET_CODE (XEXP (SET_SRC (elt), 0)) != PLUS
284           || ! rtx_equal_p (XEXP (XEXP (SET_SRC (elt), 0), 0), src_addr)
285           || GET_CODE (XEXP (XEXP (SET_SRC (elt), 0), 1)) != CONST_INT
286           || INTVAL (XEXP (XEXP (SET_SRC (elt), 0), 1)) != i * 4)
287         return 0;
288     }
289
290   return 1;
291 })
292
293 ;; Similar, but tests for store multiple.
294
295 (define_predicate "mcore_store_multiple_operation"
296   (match_code "parallel")
297 {
298   int count = XVECLEN (op, 0);
299   int src_regno;
300   rtx dest_addr;
301   int i;
302
303   /* Perform a quick check so we don't blow up below.  */
304   if (count <= 1
305       || GET_CODE (XVECEXP (op, 0, 0)) != SET
306       || GET_CODE (SET_DEST (XVECEXP (op, 0, 0))) != MEM
307       || GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != REG)
308     return 0;
309
310   src_regno = REGNO (SET_SRC (XVECEXP (op, 0, 0)));
311   dest_addr = XEXP (SET_DEST (XVECEXP (op, 0, 0)), 0);
312
313   for (i = 1; i < count; i++)
314     {
315       rtx elt = XVECEXP (op, 0, i);
316
317       if (GET_CODE (elt) != SET
318           || GET_CODE (SET_SRC (elt)) != REG
319           || GET_MODE (SET_SRC (elt)) != SImode
320           || REGNO (SET_SRC (elt)) != (unsigned) (src_regno + i)
321           || GET_CODE (SET_DEST (elt)) != MEM
322           || GET_MODE (SET_DEST (elt)) != SImode
323           || GET_CODE (XEXP (SET_DEST (elt), 0)) != PLUS
324           || ! rtx_equal_p (XEXP (XEXP (SET_DEST (elt), 0), 0), dest_addr)
325           || GET_CODE (XEXP (XEXP (SET_DEST (elt), 0), 1)) != CONST_INT
326           || INTVAL (XEXP (XEXP (SET_DEST (elt), 0), 1)) != i * 4)
327         return 0;
328     }
329
330   return 1;
331 })
332
333 ;; TODO: Add a comment here.
334
335 (define_predicate "mcore_call_address_operand"
336   (match_code "reg,subreg,const_int,symbol_ref")
337 {
338   return register_operand (op, mode) || CONSTANT_P (op);
339 })