![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genopinit.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 genopinit.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Generate code to initialize optabs from machine description.
2: Copyright (C) 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 <ctype.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: char *xmalloc ();
37: static void fatal ();
38: void fancy_abort ();
39:
40: /* Many parts of GCC use arrays that are indexed by machine mode and
41: contain the insn codes for pattern in the MD file that perform a given
42: operation on operands of that mode.
43:
44: These patterns are present in the MD file with names that contain
45: the mode(s) used and the name of the operation. This program
46: writes a function `init_all_optabs' that initializes the optabs with
47: all the insn codes of the relevant patterns present in the MD file.
48:
49: This array contains a list of optabs that need to be initialized. Within
50: each string, the name of the pattern to be matched against is delimited
51: with %( and %). In the string, %a and %b are used to match a short mode
52: name (the part of the mode name not including `mode' and converted to
53: lower-case). When writing out the initializer, the entire string is
54: used. %A and %B are replaced with the full name of the mode; %a and %b
55: are replaced with the short form of the name, as above.
56:
57: If %N is present in the pattern, it means the two modes must be consecutive
58: widths in the same mode class (e.g, QImode and HImode). %I means that
59: only integer modes should be considered for the next mode, and %F means
60: that only float modes should be considered.
61:
62: For some optabs, we store the operation by RTL codes. These are only
63: used for comparisons. In that case, %c and %C are the lower-case and
64: upper-case forms of the comparison, respectively. */
65:
66: /* The reason we use \% is to avoid sequences of the form %-capletter-%
67: which SCCS treats as magic. This gets warnings which you should ignore. */
68:
69: char *optabs[] =
70: { "extendtab[(int) %B][(int) %A][0] = CODE_FOR_%(extend%a\%b2%)",
71: "extendtab[(int) %B][(int) %A][1] = CODE_FOR_%(zero_extend%a\%b2%)",
72: "fixtab[(int) %A][(int) %B][0] = CODE_FOR_%(fix%F\%a%I\%b2%)",
73: "fixtab[(int) %A][(int) %B][1] = CODE_FOR_%(fixuns%F\%a%b2%)",
74: "fixtrunctab[(int) %A][(int) %B][0] = CODE_FOR_%(fix_trunc%F\%a%I\%b2%)",
75: "fixtrunctab[(int) %A][(int) %B][1] = CODE_FOR_%(fixuns_trunc%F\%a%I\%b2%)",
76: "floattab[(int) %B][(int) %A][0] = CODE_FOR_%(float%I\%a%F\%b2%)",
77: "floattab[(int) %B][(int) %A][1] = CODE_FOR_%(floatuns%I\%a%F\%b2%)",
78: "add_optab->handlers[(int) %A].insn_code = CODE_FOR_%(add%a3%)",
79: "sub_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sub%a3%)",
80: "smul_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mul%a3%)",
81: "smul_widen_optab->handlers[(int) %B].insn_code = CODE_FOR_%(mul%a%b3%)%N",
82: "umul_widen_optab->handlers[(int) %B].insn_code = CODE_FOR_%(umul%a%b3%)%N",
83: "sdiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(div%I\%a3%)",
84: "udiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(udiv%I\%a3%)",
85: "sdivmod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(divmod%a4%)",
86: "udivmod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(udivmod%a4%)",
87: "smod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mod%a3%)",
88: "umod_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umod%a3%)",
89: "flodiv_optab->handlers[(int) %A].insn_code = CODE_FOR_%(div%F\%a3%)",
90: "ftrunc_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ftrunc%F\%a2%)",
91: "and_optab->handlers[(int) %A].insn_code = CODE_FOR_%(and%a3%)",
92: "ior_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ior%a3%)",
93: "xor_optab->handlers[(int) %A].insn_code = CODE_FOR_%(xor%a3%)",
94: "ashl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ashl%a3%)",
95: "ashr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ashr%a3%)",
96: "lshl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(lshl%a3%)",
97: "lshr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(lshr%a3%)",
98: "rotl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(rotl%a3%)",
99: "rotr_optab->handlers[(int) %A].insn_code = CODE_FOR_%(rotr%a3%)",
100: "smin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smin%I\%a3%)",
101: "smin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(min%F\%a3%)",
102: "smax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(smax%I\%a3%)",
103: "smax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(max%F\%a3%)",
104: "umin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umin%I\%a3%)",
105: "umax_optab->handlers[(int) %A].insn_code = CODE_FOR_%(umax%I\%a3%)",
106: "neg_optab->handlers[(int) %A].insn_code = CODE_FOR_%(neg%a2%)",
107: "abs_optab->handlers[(int) %A].insn_code = CODE_FOR_%(abs%a2%)",
108: "sqrt_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sqrt%a2%)",
109: "sin_optab->handlers[(int) %A].insn_code = CODE_FOR_%(sin%a2%)",
110: "cos_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cos%a2%)",
111: "strlen_optab->handlers[(int) %A].insn_code = CODE_FOR_%(strlen%a%)",
112: "one_cmpl_optab->handlers[(int) %A].insn_code = CODE_FOR_%(one_cmpl%a2%)",
113: "ffs_optab->handlers[(int) %A].insn_code = CODE_FOR_%(ffs%a2%)",
114: "mov_optab->handlers[(int) %A].insn_code = CODE_FOR_%(mov%a%)",
115: "movstrict_optab->handlers[(int) %A].insn_code = CODE_FOR_%(movstrict%a%)",
116: "cmp_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cmp%a%)",
117: "tst_optab->handlers[(int) %A].insn_code = CODE_FOR_%(tst%a%)",
118: "bcc_gen_fctn[(int) %C] = gen_%(b%c%)",
119: "setcc_gen_code[(int) %C] = CODE_FOR_%(s%c%)",
120: "reload_in_optab[(int) %A] = CODE_FOR_%(reload_in%a%)",
121: "reload_out_optab[(int) %A] = CODE_FOR_%(reload_out%a%)",
122: "movstr_optab[(int) %A] = CODE_FOR_%(movstr%a%)" };
123:
124: /* Allow linking with print-rtl.c. */
125: char **insn_name_ptr;
126:
127: static void
128: gen_insn (insn)
129: rtx insn;
130: {
131: char *name = XSTR (insn, 0);
132: int m1, m2, op;
133: int pindex;
134: int i;
135: char *np, *pp, *p, *q;
136: struct obstack *obstack_ptr;
137:
138: /* Don't mention instructions whose names are the null string.
139: They are in the machine description just to be recognized. */
140: if (*name == 0)
141: return;
142:
143: /* See if NAME matches one of the patterns we have for the optabs we know
144: about. */
145:
146: for (pindex = 0; pindex < sizeof optabs / sizeof optabs[0]; pindex++)
147: {
148: int force_float = 0, force_int = 0;
149: int force_consec = 0;
150: int matches = 1;
151:
152: for (pp = optabs[pindex]; pp[0] != '%' || pp[1] != '('; pp++)
153: ;
154:
155: for (pp += 2, np = name; matches && ! (pp[0] == '%' && pp[1] == ')');
156: pp++)
157: {
158: if (*pp != '%')
159: {
160: if (*pp != *np++)
161: break;
162: }
163: else
164: switch (*++pp)
165: {
166: case 'N':
167: force_consec = 1;
168: break;
169: case 'I':
170: force_int = 1;
171: break;
172: case 'F':
173: force_float = 1;
174: break;
175: case 'c':
176: for (op = 0; op < NUM_RTX_CODE; op++)
177: {
178: for (p = rtx_name[op], q = np; *p; p++, q++)
179: if (*p != *q)
180: break;
181:
182: /* We have to be concerned about matching "gt" and
183: missing "gtu", e.g., so verify we have reached the
184: end of thing we are to match. We do not have this
185: problem with modes since no mode is a prefix of
186: another. */
187: if (*p == 0 && *q == 0 && rtx_class[op] == '<')
188: break;
189: }
190:
191: if (op == NUM_RTX_CODE)
192: matches = 0;
193: else
194: np += strlen (rtx_name[op]);
195: break;
196: case 'a':
197: case 'b':
198: for (i = 0; i < (int) MAX_MACHINE_MODE; i++)
199: {
200: for (p = mode_name[i], q = np; *p; p++, q++)
201: if (tolower (*p) != *q)
202: break;
203:
204: if (*p == 0
205: && (! force_int || mode_class[i] == MODE_INT)
206: && (! force_float || mode_class[i] == MODE_FLOAT))
207: break;
208: }
209:
210: if (i == (int) MAX_MACHINE_MODE)
211: matches = 0;
212: else if (*pp == 'a')
213: m1 = i, np += strlen (mode_name[i]);
214: else
215: m2 = i, np += strlen (mode_name[i]);
216:
217: force_int = force_float = 0;
218: break;
219:
220: default:
221: abort ();
222: }
223: }
224:
225: if (matches && pp[0] == '%' && pp[1] == ')'
226: && *np == 0
227: && (! force_consec || (int) mode_wider_mode[m1] == m2))
228: break;
229: }
230:
231: if (pindex == sizeof optabs / sizeof optabs[0])
232: return;
233:
234: /* We found a match. If this pattern is only conditionally present,
235: write out the "if" and two extra blanks. */
236:
237: if (*XSTR (insn, 2) != 0)
238: printf (" if (HAVE_%s)\n ", name);
239:
240: printf (" ");
241:
242: /* Now write out the initialization, making all required substitutions. */
243: for (pp = optabs[pindex]; *pp; pp++)
244: {
245: if (*pp != '%')
246: printf ("%c", *pp);
247: else
248: switch (*++pp)
249: {
250: case '(': case ')':
251: case 'I': case 'F': case 'N':
252: break;
253: case 'a':
254: for (np = mode_name[m1]; *np; np++)
255: printf ("%c", tolower (*np));
256: break;
257: case 'b':
258: for (np = mode_name[m2]; *np; np++)
259: printf ("%c", tolower (*np));
260: break;
261: case 'A':
262: printf ("%smode", mode_name[m1]);
263: break;
264: case 'B':
265: printf ("%smode", mode_name[m2]);
266: break;
267: case 'c':
268: printf ("%s", rtx_name[op]);
269: break;
270: case 'C':
271: for (np = rtx_name[op]; *np; np++)
272: printf ("%c", toupper (*np));
273: break;
274: }
275: }
276:
277: printf (";\n");
278: }
279:
280: char *
281: xmalloc (size)
282: unsigned size;
283: {
284: register char *val = (char *) malloc (size);
285:
286: if (val == 0)
287: fatal ("virtual memory exhausted");
288:
289: return val;
290: }
291:
292: char *
293: xrealloc (ptr, size)
294: char *ptr;
295: unsigned size;
296: {
297: char *result = (char *) realloc (ptr, size);
298: if (!result)
299: fatal ("virtual memory exhausted");
300: return result;
301: }
302:
303: static void
304: fatal (s, a1, a2)
305: char *s;
306: {
307: fprintf (stderr, "genopinit: ");
308: fprintf (stderr, s, a1, a2);
309: fprintf (stderr, "\n");
310: exit (FATAL_EXIT_CODE);
311: }
312:
313: /* More 'friendly' abort that prints the line and file.
314: config.h can #define abort fancy_abort if you like that sort of thing. */
315:
316: void
317: fancy_abort ()
318: {
319: fatal ("Internal gcc abort.");
320: }
321:
322: int
323: main (argc, argv)
324: int argc;
325: char **argv;
326: {
327: rtx desc;
328: rtx dummy;
329: rtx *insn_ptr;
330: FILE *infile;
331: register int c;
332:
333: obstack_init (rtl_obstack);
334:
335: if (argc <= 1)
336: fatal ("No input file name.");
337:
338: infile = fopen (argv[1], "r");
339: if (infile == 0)
340: {
341: perror (argv[1]);
342: exit (FATAL_EXIT_CODE);
343: }
344:
345: init_rtl ();
346:
347: printf ("/* Generated automatically by the program `genopinit'\n\
348: from the machine description file `md'. */\n\n");
349:
350: printf ("#include \"config.h\"\n");
351: printf ("#include \"rtl.h\"\n");
352: printf ("#include \"flags.h\"\n");
353: printf ("#include \"insn-flags.h\"\n");
354: printf ("#include \"insn-codes.h\"\n");
355: printf ("#include \"insn-config.h\"\n");
356: printf ("#include \"recog.h\"\n");
357: printf ("#include \"expr.h\"\n");
358: printf ("#include \"reload.h\"\n\n");
359:
360: printf ("void\ninit_all_optabs ()\n{\n");
361:
362: /* Read the machine description. */
363:
364: while (1)
365: {
366: c = read_skip_spaces (infile);
367: if (c == EOF)
368: break;
369: ungetc (c, infile);
370:
371: desc = read_rtx (infile);
372: if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
373: gen_insn (desc);
374: }
375:
376: printf ("}\n");
377:
378: fflush (stdout);
379: exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
380: /* NOTREACHED */
381: return 0;
382: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.