Daily bump.
[official-gcc.git] / gcc / genconfig.c
blobae08d1e21ff3a4c690eaf74350e3c2ba0c2f6e13
1 /* Generate from machine description:
2 - some #define configuration flags.
3 Copyright (C) 1987-2014 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 #include "bconfig.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "errors.h"
28 #include "gensupport.h"
31 /* flags to determine output of machine description dependent #define's. */
32 static int max_recog_operands; /* Largest operand number seen. */
33 static int max_dup_operands; /* Largest number of match_dup in any insn. */
34 static int max_clobbers_per_insn;
35 static int have_cc0_flag;
36 static int have_cmove_flag;
37 static int have_cond_exec_flag;
38 static int have_lo_sum_flag;
39 static int have_rotate_flag;
40 static int have_rotatert_flag;
41 static int have_peephole_flag;
42 static int have_peephole2_flag;
44 /* Maximum number of insns seen in a split. */
45 static int max_insns_per_split = 1;
47 /* Maximum number of input insns for peephole2. */
48 static int max_insns_per_peep2;
50 static int clobbers_seen_this_insn;
51 static int dup_operands_seen_this_insn;
53 static void walk_insn_part (rtx, int, int);
54 static void gen_insn (rtx);
55 static void gen_expand (rtx);
56 static void gen_split (rtx);
57 static void gen_peephole (rtx);
58 static void gen_peephole2 (rtx);
60 /* RECOG_P will be nonzero if this pattern was seen in a context where it will
61 be used to recognize, rather than just generate an insn.
63 NON_PC_SET_SRC will be nonzero if this pattern was seen in a SET_SRC
64 of a SET whose destination is not (pc). */
66 static void
67 walk_insn_part (rtx part, int recog_p, int non_pc_set_src)
69 int i, j;
70 RTX_CODE code;
71 const char *format_ptr;
73 if (part == 0)
74 return;
76 code = GET_CODE (part);
77 switch (code)
79 case CLOBBER:
80 clobbers_seen_this_insn++;
81 break;
83 case MATCH_OPERAND:
84 if (XINT (part, 0) > max_recog_operands)
85 max_recog_operands = XINT (part, 0);
86 return;
88 case MATCH_OP_DUP:
89 case MATCH_PAR_DUP:
90 ++dup_operands_seen_this_insn;
91 case MATCH_SCRATCH:
92 case MATCH_PARALLEL:
93 case MATCH_OPERATOR:
94 if (XINT (part, 0) > max_recog_operands)
95 max_recog_operands = XINT (part, 0);
96 /* Now scan the rtl's in the vector inside the MATCH_OPERATOR or
97 MATCH_PARALLEL. */
98 break;
100 case LABEL_REF:
101 if (GET_CODE (LABEL_REF_LABEL (part)) == MATCH_OPERAND
102 || GET_CODE (LABEL_REF_LABEL (part)) == MATCH_DUP)
103 break;
104 return;
106 case MATCH_DUP:
107 ++dup_operands_seen_this_insn;
108 if (XINT (part, 0) > max_recog_operands)
109 max_recog_operands = XINT (part, 0);
110 return;
112 case CC0:
113 if (recog_p)
114 have_cc0_flag = 1;
115 return;
117 case LO_SUM:
118 if (recog_p)
119 have_lo_sum_flag = 1;
120 return;
122 case ROTATE:
123 if (recog_p)
124 have_rotate_flag = 1;
125 return;
127 case ROTATERT:
128 if (recog_p)
129 have_rotatert_flag = 1;
130 return;
132 case SET:
133 walk_insn_part (SET_DEST (part), 0, recog_p);
134 walk_insn_part (SET_SRC (part), recog_p,
135 GET_CODE (SET_DEST (part)) != PC);
136 return;
138 case IF_THEN_ELSE:
139 /* Only consider this machine as having a conditional move if the
140 two arms of the IF_THEN_ELSE are both MATCH_OPERAND. Otherwise,
141 we have some specific IF_THEN_ELSE construct (like the doz
142 instruction on the RS/6000) that can't be used in the general
143 context we want it for. */
145 if (recog_p && non_pc_set_src
146 && GET_CODE (XEXP (part, 1)) == MATCH_OPERAND
147 && GET_CODE (XEXP (part, 2)) == MATCH_OPERAND)
148 have_cmove_flag = 1;
149 break;
151 case COND_EXEC:
152 if (recog_p)
153 have_cond_exec_flag = 1;
154 break;
156 case REG: case CONST_INT: case SYMBOL_REF:
157 case PC:
158 return;
160 default:
161 break;
164 format_ptr = GET_RTX_FORMAT (GET_CODE (part));
166 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
167 switch (*format_ptr++)
169 case 'e':
170 case 'u':
171 walk_insn_part (XEXP (part, i), recog_p, non_pc_set_src);
172 break;
173 case 'E':
174 if (XVEC (part, i) != NULL)
175 for (j = 0; j < XVECLEN (part, i); j++)
176 walk_insn_part (XVECEXP (part, i, j), recog_p, non_pc_set_src);
177 break;
181 static void
182 gen_insn (rtx insn)
184 int i;
186 /* Walk the insn pattern to gather the #define's status. */
187 clobbers_seen_this_insn = 0;
188 dup_operands_seen_this_insn = 0;
189 if (XVEC (insn, 1) != 0)
190 for (i = 0; i < XVECLEN (insn, 1); i++)
191 walk_insn_part (XVECEXP (insn, 1, i), 1, 0);
193 if (clobbers_seen_this_insn > max_clobbers_per_insn)
194 max_clobbers_per_insn = clobbers_seen_this_insn;
195 if (dup_operands_seen_this_insn > max_dup_operands)
196 max_dup_operands = dup_operands_seen_this_insn;
199 /* Similar but scan a define_expand. */
201 static void
202 gen_expand (rtx insn)
204 int i;
206 /* Walk the insn pattern to gather the #define's status. */
208 /* Note that we don't bother recording the number of MATCH_DUPs
209 that occur in a gen_expand, because only reload cares about that. */
210 if (XVEC (insn, 1) != 0)
211 for (i = 0; i < XVECLEN (insn, 1); i++)
213 /* Compute the maximum SETs and CLOBBERS
214 in any one of the sub-insns;
215 don't sum across all of them. */
216 clobbers_seen_this_insn = 0;
218 walk_insn_part (XVECEXP (insn, 1, i), 0, 0);
220 if (clobbers_seen_this_insn > max_clobbers_per_insn)
221 max_clobbers_per_insn = clobbers_seen_this_insn;
225 /* Similar but scan a define_split. */
227 static void
228 gen_split (rtx split)
230 int i;
232 /* Look through the patterns that are matched
233 to compute the maximum operand number. */
234 for (i = 0; i < XVECLEN (split, 0); i++)
235 walk_insn_part (XVECEXP (split, 0, i), 1, 0);
236 /* Look at the number of insns this insn could split into. */
237 if (XVECLEN (split, 2) > max_insns_per_split)
238 max_insns_per_split = XVECLEN (split, 2);
241 static void
242 gen_peephole (rtx peep)
244 int i;
246 /* Look through the patterns that are matched
247 to compute the maximum operand number. */
248 for (i = 0; i < XVECLEN (peep, 0); i++)
249 walk_insn_part (XVECEXP (peep, 0, i), 1, 0);
252 static void
253 gen_peephole2 (rtx peep)
255 int i, n;
257 /* Look through the patterns that are matched
258 to compute the maximum operand number. */
259 for (i = XVECLEN (peep, 0) - 1; i >= 0; --i)
260 walk_insn_part (XVECEXP (peep, 0, i), 1, 0);
262 /* Look at the number of insns this insn can be matched from. */
263 for (i = XVECLEN (peep, 0) - 1, n = 0; i >= 0; --i)
264 if (GET_CODE (XVECEXP (peep, 0, i)) != MATCH_DUP
265 && GET_CODE (XVECEXP (peep, 0, i)) != MATCH_SCRATCH)
266 n++;
267 if (n > max_insns_per_peep2)
268 max_insns_per_peep2 = n;
272 main (int argc, char **argv)
274 rtx desc;
276 progname = "genconfig";
278 if (!init_rtx_reader_args (argc, argv))
279 return (FATAL_EXIT_CODE);
281 puts ("/* Generated automatically by the program `genconfig'");
282 puts (" from the machine description file `md'. */\n");
283 puts ("#ifndef GCC_INSN_CONFIG_H");
284 puts ("#define GCC_INSN_CONFIG_H\n");
286 /* Allow at least 30 operands for the sake of asm constructs. */
287 /* ??? We *really* ought to reorganize things such that there
288 is no fixed upper bound. */
289 max_recog_operands = 29; /* We will add 1 later. */
290 max_dup_operands = 1;
292 /* Read the machine description. */
294 while (1)
296 int line_no, insn_code_number = 0;
298 desc = read_md_rtx (&line_no, &insn_code_number);
299 if (desc == NULL)
300 break;
302 switch (GET_CODE (desc))
304 case DEFINE_INSN:
305 gen_insn (desc);
306 break;
308 case DEFINE_EXPAND:
309 gen_expand (desc);
310 break;
312 case DEFINE_SPLIT:
313 gen_split (desc);
314 break;
316 case DEFINE_PEEPHOLE2:
317 have_peephole2_flag = 1;
318 gen_peephole2 (desc);
319 break;
321 case DEFINE_PEEPHOLE:
322 have_peephole_flag = 1;
323 gen_peephole (desc);
324 break;
326 default:
327 break;
331 printf ("#define MAX_RECOG_OPERANDS %d\n", max_recog_operands + 1);
332 printf ("#define MAX_DUP_OPERANDS %d\n", max_dup_operands);
334 /* This is conditionally defined, in case the user writes code which emits
335 more splits than we can readily see (and knows s/he does it). */
336 printf ("#ifndef MAX_INSNS_PER_SPLIT\n");
337 printf ("#define MAX_INSNS_PER_SPLIT %d\n", max_insns_per_split);
338 printf ("#endif\n");
340 if (have_cc0_flag)
342 printf ("#define HAVE_cc0 1\n");
343 printf ("#define CC0_P(X) ((X) == cc0_rtx)\n");
345 else
347 /* We output CC0_P this way to make sure that X is declared
348 somewhere. */
349 printf ("#define CC0_P(X) ((X) ? 0 : 0)\n");
352 if (have_cmove_flag)
353 printf ("#define HAVE_conditional_move 1\n");
355 if (have_cond_exec_flag)
356 printf ("#define HAVE_conditional_execution 1\n");
358 if (have_lo_sum_flag)
359 printf ("#define HAVE_lo_sum 1\n");
361 if (have_rotate_flag)
362 printf ("#define HAVE_rotate 1\n");
364 if (have_rotatert_flag)
365 printf ("#define HAVE_rotatert 1\n");
367 if (have_peephole_flag)
368 printf ("#define HAVE_peephole 1\n");
370 if (have_peephole2_flag)
372 printf ("#define HAVE_peephole2 1\n");
373 printf ("#define MAX_INSNS_PER_PEEP2 %d\n", max_insns_per_peep2);
376 puts ("\n#endif /* GCC_INSN_CONFIG_H */");
378 if (ferror (stdout) || fflush (stdout) || fclose (stdout))
379 return FATAL_EXIT_CODE;
381 return SUCCESS_EXIT_CODE;