From: law Date: Mon, 26 Jan 1998 22:48:32 +0000 (+0000) Subject: * toplev.c: Add -dM command line option to dump RTL after the X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=7291115d84c14dd414bcbae3885043281f106440;p=platform%2Fupstream%2Flinaro-gcc.git * toplev.c: Add -dM command line option to dump RTL after the machine dependent reorganisation pass, if there is one. Reorganise RTL dump code, so that only one file handle is needed. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@17494 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 9d277c1..9dd7f57 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +Fri Jan 23 09:39:36 1998 Nick Clifton + + * toplev.c: Add -dM command line option to dump RTL after the + machine dependent reorganisation pass, if there is one. + Reorganise RTL dump code, so that only one file handle is + needed. + Mon Jan 26 12:09:42 1998 Benjamin Kosnik * except.c (check_exception_handler_labels): Disable warning when diff --git a/gcc/invoke.texi b/gcc/invoke.texi index 7a099ed..ef83383 100644 --- a/gcc/invoke.texi +++ b/gcc/invoke.texi @@ -1924,58 +1924,48 @@ name (e.g. @file{foo.c.rtl} or @file{foo.c.jump}). Here are the possible letters for use in @var{letters}, and their meanings: @table @samp -@item M -Dump all macro definitions, at the end of preprocessing, and write no -output. -@item N -Dump all macro names, at the end of preprocessing. -@item D -Dump all macro definitions, at the end of preprocessing, in addition to -normal output. -@item y -Dump debugging information during parsing, to standard error. -@item r -Dump after RTL generation, to @file{@var{file}.rtl}. -@item x -Just generate RTL for a function instead of compiling it. Usually used -with @samp{r}. -@item j -Dump after first jump optimization, to @file{@var{file}.jump}. -@item s -Dump after CSE (including the jump optimization that sometimes -follows CSE), to @file{@var{file}.cse}. -@item D -Dump after purging ADDRESSOF, to @file{@var{file}.addressof}. -@item L -Dump after loop optimization, to @file{@var{file}.loop}. -@item t -Dump after the second CSE pass (including the jump optimization that -sometimes follows CSE), to @file{@var{file}.cse2}. @item b Dump after computing branch probabilities, to @file{@var{file}.bp}. +@item c +Dump after instruction combination, to the file @file{@var{file}.combine}. +@item d +Dump after delayed branch scheduling, to @file{@var{file}.dbr}. +@item D +Dump after purging ADDRESSOF, to @file{@var{file}.addressof}. @item f Dump after flow analysis, to @file{@var{file}.flow}. -@item c -Dump after instruction combination, to the file -@file{@var{file}.combine}. -@item S -Dump after the first instruction scheduling pass, to -@file{@var{file}.sched}. -@item l -Dump after local register allocation, to -@file{@var{file}.lreg}. @item g -Dump after global register allocation, to -@file{@var{file}.greg}. -@item R -Dump after the second instruction scheduling pass, to -@file{@var{file}.sched2}. +Dump after global register allocation, to @file{@var{file}.greg}. +@item j +Dump after first jump optimization, to @file{@var{file}.jump}. @item J Dump after last jump optimization, to @file{@var{file}.jump2}. -@item d -Dump after delayed branch scheduling, to @file{@var{file}.dbr}. @item k Dump after conversion from registers to stack, to @file{@var{file}.stack}. +@item l +Dump after local register allocation, to @file{@var{file}.lreg}. +@item L +Dump after loop optimization, to @file{@var{file}.loop}. +@item M +Dump after performing the machine dependent reorganisation pass, to +@file{@var{file}.mach}. +@item N +Dump after the register move pass, to @file{@var{file}.regmove}. +@item r +Dump after RTL generation, to @file{@var{file}.rtl}. +@item R +Dump after the second instruction scheduling pass, to @file{@var{file}.sched2}. +@item s +Dump after CSE (including the jump optimization that sometimes follows +CSE), to @file{@var{file}.cse}. +@item S +Dump after the first instruction scheduling pass, to @file{@var{file}.sched}. +@item t +Dump after the second CSE pass (including the jump optimization that +sometimes follows CSE), to @file{@var{file}.cse2}. +@item x +Just generate RTL for a function instead of compiling it. Usually used +with @samp{r}. @item a Produce all the dumps listed above. @item m @@ -1984,6 +1974,8 @@ standard error. @item p Annotate the assembler output with a comment indicating which pattern and alternative was used. +@item y +Dump debugging information during parsing, to standard error. @item A Annotate the assembler output with miscellaneous debugging information. @end table diff --git a/gcc/toplev.c b/gcc/toplev.c index fbdbc41..7c9ca60 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -163,6 +163,9 @@ extern void dump_sched_info (); extern void dump_local_alloc (); extern void regset_release_memory (); +extern void print_rtl (); +extern void print_rtl_with_bb (); + void rest_of_decl_compilation (); void error_with_file_and_line PVPROTO((char *file, int line, char *s, ...)); void error_with_decl PVPROTO((tree decl, char *s, ...)); @@ -264,7 +267,12 @@ int sched2_dump = 0; int jump2_opt_dump = 0; int dbr_sched_dump = 0; int flag_print_asm_name = 0; +#ifdef STACK_REGS int stack_reg_dump = 0; +#endif +#ifdef MACHINE_DEPENDENT_REORG +int mach_dep_reorg_dump = 0; +#endif /* Name for output file of assembly code, specified with -o. */ @@ -947,23 +955,7 @@ struct { char *string; int *variable; int on_value;} W_options[] = FILE *asm_out_file; FILE *aux_info_file; -FILE *rtl_dump_file; -FILE *jump_opt_dump_file; -FILE *addressof_dump_file; -FILE *cse_dump_file; -FILE *loop_dump_file; -FILE *cse2_dump_file; -FILE *branch_prob_dump_file; -FILE *flow_dump_file; -FILE *combine_dump_file; -FILE *regmove_dump_file; -FILE *sched_dump_file; -FILE *local_reg_dump_file; -FILE *global_reg_dump_file; -FILE *sched2_dump_file; -FILE *jump2_opt_dump_file; -FILE *dbr_sched_dump_file; -FILE *stack_reg_dump_file; +FILE *rtl_dump_file = NULL; /* Time accumulators, to count the total time spent in various passes. */ @@ -1122,38 +1114,8 @@ fatal_insn (message, insn) fflush (asm_out_file); if (aux_info_file) fflush (aux_info_file); - if (rtl_dump_file) + if (rtl_dump_file != NULL) fflush (rtl_dump_file); - if (jump_opt_dump_file) - fflush (jump_opt_dump_file); - if (addressof_dump_file) - fflush (addressof_dump_file); - if (cse_dump_file) - fflush (cse_dump_file); - if (loop_dump_file) - fflush (loop_dump_file); - if (cse2_dump_file) - fflush (cse2_dump_file); - if (flow_dump_file) - fflush (flow_dump_file); - if (combine_dump_file) - fflush (combine_dump_file); - if (regmove_dump_file) - fflush (regmove_dump_file); - if (sched_dump_file) - fflush (sched_dump_file); - if (local_reg_dump_file) - fflush (local_reg_dump_file); - if (global_reg_dump_file) - fflush (global_reg_dump_file); - if (sched2_dump_file) - fflush (sched2_dump_file); - if (jump2_opt_dump_file) - fflush (jump2_opt_dump_file); - if (dbr_sched_dump_file) - fflush (dbr_sched_dump_file); - if (stack_reg_dump_file) - fflush (stack_reg_dump_file); fflush (stdout); fflush (stderr); abort (); @@ -2183,23 +2145,97 @@ output_lang_identify (asm_out_file) } /* Routine to open a dump file. */ +static void +open_dump_file (suffix, function_name) + char *suffix; + char *function_name; +{ + char *dumpname; -static FILE * -open_dump_file (base_name, suffix) - char *base_name; + TIMEVAR + (dump_time, + { + dumpname = (char *) xmalloc (strlen (dump_base_name) + strlen (suffix) + 1); + + if (rtl_dump_file != NULL) + fclose (rtl_dump_file); + + strcpy (dumpname, dump_base_name); + strcat (dumpname, suffix); + + rtl_dump_file = fopen (dumpname, "a"); + + if (rtl_dump_file == NULL) + pfatal_with_name (dumpname); + + free (dumpname); + + if (function_name) + fprintf (rtl_dump_file, "\n;; Function %s\n\n", function_name); + }); + + return; +} + +/* Routine to close a dump file. */ +static void +close_dump_file (func, insns) + void (*func)(FILE *, rtx); + rtx insns; +{ + TIMEVAR + (dump_time, + { + if (func) + func (rtl_dump_file, insns); + + fflush (rtl_dump_file); + fclose (rtl_dump_file); + + rtl_dump_file = NULL; + }); + + return; +} + +/* Routine to dump rtl into a file. */ +static void +dump_rtl (suffix, decl, func, insns) char *suffix; + tree decl; + void (*func)(FILE *, rtx); + rtx insns; +{ + open_dump_file (suffix, decl_printable_name (decl, 2)); + close_dump_file (func, insns); +} + +/* Routine to empty a dump file. */ +static void +clean_dump_file (suffix) + char * suffix; { - FILE *f; - char *dumpname = (char *) alloca (strlen (base_name) + strlen (suffix) + 1); + char * dumpname; + + dumpname = (char *) xmalloc (strlen (dump_base_name) + strlen (suffix) + 1); - strcpy (dumpname, base_name); + strcpy (dumpname, dump_base_name); strcat (dumpname, suffix); - f = fopen (dumpname, "w"); - if (f == 0) - pfatal_with_name (dumpname); - return f; + + rtl_dump_file = fopen (dumpname, "w"); + + if (rtl_dump_file == NULL) + pfatal_with_name (dumpname); + + free (dumpname); + + fclose (rtl_dump_file); + rtl_dump_file = NULL; + + return; } + /* Compile an entire file of output from cpp, named NAME. Write a file of assembly output and various debugging dumps. */ @@ -2291,76 +2327,46 @@ compile_file (name) pfatal_with_name (aux_info_file_name); } - /* If rtl dump desired, open the output file. */ + /* Clear the dump files file. */ if (rtl_dump) - rtl_dump_file = open_dump_file (dump_base_name, ".rtl"); - - /* If jump_opt dump desired, open the output file. */ + clean_dump_file (".rtl"); if (jump_opt_dump) - jump_opt_dump_file = open_dump_file (dump_base_name, ".jump"); - - /* If addressof dump desired, open the output file. */ + clean_dump_file (".jump"); if (addressof_dump) - addressof_dump_file = open_dump_file (dump_base_name, ".addressof"); - - /* If cse dump desired, open the output file. */ + clean_dump_file (".addressof"); if (cse_dump) - cse_dump_file = open_dump_file (dump_base_name, ".cse"); - - /* If loop dump desired, open the output file. */ + clean_dump_file (".cse"); if (loop_dump) - loop_dump_file = open_dump_file (dump_base_name, ".loop"); - - /* If cse2 dump desired, open the output file. */ + clean_dump_file (".loop"); if (cse2_dump) - cse2_dump_file = open_dump_file (dump_base_name, ".cse2"); - - /* If branch_prob dump desired, open the output file. */ + clean_dump_file (".cse2"); if (branch_prob_dump) - branch_prob_dump_file = open_dump_file (dump_base_name, ".bp"); - - /* If flow dump desired, open the output file. */ + clean_dump_file (".bp"); if (flow_dump) - flow_dump_file = open_dump_file (dump_base_name, ".flow"); - - /* If combine dump desired, open the output file. */ + clean_dump_file (".flow"); if (combine_dump) - combine_dump_file = open_dump_file (dump_base_name, ".combine"); - - /* If regmove dump desired, open the output file. */ + clean_dump_file (".combine"); if (regmove_dump) - regmove_dump_file = open_dump_file (dump_base_name, ".regmove"); - - /* If scheduling dump desired, open the output file. */ + clean_dump_file (".regmove"); if (sched_dump) - sched_dump_file = open_dump_file (dump_base_name, ".sched"); - - /* If local_reg dump desired, open the output file. */ + clean_dump_file (".sched"); if (local_reg_dump) - local_reg_dump_file = open_dump_file (dump_base_name, ".lreg"); - - /* If global_reg dump desired, open the output file. */ + clean_dump_file (".lreg"); if (global_reg_dump) - global_reg_dump_file = open_dump_file (dump_base_name, ".greg"); - - /* If 2nd scheduling dump desired, open the output file. */ + clean_dump_file (".greg"); if (sched2_dump) - sched2_dump_file = open_dump_file (dump_base_name, ".sched2"); - - /* If jump2_opt dump desired, open the output file. */ + clean_dump_file (".sched2"); if (jump2_opt_dump) - jump2_opt_dump_file = open_dump_file (dump_base_name, ".jump2"); - - /* If dbr_sched dump desired, open the output file. */ + clean_dump_file (".jump2"); if (dbr_sched_dump) - dbr_sched_dump_file = open_dump_file (dump_base_name, ".dbr"); - + clean_dump_file (".dbr"); #ifdef STACK_REGS - - /* If stack_reg dump desired, open the output file. */ if (stack_reg_dump) - stack_reg_dump_file = open_dump_file (dump_base_name, ".stack"); - + clean_dump_file (".stack"); +#endif +#ifdef MACHINE_DEPENDENT_REORG + if (mach_dep_reorg_dump) + clean_dump_file (".mach"); #endif /* Open assembler code output file. */ @@ -2775,8 +2781,15 @@ compile_file (name) /* Output some stuff at end of file if nec. */ end_final (dump_base_name); - end_branch_prob (branch_prob_dump_file); - + + if (branch_prob_dump) + open_dump_file (".bp", NULL); + + TIMEVAR (dump_time, end_branch_prob (rtl_dump_file)); + + if (branch_prob_dump) + close_dump_file (NULL, NULL_RTX); + #ifdef ASM_FILE_END ASM_FILE_END (asm_out_file); #endif @@ -2794,62 +2807,13 @@ compile_file (name) unlink (aux_info_file_name); } - if (rtl_dump) - fclose (rtl_dump_file); - - if (jump_opt_dump) - fclose (jump_opt_dump_file); - - if (addressof_dump) - fclose (addressof_dump_file); - - if (cse_dump) - fclose (cse_dump_file); - - if (loop_dump) - fclose (loop_dump_file); - - if (cse2_dump) - fclose (cse2_dump_file); - - if (branch_prob_dump) - fclose (branch_prob_dump_file); - - if (flow_dump) - fclose (flow_dump_file); - if (combine_dump) { - dump_combine_total_stats (combine_dump_file); - fclose (combine_dump_file); + open_dump_file (".combine", NULL); + TIMEVAR (dump_time, dump_combine_total_stats (rtl_dump_file)); + close_dump_file (NULL, NULL_RTX); } - if (regmove_dump) - fclose (regmove_dump_file); - - if (sched_dump) - fclose (sched_dump_file); - - if (local_reg_dump) - fclose (local_reg_dump_file); - - if (global_reg_dump) - fclose (global_reg_dump_file); - - if (sched2_dump) - fclose (sched2_dump_file); - - if (jump2_opt_dump) - fclose (jump2_opt_dump_file); - - if (dbr_sched_dump) - fclose (dbr_sched_dump_file); - -#ifdef STACK_REGS - if (stack_reg_dump) - fclose (stack_reg_dump_file); -#endif - /* Close non-debugging input and output files. Take special care to note whether fclose returns an error, since the pages might still be on the buffer chain while the file is open. */ @@ -3045,15 +3009,14 @@ rest_of_compilation (decl) /* Dump the rtl code if we are dumping rtl. */ if (rtl_dump) - TIMEVAR (dump_time, - { - fprintf (rtl_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - if (DECL_SAVED_INSNS (decl)) - fprintf (rtl_dump_file, ";; (integrable)\n\n"); - print_rtl (rtl_dump_file, insns); - fflush (rtl_dump_file); - }); + { + open_dump_file (".rtl", decl_printable_name (decl, 2)); + + if (DECL_SAVED_INSNS (decl)) + fprintf (rtl_dump_file, ";; (integrable)\n\n"); + + close_dump_file (print_rtl, insns); + } /* If we can, defer compiling inlines until EOF. save_for_inline_copying can be extremely expensive. */ @@ -3244,29 +3207,19 @@ rest_of_compilation (decl) /* Dump rtl code after jump, if we are doing that. */ - if (jump_opt_dump) - TIMEVAR (dump_time, - { - fprintf (jump_opt_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - print_rtl (jump_opt_dump_file, insns); - fflush (jump_opt_dump_file); - }); + if (jump_opt_dump) + dump_rtl (".jump", decl, print_rtl, insns); /* Perform common subexpression elimination. Nonzero value from `cse_main' means that jumps were simplified and some code may now be unreachable, so do jump optimization again. */ - if (cse_dump) - TIMEVAR (dump_time, - { - fprintf (cse_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); - if (optimize > 0) { + if (cse_dump) + open_dump_file (".cse", decl_printable_name (decl, 2)); + TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1)); if (flag_thread_jumps) @@ -3274,129 +3227,104 @@ rest_of_compilation (decl) TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 1)); TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (), - 0, cse_dump_file)); + 0, rtl_dump_file)); TIMEVAR (cse_time, delete_dead_from_cse (insns, max_reg_num ())); if (tem || optimize > 1) TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0)); - } - - /* Dump rtl code after cse, if we are doing that. */ - if (cse_dump) - TIMEVAR (dump_time, - { - print_rtl (cse_dump_file, insns); - fflush (cse_dump_file); - }); + /* Dump rtl code after cse, if we are doing that. */ + + if (cse_dump) + close_dump_file (print_rtl, insns); + } purge_addressof (insns); reg_scan (insns, max_reg_num (), 1); if (addressof_dump) - TIMEVAR (dump_time, - { - fprintf (addressof_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - print_rtl (addressof_dump_file, insns); - fflush (addressof_dump_file); - }); - - if (loop_dump) - TIMEVAR (dump_time, - { - fprintf (loop_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); - + dump_rtl (".addressof", decl, print_rtl, insns); + /* Move constant computations out of loops. */ if (optimize > 0) { - TIMEVAR (loop_time, - { - if (flag_rerun_loop_opt) - { - /* We only want to perform unrolling once. */ - - loop_optimize (insns, loop_dump_file, 0); - - /* The regscan pass may not be necessary, but let's - be safe until we can prove otherwise. */ - reg_scan (insns, max_reg_num (), 1); - } - loop_optimize (insns, loop_dump_file, flag_unroll_loops); - }); - } - - /* Dump rtl code after loop opt, if we are doing that. */ - - if (loop_dump) - TIMEVAR (dump_time, - { - print_rtl (loop_dump_file, insns); - fflush (loop_dump_file); - }); - - if (cse2_dump) - TIMEVAR (dump_time, + if (loop_dump) + open_dump_file (".loop", decl_printable_name (decl, 2)); + + TIMEVAR + (loop_time, + { + if (flag_rerun_loop_opt) { - fprintf (cse2_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); - - if (optimize > 0 && flag_rerun_cse_after_loop) - { - /* Running another jump optimization pass before the second - cse pass sometimes simplifies the RTL enough to allow - the second CSE pass to do a better job. Jump_optimize can change - max_reg_num so we must rerun reg_scan afterwards. - ??? Rework to not call reg_scan so often. */ - TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0)); - TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1)); - - TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0)); - TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (), - 1, cse2_dump_file)); - if (tem) - TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0)); + /* We only want to perform unrolling once. */ + + loop_optimize (insns, rtl_dump_file, 0); + + /* The regscan pass may not be necessary, but let's + be safe until we can prove otherwise. */ + reg_scan (insns, max_reg_num (), 1); + } + loop_optimize (insns, rtl_dump_file, flag_unroll_loops); + }); + + /* Dump rtl code after loop opt, if we are doing that. */ + + if (loop_dump) + close_dump_file (print_rtl, insns); } - if (optimize > 0 && flag_thread_jumps) + if (optimize > 0) { - /* This pass of jump threading straightens out code - that was kinked by loop optimization. */ - TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0)); - TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0)); - } - /* Dump rtl code after cse, if we are doing that. */ - - if (cse2_dump) - TIMEVAR (dump_time, - { - print_rtl (cse2_dump_file, insns); - fflush (cse2_dump_file); - }); - - if (branch_prob_dump) - TIMEVAR (dump_time, - { - fprintf (branch_prob_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); + if (cse2_dump) + open_dump_file (".cse2", decl_printable_name (decl, 2)); + + if (flag_rerun_cse_after_loop) + { + /* Running another jump optimization pass before the second + cse pass sometimes simplifies the RTL enough to allow + the second CSE pass to do a better job. Jump_optimize can change + max_reg_num so we must rerun reg_scan afterwards. + ??? Rework to not call reg_scan so often. */ + TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0)); + TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 1)); + + TIMEVAR (cse2_time, reg_scan (insns, max_reg_num (), 0)); + TIMEVAR (cse2_time, tem = cse_main (insns, max_reg_num (), + 1, rtl_dump_file)); + if (tem) + TIMEVAR (jump_time, jump_optimize (insns, 0, 0, 0)); + } + if (flag_thread_jumps) + { + /* This pass of jump threading straightens out code + that was kinked by loop optimization. */ + TIMEVAR (jump_time, reg_scan (insns, max_reg_num (), 0)); + TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 0)); + } + + /* Dump rtl code after cse, if we are doing that. */ + + if (cse2_dump) + close_dump_file (print_rtl, insns); + } + if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities) - TIMEVAR (branch_prob_time, - { - branch_prob (insns, branch_prob_dump_file); - }); - - if (branch_prob_dump) - TIMEVAR (dump_time, - { - print_rtl (branch_prob_dump_file, insns); - fflush (branch_prob_dump_file); - }); + { + if (branch_prob_dump) + open_dump_file (".bp", decl_printable_name (decl, 2)); + + TIMEVAR + (branch_prob_time, + { + branch_prob (insns, rtl_dump_file); + }); + + if (branch_prob_dump) + close_dump_file (print_rtl, insns); + } + /* We are no longer anticipating cse in this function, at least. */ cse_not_expected = 1; @@ -3414,19 +3342,15 @@ rest_of_compilation (decl) because doing the flow analysis makes some of the dump. */ if (flow_dump) - TIMEVAR (dump_time, - { - fprintf (flow_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); - + open_dump_file (".flow", decl_printable_name (decl, 2)); + if (obey_regdecls) { TIMEVAR (flow_time, { regclass (insns, max_reg_num ()); stupid_life_analysis (insns, max_reg_num (), - flow_dump_file); + rtl_dump_file); }); } else @@ -3435,7 +3359,7 @@ rest_of_compilation (decl) and write some of the results to dump file. */ TIMEVAR (flow_time, flow_analysis (insns, max_reg_num (), - flow_dump_file)); + rtl_dump_file)); if (warn_uninitialized) { uninitialized_vars_warning (DECL_INITIAL (decl)); @@ -3446,76 +3370,53 @@ rest_of_compilation (decl) /* Dump rtl after flow analysis. */ if (flow_dump) - TIMEVAR (dump_time, - { - print_rtl_with_bb (flow_dump_file, insns); - fflush (flow_dump_file); - }); - + close_dump_file (print_rtl_with_bb, insns); + /* If -opt, try combining insns through substitution. */ if (optimize > 0) - TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ())); - - /* Dump rtl code after insn combination. */ - - if (combine_dump) - TIMEVAR (dump_time, - { - fprintf (combine_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - dump_combine_stats (combine_dump_file); - print_rtl_with_bb (combine_dump_file, insns); - fflush (combine_dump_file); - }); - - if (regmove_dump) - TIMEVAR (dump_time, - { - fprintf (regmove_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); + { + TIMEVAR (combine_time, combine_instructions (insns, max_reg_num ())); + + /* Dump rtl code after insn combination. */ + + if (combine_dump) + dump_rtl (".combine", decl, print_rtl_with_bb, insns); + } /* Register allocation pre-pass, to reduce number of moves necessary for two-address machines. */ if (optimize > 0 && flag_regmove) - TIMEVAR (regmove_time, regmove_optimize (insns, max_reg_num (), - regmove_dump_file)); - - if (regmove_dump) - TIMEVAR (dump_time, - { - print_rtl_with_bb (regmove_dump_file, insns); - fflush (regmove_dump_file); - }); + { + if (regmove_dump) + open_dump_file (".regmove", decl_printable_name (decl, 2)); + + TIMEVAR (regmove_time, regmove_optimize (insns, max_reg_num (), + rtl_dump_file)); + + if (regmove_dump) + close_dump_file (print_rtl_with_bb, insns); + } /* Print function header into sched dump now because doing the sched analysis makes some of the dump. */ - if (sched_dump) - TIMEVAR (dump_time, - { - fprintf (sched_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); - if (optimize > 0 && flag_schedule_insns) { + if (sched_dump) + open_dump_file (".sched", decl_printable_name (decl, 2)); + /* Do control and data sched analysis, and write some of the results to dump file. */ - TIMEVAR (sched_time, schedule_insns (sched_dump_file)); + TIMEVAR (sched_time, schedule_insns (rtl_dump_file)); + + /* Dump rtl after instruction scheduling. */ + + if (sched_dump) + close_dump_file (print_rtl_with_bb, insns); } - /* Dump rtl after instruction scheduling. */ - - if (sched_dump) - TIMEVAR (dump_time, - { - print_rtl_with_bb (sched_dump_file, insns); - fflush (sched_dump_file); - }); - /* Unless we did stupid register allocation, allocate pseudo-regs that are used only within 1 basic block. */ @@ -3529,20 +3430,17 @@ rest_of_compilation (decl) /* Dump rtl code after allocating regs within basic blocks. */ if (local_reg_dump) - TIMEVAR (dump_time, - { - fprintf (local_reg_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - dump_flow_info (local_reg_dump_file); - dump_local_alloc (local_reg_dump_file); - print_rtl_with_bb (local_reg_dump_file, insns); - fflush (local_reg_dump_file); - }); + { + open_dump_file (".lreg", decl_printable_name (decl, 2)); + + TIMEVAR (dump_time, dump_flow_info (rtl_dump_file)); + TIMEVAR (dump_time, dump_local_alloc (rtl_dump_file)); + + close_dump_file (print_rtl_with_bb, insns); + } if (global_reg_dump) - TIMEVAR (dump_time, - fprintf (global_reg_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2))); + open_dump_file (".greg", decl_printable_name (decl, 2)); /* Save the last label number used so far, so reorg can tell when it's safe to kill spill regs. */ @@ -3555,18 +3453,16 @@ rest_of_compilation (decl) TIMEVAR (global_alloc_time, { if (!obey_regdecls) - failure = global_alloc (global_reg_dump_file); + failure = global_alloc (rtl_dump_file); else - failure = reload (insns, 0, global_reg_dump_file); + failure = reload (insns, 0, rtl_dump_file); }); if (global_reg_dump) - TIMEVAR (dump_time, - { - dump_global_regs (global_reg_dump_file); - print_rtl_with_bb (global_reg_dump_file, insns); - fflush (global_reg_dump_file); - }); + { + TIMEVAR (dump_time, dump_global_regs (rtl_dump_file)); + close_dump_file (print_rtl_with_bb, insns); + } if (failure) goto exit_rest_of_compilation; @@ -3587,25 +3483,17 @@ rest_of_compilation (decl) if (optimize > 0 && flag_schedule_insns_after_reload) { if (sched2_dump) - TIMEVAR (dump_time, - { - fprintf (sched2_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - }); + open_dump_file (".sched2", decl_printable_name (decl, 2)); /* Do control and data sched analysis again, and write some more of the results to dump file. */ - TIMEVAR (sched2_time, schedule_insns (sched2_dump_file)); + TIMEVAR (sched2_time, schedule_insns (rtl_dump_file)); /* Dump rtl after post-reorder instruction scheduling. */ if (sched2_dump) - TIMEVAR (dump_time, - { - print_rtl_with_bb (sched2_dump_file, insns); - fflush (sched2_dump_file); - }); + close_dump_file (print_rtl_with_bb, insns); } #ifdef LEAF_REGISTERS @@ -3622,22 +3510,19 @@ rest_of_compilation (decl) if (optimize > 0) { TIMEVAR (jump_time, jump_optimize (insns, 1, 1, 0)); - } - - /* Dump rtl code after jump, if we are doing that. */ + + /* Dump rtl code after jump, if we are doing that. */ - if (jump2_opt_dump) - TIMEVAR (dump_time, - { - fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - print_rtl_with_bb (jump2_opt_dump_file, insns); - fflush (jump2_opt_dump_file); - }); + if (jump2_opt_dump) + dump_rtl (".jump2", decl, print_rtl_with_bb, insns); + } /* If a machine dependent reorganization is needed, call it. */ #ifdef MACHINE_DEPENDENT_REORG MACHINE_DEPENDENT_REORG (insns); + + if (mach_dep_reorg_dump) + dump_rtl (".mach", decl, print_rtl_with_bb, insns); #endif /* If a scheduling pass for delayed branches is to be done, @@ -3647,16 +3532,9 @@ rest_of_compilation (decl) if (optimize > 0 && flag_delayed_branch) { TIMEVAR (dbr_sched_time, dbr_schedule (insns, dbr_sched_dump_file)); + if (dbr_sched_dump) - { - TIMEVAR (dump_time, - { - fprintf (dbr_sched_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - print_rtl_with_bb (dbr_sched_dump_file, insns); - fflush (dbr_sched_dump_file); - }); - } + dump_rtl (".dbr", decl, print_rtl_with_bb, insns); } #endif @@ -3668,16 +3546,9 @@ rest_of_compilation (decl) #ifdef STACK_REGS TIMEVAR (stack_reg_time, reg_to_stack (insns, stack_reg_dump_file)); + if (stack_reg_dump) - { - TIMEVAR (dump_time, - { - fprintf (stack_reg_dump_file, "\n;; Function %s\n\n", - (*decl_printable_name) (decl, 2)); - print_rtl_with_bb (stack_reg_dump_file, insns); - fflush (stack_reg_dump_file); - }); - } + dump_rtl (".stack", decl, print_rtl_with_bb, insns); #endif /* Now turn the rtl into assembler code. */ @@ -3956,14 +3827,21 @@ main (argc, argv, envp) cse_dump = 1, cse2_dump = 1; sched_dump = 1; sched2_dump = 1; +#ifdef STACK_REGS stack_reg_dump = 1; +#endif +#ifdef MACHINE_DEPENDENT_REORG + mach_dep_reorg_dump = 1; +#endif break; case 'b': branch_prob_dump = 1; break; +#ifdef STACK_REGS case 'k': stack_reg_dump = 1; break; +#endif case 'c': combine_dump = 1; break; @@ -3994,6 +3872,11 @@ main (argc, argv, envp) case 'm': flag_print_mem = 1; break; +#ifdef MACHINE_DEPENDENT_REORG + case 'M': + mach_dep_reorg_dump = 1; + break; +#endif case 'p': flag_print_asm_name = 1; break; @@ -4024,6 +3907,9 @@ main (argc, argv, envp) case 'A': flag_debug_asm = 1; break; + default: + warning ("unrecognised gcc debugging option: %c", p[-1]); + break; } } else if (str[0] == 'f')