1 /* Generate code from machine description to emit insns as rtl.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
28 #include "gensupport.h"
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. */
37 struct clobber_ent
*insns
;
40 struct clobber_pat
*next
;
44 /* Records one insn that uses the clobber list. */
48 int code_number
; /* Counts only insns. */
49 struct clobber_ent
*next
;
52 static void output_peephole2_scratches (rtx
);
54 /* True for <X>_optab if that optab isn't allowed to fail. */
55 static bool nofail_optabs
[NUM_OPTABS
];
58 print_code (RTX_CODE code
)
61 for (p1
= GET_RTX_NAME (code
); *p1
; p1
++)
62 putchar (TOUPPER (*p1
));
66 gen_rtx_scratch (rtx x
, enum rtx_code subroutine_type
)
68 if (subroutine_type
== DEFINE_PEEPHOLE2
)
70 printf ("operand%d", XINT (x
, 0));
74 printf ("gen_rtx_SCRATCH (%smode)", GET_MODE_NAME (GET_MODE (x
)));
78 /* Print a C expression to construct an RTX just like X,
79 substituting any operand references appearing within. */
82 gen_exp (rtx x
, enum rtx_code subroutine_type
, char *used
, md_rtx_info
*info
)
104 if (used
[XINT (x
, 0)])
106 printf ("copy_rtx (operand%d)", XINT (x
, 0));
109 used
[XINT (x
, 0)] = 1;
111 printf ("operand%d", XINT (x
, 0));
115 printf ("gen_rtx_fmt_");
116 for (i
= 0; i
< XVECLEN (x
, 1); i
++)
118 printf (" (GET_CODE (operand%d), ", XINT (x
, 0));
119 if (GET_MODE (x
) == VOIDmode
)
120 printf ("GET_MODE (operand%d)", XINT (x
, 0));
122 printf ("%smode", GET_MODE_NAME (GET_MODE (x
)));
123 for (i
= 0; i
< XVECLEN (x
, 1); i
++)
126 gen_exp (XVECEXP (x
, 1, i
), subroutine_type
, used
, info
);
132 printf ("gen_rtx_fmt_");
133 for (i
= 0; i
< XVECLEN (x
, 2); i
++)
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
++)
140 gen_exp (XVECEXP (x
, 2, i
), subroutine_type
, used
, info
);
147 printf ("operand%d", XINT (x
, 0));
151 gen_rtx_scratch (x
, subroutine_type
);
161 printf ("simple_return_rtx");
164 if (REG_P (XEXP (x
, 0)))
166 printf ("gen_hard_reg_clobber (%smode, %i)",
167 GET_MODE_NAME (GET_MODE (XEXP (x
, 0))),
168 REGNO (XEXP (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
)
184 && INTVAL (x
) <= MAX_SAVED_CONST_INT
)
185 printf ("const_int_rtx[MAX_SAVED_CONST_INT + (%d)]",
187 else if (INTVAL (x
) == STORE_FLAG_VALUE
)
188 printf ("const_true_rtx");
191 printf ("GEN_INT (");
192 printf (HOST_WIDE_INT_PRINT_DEC_C
, INTVAL (x
));
200 /* These shouldn't be written in MD files. Instead, the appropriate
201 routines in varasm.c should be called. */
211 if (!always_void_p (code
))
213 printf ("%smode", GET_MODE_NAME (GET_MODE (x
)));
217 fmt
= GET_RTX_FORMAT (code
);
218 len
= GET_RTX_LENGTH (code
);
219 for (i
= 0; i
< len
; i
++)
227 gen_exp (XEXP (x
, i
), subroutine_type
, used
, info
);
231 printf ("%u", XINT (x
, i
));
235 printf ("%u", REGNO (x
));
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 ());
245 printf ("\"%s\"", XSTR (x
, i
));
251 printf ("gen_rtvec (%d", XVECLEN (x
, i
));
252 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
255 gen_exp (XVECEXP (x
, i
, j
), subroutine_type
, used
, info
);
269 /* Output code to emit the instruction patterns in VEC, with each element
270 becoming a separate instruction. USED is as for gen_exp. */
273 gen_emit_seq (rtvec vec
, char *used
, md_rtx_info
*info
)
275 for (int i
= 0, len
= GET_NUM_ELEM (vec
); i
< len
; ++i
)
277 bool last_p
= (i
== len
- 1);
278 rtx next
= RTVEC_ELT (vec
, i
);
279 if (const char *name
= get_emit_function (next
))
281 printf (" %s (", name
);
282 gen_exp (next
, DEFINE_EXPAND
, used
, info
);
284 if (!last_p
&& needs_barrier_p (next
))
285 printf (" emit_barrier ();");
290 gen_exp (next
, DEFINE_EXPAND
, used
, info
);
291 printf (", %s);\n", last_p
? "false" : "true");
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. */
301 emit_c_code (const char *code
, bool can_fail_p
, const char *name
)
304 printf ("#define FAIL return (end_sequence (), _val)\n");
306 printf ("#define FAIL _Pragma (\"GCC error \\\"%s cannot FAIL\\\"\")"
308 printf ("#define DONE return (_val = get_insns (), "
309 "end_sequence (), _val)\n");
311 rtx_reader_ptr
->print_md_ptr_loc (code
);
312 printf ("%s\n", code
);
314 printf ("#undef DONE\n");
315 printf ("#undef FAIL\n");
318 /* Generate the `gen_...' function for a DEFINE_INSN. */
321 gen_insn (md_rtx_info
*info
)
323 struct pattern_stats stats
;
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
330 rtx insn
= info
->def
;
333 int has_hard_reg
= 0;
335 for (i
= XVECLEN (insn
, 1) - 1; i
> 0; i
--)
337 if (GET_CODE (XVECEXP (insn
, 1, i
)) != CLOBBER
)
340 if (REG_P (XEXP (XVECEXP (insn
, 1, i
), 0)))
342 else if (GET_CODE (XEXP (XVECEXP (insn
, 1, i
), 0)) != MATCH_SCRATCH
)
346 if (i
!= XVECLEN (insn
, 1) - 1)
348 struct clobber_pat
*p
;
349 struct clobber_ent
*link
= XNEW (struct clobber_ent
);
352 link
->code_number
= info
->index
;
354 /* See if any previous CLOBBER_LIST entry is the same as this
357 for (p
= clobber_list
; p
; p
= p
->next
)
359 if (p
->first_clobber
!= i
+ 1
360 || XVECLEN (p
->pattern
, 1) != XVECLEN (insn
, 1))
363 for (j
= i
+ 1; j
< XVECLEN (insn
, 1); j
++)
365 rtx old_rtx
= XEXP (XVECEXP (p
->pattern
, 1, j
), 0);
366 rtx new_rtx
= XEXP (XVECEXP (insn
, 1, j
), 0);
368 /* OLD and NEW_INSN are the same if both are to be a SCRATCH
370 or if both are registers of the same mode and number. */
371 if (! (GET_CODE (old_rtx
) == GET_CODE (new_rtx
)
372 && GET_MODE (old_rtx
) == GET_MODE (new_rtx
)
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
)))))
380 if (j
== XVECLEN (insn
, 1))
386 p
= XNEW (struct clobber_pat
);
390 p
->first_clobber
= i
+ 1;
391 p
->next
= clobber_list
;
392 p
->has_hard_reg
= has_hard_reg
;
396 link
->next
= p
->insns
;
401 /* Don't mention instructions whose names are the null string
402 or begin with '*'. They are in the machine description just
404 if (XSTR (insn
, 0)[0] == 0 || XSTR (insn
, 0)[0] == '*')
407 printf ("/* %s:%d */\n", info
->loc
.filename
, info
->loc
.lineno
);
409 /* Find out how many operands this function has. */
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");
414 /* Output the function name and argument declarations. */
415 printf ("rtx\ngen_%s (", XSTR (insn
, 0));
416 if (stats
.num_generator_args
)
417 for (i
= 0; i
< stats
.num_generator_args
; i
++)
419 printf (",\n\trtx operand%d ATTRIBUTE_UNUSED", i
);
421 printf ("rtx operand%d ATTRIBUTE_UNUSED", i
);
427 /* Output code to construct and return the rtl for the instruction body. */
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
433 : XCNEWVEC (char, stats
.num_generator_args
));
435 gen_exp (pattern
, DEFINE_INSN
, used
, info
);
440 /* Generate the `gen_...' function for a DEFINE_EXPAND. */
443 gen_expand (md_rtx_info
*info
)
445 struct pattern_stats stats
;
449 rtx expand
= info
->def
;
450 if (strlen (XSTR (expand
, 0)) == 0)
451 fatal_at (info
->loc
, "define_expand lacks a name");
452 if (XVEC (expand
, 1) == 0)
453 fatal_at (info
->loc
, "define_expand for %s lacks a pattern",
456 /* Find out how many operands this function has. */
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));
463 /* Output the function name and argument declarations. */
464 printf ("rtx\ngen_%s (", XSTR (expand
, 0));
465 if (stats
.num_generator_args
)
466 for (i
= 0; i
< stats
.num_generator_args
; i
++)
468 printf (",\n\trtx operand%d", i
);
470 printf ("rtx operand%d", i
);
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')
480 && stats
.max_opno
>= stats
.max_dup_opno
481 && XVECLEN (expand
, 1) == 1)
484 gen_exp (XVECEXP (expand
, 1, 0), DEFINE_EXPAND
, NULL
, info
);
489 /* For each operand referred to only with MATCH_DUPs,
490 make a local variable. */
491 for (i
= stats
.num_generator_args
; i
<= stats
.max_dup_opno
; i
++)
492 printf (" rtx operand%d;\n", i
);
493 printf (" rtx_insn *_val = 0;\n");
494 printf (" start_sequence ();\n");
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))
505 if (stats
.num_operand_vars
> 0)
506 printf (" rtx operands[%d];\n", stats
.num_operand_vars
);
508 /* Output code to copy the arguments into `operands'. */
509 for (i
= 0; i
< stats
.num_generator_args
; i
++)
510 printf (" operands[%d] = operand%d;\n", i
, i
);
512 /* Output the special code to be executed before the sequence
515 bool can_fail_p
= true;
516 if (find_optab (&p
, XSTR (expand
, 0)))
518 gcc_assert (p
.op
< NUM_OPTABS
);
519 if (nofail_optabs
[p
.op
])
522 emit_c_code (XSTR (expand
, 3), can_fail_p
, XSTR (expand
, 0));
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)
528 for (i
= 0; i
<= MAX (stats
.max_opno
, stats
.max_dup_opno
); i
++)
530 printf (" operand%d = operands[%d];\n", i
, i
);
531 printf (" (void) operand%d;\n", i
);
537 used
= XCNEWVEC (char, stats
.num_operand_vars
);
538 gen_emit_seq (XVEC (expand
, 1), used
, info
);
541 /* Call `get_insns' to extract the list of all the
542 insns emitted within this gen_... function. */
544 printf (" _val = get_insns ();\n");
545 printf (" end_sequence ();\n");
546 printf (" return _val;\n}\n\n");
549 /* Like gen_expand, but generates insns resulting from splitting SPLIT. */
552 gen_split (md_rtx_info
*info
)
554 struct pattern_stats stats
;
556 rtx split
= info
->def
;
557 const char *const name
=
558 ((GET_CODE (split
) == DEFINE_PEEPHOLE2
) ? "peephole2" : "split");
562 if (XVEC (split
, 0) == 0)
563 fatal_at (info
->loc
, "%s lacks a pattern",
564 GET_RTX_NAME (GET_CODE (split
)));
565 else if (XVEC (split
, 2) == 0)
566 fatal_at (info
->loc
, "%s lacks a replacement pattern",
567 GET_RTX_NAME (GET_CODE (split
)));
569 /* Find out how many operands this function has. */
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
);
575 /* Output the prototype, function name and argument declarations. */
576 if (GET_CODE (split
) == DEFINE_PEEPHOLE2
)
578 printf ("extern rtx_insn *gen_%s_%d (rtx_insn *, rtx *);\n",
580 printf ("rtx_insn *\ngen_%s_%d (rtx_insn *curr_insn ATTRIBUTE_UNUSED,"
581 " rtx *operands%s)\n",
582 name
, info
->index
, unused
);
586 printf ("extern rtx_insn *gen_split_%d (rtx_insn *, rtx *);\n",
588 printf ("rtx_insn *\ngen_split_%d "
589 "(rtx_insn *curr_insn ATTRIBUTE_UNUSED, rtx *operands%s)\n",
590 info
->index
, unused
);
594 /* Declare all local variables. */
595 for (i
= 0; i
< stats
.num_operand_vars
; i
++)
596 printf (" rtx operand%d;\n", i
);
597 printf (" rtx_insn *_val = NULL;\n");
599 if (GET_CODE (split
) == DEFINE_PEEPHOLE2
)
600 output_peephole2_scratches (split
);
602 const char *fn
= info
->loc
.filename
;
603 for (const char *p
= fn
; *p
; p
++)
607 printf (" if (dump_file)\n");
608 printf (" fprintf (dump_file, \"Splitting with gen_%s_%d (%s:%d)\\n\");\n",
609 name
, info
->index
, fn
, info
->loc
.lineno
);
611 printf (" start_sequence ();\n");
613 /* The fourth operand of DEFINE_SPLIT is some code to be executed
614 before the actual construction. */
617 emit_c_code (XSTR (split
, 3), true, name
);
619 /* Output code to copy the arguments back out of `operands' */
620 for (i
= 0; i
< stats
.num_operand_vars
; i
++)
622 printf (" operand%d = operands[%d];\n", i
, i
);
623 printf (" (void) operand%d;\n", i
);
626 gen_emit_seq (XVEC (split
, 2), used
, info
);
628 /* Call `get_insns' to make a list of all the
629 insns emitted within this gen_... function. */
631 printf (" _val = get_insns ();\n");
632 printf (" end_sequence ();\n");
633 printf (" return _val;\n}\n\n");
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. */
643 output_add_clobbers (md_rtx_info
*info
)
645 struct clobber_pat
*clobber
;
646 struct clobber_ent
*ent
;
649 printf ("\n\nvoid\nadd_clobbers (rtx pattern ATTRIBUTE_UNUSED, int insn_code_number)\n");
651 printf (" switch (insn_code_number)\n");
654 for (clobber
= clobber_list
; clobber
; clobber
= clobber
->next
)
656 for (ent
= clobber
->insns
; ent
; ent
= ent
->next
)
657 printf (" case %d:\n", ent
->code_number
);
659 for (i
= clobber
->first_clobber
; i
< XVECLEN (clobber
->pattern
, 1); i
++)
661 printf (" XVECEXP (pattern, 0, %d) = ", i
);
662 gen_exp (XVECEXP (clobber
->pattern
, 1, i
),
663 GET_CODE (clobber
->pattern
), NULL
, info
);
667 printf (" break;\n\n");
670 printf (" default:\n");
671 printf (" gcc_unreachable ();\n");
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
682 output_added_clobbers_hard_reg_p (void)
684 struct clobber_pat
*clobber
;
685 struct clobber_ent
*ent
;
688 printf ("\n\nint\nadded_clobbers_hard_reg_p (int insn_code_number)\n");
690 printf (" switch (insn_code_number)\n");
693 for (clobber_p
= 0; clobber_p
<= 1; clobber_p
++)
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
)
700 printf (" case %d:\n", ent
->code_number
);
705 printf (" return %d;\n\n", clobber_p
);
708 printf (" default:\n");
709 printf (" gcc_unreachable ();\n");
714 /* Generate code to invoke find_free_register () as needed for the
715 scratch registers used by the peephole2 pattern in SPLIT. */
718 output_peephole2_scratches (rtx split
)
724 for (i
= 0; i
< XVECLEN (split
, 0); i
++)
726 rtx elt
= XVECEXP (split
, 0, i
);
727 if (GET_CODE (elt
) == MATCH_SCRATCH
)
729 int last_insn_nr
= insn_nr
;
730 int cur_insn_nr
= insn_nr
;
732 for (j
= i
+ 1; j
< XVECLEN (split
, 0); j
++)
733 if (GET_CODE (XVECEXP (split
, 0, j
)) == MATCH_DUP
)
735 if (XINT (XVECEXP (split
, 0, j
), 0) == XINT (elt
, 0))
736 last_insn_nr
= cur_insn_nr
;
738 else if (GET_CODE (XVECEXP (split
, 0, j
)) != MATCH_SCRATCH
)
743 printf (" HARD_REG_SET _regs_allocated;\n");
744 printf (" CLEAR_HARD_REG_SET (_regs_allocated);\n");
748 printf (" if ((operands[%d] = peep2_find_free_register (%d, %d, \"%s\", %smode, &_regs_allocated)) == NULL_RTX)\n\
751 insn_nr
, last_insn_nr
,
753 GET_MODE_NAME (GET_MODE (elt
)));
756 else if (GET_CODE (elt
) != MATCH_DUP
)
761 /* Print "arg<N>" parameter declarations for each argument N of ONAME. */
764 print_overload_arguments (overloaded_name
*oname
)
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
);
770 /* Print code to test whether INSTANCE should be chosen, given that
771 argument N of the overload is available as "arg<N>". */
774 print_overload_test (overloaded_instance
*instance
)
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
]);
782 /* Emit a maybe_code_for_* function for ONAME. */
785 handle_overloaded_code_for (overloaded_name
*oname
)
787 /* Print the function prototype. */
788 printf ("\ninsn_code\nmaybe_code_for_%s (", oname
->name
);
789 print_overload_arguments (oname
);
792 /* Use a sequence of "if" statements for each instance. */
793 for (overloaded_instance
*instance
= oname
->first_instance
;
794 instance
; instance
= instance
->next
)
796 print_overload_test (instance
);
797 printf (" return CODE_FOR_%s;\n", instance
->name
);
800 /* Return null if no match was found. */
801 printf (" return CODE_FOR_nothing;\n}\n");
804 /* Emit a maybe_gen_* function for ONAME. */
807 handle_overloaded_gen (overloaded_name
*oname
)
809 unsigned HOST_WIDE_INT seen
= 0;
810 /* All patterns must have the same number of operands. */
811 for (overloaded_instance
*instance
= oname
->first_instance
->next
;
812 instance
; instance
= instance
->next
)
815 get_pattern_stats (&stats
, XVEC (instance
->insn
, 1));
816 unsigned HOST_WIDE_INT mask
817 = HOST_WIDE_INT_1U
<< stats
.num_generator_args
;
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
);
830 /* Use maybe_code_for_*, instead of duplicating the selection
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
);
836 " if (code != CODE_FOR_nothing)\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
);
845 " return NULL_RTX;\n"
851 main (int argc
, const char **argv
)
853 progname
= "genemit";
855 if (!init_rtx_reader_args (argc
, argv
))
856 return (FATAL_EXIT_CODE
);
858 #define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE) \
859 nofail_optabs[OPTAB##_optab] = true;
860 #include "internal-fn.def"
862 /* Assign sequential codes to all entries in the machine description
863 in parallel with the tables in insn-output.c. */
865 printf ("/* Generated automatically by the program `genemit'\n\
866 from the machine description file `md'. */\n\n");
868 printf ("#define IN_TARGET_CODE 1\n");
869 printf ("#include \"config.h\"\n");
870 printf ("#include \"system.h\"\n");
871 printf ("#include \"coretypes.h\"\n");
872 printf ("#include \"backend.h\"\n");
873 printf ("#include \"predict.h\"\n");
874 printf ("#include \"tree.h\"\n");
875 printf ("#include \"rtl.h\"\n");
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");
881 printf ("#include \"tm_p.h\"\n");
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");
889 printf ("#include \"expr.h\"\n");
890 printf ("#include \"insn-codes.h\"\n");
891 printf ("#include \"optabs.h\"\n");
892 printf ("#include \"dfp.h\"\n");
893 printf ("#include \"output.h\"\n");
894 printf ("#include \"recog.h\"\n");
895 printf ("#include \"df.h\"\n");
896 printf ("#include \"resource.h\"\n");
897 printf ("#include \"reload.h\"\n");
898 printf ("#include \"diagnostic-core.h\"\n");
899 printf ("#include \"regs.h\"\n");
900 printf ("#include \"tm-constrs.h\"\n");
901 printf ("#include \"ggc.h\"\n");
902 printf ("#include \"target.h\"\n\n");
904 /* Read the machine description. */
907 while (read_md_rtx (&info
))
908 switch (GET_CODE (info
.def
))
915 printf ("/* %s:%d */\n", info
.loc
.filename
, info
.loc
.lineno
);
920 printf ("/* %s:%d */\n", info
.loc
.filename
, info
.loc
.lineno
);
924 case DEFINE_PEEPHOLE2
:
925 printf ("/* %s:%d */\n", info
.loc
.filename
, info
.loc
.lineno
);
933 /* Write out the routines to add CLOBBERs to a pattern and say whether they
934 clobber a hard reg. */
935 output_add_clobbers (&info
);
936 output_added_clobbers_hard_reg_p ();
938 for (overloaded_name
*oname
= rtx_reader_ptr
->get_overloads ();
939 oname
; oname
= oname
->next
)
941 handle_overloaded_code_for (oname
);
942 handle_overloaded_gen (oname
);
946 return (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);