Mercurial > hg > CbC > CbC_gcc
annotate gcc/gengenrtl.c @ 120:f93fa5091070
fix conv1.c
author | mir3636 |
---|---|
date | Thu, 08 Mar 2018 14:53:42 +0900 |
parents | 04ced10e8804 |
children | 84e7813d76e9 |
rev | line source |
---|---|
0 | 1 /* Generate code to allocate RTL structures. |
111 | 2 Copyright (C) 1997-2017 Free Software Foundation, Inc. |
0 | 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 3, 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 COPYING3. If not see | |
18 <http://www.gnu.org/licenses/>. */ | |
19 | |
20 | |
21 #include "bconfig.h" | |
22 #include "system.h" | |
23 | |
24 struct rtx_definition | |
25 { | |
26 const char *const enumname, *const name, *const format; | |
27 }; | |
28 | |
29 /* rtl.def needs CONST_DOUBLE_FORMAT, but we don't care what | |
30 CONST_DOUBLE_FORMAT is because we're not going to be generating | |
31 anything for CONST_DOUBLE anyway. */ | |
32 #define CONST_DOUBLE_FORMAT "" | |
33 | |
34 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { #ENUM, NAME, FORMAT }, | |
35 | |
36 static const struct rtx_definition defs[] = | |
37 { | |
38 #include "rtl.def" /* rtl expressions are documented here */ | |
39 }; | |
111 | 40 #define NUM_RTX_CODE ARRAY_SIZE (defs) |
0 | 41 |
42 static const char *formats[NUM_RTX_CODE]; | |
43 | |
44 /* Decode a format letter into a C type string. */ | |
45 | |
46 static const char * | |
47 type_from_format (int c) | |
48 { | |
49 switch (c) | |
50 { | |
51 case 'i': | |
52 return "int "; | |
53 | |
54 case 'w': | |
55 return "HOST_WIDE_INT "; | |
56 | |
57 case 's': | |
58 return "const char *"; | |
59 | |
60 case 'e': case 'u': | |
61 return "rtx "; | |
62 | |
63 case 'E': | |
64 return "rtvec "; | |
65 case 't': | |
111 | 66 return "tree "; |
0 | 67 case 'B': |
111 | 68 return "basic_block "; |
0 | 69 default: |
70 gcc_unreachable (); | |
71 } | |
72 } | |
73 | |
74 /* Decode a format letter into the proper accessor function. */ | |
75 | |
76 static const char * | |
77 accessor_from_format (int c) | |
78 { | |
79 switch (c) | |
80 { | |
81 case 'i': | |
82 return "XINT"; | |
83 | |
84 case 'w': | |
85 return "XWINT"; | |
86 | |
87 case 's': | |
88 return "XSTR"; | |
89 | |
90 case 'e': case 'u': | |
91 return "XEXP"; | |
92 | |
93 case 'E': | |
94 return "XVEC"; | |
95 | |
96 case 't': | |
97 return "XTREE"; | |
98 | |
99 case 'B': | |
100 return "XBBDEF"; | |
101 | |
102 default: | |
103 gcc_unreachable (); | |
104 } | |
105 } | |
106 | |
107 /* Return nonzero if we should ignore FMT, an RTL format, when making | |
108 the list of formats we write routines to create. */ | |
109 | |
110 static int | |
111 special_format (const char *fmt) | |
112 { | |
113 return (strchr (fmt, '*') != 0 | |
114 || strchr (fmt, 'V') != 0 | |
115 || strchr (fmt, 'S') != 0 | |
111 | 116 || strchr (fmt, 'n') != 0 |
117 || strchr (fmt, 'r') != 0); | |
118 } | |
119 | |
120 /* Return true if CODE always has VOIDmode. */ | |
121 | |
122 static inline bool | |
123 always_void_p (int idx) | |
124 { | |
125 return strcmp (defs[idx].enumname, "SET") == 0; | |
0 | 126 } |
127 | |
128 /* Return nonzero if the RTL code given by index IDX is one that we should | |
129 generate a gen_rtx_raw_FOO macro for, not gen_rtx_FOO (because gen_rtx_FOO | |
130 is a wrapper in emit-rtl.c). */ | |
131 | |
132 static int | |
133 special_rtx (int idx) | |
134 { | |
111 | 135 return (strcmp (defs[idx].enumname, "EXPR_LIST") == 0 |
136 || strcmp (defs[idx].enumname, "INSN_LIST") == 0 | |
137 || strcmp (defs[idx].enumname, "INSN") == 0 | |
138 || strcmp (defs[idx].enumname, "CONST_INT") == 0 | |
0 | 139 || strcmp (defs[idx].enumname, "REG") == 0 |
140 || strcmp (defs[idx].enumname, "SUBREG") == 0 | |
141 || strcmp (defs[idx].enumname, "MEM") == 0 | |
111 | 142 || strcmp (defs[idx].enumname, "PC") == 0 |
143 || strcmp (defs[idx].enumname, "CC0") == 0 | |
144 || strcmp (defs[idx].enumname, "RETURN") == 0 | |
145 || strcmp (defs[idx].enumname, "SIMPLE_RETURN") == 0 | |
0 | 146 || strcmp (defs[idx].enumname, "CONST_VECTOR") == 0); |
147 } | |
148 | |
149 /* Return nonzero if the RTL code given by index IDX is one that we should | |
150 generate no macro for at all (because gen_rtx_FOO is never used or | |
151 cannot have the obvious interface). */ | |
152 | |
153 static int | |
154 excluded_rtx (int idx) | |
155 { | |
111 | 156 return (strcmp (defs[idx].enumname, "VAR_LOCATION") == 0 |
157 || strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0 | |
158 || strcmp (defs[idx].enumname, "CONST_WIDE_INT") == 0 | |
159 || strcmp (defs[idx].enumname, "CONST_FIXED") == 0); | |
0 | 160 } |
161 | |
162 /* Place a list of all format specifiers we use into the array FORMAT. */ | |
163 | |
164 static void | |
165 find_formats (void) | |
166 { | |
167 unsigned int i; | |
168 | |
169 for (i = 0; i < NUM_RTX_CODE; i++) | |
170 { | |
171 const char **f; | |
172 | |
173 if (special_format (defs[i].format)) | |
174 continue; | |
175 | |
176 for (f = formats; *f; f++) | |
177 if (! strcmp (*f, defs[i].format)) | |
178 break; | |
179 | |
180 if (*f == 0) | |
181 *f = defs[i].format; | |
182 } | |
183 } | |
184 | |
185 | |
186 /* Generate macros to generate RTL of code IDX using the functions we | |
187 write. */ | |
188 | |
189 static void | |
190 genmacro (int idx) | |
191 { | |
192 const char *p; | |
111 | 193 const char *sep = ""; |
0 | 194 int i; |
195 | |
196 /* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to | |
197 gen_rtx_fmt_FORMAT where FORMAT is the RTX_FORMAT of RTLCODE. */ | |
198 | |
199 if (excluded_rtx (idx)) | |
200 /* Don't define a macro for this code. */ | |
201 return; | |
202 | |
111 | 203 bool has_mode_p = !always_void_p (idx); |
204 printf ("#define gen_rtx_%s%s(", | |
0 | 205 special_rtx (idx) ? "raw_" : "", defs[idx].enumname); |
111 | 206 if (has_mode_p) |
207 { | |
208 printf ("MODE"); | |
209 sep = ", "; | |
210 } | |
0 | 211 |
212 for (p = defs[idx].format, i = 0; *p != 0; p++) | |
213 if (*p != '0') | |
111 | 214 { |
215 printf ("%sARG%d", sep, i++); | |
216 sep = ", "; | |
217 } | |
0 | 218 |
111 | 219 printf (") \\\n gen_rtx_fmt_%s (%s, %s", |
220 defs[idx].format, defs[idx].enumname, | |
221 has_mode_p ? "(MODE)" : "VOIDmode"); | |
0 | 222 |
223 for (p = defs[idx].format, i = 0; *p != 0; p++) | |
224 if (*p != '0') | |
225 printf (", (ARG%d)", i++); | |
226 | |
227 puts (")"); | |
228 } | |
229 | |
230 /* Generate the code for the function to generate RTL whose | |
231 format is FORMAT. */ | |
232 | |
233 static void | |
234 gendef (const char *format) | |
235 { | |
236 const char *p; | |
237 int i, j; | |
238 | |
239 /* Start by writing the definition of the function name and the types | |
240 of the arguments. */ | |
241 | |
111 | 242 printf ("static inline rtx\ngen_rtx_fmt_%s_stat (RTX_CODE code, machine_mode mode", format); |
0 | 243 for (p = format, i = 0; *p != 0; p++) |
244 if (*p != '0') | |
245 printf (",\n\t%sarg%d", type_from_format (*p), i++); | |
246 | |
247 puts (" MEM_STAT_DECL)"); | |
248 | |
249 /* Now write out the body of the function itself, which allocates | |
250 the memory and initializes it. */ | |
251 puts ("{"); | |
252 puts (" rtx rt;"); | |
111 | 253 puts (" rt = rtx_alloc (code PASS_MEM_STAT);\n"); |
0 | 254 |
111 | 255 puts (" PUT_MODE_RAW (rt, mode);"); |
0 | 256 |
257 for (p = format, i = j = 0; *p ; ++p, ++i) | |
258 if (*p != '0') | |
259 printf (" %s (rt, %d) = arg%d;\n", accessor_from_format (*p), i, j++); | |
260 else | |
261 printf (" X0EXP (rt, %d) = NULL_RTX;\n", i); | |
262 | |
263 puts ("\n return rt;\n}\n"); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
264 printf ("#define gen_rtx_fmt_%s(c, m", format); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
265 for (p = format, i = 0; *p != 0; p++) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
266 if (*p != '0') |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
267 printf (", p%i",i++); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
268 printf (")\\\n gen_rtx_fmt_%s_stat (c, m", format); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
269 for (p = format, i = 0; *p != 0; p++) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
270 if (*p != '0') |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
271 printf (", p%i",i++); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
272 printf (" MEM_STAT_INFO)\n\n"); |
0 | 273 } |
274 | |
275 /* Generate the documentation header for files we write. */ | |
276 | |
277 static void | |
278 genlegend (void) | |
279 { | |
280 puts ("/* Generated automatically by gengenrtl from rtl.def. */\n"); | |
281 } | |
282 | |
283 /* Generate the text of the header file we make, genrtl.h. */ | |
284 | |
285 static void | |
286 genheader (void) | |
287 { | |
288 unsigned int i; | |
289 const char **fmt; | |
290 | |
291 puts ("#ifndef GCC_GENRTL_H"); | |
292 puts ("#define GCC_GENRTL_H\n"); | |
293 puts ("#include \"statistics.h\"\n"); | |
294 | |
295 for (fmt = formats; *fmt; ++fmt) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
296 gendef (*fmt); |
0 | 297 |
298 putchar ('\n'); | |
299 | |
300 for (i = 0; i < NUM_RTX_CODE; i++) | |
301 if (! special_format (defs[i].format)) | |
302 genmacro (i); | |
303 | |
304 puts ("\n#endif /* GCC_GENRTL_H */"); | |
305 } | |
306 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
307 /* This is the main program. */ |
0 | 308 |
309 int | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
310 main (void) |
0 | 311 { |
312 find_formats (); | |
313 genlegend (); | |
314 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
315 genheader (); |
0 | 316 |
317 if (ferror (stdout) || fflush (stdout) || fclose (stdout)) | |
318 return FATAL_EXIT_CODE; | |
319 | |
320 return SUCCESS_EXIT_CODE; | |
321 } |