OSDN Git Service

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