![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genconfig.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to genconfig.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Generate from machine description:
2:
3: - some #define configuration flags.
4: Copyright (C) 1987, 1991 Free Software Foundation, Inc.
5:
6: This file is part of GNU CC.
7:
8: GNU CC is free software; you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation; either version 2, or (at your option)
11: any later version.
12:
13: GNU CC is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with GNU CC; see the file COPYING. If not, write to
20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21:
22:
23: #include <stdio.h>
24: #include "config.h"
25: #include "rtl.h"
26: #include "obstack.h"
27:
28: static struct obstack obstack;
29: struct obstack *rtl_obstack = &obstack;
30:
31: #define obstack_chunk_alloc xmalloc
32: #define obstack_chunk_free free
33:
34: extern void free ();
1.1.1.2 ! root 35: extern rtx read_rtx ();
1.1 root 36:
37: /* flags to determine output of machine description dependent #define's. */
1.1.1.2 ! root 38: static int max_recog_operands; /* Largest operand number seen. */
! 39: static int max_dup_operands; /* Largest number of match_dup in any insn. */
1.1 root 40: static int max_clobbers_per_insn;
41: static int register_constraint_flag;
42: static int have_cc0_flag;
43: static int have_lo_sum_flag;
44:
45: /* Maximum number of insns seen in a split. */
46: static int max_insns_per_split = 1;
47:
48: static int clobbers_seen_this_insn;
49: static int dup_operands_seen_this_insn;
50:
51: char *xmalloc ();
52: static void fatal ();
53: void fancy_abort ();
54:
55: /* RECOG_P will be non-zero if this pattern was seen in a context where it will
56: be used to recognize, rather than just generate an insn. */
57:
58: static void
59: walk_insn_part (part, recog_p)
60: rtx part;
61: {
62: register int i, j;
63: register RTX_CODE code;
64: register char *format_ptr;
65:
66: if (part == 0)
67: return;
68:
69: code = GET_CODE (part);
70: switch (code)
71: {
72: case CLOBBER:
73: clobbers_seen_this_insn++;
74: break;
75:
76: case MATCH_OPERAND:
77: if (XINT (part, 0) > max_recog_operands)
78: max_recog_operands = XINT (part, 0);
79: if (XSTR (part, 2) && *XSTR (part, 2))
80: register_constraint_flag = 1;
81: return;
82:
83: case MATCH_OP_DUP:
84: ++dup_operands_seen_this_insn;
85: case MATCH_SCRATCH:
86: case MATCH_PARALLEL:
87: case MATCH_OPERATOR:
88: if (XINT (part, 0) > max_recog_operands)
89: max_recog_operands = XINT (part, 0);
90: /* Now scan the rtl's in the vector inside the MATCH_OPERATOR or
91: MATCH_PARALLEL. */
92: break;
93:
94: case LABEL_REF:
95: if (GET_CODE (XEXP (part, 0)) == MATCH_OPERAND)
96: break;
97: return;
98:
99: case MATCH_DUP:
100: ++dup_operands_seen_this_insn;
101: if (XINT (part, 0) > max_recog_operands)
102: max_recog_operands = XINT (part, 0);
103: return;
104:
105: case CC0:
106: if (recog_p)
107: have_cc0_flag = 1;
108: return;
109:
110: case LO_SUM:
111: if (recog_p)
112: have_lo_sum_flag = 1;
113: return;
114:
115: case REG: case CONST_INT: case SYMBOL_REF:
116: case PC:
117: return;
118: }
119:
120: format_ptr = GET_RTX_FORMAT (GET_CODE (part));
121:
122: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
123: switch (*format_ptr++)
124: {
125: case 'e':
126: case 'u':
127: walk_insn_part (XEXP (part, i), recog_p);
128: break;
129: case 'E':
130: if (XVEC (part, i) != NULL)
131: for (j = 0; j < XVECLEN (part, i); j++)
132: walk_insn_part (XVECEXP (part, i, j), recog_p);
133: break;
134: }
135: }
136:
137: static void
138: gen_insn (insn)
139: rtx insn;
140: {
141: int i;
142:
143: /* Walk the insn pattern to gather the #define's status. */
144: clobbers_seen_this_insn = 0;
145: dup_operands_seen_this_insn = 0;
146: if (XVEC (insn, 1) != 0)
147: for (i = 0; i < XVECLEN (insn, 1); i++)
148: walk_insn_part (XVECEXP (insn, 1, i), 1);
149:
150: if (clobbers_seen_this_insn > max_clobbers_per_insn)
151: max_clobbers_per_insn = clobbers_seen_this_insn;
152: if (dup_operands_seen_this_insn > max_dup_operands)
153: max_dup_operands = dup_operands_seen_this_insn;
154: }
155:
156: /* Similar but scan a define_expand. */
157:
158: static void
159: gen_expand (insn)
160: rtx insn;
161: {
162: int i;
163:
164: /* Walk the insn pattern to gather the #define's status. */
165:
166: /* Note that we don't bother recording the number of MATCH_DUPs
167: that occur in a gen_expand, because only reload cares about that. */
168: if (XVEC (insn, 1) != 0)
169: for (i = 0; i < XVECLEN (insn, 1); i++)
170: {
171: /* Compute the maximum SETs and CLOBBERS
172: in any one of the sub-insns;
173: don't sum across all of them. */
174: clobbers_seen_this_insn = 0;
175:
176: walk_insn_part (XVECEXP (insn, 1, i), 0);
177:
178: if (clobbers_seen_this_insn > max_clobbers_per_insn)
179: max_clobbers_per_insn = clobbers_seen_this_insn;
180: }
181: }
182:
183: /* Similar but scan a define_split. */
184:
185: static void
186: gen_split (split)
187: rtx split;
188: {
189: int i;
190:
191: /* Look through the patterns that are matched
192: to compute the maximum operand number. */
193: for (i = 0; i < XVECLEN (split, 0); i++)
194: walk_insn_part (XVECEXP (split, 0, i), 1);
195: /* Look at the number of insns this insn could split into. */
196: if (XVECLEN (split, 2) > max_insns_per_split)
197: max_insns_per_split = XVECLEN (split, 2);
198: }
199:
200: static void
201: gen_peephole (peep)
202: rtx peep;
203: {
204: int i;
205:
206: /* Look through the patterns that are matched
207: to compute the maximum operand number. */
208: for (i = 0; i < XVECLEN (peep, 0); i++)
209: walk_insn_part (XVECEXP (peep, 0, i), 1);
210: }
211:
212: char *
213: xmalloc (size)
214: unsigned size;
215: {
216: register char *val = (char *) malloc (size);
217:
218: if (val == 0)
219: fatal ("virtual memory exhausted");
220:
221: return val;
222: }
223:
224: char *
225: xrealloc (ptr, size)
226: char *ptr;
227: unsigned size;
228: {
229: char *result = (char *) realloc (ptr, size);
230: if (!result)
231: fatal ("virtual memory exhausted");
232: return result;
233: }
234:
235: static void
236: fatal (s, a1, a2)
237: char *s;
238: {
239: fprintf (stderr, "genconfig: ");
240: fprintf (stderr, s, a1, a2);
241: fprintf (stderr, "\n");
242: exit (FATAL_EXIT_CODE);
243: }
244:
245: /* More 'friendly' abort that prints the line and file.
246: config.h can #define abort fancy_abort if you like that sort of thing. */
247:
248: void
249: fancy_abort ()
250: {
251: fatal ("Internal gcc abort.");
252: }
253:
254: int
255: main (argc, argv)
256: int argc;
257: char **argv;
258: {
259: rtx desc;
260: FILE *infile;
261: register int c;
262:
263: obstack_init (rtl_obstack);
264:
265: if (argc <= 1)
266: fatal ("No input file name.");
267:
268: infile = fopen (argv[1], "r");
269: if (infile == 0)
270: {
271: perror (argv[1]);
272: exit (FATAL_EXIT_CODE);
273: }
274:
275: init_rtl ();
276:
277: printf ("/* Generated automatically by the program `genconfig'\n\
278: from the machine description file `md'. */\n\n");
279:
280: /* Allow at least 10 operands for the sake of asm constructs. */
1.1.1.2 ! root 281: max_recog_operands = 9; /* We will add 1 later. */
1.1 root 282: max_dup_operands = 1;
283:
284: /* Read the machine description. */
285:
286: while (1)
287: {
288: c = read_skip_spaces (infile);
289: if (c == EOF)
290: break;
291: ungetc (c, infile);
292:
293: desc = read_rtx (infile);
294: if (GET_CODE (desc) == DEFINE_INSN)
295: gen_insn (desc);
296: if (GET_CODE (desc) == DEFINE_EXPAND)
297: gen_expand (desc);
298: if (GET_CODE (desc) == DEFINE_SPLIT)
299: gen_split (desc);
300: if (GET_CODE (desc) == DEFINE_PEEPHOLE)
301: gen_peephole (desc);
302: }
303:
1.1.1.2 ! root 304: printf ("\n#define MAX_RECOG_OPERANDS %d\n", max_recog_operands + 1);
1.1 root 305:
306: printf ("\n#define MAX_DUP_OPERANDS %d\n", max_dup_operands);
307:
308: /* This is conditionally defined, in case the user writes code which emits
309: more splits than we can readily see (and knows s/he does it). */
310: printf ("#ifndef MAX_INSNS_PER_SPLIT\n#define MAX_INSNS_PER_SPLIT %d\n#endif\n",
311: max_insns_per_split);
312:
313: if (register_constraint_flag)
314: printf ("#define REGISTER_CONSTRAINTS\n");
315:
316: if (have_cc0_flag)
317: printf ("#define HAVE_cc0\n");
318:
319: if (have_lo_sum_flag)
320: printf ("#define HAVE_lo_sum\n");
321:
322: fflush (stdout);
323: exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
324: /* NOTREACHED */
325: return 0;
326: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.