![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genpeep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to genpeep.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Generate code from machine description to perform peephole optimizations.
2: Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: #include <stdio.h>
23: #include "config.h"
24: #include "rtl.h"
25: #include "obstack.h"
26:
27: struct obstack obstack;
28: struct obstack *rtl_obstack = &obstack;
29:
30: #define obstack_chunk_alloc xmalloc
31: #define obstack_chunk_free free
32: extern int xmalloc ();
33: extern void free ();
34:
35: void match_rtx ();
36: void gen_exp ();
37: void fatal ();
38:
39:
40: int max_opno;
41:
42: /* While tree-walking an instruction pattern, we keep a chain
43: of these `struct link's to record how to get down to the
44: current position. In each one, POS is the operand number,
45: and if the operand is a vector VEC is the element number.
46: VEC is -1 if the operand is not a vector. */
47:
48: struct link
49: {
50: struct link *next;
51: int pos;
52: int vecelt;
53: };
54:
55: /* Number of operands used in current peephole definition. */
56:
57: int n_operands;
58:
59: /* Peephole optimizations get insn codes just like insn patterns.
60: Count them so we know the code of the define_peephole we are handling. */
61:
62: int insn_code_number = 0;
63:
64: void print_path ();
65: void print_code ();
66:
67: void
68: gen_peephole (peep)
69: rtx peep;
70: {
71: int ninsns = XVECLEN (peep, 0);
72: int i;
73:
74: n_operands = 0;
75:
76: printf (" insn = ins1;\n");
77:
78: for (i = 0; i < ninsns; i++)
79: {
80: if (i > 0)
81: {
82: printf (" do { insn = NEXT_INSN (insn);\n");
83: printf (" if (insn == 0) goto L%d; }\n",
84: insn_code_number);
85: printf (" while (GET_CODE (insn) == NOTE);\n");
86: }
87:
88: printf (" if (GET_CODE (insn) == CODE_LABEL) goto L%d;\n",
89: insn_code_number);
90:
91: printf (" pat = PATTERN (insn);\n");
92: /* Walk the insn's pattern, remembering at all times the path
93: down to the walking point. */
94:
95: match_rtx (XVECEXP (peep, 0, i), 0, insn_code_number);
96: }
97:
98: /* We get this far if the pattern matches.
99: Now test the extra condition. */
100:
101: if (XSTR (peep, 1) && XSTR (peep, 1)[0])
102: printf (" if (! (%s)) goto L%d;\n",
103: XSTR (peep, 1), insn_code_number);
104:
105: /* If that matches, construct new pattern and put it in the first insn.
106: This new pattern will never be matched.
107: It exists only so that insn-extract can get the operands back.
108: So use a simple regular form: a PARALLEL containing a vector
109: of all the operands. */
110:
111: printf (" PATTERN (ins1) = gen_rtx (PARALLEL, VOIDmode, gen_rtvec_v (%d, operands));\n", n_operands);
112: printf (" insn = ins1;\n");
113:
114: /* Make sure that labels referred to by the insns
115: don't get deleted because of their counts' going to zero. */
116: printf (" for (i = 0; i < %d; i++)\n", n_operands);
117: printf (" if (GET_CODE (operands[i]) == CODE_LABEL)\n");
118: printf (" LABEL_NUSES (operands[i])++;\n");
119:
120: /* Record this define_peephole's insn code in the insn,
121: as if it had been recognized to match this. */
122: printf (" INSN_CODE (insn) = %d;\n",
123: insn_code_number);
124:
125: /* Delete the remaining insns. */
126: for (i = 1; i < ninsns; i++)
127: {
128: printf (" do insn = NEXT_INSN (insn);\n");
129: printf (" while (GET_CODE (insn) == NOTE);\n");
130: printf (" delete_insn (insn);\n");
131: }
132:
133: printf (" return 1;\n");
134:
135: printf (" L%d:\n\n", insn_code_number);
136: }
137:
138: void
139: match_rtx (x, path, fail_label)
140: rtx x;
141: struct link *path;
142: int fail_label;
143: {
144: register RTX_CODE code;
145: register int i;
146: register int len;
147: register char *fmt;
148: struct link link;
149:
150: if (x == 0)
151: return;
152:
153:
154: code = GET_CODE (x);
155:
156: switch (code)
157: {
158: case MATCH_OPERAND:
159: if (XINT (x, 0) > max_opno)
160: max_opno = XINT (x, 0);
161: if (XINT (x, 0) >= n_operands)
162: n_operands = 1 + XINT (x, 0);
163:
164: printf (" x = ");
165: print_path (path);
166: printf (";\n");
167:
168: printf (" operands[%d] = x;\n", XINT (x, 0));
169: if (XSTR (x, 1) && XSTR (x, 1)[0])
170: printf (" if (! %s (x, %smode)) goto L%d;\n",
171: XSTR (x, 1), GET_MODE_NAME (GET_MODE (x)), fail_label);
172: return;
173:
174: case MATCH_DUP:
175: printf (" x = ");
176: print_path (path);
177: printf (";\n");
178:
179: printf (" if (!rtx_equal_p (operands[%d], x)) goto L%d;\n",
180: XINT (x, 0), fail_label);
181: return;
182:
183: case ADDRESS:
184: match_rtx (XEXP (x, 0), path, fail_label);
185: return;
186: }
187:
188: printf (" x = ");
189: print_path (path);
190: printf (";\n");
191:
192: printf (" if (GET_CODE (x) != ");
193: print_code (code);
194: printf (") goto L%d;\n", fail_label);
195:
196: if (GET_MODE (x) != VOIDmode)
197: {
198: printf (" if (GET_MODE (x) != %smode) goto L%d;\n",
199: GET_MODE_NAME (GET_MODE (x)), fail_label);
200: }
201:
202: link.next = path;
203: link.vecelt = -1;
204: fmt = GET_RTX_FORMAT (code);
205: len = GET_RTX_LENGTH (code);
206: for (i = 0; i < len; i++)
207: {
208: link.pos = i;
209: if (fmt[i] == 'e' || fmt[i] == 'u')
210: match_rtx (XEXP (x, i), &link, fail_label);
211: else if (fmt[i] == 'E')
212: {
213: int j;
214: printf (" if (XVECLEN (x, %d) != %d) goto L%d;\n",
215: i, XVECLEN (x, i), fail_label);
216: for (j = XVECLEN (x, i) - 1; j >= 0; j--)
217: {
218: link.vecelt = j;
219: match_rtx (XVECEXP (x, i, j), &link, fail_label);
220: }
221: }
222: else if (fmt[i] == 'i')
223: {
224: /* Make sure that at run time `x' is the RTX we want to test. */
225: if (i != 0)
226: {
227: printf (" x = ");
228: print_path (path);
229: printf (";\n");
230: }
231:
232: printf (" if (XINT (x, %d) != %d) goto L%d;\n",
233: i, XINT (x, i), fail_label);
234: }
235: else if (fmt[i] == 's')
236: {
237: /* Make sure that at run time `x' is the RTX we want to test. */
238: if (i != 0)
239: {
240: printf (" x = ");
241: print_path (path);
242: printf (";\n");
243: }
244:
245: printf (" if (strcmp (XSTR (x, %d), \"%s\")) goto L%d;\n",
246: i, XSTR (x, i), fail_label);
247: }
248: }
249: }
250:
251: /* Given a PATH, representing a path down the instruction's
252: pattern from the root to a certain point, output code to
253: evaluate to the rtx at that point. */
254:
255: void
256: print_path (path)
257: struct link *path;
258: {
259: if (path == 0)
260: printf ("pat");
261: else if (path->vecelt >= 0)
262: {
263: printf ("XVECEXP (");
264: print_path (path->next);
265: printf (", %d, %d)", path->pos, path->vecelt);
266: }
267: else
268: {
269: printf ("XEXP (");
270: print_path (path->next);
271: printf (", %d)", path->pos);
272: }
273: }
274:
275: void
276: print_code (code)
277: RTX_CODE code;
278: {
279: register char *p1;
280: for (p1 = GET_RTX_NAME (code); *p1; p1++)
281: {
282: if (*p1 >= 'a' && *p1 <= 'z')
283: putchar (*p1 + 'A' - 'a');
284: else
285: putchar (*p1);
286: }
287: }
288:
289: int
290: xmalloc (size)
291: {
292: register int val = malloc (size);
293:
294: if (val == 0)
295: fatal ("virtual memory exhausted");
296: return val;
297: }
298:
299: int
300: xrealloc (ptr, size)
301: char *ptr;
302: int size;
303: {
304: int result = realloc (ptr, size);
305: if (!result)
306: fatal ("virtual memory exhausted");
307: return result;
308: }
309:
310: void
311: fatal (s, a1, a2)
312: {
313: fprintf (stderr, "genpeep: ");
314: fprintf (stderr, s, a1, a2);
315: fprintf (stderr, "\n");
316: exit (FATAL_EXIT_CODE);
317: }
318:
319: int
320: main (argc, argv)
321: int argc;
322: char **argv;
323: {
324: rtx desc;
325: FILE *infile;
326: extern rtx read_rtx ();
327: register int c, i;
328:
329: max_opno = -1;
330:
331: obstack_init (rtl_obstack);
332:
333: if (argc <= 1)
334: fatal ("No input file name.");
335:
336: infile = fopen (argv[1], "r");
337: if (infile == 0)
338: {
339: perror (argv[1]);
340: exit (FATAL_EXIT_CODE);
341: }
342:
343: init_rtl ();
344:
345: printf ("/* Generated automatically by the program `genpeep'\n\
346: from the machine description file `md'. */\n\n");
347:
348: printf ("#include \"rtl.h\"\n\n");
349: printf ("#include \"config.h\"\n\n");
350: printf ("#include \"regs.h\"\n\n");
351:
352: printf ("rtx peep_operand[];\n\n");
353: printf ("#define operands peep_operand\n\n");
354:
355: printf ("int\npeephole (ins1)\n rtx ins1;\n{\n");
356: printf (" rtx insn, x, pat;\n");
357: printf (" int i;\n");
358:
359: /* Read the machine description. */
360:
361: while (1)
362: {
363: c = read_skip_spaces (infile);
364: if (c == EOF)
365: break;
366: ungetc (c, infile);
367:
368: desc = read_rtx (infile);
369: if (GET_CODE (desc) == DEFINE_PEEPHOLE)
370: {
371: gen_peephole (desc);
372: insn_code_number++;
373: }
374: if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
375: {
376: insn_code_number++;
377: }
378: }
379:
380: printf (" return 0;\n}\n\n");
381:
382: if (max_opno == -1)
383: max_opno = 1;
384:
385: printf ("rtx peep_operand[%d];\n", max_opno + 1);
386:
387: fflush (stdout);
388: exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
389: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.