Mercurial > hg > CbC > CbC_gcc
annotate gcc/genemit.c @ 158:494b0b89df80 default tip
...
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Mon, 25 May 2020 18:13:55 +0900 |
parents | 1830386684a0 |
children |
rev | line source |
---|---|
0 | 1 /* Generate code from machine description to emit insns as rtl. |
145 | 2 Copyright (C) 1987-2020 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 #include "coretypes.h" | |
24 #include "tm.h" | |
25 #include "rtl.h" | |
26 #include "errors.h" | |
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
|
27 #include "read-md.h" |
0 | 28 #include "gensupport.h" |
29 | |
30 | |
31 /* Data structure for recording the patterns of insns that have CLOBBERs. | |
32 We use this to output a function that adds these CLOBBERs to a | |
33 previously-allocated PARALLEL expression. */ | |
34 | |
35 struct clobber_pat | |
36 { | |
37 struct clobber_ent *insns; | |
38 rtx pattern; | |
39 int first_clobber; | |
40 struct clobber_pat *next; | |
41 int has_hard_reg; | |
42 } *clobber_list; | |
43 | |
44 /* Records one insn that uses the clobber list. */ | |
45 | |
46 struct clobber_ent | |
47 { | |
48 int code_number; /* Counts only insns. */ | |
49 struct clobber_ent *next; | |
50 }; | |
51 | |
52 static void output_peephole2_scratches (rtx); | |
53 | |
111 | 54 /* True for <X>_optab if that optab isn't allowed to fail. */ |
55 static bool nofail_optabs[NUM_OPTABS]; | |
0 | 56 |
57 static void | |
58 print_code (RTX_CODE code) | |
59 { | |
60 const char *p1; | |
61 for (p1 = GET_RTX_NAME (code); *p1; p1++) | |
111 | 62 putchar (TOUPPER (*p1)); |
0 | 63 } |
64 | |
65 static void | |
66 gen_rtx_scratch (rtx x, enum rtx_code subroutine_type) | |
67 { | |
68 if (subroutine_type == DEFINE_PEEPHOLE2) | |
69 { | |
70 printf ("operand%d", XINT (x, 0)); | |
71 } | |
72 else | |
73 { | |
74 printf ("gen_rtx_SCRATCH (%smode)", GET_MODE_NAME (GET_MODE (x))); | |
75 } | |
76 } | |
77 | |
78 /* Print a C expression to construct an RTX just like X, | |
79 substituting any operand references appearing within. */ | |
80 | |
81 static void | |
131 | 82 gen_exp (rtx x, enum rtx_code subroutine_type, char *used, md_rtx_info *info) |
0 | 83 { |
84 RTX_CODE code; | |
85 int i; | |
86 int len; | |
87 const char *fmt; | |
111 | 88 const char *sep = ""; |
0 | 89 |
90 if (x == 0) | |
91 { | |
92 printf ("NULL_RTX"); | |
93 return; | |
94 } | |
95 | |
96 code = GET_CODE (x); | |
97 | |
98 switch (code) | |
99 { | |
100 case MATCH_OPERAND: | |
101 case MATCH_DUP: | |
102 if (used) | |
103 { | |
104 if (used[XINT (x, 0)]) | |
105 { | |
106 printf ("copy_rtx (operand%d)", XINT (x, 0)); | |
107 return; | |
108 } | |
109 used[XINT (x, 0)] = 1; | |
110 } | |
111 printf ("operand%d", XINT (x, 0)); | |
112 return; | |
113 | |
114 case MATCH_OP_DUP: | |
115 printf ("gen_rtx_fmt_"); | |
116 for (i = 0; i < XVECLEN (x, 1); i++) | |
117 printf ("e"); | |
118 printf (" (GET_CODE (operand%d), ", XINT (x, 0)); | |
119 if (GET_MODE (x) == VOIDmode) | |
120 printf ("GET_MODE (operand%d)", XINT (x, 0)); | |
121 else | |
122 printf ("%smode", GET_MODE_NAME (GET_MODE (x))); | |
123 for (i = 0; i < XVECLEN (x, 1); i++) | |
124 { | |
125 printf (",\n\t\t"); | |
131 | 126 gen_exp (XVECEXP (x, 1, i), subroutine_type, used, info); |
0 | 127 } |
128 printf (")"); | |
129 return; | |
130 | |
131 case MATCH_OPERATOR: | |
132 printf ("gen_rtx_fmt_"); | |
133 for (i = 0; i < XVECLEN (x, 2); i++) | |
134 printf ("e"); | |
135 printf (" (GET_CODE (operand%d)", XINT (x, 0)); | |
136 printf (", %smode", GET_MODE_NAME (GET_MODE (x))); | |
137 for (i = 0; i < XVECLEN (x, 2); i++) | |
138 { | |
139 printf (",\n\t\t"); | |
131 | 140 gen_exp (XVECEXP (x, 2, i), subroutine_type, used, info); |
0 | 141 } |
142 printf (")"); | |
143 return; | |
144 | |
145 case MATCH_PARALLEL: | |
146 case MATCH_PAR_DUP: | |
147 printf ("operand%d", XINT (x, 0)); | |
148 return; | |
149 | |
150 case MATCH_SCRATCH: | |
151 gen_rtx_scratch (x, subroutine_type); | |
152 return; | |
153 | |
154 case PC: | |
155 printf ("pc_rtx"); | |
156 return; | |
111 | 157 case RETURN: |
158 printf ("ret_rtx"); | |
159 return; | |
160 case SIMPLE_RETURN: | |
161 printf ("simple_return_rtx"); | |
162 return; | |
0 | 163 case CLOBBER: |
164 if (REG_P (XEXP (x, 0))) | |
165 { | |
131 | 166 printf ("gen_hard_reg_clobber (%smode, %i)", |
167 GET_MODE_NAME (GET_MODE (XEXP (x, 0))), | |
168 REGNO (XEXP (x, 0))); | |
0 | 169 return; |
170 } | |
171 break; | |
172 case CC0: | |
173 printf ("cc0_rtx"); | |
174 return; | |
175 | |
176 case CONST_INT: | |
177 if (INTVAL (x) == 0) | |
178 printf ("const0_rtx"); | |
179 else if (INTVAL (x) == 1) | |
180 printf ("const1_rtx"); | |
181 else if (INTVAL (x) == -1) | |
182 printf ("constm1_rtx"); | |
183 else if (-MAX_SAVED_CONST_INT <= INTVAL (x) | |
111 | 184 && INTVAL (x) <= MAX_SAVED_CONST_INT) |
0 | 185 printf ("const_int_rtx[MAX_SAVED_CONST_INT + (%d)]", |
186 (int) INTVAL (x)); | |
187 else if (INTVAL (x) == STORE_FLAG_VALUE) | |
188 printf ("const_true_rtx"); | |
189 else | |
190 { | |
191 printf ("GEN_INT ("); | |
192 printf (HOST_WIDE_INT_PRINT_DEC_C, INTVAL (x)); | |
193 printf (")"); | |
194 } | |
195 return; | |
196 | |
197 case CONST_DOUBLE: | |
198 case CONST_FIXED: | |
111 | 199 case CONST_WIDE_INT: |
0 | 200 /* These shouldn't be written in MD files. Instead, the appropriate |
201 routines in varasm.c should be called. */ | |
202 gcc_unreachable (); | |
203 | |
204 default: | |
205 break; | |
206 } | |
207 | |
208 printf ("gen_rtx_"); | |
209 print_code (code); | |
111 | 210 printf (" ("); |
211 if (!always_void_p (code)) | |
212 { | |
213 printf ("%smode", GET_MODE_NAME (GET_MODE (x))); | |
214 sep = ",\n\t"; | |
215 } | |
0 | 216 |
217 fmt = GET_RTX_FORMAT (code); | |
218 len = GET_RTX_LENGTH (code); | |
219 for (i = 0; i < len; i++) | |
220 { | |
221 if (fmt[i] == '0') | |
222 break; | |
111 | 223 fputs (sep, stdout); |
0 | 224 switch (fmt[i]) |
225 { | |
226 case 'e': case 'u': | |
131 | 227 gen_exp (XEXP (x, i), subroutine_type, used, info); |
0 | 228 break; |
229 | |
230 case 'i': | |
231 printf ("%u", XINT (x, i)); | |
232 break; | |
233 | |
111 | 234 case 'r': |
235 printf ("%u", REGNO (x)); | |
236 break; | |
237 | |
131 | 238 case 'p': |
239 /* We don't have a way of parsing polynomial offsets yet, | |
240 and hopefully never will. */ | |
241 printf ("%d", SUBREG_BYTE (x).to_constant ()); | |
242 break; | |
243 | |
0 | 244 case 's': |
245 printf ("\"%s\"", XSTR (x, i)); | |
246 break; | |
247 | |
248 case 'E': | |
249 { | |
250 int j; | |
251 printf ("gen_rtvec (%d", XVECLEN (x, i)); | |
252 for (j = 0; j < XVECLEN (x, i); j++) | |
253 { | |
254 printf (",\n\t\t"); | |
131 | 255 gen_exp (XVECEXP (x, i, j), subroutine_type, used, info); |
0 | 256 } |
257 printf (")"); | |
258 break; | |
259 } | |
260 | |
261 default: | |
262 gcc_unreachable (); | |
263 } | |
111 | 264 sep = ",\n\t"; |
0 | 265 } |
266 printf (")"); | |
267 } | |
111 | 268 |
269 /* Output code to emit the instruction patterns in VEC, with each element | |
270 becoming a separate instruction. USED is as for gen_exp. */ | |
271 | |
272 static void | |
131 | 273 gen_emit_seq (rtvec vec, char *used, md_rtx_info *info) |
111 | 274 { |
275 for (int i = 0, len = GET_NUM_ELEM (vec); i < len; ++i) | |
276 { | |
277 bool last_p = (i == len - 1); | |
278 rtx next = RTVEC_ELT (vec, i); | |
279 if (const char *name = get_emit_function (next)) | |
280 { | |
281 printf (" %s (", name); | |
131 | 282 gen_exp (next, DEFINE_EXPAND, used, info); |
111 | 283 printf (");\n"); |
284 if (!last_p && needs_barrier_p (next)) | |
285 printf (" emit_barrier ();"); | |
286 } | |
287 else | |
288 { | |
289 printf (" emit ("); | |
131 | 290 gen_exp (next, DEFINE_EXPAND, used, info); |
111 | 291 printf (", %s);\n", last_p ? "false" : "true"); |
292 } | |
293 } | |
294 } | |
295 | |
296 /* Emit the given C code to the output file. The code is allowed to | |
297 fail if CAN_FAIL_P. NAME describes what we're generating, | |
298 for use in error messages. */ | |
299 | |
300 static void | |
301 emit_c_code (const char *code, bool can_fail_p, const char *name) | |
302 { | |
303 if (can_fail_p) | |
304 printf ("#define FAIL return (end_sequence (), _val)\n"); | |
305 else | |
306 printf ("#define FAIL _Pragma (\"GCC error \\\"%s cannot FAIL\\\"\")" | |
307 " (void)0\n", name); | |
145 | 308 printf ("#define DONE return (_val = get_insns (), " |
111 | 309 "end_sequence (), _val)\n"); |
310 | |
311 rtx_reader_ptr->print_md_ptr_loc (code); | |
312 printf ("%s\n", code); | |
313 | |
314 printf ("#undef DONE\n"); | |
315 printf ("#undef FAIL\n"); | |
316 } | |
0 | 317 |
318 /* Generate the `gen_...' function for a DEFINE_INSN. */ | |
319 | |
320 static void | |
111 | 321 gen_insn (md_rtx_info *info) |
0 | 322 { |
111 | 323 struct pattern_stats stats; |
0 | 324 int i; |
325 | |
326 /* See if the pattern for this insn ends with a group of CLOBBERs of (hard) | |
327 registers or MATCH_SCRATCHes. If so, store away the information for | |
328 later. */ | |
329 | |
111 | 330 rtx insn = info->def; |
0 | 331 if (XVEC (insn, 1)) |
332 { | |
333 int has_hard_reg = 0; | |
334 | |
335 for (i = XVECLEN (insn, 1) - 1; i > 0; i--) | |
336 { | |
145 | 337 if (GET_CODE (XVECEXP (insn, 1, i)) != CLOBBER) |
0 | 338 break; |
339 | |
340 if (REG_P (XEXP (XVECEXP (insn, 1, i), 0))) | |
341 has_hard_reg = 1; | |
342 else if (GET_CODE (XEXP (XVECEXP (insn, 1, i), 0)) != MATCH_SCRATCH) | |
343 break; | |
344 } | |
345 | |
346 if (i != XVECLEN (insn, 1) - 1) | |
347 { | |
348 struct clobber_pat *p; | |
349 struct clobber_ent *link = XNEW (struct clobber_ent); | |
350 int j; | |
351 | |
111 | 352 link->code_number = info->index; |
0 | 353 |
354 /* See if any previous CLOBBER_LIST entry is the same as this | |
355 one. */ | |
356 | |
357 for (p = clobber_list; p; p = p->next) | |
358 { | |
359 if (p->first_clobber != i + 1 | |
360 || XVECLEN (p->pattern, 1) != XVECLEN (insn, 1)) | |
361 continue; | |
362 | |
363 for (j = i + 1; j < XVECLEN (insn, 1); j++) | |
364 { | |
365 rtx old_rtx = XEXP (XVECEXP (p->pattern, 1, j), 0); | |
366 rtx new_rtx = XEXP (XVECEXP (insn, 1, j), 0); | |
367 | |
368 /* OLD and NEW_INSN are the same if both are to be a SCRATCH | |
369 of the same mode, | |
370 or if both are registers of the same mode and number. */ | |
131 | 371 if (! (GET_CODE (old_rtx) == GET_CODE (new_rtx) |
372 && GET_MODE (old_rtx) == GET_MODE (new_rtx) | |
0 | 373 && ((GET_CODE (old_rtx) == MATCH_SCRATCH |
374 && GET_CODE (new_rtx) == MATCH_SCRATCH) | |
375 || (REG_P (old_rtx) && REG_P (new_rtx) | |
376 && REGNO (old_rtx) == REGNO (new_rtx))))) | |
377 break; | |
378 } | |
379 | |
380 if (j == XVECLEN (insn, 1)) | |
381 break; | |
382 } | |
383 | |
384 if (p == 0) | |
385 { | |
386 p = XNEW (struct clobber_pat); | |
387 | |
388 p->insns = 0; | |
389 p->pattern = insn; | |
390 p->first_clobber = i + 1; | |
391 p->next = clobber_list; | |
392 p->has_hard_reg = has_hard_reg; | |
393 clobber_list = p; | |
394 } | |
395 | |
396 link->next = p->insns; | |
397 p->insns = link; | |
398 } | |
399 } | |
400 | |
401 /* Don't mention instructions whose names are the null string | |
402 or begin with '*'. They are in the machine description just | |
403 to be recognized. */ | |
404 if (XSTR (insn, 0)[0] == 0 || XSTR (insn, 0)[0] == '*') | |
405 return; | |
406 | |
111 | 407 printf ("/* %s:%d */\n", info->loc.filename, info->loc.lineno); |
0 | 408 |
409 /* Find out how many operands this function has. */ | |
111 | 410 get_pattern_stats (&stats, XVEC (insn, 1)); |
411 if (stats.max_dup_opno > stats.max_opno) | |
412 fatal_at (info->loc, "match_dup operand number has no match_operand"); | |
0 | 413 |
414 /* Output the function name and argument declarations. */ | |
415 printf ("rtx\ngen_%s (", XSTR (insn, 0)); | |
111 | 416 if (stats.num_generator_args) |
417 for (i = 0; i < stats.num_generator_args; i++) | |
0 | 418 if (i) |
419 printf (",\n\trtx operand%d ATTRIBUTE_UNUSED", i); | |
420 else | |
421 printf ("rtx operand%d ATTRIBUTE_UNUSED", i); | |
422 else | |
423 printf ("void"); | |
424 printf (")\n"); | |
425 printf ("{\n"); | |
426 | |
427 /* Output code to construct and return the rtl for the instruction body. */ | |
428 | |
111 | 429 rtx pattern = add_implicit_parallel (XVEC (insn, 1)); |
430 /* ??? This is the traditional behavior, but seems suspect. */ | |
431 char *used = (XVECLEN (insn, 1) == 1 | |
432 ? NULL | |
433 : XCNEWVEC (char, stats.num_generator_args)); | |
434 printf (" return "); | |
131 | 435 gen_exp (pattern, DEFINE_INSN, used, info); |
111 | 436 printf (";\n}\n\n"); |
437 XDELETEVEC (used); | |
0 | 438 } |
439 | |
440 /* Generate the `gen_...' function for a DEFINE_EXPAND. */ | |
441 | |
442 static void | |
111 | 443 gen_expand (md_rtx_info *info) |
0 | 444 { |
111 | 445 struct pattern_stats stats; |
0 | 446 int i; |
447 char *used; | |
448 | |
111 | 449 rtx expand = info->def; |
0 | 450 if (strlen (XSTR (expand, 0)) == 0) |
111 | 451 fatal_at (info->loc, "define_expand lacks a name"); |
0 | 452 if (XVEC (expand, 1) == 0) |
111 | 453 fatal_at (info->loc, "define_expand for %s lacks a pattern", |
454 XSTR (expand, 0)); | |
0 | 455 |
456 /* Find out how many operands this function has. */ | |
111 | 457 get_pattern_stats (&stats, XVEC (expand, 1)); |
458 if (stats.min_scratch_opno != -1 | |
459 && stats.min_scratch_opno <= MAX (stats.max_opno, stats.max_dup_opno)) | |
460 fatal_at (info->loc, "define_expand for %s needs to have match_scratch " | |
461 "numbers above all other operands", XSTR (expand, 0)); | |
0 | 462 |
463 /* Output the function name and argument declarations. */ | |
464 printf ("rtx\ngen_%s (", XSTR (expand, 0)); | |
111 | 465 if (stats.num_generator_args) |
466 for (i = 0; i < stats.num_generator_args; i++) | |
0 | 467 if (i) |
468 printf (",\n\trtx operand%d", i); | |
469 else | |
470 printf ("rtx operand%d", i); | |
471 else | |
472 printf ("void"); | |
473 printf (")\n"); | |
474 printf ("{\n"); | |
475 | |
476 /* If we don't have any C code to write, only one insn is being written, | |
477 and no MATCH_DUPs are present, we can just return the desired insn | |
478 like we do for a DEFINE_INSN. This saves memory. */ | |
479 if ((XSTR (expand, 3) == 0 || *XSTR (expand, 3) == '\0') | |
111 | 480 && stats.max_opno >= stats.max_dup_opno |
0 | 481 && XVECLEN (expand, 1) == 1) |
482 { | |
483 printf (" return "); | |
131 | 484 gen_exp (XVECEXP (expand, 1, 0), DEFINE_EXPAND, NULL, info); |
0 | 485 printf (";\n}\n\n"); |
486 return; | |
487 } | |
488 | |
489 /* For each operand referred to only with MATCH_DUPs, | |
490 make a local variable. */ | |
111 | 491 for (i = stats.num_generator_args; i <= stats.max_dup_opno; i++) |
0 | 492 printf (" rtx operand%d;\n", i); |
111 | 493 printf (" rtx_insn *_val = 0;\n"); |
0 | 494 printf (" start_sequence ();\n"); |
495 | |
496 /* The fourth operand of DEFINE_EXPAND is some code to be executed | |
497 before the actual construction. | |
498 This code expects to refer to `operands' | |
499 just as the output-code in a DEFINE_INSN does, | |
500 but here `operands' is an automatic array. | |
501 So copy the operand values there before executing it. */ | |
502 if (XSTR (expand, 3) && *XSTR (expand, 3)) | |
503 { | |
504 printf (" {\n"); | |
111 | 505 if (stats.num_operand_vars > 0) |
506 printf (" rtx operands[%d];\n", stats.num_operand_vars); | |
507 | |
0 | 508 /* Output code to copy the arguments into `operands'. */ |
111 | 509 for (i = 0; i < stats.num_generator_args; i++) |
0 | 510 printf (" operands[%d] = operand%d;\n", i, i); |
511 | |
512 /* Output the special code to be executed before the sequence | |
513 is generated. */ | |
111 | 514 optab_pattern p; |
515 bool can_fail_p = true; | |
516 if (find_optab (&p, XSTR (expand, 0))) | |
517 { | |
518 gcc_assert (p.op < NUM_OPTABS); | |
519 if (nofail_optabs[p.op]) | |
520 can_fail_p = false; | |
521 } | |
522 emit_c_code (XSTR (expand, 3), can_fail_p, XSTR (expand, 0)); | |
0 | 523 |
524 /* Output code to copy the arguments back out of `operands' | |
525 (unless we aren't going to use them at all). */ | |
526 if (XVEC (expand, 1) != 0) | |
527 { | |
111 | 528 for (i = 0; i <= MAX (stats.max_opno, stats.max_dup_opno); i++) |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
529 { |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
530 printf (" operand%d = operands[%d];\n", i, i); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
531 printf (" (void) operand%d;\n", i); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
532 } |
0 | 533 } |
534 printf (" }\n"); | |
535 } | |
536 | |
111 | 537 used = XCNEWVEC (char, stats.num_operand_vars); |
131 | 538 gen_emit_seq (XVEC (expand, 1), used, info); |
0 | 539 XDELETEVEC (used); |
540 | |
541 /* Call `get_insns' to extract the list of all the | |
542 insns emitted within this gen_... function. */ | |
543 | |
544 printf (" _val = get_insns ();\n"); | |
545 printf (" end_sequence ();\n"); | |
546 printf (" return _val;\n}\n\n"); | |
547 } | |
548 | |
549 /* Like gen_expand, but generates insns resulting from splitting SPLIT. */ | |
550 | |
551 static void | |
111 | 552 gen_split (md_rtx_info *info) |
0 | 553 { |
111 | 554 struct pattern_stats stats; |
0 | 555 int i; |
111 | 556 rtx split = info->def; |
0 | 557 const char *const name = |
558 ((GET_CODE (split) == DEFINE_PEEPHOLE2) ? "peephole2" : "split"); | |
559 const char *unused; | |
560 char *used; | |
561 | |
562 if (XVEC (split, 0) == 0) | |
111 | 563 fatal_at (info->loc, "%s lacks a pattern", |
564 GET_RTX_NAME (GET_CODE (split))); | |
0 | 565 else if (XVEC (split, 2) == 0) |
111 | 566 fatal_at (info->loc, "%s lacks a replacement pattern", |
567 GET_RTX_NAME (GET_CODE (split))); | |
0 | 568 |
569 /* Find out how many operands this function has. */ | |
570 | |
111 | 571 get_pattern_stats (&stats, XVEC (split, 2)); |
572 unused = (stats.num_operand_vars == 0 ? " ATTRIBUTE_UNUSED" : ""); | |
573 used = XCNEWVEC (char, stats.num_operand_vars); | |
0 | 574 |
575 /* Output the prototype, function name and argument declarations. */ | |
576 if (GET_CODE (split) == DEFINE_PEEPHOLE2) | |
577 { | |
111 | 578 printf ("extern rtx_insn *gen_%s_%d (rtx_insn *, rtx *);\n", |
579 name, info->index); | |
580 printf ("rtx_insn *\ngen_%s_%d (rtx_insn *curr_insn ATTRIBUTE_UNUSED," | |
581 " rtx *operands%s)\n", | |
582 name, info->index, unused); | |
0 | 583 } |
584 else | |
585 { | |
111 | 586 printf ("extern rtx_insn *gen_split_%d (rtx_insn *, rtx *);\n", |
587 info->index); | |
588 printf ("rtx_insn *\ngen_split_%d " | |
589 "(rtx_insn *curr_insn ATTRIBUTE_UNUSED, rtx *operands%s)\n", | |
590 info->index, unused); | |
0 | 591 } |
592 printf ("{\n"); | |
593 | |
594 /* Declare all local variables. */ | |
111 | 595 for (i = 0; i < stats.num_operand_vars; i++) |
0 | 596 printf (" rtx operand%d;\n", i); |
111 | 597 printf (" rtx_insn *_val = NULL;\n"); |
0 | 598 |
599 if (GET_CODE (split) == DEFINE_PEEPHOLE2) | |
600 output_peephole2_scratches (split); | |
601 | |
145 | 602 const char *fn = info->loc.filename; |
603 for (const char *p = fn; *p; p++) | |
604 if (*p == '/') | |
605 fn = p + 1; | |
606 | |
111 | 607 printf (" if (dump_file)\n"); |
145 | 608 printf (" fprintf (dump_file, \"Splitting with gen_%s_%d (%s:%d)\\n\");\n", |
609 name, info->index, fn, info->loc.lineno); | |
111 | 610 |
0 | 611 printf (" start_sequence ();\n"); |
612 | |
613 /* The fourth operand of DEFINE_SPLIT is some code to be executed | |
614 before the actual construction. */ | |
615 | |
616 if (XSTR (split, 3)) | |
111 | 617 emit_c_code (XSTR (split, 3), true, name); |
0 | 618 |
619 /* Output code to copy the arguments back out of `operands' */ | |
111 | 620 for (i = 0; i < stats.num_operand_vars; i++) |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
621 { |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
622 printf (" operand%d = operands[%d];\n", i, i); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
623 printf (" (void) operand%d;\n", i); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
624 } |
0 | 625 |
131 | 626 gen_emit_seq (XVEC (split, 2), used, info); |
0 | 627 |
628 /* Call `get_insns' to make a list of all the | |
629 insns emitted within this gen_... function. */ | |
630 | |
631 printf (" _val = get_insns ();\n"); | |
632 printf (" end_sequence ();\n"); | |
633 printf (" return _val;\n}\n\n"); | |
634 | |
635 free (used); | |
636 } | |
637 | |
638 /* Write a function, `add_clobbers', that is given a PARALLEL of sufficient | |
639 size for the insn and an INSN_CODE, and inserts the required CLOBBERs at | |
640 the end of the vector. */ | |
641 | |
642 static void | |
131 | 643 output_add_clobbers (md_rtx_info *info) |
0 | 644 { |
645 struct clobber_pat *clobber; | |
646 struct clobber_ent *ent; | |
647 int i; | |
648 | |
649 printf ("\n\nvoid\nadd_clobbers (rtx pattern ATTRIBUTE_UNUSED, int insn_code_number)\n"); | |
650 printf ("{\n"); | |
651 printf (" switch (insn_code_number)\n"); | |
652 printf (" {\n"); | |
653 | |
654 for (clobber = clobber_list; clobber; clobber = clobber->next) | |
655 { | |
656 for (ent = clobber->insns; ent; ent = ent->next) | |
657 printf (" case %d:\n", ent->code_number); | |
658 | |
659 for (i = clobber->first_clobber; i < XVECLEN (clobber->pattern, 1); i++) | |
660 { | |
661 printf (" XVECEXP (pattern, 0, %d) = ", i); | |
662 gen_exp (XVECEXP (clobber->pattern, 1, i), | |
131 | 663 GET_CODE (clobber->pattern), NULL, info); |
0 | 664 printf (";\n"); |
665 } | |
666 | |
667 printf (" break;\n\n"); | |
668 } | |
669 | |
670 printf (" default:\n"); | |
671 printf (" gcc_unreachable ();\n"); | |
672 printf (" }\n"); | |
673 printf ("}\n"); | |
674 } | |
675 | |
676 /* Write a function, `added_clobbers_hard_reg_p' that is given an insn_code | |
677 number that will have clobbers added (as indicated by `recog') and returns | |
678 1 if those include a clobber of a hard reg or 0 if all of them just clobber | |
679 SCRATCH. */ | |
680 | |
681 static void | |
682 output_added_clobbers_hard_reg_p (void) | |
683 { | |
684 struct clobber_pat *clobber; | |
685 struct clobber_ent *ent; | |
686 int clobber_p, used; | |
687 | |
688 printf ("\n\nint\nadded_clobbers_hard_reg_p (int insn_code_number)\n"); | |
689 printf ("{\n"); | |
690 printf (" switch (insn_code_number)\n"); | |
691 printf (" {\n"); | |
692 | |
693 for (clobber_p = 0; clobber_p <= 1; clobber_p++) | |
694 { | |
695 used = 0; | |
696 for (clobber = clobber_list; clobber; clobber = clobber->next) | |
697 if (clobber->has_hard_reg == clobber_p) | |
698 for (ent = clobber->insns; ent; ent = ent->next) | |
699 { | |
700 printf (" case %d:\n", ent->code_number); | |
701 used++; | |
702 } | |
703 | |
704 if (used) | |
705 printf (" return %d;\n\n", clobber_p); | |
706 } | |
707 | |
708 printf (" default:\n"); | |
709 printf (" gcc_unreachable ();\n"); | |
710 printf (" }\n"); | |
711 printf ("}\n"); | |
712 } | |
713 | |
714 /* Generate code to invoke find_free_register () as needed for the | |
715 scratch registers used by the peephole2 pattern in SPLIT. */ | |
716 | |
717 static void | |
718 output_peephole2_scratches (rtx split) | |
719 { | |
720 int i; | |
721 int insn_nr = 0; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
722 bool first = true; |
0 | 723 |
724 for (i = 0; i < XVECLEN (split, 0); i++) | |
725 { | |
726 rtx elt = XVECEXP (split, 0, i); | |
727 if (GET_CODE (elt) == MATCH_SCRATCH) | |
728 { | |
729 int last_insn_nr = insn_nr; | |
730 int cur_insn_nr = insn_nr; | |
731 int j; | |
732 for (j = i + 1; j < XVECLEN (split, 0); j++) | |
733 if (GET_CODE (XVECEXP (split, 0, j)) == MATCH_DUP) | |
734 { | |
735 if (XINT (XVECEXP (split, 0, j), 0) == XINT (elt, 0)) | |
736 last_insn_nr = cur_insn_nr; | |
737 } | |
738 else if (GET_CODE (XVECEXP (split, 0, j)) != MATCH_SCRATCH) | |
739 cur_insn_nr++; | |
740 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
741 if (first) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
742 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
743 printf (" HARD_REG_SET _regs_allocated;\n"); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
744 printf (" CLEAR_HARD_REG_SET (_regs_allocated);\n"); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
745 first = false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
746 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
747 |
0 | 748 printf (" if ((operands[%d] = peep2_find_free_register (%d, %d, \"%s\", %smode, &_regs_allocated)) == NULL_RTX)\n\ |
749 return NULL;\n", | |
750 XINT (elt, 0), | |
751 insn_nr, last_insn_nr, | |
752 XSTR (elt, 1), | |
753 GET_MODE_NAME (GET_MODE (elt))); | |
754 | |
755 } | |
756 else if (GET_CODE (elt) != MATCH_DUP) | |
757 insn_nr++; | |
758 } | |
759 } | |
760 | |
131 | 761 /* Print "arg<N>" parameter declarations for each argument N of ONAME. */ |
762 | |
763 static void | |
764 print_overload_arguments (overloaded_name *oname) | |
765 { | |
766 for (unsigned int i = 0; i < oname->arg_types.length (); ++i) | |
767 printf ("%s%s arg%d", i == 0 ? "" : ", ", oname->arg_types[i], i); | |
768 } | |
769 | |
770 /* Print code to test whether INSTANCE should be chosen, given that | |
771 argument N of the overload is available as "arg<N>". */ | |
772 | |
773 static void | |
774 print_overload_test (overloaded_instance *instance) | |
775 { | |
776 for (unsigned int i = 0; i < instance->arg_values.length (); ++i) | |
777 printf ("%sarg%d == %s", i == 0 ? " if (" : "\n && ", | |
778 i, instance->arg_values[i]); | |
779 printf (")\n"); | |
780 } | |
781 | |
782 /* Emit a maybe_code_for_* function for ONAME. */ | |
783 | |
784 static void | |
785 handle_overloaded_code_for (overloaded_name *oname) | |
786 { | |
787 /* Print the function prototype. */ | |
788 printf ("\ninsn_code\nmaybe_code_for_%s (", oname->name); | |
789 print_overload_arguments (oname); | |
790 printf (")\n{\n"); | |
791 | |
792 /* Use a sequence of "if" statements for each instance. */ | |
793 for (overloaded_instance *instance = oname->first_instance; | |
794 instance; instance = instance->next) | |
795 { | |
796 print_overload_test (instance); | |
797 printf (" return CODE_FOR_%s;\n", instance->name); | |
798 } | |
799 | |
800 /* Return null if no match was found. */ | |
801 printf (" return CODE_FOR_nothing;\n}\n"); | |
802 } | |
803 | |
804 /* Emit a maybe_gen_* function for ONAME. */ | |
805 | |
806 static void | |
807 handle_overloaded_gen (overloaded_name *oname) | |
808 { | |
145 | 809 unsigned HOST_WIDE_INT seen = 0; |
131 | 810 /* All patterns must have the same number of operands. */ |
811 for (overloaded_instance *instance = oname->first_instance->next; | |
812 instance; instance = instance->next) | |
813 { | |
145 | 814 pattern_stats stats; |
815 get_pattern_stats (&stats, XVEC (instance->insn, 1)); | |
816 unsigned HOST_WIDE_INT mask | |
817 = HOST_WIDE_INT_1U << stats.num_generator_args; | |
818 if (seen & mask) | |
819 continue; | |
820 | |
821 seen |= mask; | |
822 | |
823 /* Print the function prototype. */ | |
824 printf ("\nrtx\nmaybe_gen_%s (", oname->name); | |
825 print_overload_arguments (oname); | |
826 for (int i = 0; i < stats.num_generator_args; ++i) | |
827 printf (", rtx x%d", i); | |
828 printf (")\n{\n"); | |
131 | 829 |
145 | 830 /* Use maybe_code_for_*, instead of duplicating the selection |
831 logic here. */ | |
832 printf (" insn_code code = maybe_code_for_%s (", oname->name); | |
833 for (unsigned int i = 0; i < oname->arg_types.length (); ++i) | |
834 printf ("%sarg%d", i == 0 ? "" : ", ", i); | |
835 printf (");\n" | |
836 " if (code != CODE_FOR_nothing)\n" | |
837 " {\n" | |
838 " gcc_assert (insn_data[code].n_generator_args == %d);\n" | |
839 " return GEN_FCN (code) (", stats.num_generator_args); | |
840 for (int i = 0; i < stats.num_generator_args; ++i) | |
841 printf ("%sx%d", i == 0 ? "" : ", ", i); | |
842 printf (");\n" | |
843 " }\n" | |
844 " else\n" | |
845 " return NULL_RTX;\n" | |
846 "}\n"); | |
847 } | |
131 | 848 } |
849 | |
0 | 850 int |
111 | 851 main (int argc, const char **argv) |
0 | 852 { |
853 progname = "genemit"; | |
854 | |
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
|
855 if (!init_rtx_reader_args (argc, argv)) |
0 | 856 return (FATAL_EXIT_CODE); |
857 | |
111 | 858 #define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE) \ |
859 nofail_optabs[OPTAB##_optab] = true; | |
860 #include "internal-fn.def" | |
861 | |
0 | 862 /* Assign sequential codes to all entries in the machine description |
863 in parallel with the tables in insn-output.c. */ | |
864 | |
865 printf ("/* Generated automatically by the program `genemit'\n\ | |
866 from the machine description file `md'. */\n\n"); | |
867 | |
131 | 868 printf ("#define IN_TARGET_CODE 1\n"); |
0 | 869 printf ("#include \"config.h\"\n"); |
870 printf ("#include \"system.h\"\n"); | |
871 printf ("#include \"coretypes.h\"\n"); | |
111 | 872 printf ("#include \"backend.h\"\n"); |
873 printf ("#include \"predict.h\"\n"); | |
874 printf ("#include \"tree.h\"\n"); | |
0 | 875 printf ("#include \"rtl.h\"\n"); |
111 | 876 printf ("#include \"alias.h\"\n"); |
877 printf ("#include \"varasm.h\"\n"); | |
878 printf ("#include \"stor-layout.h\"\n"); | |
879 printf ("#include \"calls.h\"\n"); | |
880 printf ("#include \"memmodel.h\"\n"); | |
0 | 881 printf ("#include \"tm_p.h\"\n"); |
111 | 882 printf ("#include \"flags.h\"\n"); |
883 printf ("#include \"insn-config.h\"\n"); | |
884 printf ("#include \"expmed.h\"\n"); | |
885 printf ("#include \"dojump.h\"\n"); | |
886 printf ("#include \"explow.h\"\n"); | |
887 printf ("#include \"emit-rtl.h\"\n"); | |
888 printf ("#include \"stmt.h\"\n"); | |
0 | 889 printf ("#include \"expr.h\"\n"); |
111 | 890 printf ("#include \"insn-codes.h\"\n"); |
0 | 891 printf ("#include \"optabs.h\"\n"); |
892 printf ("#include \"dfp.h\"\n"); | |
893 printf ("#include \"output.h\"\n"); | |
894 printf ("#include \"recog.h\"\n"); | |
111 | 895 printf ("#include \"df.h\"\n"); |
0 | 896 printf ("#include \"resource.h\"\n"); |
897 printf ("#include \"reload.h\"\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
|
898 printf ("#include \"diagnostic-core.h\"\n"); |
0 | 899 printf ("#include \"regs.h\"\n"); |
900 printf ("#include \"tm-constrs.h\"\n"); | |
901 printf ("#include \"ggc.h\"\n"); | |
111 | 902 printf ("#include \"target.h\"\n\n"); |
0 | 903 |
904 /* Read the machine description. */ | |
905 | |
111 | 906 md_rtx_info info; |
907 while (read_md_rtx (&info)) | |
908 switch (GET_CODE (info.def)) | |
909 { | |
910 case DEFINE_INSN: | |
911 gen_insn (&info); | |
912 break; | |
0 | 913 |
111 | 914 case DEFINE_EXPAND: |
915 printf ("/* %s:%d */\n", info.loc.filename, info.loc.lineno); | |
916 gen_expand (&info); | |
0 | 917 break; |
918 | |
111 | 919 case DEFINE_SPLIT: |
920 printf ("/* %s:%d */\n", info.loc.filename, info.loc.lineno); | |
921 gen_split (&info); | |
922 break; | |
0 | 923 |
111 | 924 case DEFINE_PEEPHOLE2: |
925 printf ("/* %s:%d */\n", info.loc.filename, info.loc.lineno); | |
926 gen_split (&info); | |
927 break; | |
0 | 928 |
111 | 929 default: |
930 break; | |
931 } | |
0 | 932 |
933 /* Write out the routines to add CLOBBERs to a pattern and say whether they | |
934 clobber a hard reg. */ | |
131 | 935 output_add_clobbers (&info); |
0 | 936 output_added_clobbers_hard_reg_p (); |
937 | |
131 | 938 for (overloaded_name *oname = rtx_reader_ptr->get_overloads (); |
939 oname; oname = oname->next) | |
940 { | |
941 handle_overloaded_code_for (oname); | |
942 handle_overloaded_gen (oname); | |
943 } | |
944 | |
0 | 945 fflush (stdout); |
946 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); | |
947 } |