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