gcse.c (gcse_emit_move_after): New.
[gcc.git] / gcc / gengenrtl.c
1 /* Generate code to allocate RTL structures.
2 Copyright (C) 1997, 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
19 02111-1307, USA. */
20
21
22 #include "hconfig.h"
23 #include "system.h"
24
25 #define NO_GENRTL_H
26 #include "rtl.h"
27 #undef abort
28
29 #include "real.h"
30
31 struct rtx_definition
32 {
33 const char *const enumname, *const name, *const format;
34 };
35
36 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { STRINGX(ENUM), NAME, FORMAT },
37
38 static const struct rtx_definition defs[] =
39 {
40 #include "rtl.def" /* rtl expressions are documented here */
41 };
42
43 static const char *formats[NUM_RTX_CODE];
44
45 static const char *type_from_format PARAMS ((int));
46 static const char *accessor_from_format PARAMS ((int));
47 static int special_format PARAMS ((const char *));
48 static int special_rtx PARAMS ((int));
49 static int excluded_rtx PARAMS ((int));
50 static void find_formats PARAMS ((void));
51 static void gendecl PARAMS ((const char *));
52 static void genmacro PARAMS ((int));
53 static void gendef PARAMS ((const char *));
54 static void genlegend PARAMS ((void));
55 static void genheader PARAMS ((void));
56 static void gencode PARAMS ((void));
57 \f
58 /* Decode a format letter into a C type string. */
59
60 static const char *
61 type_from_format (c)
62 int c;
63 {
64 switch (c)
65 {
66 case 'i':
67 return "int ";
68
69 case 'w':
70 return "HOST_WIDE_INT ";
71
72 case 's':
73 return "const char *";
74
75 case 'e': case 'u':
76 return "rtx ";
77
78 case 'E':
79 return "rtvec ";
80 case 'b':
81 return "struct bitmap_head_def *"; /* bitmap - typedef not available */
82 case 't':
83 return "union tree_node *"; /* tree - typedef not available */
84 case 'B':
85 return "struct basic_block_def *"; /* basic block - typedef not available */
86 default:
87 abort ();
88 }
89 }
90
91 /* Decode a format letter into the proper accessor function. */
92
93 static const char *
94 accessor_from_format (c)
95 int c;
96 {
97 switch (c)
98 {
99 case 'i':
100 return "XINT";
101
102 case 'w':
103 return "XWINT";
104
105 case 's':
106 return "XSTR";
107
108 case 'e': case 'u':
109 return "XEXP";
110
111 case 'E':
112 return "XVEC";
113
114 case 'b':
115 return "XBITMAP";
116
117 case 't':
118 return "XTREE";
119
120 case 'B':
121 return "XBBDEF";
122
123 default:
124 abort ();
125 }
126 }
127
128 /* Return nonzero if we should ignore FMT, an RTL format, when making
129 the list of formats we write routines to create. */
130
131 static int
132 special_format (fmt)
133 const char *fmt;
134 {
135 return (strchr (fmt, '*') != 0
136 || strchr (fmt, 'V') != 0
137 || strchr (fmt, 'S') != 0
138 || strchr (fmt, 'n') != 0);
139 }
140
141 /* Return nonzero if the RTL code given by index IDX is one that we should
142 generate a gen_rtx_raw_FOO macro for, not gen_rtx_FOO (because gen_rtx_FOO
143 is a wrapper in emit-rtl.c). */
144
145 static int
146 special_rtx (idx)
147 int idx;
148 {
149 return (strcmp (defs[idx].enumname, "CONST_INT") == 0
150 || strcmp (defs[idx].enumname, "REG") == 0
151 || strcmp (defs[idx].enumname, "SUBREG") == 0
152 || strcmp (defs[idx].enumname, "MEM") == 0);
153 }
154
155 /* Return nonzero if the RTL code given by index IDX is one that we should
156 generate no macro for at all (because gen_rtx_FOO is never used or
157 cannot have the obvious interface). */
158
159 static int
160 excluded_rtx (idx)
161 int idx;
162 {
163 return (strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0);
164 }
165
166 /* Place a list of all format specifiers we use into the array FORMAT. */
167
168 static void
169 find_formats ()
170 {
171 int i;
172
173 for (i = 0; i < NUM_RTX_CODE; i++)
174 {
175 const char **f;
176
177 if (special_format (defs[i].format))
178 continue;
179
180 for (f = formats; *f; f++)
181 if (! strcmp (*f, defs[i].format))
182 break;
183
184 if (*f == 0)
185 *f = defs[i].format;
186 }
187 }
188
189 /* Write the declarations for the routine to allocate RTL with FORMAT. */
190
191 static void
192 gendecl (format)
193 const char *format;
194 {
195 const char *p;
196 int i, pos;
197
198 printf ("extern rtx gen_rtx_fmt_%s\tPARAMS ((RTX_CODE, ", format);
199 printf ("enum machine_mode mode");
200
201 /* Write each parameter that is needed and start a new line when the line
202 would overflow. */
203 for (p = format, i = 0, pos = 75; *p != 0; p++)
204 if (*p != '0')
205 {
206 int ourlen = strlen (type_from_format (*p)) + 6 + (i > 9);
207
208 printf (",");
209 if (pos + ourlen > 76)
210 printf ("\n\t\t\t\t "), pos = 39;
211
212 printf (" %sarg%d", type_from_format (*p), i++);
213 pos += ourlen;
214 }
215
216 printf ("));\n");
217 }
218
219 /* Generate macros to generate RTL of code IDX using the functions we
220 write. */
221
222 static void
223 genmacro (idx)
224 int idx;
225 {
226 const char *p;
227 int i;
228
229 /* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to
230 gen_rtx_fmt_FORMAT where FORMAT is the RTX_FORMAT of RTLCODE. */
231
232 if (excluded_rtx (idx))
233 /* Don't define a macro for this code. */
234 return;
235
236 printf ("#define gen_rtx_%s%s(MODE",
237 special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
238
239 for (p = defs[idx].format, i = 0; *p != 0; p++)
240 if (*p != '0')
241 printf (", ARG%d", i++);
242
243 printf (") \\\n gen_rtx_fmt_%s (%s, (MODE)",
244 defs[idx].format, defs[idx].enumname);
245
246 for (p = defs[idx].format, i = 0; *p != 0; p++)
247 if (*p != '0')
248 printf (", (ARG%d)", i++);
249
250 puts (")");
251 }
252
253 /* Generate the code for the function to generate RTL whose
254 format is FORMAT. */
255
256 static void
257 gendef (format)
258 const char *format;
259 {
260 const char *p;
261 int i, j;
262
263 /* Start by writing the definition of the function name and the types
264 of the arguments. */
265
266 printf ("rtx\ngen_rtx_fmt_%s (code, mode", format);
267 for (p = format, i = 0; *p != 0; p++)
268 if (*p != '0')
269 printf (", arg%d", i++);
270
271 puts (")\n RTX_CODE code;\n enum machine_mode mode;");
272 for (p = format, i = 0; *p != 0; p++)
273 if (*p != '0')
274 printf (" %sarg%d;\n", type_from_format (*p), i++);
275
276 /* Now write out the body of the function itself, which allocates
277 the memory and initializes it. */
278 puts ("{");
279 puts (" rtx rt;");
280 printf (" rt = ggc_alloc_rtx (%d);\n", (int) strlen (format));
281
282 puts (" memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));\n");
283 puts (" PUT_CODE (rt, code);");
284 puts (" PUT_MODE (rt, mode);");
285
286 for (p = format, i = j = 0; *p ; ++p, ++i)
287 if (*p != '0')
288 printf (" %s (rt, %d) = arg%d;\n", accessor_from_format (*p), i, j++);
289 else
290 printf (" X0EXP (rt, %d) = NULL_RTX;\n", i);
291
292 puts ("\n return rt;\n}\n");
293 }
294
295 /* Generate the documentation header for files we write. */
296
297 static void
298 genlegend ()
299 {
300 puts ("/* Generated automatically by gengenrtl from rtl.def. */\n");
301 }
302
303 /* Generate the text of the header file we make, genrtl.h. */
304
305 static void
306 genheader ()
307 {
308 int i;
309 const char **fmt;
310
311 puts ("#ifndef GCC_GENRTL_H");
312 puts ("#define GCC_GENRTL_H\n");
313
314 for (fmt = formats; *fmt; ++fmt)
315 gendecl (*fmt);
316
317 putchar ('\n');
318
319 for (i = 0; i < NUM_RTX_CODE; i++)
320 if (! special_format (defs[i].format))
321 genmacro (i);
322
323 puts ("\n#endif /* GCC_GENRTL_H */");
324 }
325
326 /* Generate the text of the code file we write, genrtl.c. */
327
328 static void
329 gencode ()
330 {
331 const char **fmt;
332
333 puts ("#include \"config.h\"");
334 puts ("#include \"system.h\"");
335 puts ("#include \"obstack.h\"");
336 puts ("#include \"rtl.h\"");
337 puts ("#include \"ggc.h\"\n");
338 puts ("extern struct obstack *rtl_obstack;\n");
339 puts ("#define obstack_alloc_rtx(n) \\");
340 puts (" ((rtx) obstack_alloc (rtl_obstack, \\");
341 puts (" sizeof (struct rtx_def) \\");
342 puts (" + ((n) - 1) * sizeof (rtunion)))\n");
343
344 for (fmt = formats; *fmt != 0; fmt++)
345 gendef (*fmt);
346 }
347
348 /* This is the main program. We accept only one argument, "-h", which
349 says we are writing the genrtl.h file. Otherwise we are writing the
350 genrtl.c file. */
351 extern int main PARAMS ((int, char **));
352
353 int
354 main (argc, argv)
355 int argc;
356 char **argv;
357 {
358 find_formats ();
359 genlegend ();
360
361 if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'h')
362 genheader ();
363 else
364 gencode ();
365
366 if (ferror (stdout) || fflush (stdout) || fclose (stdout))
367 return FATAL_EXIT_CODE;
368
369 return SUCCESS_EXIT_CODE;
370 }