![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genextract.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to genextract.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Generate code from machine description to extract operands from insn as rtl.
2: Copyright (C) 1987, 1991, 1992, 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC 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: GNU CC 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 GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: #include <stdio.h>
22: #include "hconfig.h"
23: #include "rtl.h"
24: #include "obstack.h"
25: #include "insn-config.h"
26:
27: static struct obstack obstack;
28: struct obstack *rtl_obstack = &obstack;
29:
30: #define obstack_chunk_alloc xmalloc
31: #define obstack_chunk_free free
32:
33: extern void free ();
34: extern rtx read_rtx ();
35:
36: /* Names for patterns. Need to allow linking with print-rtl. */
37: char **insn_name_ptr;
38:
39: /* This structure contains all the information needed to describe one
40: set of extractions methods. Each method may be used by more than
41: one pattern if the operands are in the same place.
42:
43: The string for each operand describes that path to the operand and
44: contains `0' through `9' when going into an expression and `a' through
45: `z' when going into a vector. We assume here that only the first operand
46: of an rtl expression is a vector. genrecog.c makes the same assumption
47: (and uses the same representation) and it is currently true. */
48:
49: struct extraction
50: {
51: int op_count;
52: char *oplocs[MAX_RECOG_OPERANDS];
53: int dup_count;
54: char *duplocs[MAX_DUP_OPERANDS];
55: int dupnums[MAX_DUP_OPERANDS];
56: struct code_ptr *insns;
57: struct extraction *next;
58: };
59:
60: /* Holds a single insn code that use an extraction method. */
61:
62: struct code_ptr
63: {
64: int insn_code;
65: struct code_ptr *next;
66: };
67:
68: static struct extraction *extractions;
69:
70: /* Number instruction patterns handled, starting at 0 for first one. */
71:
72: static int insn_code_number;
73:
74: /* Records the large operand number in this insn. */
75:
76: static int op_count;
77:
78: /* Records the location of any operands using the string format described
79: above. */
80:
81: static char *oplocs[MAX_RECOG_OPERANDS];
82:
83: /* Number the occurrences of MATCH_DUP in each instruction,
84: starting at 0 for the first occurrence. */
85:
86: static int dup_count;
87:
88: /* Records the location of any MATCH_DUP operands. */
89:
90: static char *duplocs[MAX_DUP_OPERANDS];
91:
92: /* Record the operand number of any MATCH_DUPs. */
93:
94: static int dupnums[MAX_DUP_OPERANDS];
95:
96: /* Record the list of insn_codes for peepholes. */
97:
98: static struct code_ptr *peepholes;
99:
100: static void walk_rtx ();
101: static void print_path ();
102: char *xmalloc ();
103: char *xrealloc ();
104: static void fatal ();
105: static char *copystr ();
106: static void mybzero ();
107: void fancy_abort ();
108:
109: static void
110: gen_insn (insn)
111: rtx insn;
112: {
113: register int i;
114: register struct extraction *p;
115: register struct code_ptr *link;
116:
117: op_count = 0;
118: dup_count = 0;
119:
120: /* No operands seen so far in this pattern. */
121: mybzero (oplocs, sizeof oplocs);
122:
123: /* Walk the insn's pattern, remembering at all times the path
124: down to the walking point. */
125:
126: if (XVECLEN (insn, 1) == 1)
127: walk_rtx (XVECEXP (insn, 1, 0), "");
128: else
129: for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
130: {
131: char *path = (char *) alloca (2);
132:
133: path[0] = 'a' + i;
134: path[1] = 0;
135:
136: walk_rtx (XVECEXP (insn, 1, i), path);
137: }
138:
139: link = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
140: link->insn_code = insn_code_number;
141:
142: /* See if we find something that already had this extraction method. */
143:
144: for (p = extractions; p; p = p->next)
145: {
146: if (p->op_count != op_count || p->dup_count != dup_count)
147: continue;
148:
149: for (i = 0; i < op_count; i++)
150: if (p->oplocs[i] != oplocs[i]
151: && ! (p->oplocs[i] != 0 && oplocs[i] != 0
152: && ! strcmp (p->oplocs[i], oplocs[i])))
153: break;
154:
155: if (i != op_count)
156: continue;
157:
158: for (i = 0; i < dup_count; i++)
159: if (p->dupnums[i] != dupnums[i]
160: || strcmp (p->duplocs[i], duplocs[i]))
161: break;
162:
163: if (i != dup_count)
164: continue;
165:
166: /* This extraction is the same as ours. Just link us in. */
167: link->next = p->insns;
168: p->insns = link;
169: return;
170: }
171:
172: /* Otherwise, make a new extraction method. */
173:
174: p = (struct extraction *) xmalloc (sizeof (struct extraction));
175: p->op_count = op_count;
176: p->dup_count = dup_count;
177: p->next = extractions;
178: extractions = p;
179: p->insns = link;
180: link->next = 0;
181:
182: for (i = 0; i < op_count; i++)
183: p->oplocs[i] = oplocs[i];
184:
185: for (i = 0; i < dup_count; i++)
186: p->dupnums[i] = dupnums[i], p->duplocs[i] = duplocs[i];
187: }
188:
189: static void
190: walk_rtx (x, path)
191: rtx x;
192: char *path;
193: {
194: register RTX_CODE code;
195: register int i;
196: register int len;
197: register char *fmt;
198: register struct code_ptr *link;
199: int depth = strlen (path);
200: char *newpath;
201:
202: if (x == 0)
203: return;
204:
205: code = GET_CODE (x);
206:
207: switch (code)
208: {
209: case PC:
210: case CC0:
211: case CONST_INT:
212: case SYMBOL_REF:
213: return;
214:
215: case MATCH_OPERAND:
216: case MATCH_SCRATCH:
217: oplocs[XINT (x, 0)] = copystr (path);
218: op_count = MAX (op_count, XINT (x, 0) + 1);
219: break;
220:
221: case MATCH_DUP:
222: case MATCH_PAR_DUP:
223: duplocs[dup_count] = copystr (path);
224: dupnums[dup_count] = XINT (x, 0);
225: dup_count++;
226: break;
227:
228: case MATCH_OP_DUP:
229: duplocs[dup_count] = copystr (path);
230: dupnums[dup_count] = XINT (x, 0);
231: dup_count++;
232:
233: newpath = (char *) alloca (depth + 2);
234: strcpy (newpath, path);
235: newpath[depth + 1] = 0;
236:
237: for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
238: {
239: newpath[depth] = '0' + i;
240: walk_rtx (XVECEXP (x, 1, i), newpath);
241: }
242: return;
243:
244: case MATCH_OPERATOR:
245: oplocs[XINT (x, 0)] = copystr (path);
246: op_count = MAX (op_count, XINT (x, 0) + 1);
247:
248: newpath = (char *) alloca (depth + 2);
249: strcpy (newpath, path);
250: newpath[depth + 1] = 0;
251:
252: for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
253: {
254: newpath[depth] = '0' + i;
255: walk_rtx (XVECEXP (x, 2, i), newpath);
256: }
257: return;
258:
259: case MATCH_PARALLEL:
260: oplocs[XINT (x, 0)] = copystr (path);
261: op_count = MAX (op_count, XINT (x, 0) + 1);
262:
263: newpath = (char *) alloca (depth + 2);
264: strcpy (newpath, path);
265: newpath[depth + 1] = 0;
266:
267: for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
268: {
269: newpath[depth] = 'a' + i;
270: walk_rtx (XVECEXP (x, 2, i), newpath);
271: }
272: return;
273:
274: case ADDRESS:
275: walk_rtx (XEXP (x, 0), path);
276: return;
277: }
278:
279: newpath = (char *) alloca (depth + 2);
280: strcpy (newpath, path);
281: newpath[depth + 1] = 0;
282:
283: fmt = GET_RTX_FORMAT (code);
284: len = GET_RTX_LENGTH (code);
285: for (i = 0; i < len; i++)
286: {
287: if (fmt[i] == 'e' || fmt[i] == 'u')
288: {
289: newpath[depth] = '0' + i;
290: walk_rtx (XEXP (x, i), newpath);
291: }
292: else if (fmt[i] == 'E')
293: {
294: int j;
295: for (j = XVECLEN (x, i) - 1; j >= 0; j--)
296: {
297: newpath[depth] = 'a' + j;
298: walk_rtx (XVECEXP (x, i, j), newpath);
299: }
300: }
301: }
302: }
303:
304: /* Given a PATH, representing a path down the instruction's
305: pattern from the root to a certain point, output code to
306: evaluate to the rtx at that point. */
307:
308: static void
309: print_path (path)
310: char *path;
311: {
312: register int len = strlen (path);
313: register int i;
314:
315: /* We first write out the operations (XEXP or XVECEXP) in reverse
316: order, then write "insn", then the indices in forward order. */
317:
318: for (i = len - 1; i >=0 ; i--)
319: {
320: if (path[i] >= 'a' && path[i] <= 'z')
321: printf ("XVECEXP (");
322: else if (path[i] >= '0' && path[i] <= '9')
323: printf ("XEXP (");
324: else
325: abort ();
326: }
327:
328: printf ("pat");
329:
330: for (i = 0; i < len; i++)
331: {
332: if (path[i] >= 'a' && path[i] <= 'z')
333: printf (", 0, %d)", path[i] - 'a');
334: else if (path[i] >= '0' && path[i] <= '9')
335: printf (", %d)", path[i] - '0');
336: else
337: abort ();
338: }
339: }
340:
341: char *
342: xmalloc (size)
343: unsigned size;
344: {
345: register char *val = (char *) malloc (size);
346:
347: if (val == 0)
348: fatal ("virtual memory exhausted");
349: return val;
350: }
351:
352: char *
353: xrealloc (ptr, size)
354: char *ptr;
355: unsigned size;
356: {
357: char *result = (char *) realloc (ptr, size);
358: if (!result)
359: fatal ("virtual memory exhausted");
360: return result;
361: }
362:
363: static void
364: fatal (s, a1, a2)
365: char *s;
366: {
367: fprintf (stderr, "genextract: ");
368: fprintf (stderr, s, a1, a2);
369: fprintf (stderr, "\n");
370: exit (FATAL_EXIT_CODE);
371: }
372:
373: /* More 'friendly' abort that prints the line and file.
374: config.h can #define abort fancy_abort if you like that sort of thing. */
375:
376: void
377: fancy_abort ()
378: {
379: fatal ("Internal gcc abort.");
380: }
381:
382: static char *
383: copystr (s1)
384: char *s1;
385: {
386: register char *tem;
387:
388: if (s1 == 0)
389: return 0;
390:
391: tem = (char *) xmalloc (strlen (s1) + 1);
392: strcpy (tem, s1);
393:
394: return tem;
395: }
396:
397: static void
398: mybzero (b, length)
399: register char *b;
400: register unsigned length;
401: {
402: while (length-- > 0)
403: *b++ = 0;
404: }
405:
406: int
407: main (argc, argv)
408: int argc;
409: char **argv;
410: {
411: rtx desc;
412: FILE *infile;
413: register int c, i;
414: struct extraction *p;
415: struct code_ptr *link;
416:
417: obstack_init (rtl_obstack);
418:
419: if (argc <= 1)
420: fatal ("No input file name.");
421:
422: infile = fopen (argv[1], "r");
423: if (infile == 0)
424: {
425: perror (argv[1]);
426: exit (FATAL_EXIT_CODE);
427: }
428:
429: init_rtl ();
430:
431: /* Assign sequential codes to all entries in the machine description
432: in parallel with the tables in insn-output.c. */
433:
434: insn_code_number = 0;
435:
436: printf ("/* Generated automatically by the program `genextract'\n\
437: from the machine description file `md'. */\n\n");
438:
439: printf ("#include \"config.h\"\n");
440: printf ("#include \"rtl.h\"\n\n");
441:
442: /* This variable exists only so it can be the "location"
443: of any missing operand whose numbers are skipped by a given pattern. */
444: printf ("static rtx junk;\n");
445:
446: printf ("extern rtx recog_operand[];\n");
447: printf ("extern rtx *recog_operand_loc[];\n");
448: printf ("extern rtx *recog_dup_loc[];\n");
449: printf ("extern char recog_dup_num[];\n");
450: printf ("extern\n#ifdef __GNUC__\n__volatile__\n#endif\n");
451: printf ("void fatal_insn_not_found ();\n\n");
452:
453: printf ("void\ninsn_extract (insn)\n");
454: printf (" rtx insn;\n");
455: printf ("{\n");
456: printf (" register rtx *ro = recog_operand;\n");
457: printf (" register rtx **ro_loc = recog_operand_loc;\n");
458: printf (" rtx pat = PATTERN (insn);\n");
459: printf (" switch (INSN_CODE (insn))\n");
460: printf (" {\n");
461: printf (" case -1:\n");
462: printf (" fatal_insn_not_found (insn);\n\n");
463:
464: /* Read the machine description. */
465:
466: while (1)
467: {
468: c = read_skip_spaces (infile);
469: if (c == EOF)
470: break;
471: ungetc (c, infile);
472:
473: desc = read_rtx (infile);
474: if (GET_CODE (desc) == DEFINE_INSN)
475: {
476: gen_insn (desc);
477: ++insn_code_number;
478: }
479:
480: else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
481: {
482: struct code_ptr *link
483: = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
484:
485: link->insn_code = insn_code_number;
486: link->next = peepholes;
487: peepholes = link;
488: ++insn_code_number;
489: }
490:
491: else if (GET_CODE (desc) == DEFINE_EXPAND
492: || GET_CODE (desc) == DEFINE_SPLIT)
493: ++insn_code_number;
494: }
495:
496: /* Write out code to handle peepholes and the insn_codes that it should
497: be called for. */
498: if (peepholes)
499: {
500: for (link = peepholes; link; link = link->next)
501: printf (" case %d:\n", link->insn_code);
502:
503: /* The vector in the insn says how many operands it has.
504: And all it contains are operands. In fact, the vector was
505: created just for the sake of this function. */
506: printf ("#if __GNUC__ > 1 && !defined (bcopy)\n");
507: printf ("#define bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)\n");
508: printf ("#endif\n");
509: printf (" bcopy (&XVECEXP (pat, 0, 0), ro,\n");
510: printf (" sizeof (rtx) * XVECLEN (pat, 0));\n");
511: printf (" break;\n\n");
512: }
513:
514: /* Write out all the ways to extract insn operands. */
515: for (p = extractions; p; p = p->next)
516: {
517: for (link = p->insns; link; link = link->next)
518: printf (" case %d:\n", link->insn_code);
519:
520: for (i = 0; i < p->op_count; i++)
521: {
522: if (p->oplocs[i] == 0)
523: {
524: printf (" ro[%d] = const0_rtx;\n", i);
525: printf (" ro_loc[%d] = &junk;\n", i);
526: }
527: else
528: {
529: printf (" ro[%d] = *(ro_loc[%d] = &", i, i);
530: print_path (p->oplocs[i]);
531: printf (");\n");
532: }
533: }
534:
535: for (i = 0; i < p->dup_count; i++)
536: {
537: printf (" recog_dup_loc[%d] = &", i);
538: print_path (p->duplocs[i]);
539: printf (";\n");
540: printf (" recog_dup_num[%d] = %d;\n", i, p->dupnums[i]);
541: }
542:
543: printf (" break;\n\n");
544: }
545:
546: /* This should never be reached. Note that we would also reach this abort
547: if we tried to extract something whose INSN_CODE was a DEFINE_EXPAND or
548: DEFINE_SPLIT, but that is correct. */
549: printf (" default:\n abort ();\n");
550:
551: printf (" }\n}\n");
552:
553: fflush (stdout);
554: exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
555: /* NOTREACHED */
556: return 0;
557: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.