Skip to content

R
riscv-gcc-1
Commit ddc9542b by Aldy Hernandez Committed by Aldy Hernandez
Options

toplev.c (botch): Remove. 

2003-05-31  Aldy Hernandez  <aldyh@redhat.com>

	* toplev.c (botch): Remove.
	(do_abort): Remove.
	(set_Wunused): Comment.
	(set_Wextra): Comment.
	Remove ^L's.
	(rest_of_compilation): Factor out common code into functions.
	(rest_of_handle_inlining): New.
	(rest_of_handle_ssa): New.
	(rest_of_handle_cse): New.
	(rest_of_handle_gcse): New.
	(rest_of_handle_loop_optimize): New.
	(rest_of_handle_jump_bypass): New.
	(rest_of_handle_sibling_calls): New.
	(rest_of_handle_null_pointer): New.
	(rest_of_handle_addresof): New.
	(rest_of_handle_flow): New.
	(rest_of_handle_branch_prob): New.
	(rest_of_handle_if_conversion): New.
	(rest_of_handle_tracer): New.
	(rest_of_handle_loop2): New.
	(rest_of_handle_cse2): New.
	(rest_of_handle_life): New.
	(rest_of_handle_combine): New.
	(rest_of_handle_if_after_combine): New.
	(rest_of_handle_regmove): New.
	(rest_of_handle_sched): New.
	(rest_of_handle_old_regalloc): New.
	(rest_of_handle_new_regalloc): New.
	(rest_of_handle_regrename): New.
	(rest_of_handle_reorder_blocks): New.
	(rest_of_handle_sched2): New.
	(rest_of_handle_new_regalloc): New.
	(rest_of_handle_old_regalloc): New.
	(rest_of_handle_regrename): New.
	(rest_of_handle_reorder_blocks): New.
	(rest_of_handle_stack_regs): New.
	(rest_of_handle_machine_reorg): New.
	(rest_of_handle_delay_slots): New.
	(rest_of_handle_final): New.

	* toplev.h (botch): Remove prototype.
	(do_abort): Same.

From-SVN: r67281
parent c487d8b6
Showing with 1034 additions and 803 deletions
gcc/ChangeLog
2003-05-31 Aldy Hernandez <aldyh@redhat.com>
* toplev.c (botch): Remove.
(do_abort): Remove.
(set_Wunused): Comment.
(set_Wextra): Comment.
Remove ^L's.
(rest_of_compilation): Factor out common code into functions.
(rest_of_handle_inlining): New.
(rest_of_handle_ssa): New.
(rest_of_handle_cse): New.
(rest_of_handle_gcse): New.
(rest_of_handle_loop_optimize): New.
(rest_of_handle_jump_bypass): New.
(rest_of_handle_sibling_calls): New.
(rest_of_handle_null_pointer): New.
(rest_of_handle_addresof): New.
(rest_of_handle_flow): New.
(rest_of_handle_branch_prob): New.
(rest_of_handle_if_conversion): New.
(rest_of_handle_tracer): New.
(rest_of_handle_loop2): New.
(rest_of_handle_cse2): New.
(rest_of_handle_life): New.
(rest_of_handle_combine): New.
(rest_of_handle_if_after_combine): New.
(rest_of_handle_regmove): New.
(rest_of_handle_sched): New.
(rest_of_handle_old_regalloc): New.
(rest_of_handle_new_regalloc): New.
(rest_of_handle_regrename): New.
(rest_of_handle_reorder_blocks): New.
(rest_of_handle_sched2): New.
(rest_of_handle_new_regalloc): New.
(rest_of_handle_old_regalloc): New.
(rest_of_handle_regrename): New.
(rest_of_handle_reorder_blocks): New.
(rest_of_handle_stack_regs): New.
(rest_of_handle_machine_reorg): New.
(rest_of_handle_delay_slots): New.
(rest_of_handle_final): New.
* toplev.h (botch): Remove prototype.
(do_abort): Same.
2003-05-31 Neil Booth <neil@daikokuya.co.uk> 2003-05-31 Neil Booth <neil@daikokuya.co.uk>
* Makefile.in (c-opts.o, c-options.h): Update dependencies. * Makefile.in (c-opts.o, c-options.h): Update dependencies.
......
gcc/toplev.c
...@@ -133,6 +133,43 @@ static int print_single_switch PARAMS ((FILE *, int, int, const char *, ...@@ -133,6 +133,43 @@ static int print_single_switch PARAMS ((FILE *, int, int, const char *,
static void print_switch_values PARAMS ((FILE *, int, int, const char *, static void print_switch_values PARAMS ((FILE *, int, int, const char *,
const char *, const char *)); const char *, const char *));
/* Rest of compilation helper functions. */
static bool rest_of_handle_inlining (tree);
static rtx rest_of_handle_ssa (tree, rtx);
static void rest_of_handle_cse (tree, rtx);
static void rest_of_handle_cse2 (tree, rtx);
static void rest_of_handle_gcse (tree, rtx);
static void rest_of_handle_life (tree, rtx);
static void rest_of_handle_loop_optimize (tree, rtx);
static void rest_of_handle_loop2 (tree, rtx);
static void rest_of_handle_jump_bypass (tree, rtx);
static void rest_of_handle_sibling_calls (rtx);
static void rest_of_handle_null_pointer (tree, rtx);
static void rest_of_handle_addresof (tree, rtx);
static void rest_of_handle_cfg (tree, rtx);
static void rest_of_handle_branch_prob (tree, rtx);
static void rest_of_handle_if_conversion (tree, rtx);
static void rest_of_handle_if_after_combine (tree, rtx);
static void rest_of_handle_tracer (tree, rtx);
static void rest_of_handle_combine (tree, rtx);
static void rest_of_handle_regmove (tree, rtx);
static void rest_of_handle_sched (tree, rtx);
#ifdef INSN_SCHEDULING
static void rest_of_handle_sched2 (tree, rtx);
#endif
static bool rest_of_handle_new_regalloc (tree, rtx, int *);
static bool rest_of_handle_old_regalloc (tree, rtx, int *);
static void rest_of_handle_regrename (tree, rtx);
static void rest_of_handle_reorder_blocks (tree, rtx);
#ifdef STACK_REGS
static void rest_of_handle_stack_regs (tree, rtx);
#endif
static void rest_of_handle_machine_reorg (tree, rtx);
#ifdef DELAY_SLOTS
static void rest_of_handle_delay_slots (tree, rtx);
#endif
static void rest_of_handle_final (tree, rtx);
/* Nonzero to dump debug info whilst parsing (-dy option). */ /* Nonzero to dump debug info whilst parsing (-dy option). */
static int set_yydebug; static int set_yydebug;
...@@ -438,7 +475,6 @@ int mem_report = 0; ...@@ -438,7 +475,6 @@ int mem_report = 0;
and to print them when we are done. */ and to print them when we are done. */
int flag_detailed_statistics = 0; int flag_detailed_statistics = 0;
/* -f flags. */ /* -f flags. */
/* Nonzero means `char' should be signed. */ /* Nonzero means `char' should be signed. */
...@@ -1596,6 +1632,7 @@ static const lang_independent_options W_options[] = ...@@ -1596,6 +1632,7 @@ static const lang_independent_options W_options[] =
N_ ("Warn about code which might break the strict aliasing rules") } N_ ("Warn about code which might break the strict aliasing rules") }
}; };
/* Initialize unused warning flags. */
void void
set_Wunused (setting) set_Wunused (setting)
int setting; int setting;
...@@ -1613,6 +1650,7 @@ set_Wunused (setting) ...@@ -1613,6 +1650,7 @@ set_Wunused (setting)
warn_unused_value = setting; warn_unused_value = setting;
} }
/* Initialize more unused warning flags. */
static void static void
set_Wextra (setting) set_Wextra (setting)
int setting; int setting;
...@@ -1655,7 +1693,6 @@ fast_math_flags_set_p () ...@@ -1655,7 +1693,6 @@ fast_math_flags_set_p ()
&& !flag_errno_math); && !flag_errno_math);
} }
/* Output files for assembler code (real compiler output) /* Output files for assembler code (real compiler output)
and debugging dumps. */ and debugging dumps. */
...@@ -1694,25 +1731,6 @@ read_integral_parameter (p, pname, defval) ...@@ -1694,25 +1731,6 @@ read_integral_parameter (p, pname, defval)
return atoi (p); return atoi (p);
} }
/* This calls abort and is used to avoid problems when abort is a macro.
It is used when we need to pass the address of abort. */
void
do_abort ()
{
abort ();
}
/* When `malloc.c' is compiled with `rcheck' defined,
it calls this function to report clobberage. */
void
botch (s)
const char *s ATTRIBUTE_UNUSED;
{
abort ();
}
/* Return the logarithm of X, base 2, considering X unsigned, /* Return the logarithm of X, base 2, considering X unsigned,
if X is a power of 2. Otherwise, returns -1. if X is a power of 2. Otherwise, returns -1.
...@@ -2424,255 +2442,466 @@ rest_of_type_compilation (type, toplev) ...@@ -2424,255 +2442,466 @@ rest_of_type_compilation (type, toplev)
timevar_pop (TV_SYMOUT); timevar_pop (TV_SYMOUT);
} }
/* This is called from finish_function (within langhooks.parse_file) /* Turn the RTL into assembly. */
after each top-level definition is parsed. static void
It is supposed to compile that function or variable rest_of_handle_final (tree decl, rtx insns)
and output the assembler code for it.
After we return, the tree storage is freed. */
void
rest_of_compilation (decl)
tree decl;
{ {
rtx insns; timevar_push (TV_FINAL);
int tem; {
int failure = 0; rtx x;
int rebuild_label_notes_after_reload; const char *fnname;
timevar_push (TV_REST_OF_COMPILATION); /* Get the function's name, as described by its RTL. This may be
different from the DECL_NAME name used in the source file. */
/* Now that we're out of the frontend, we shouldn't have any more x = DECL_RTL (decl);
CONCATs anywhere. */ if (GET_CODE (x) != MEM)
generating_concat_p = 0; abort ();
x = XEXP (x, 0);
if (GET_CODE (x) != SYMBOL_REF)
abort ();
fnname = XSTR (x, 0);
/* When processing delayed functions, prepare_function_start() won't assemble_start_function (decl, fnname);
have been run to re-initialize it. */ final_start_function (insns, asm_out_file, optimize);
cse_not_expected = ! optimize; final (insns, asm_out_file, optimize, 0);
final_end_function ();
/* First, make sure that NOTE_BLOCK is set correctly for each #ifdef IA64_UNWIND_INFO
NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */ /* ??? The IA-64 ".handlerdata" directive must be issued before
if (!cfun->x_whole_function_mode_p) the ".endp" directive that closes the procedure descriptor. */
identify_blocks (); output_function_exception_table ();
#endif
/* In function-at-a-time mode, we do not attempt to keep the BLOCK assemble_end_function (decl, fnname);
tree in sensible shape. So, we just recalculate it here. */
if (cfun->x_whole_function_mode_p)
reorder_blocks ();
init_flow (); #ifndef IA64_UNWIND_INFO
/* Otherwise, it feels unclean to switch sections in the middle. */
output_function_exception_table ();
#endif
/* If we are reconsidering an inline function if (! quiet_flag)
at the end of compilation, skip the stuff for making it inline. */ fflush (asm_out_file);
if (DECL_SAVED_INSNS (decl) == 0) /* Release all memory allocated by flow. */
{ free_basic_block_vars (0);
int inlinable = 0;
tree parent;
const char *lose;
/* If this is nested inside an inlined external function, pretend /* Release all memory held by regsets now. */
it was only declared. Since we cannot inline such functions, regset_release_memory ();
generating code for this one is not only not necessary but will
confuse some debugging output writers. */
for (parent = DECL_CONTEXT (current_function_decl);
parent != NULL_TREE;
parent = get_containing_scope (parent))
if (TREE_CODE (parent) == FUNCTION_DECL
&& DECL_INLINE (parent) && DECL_EXTERNAL (parent))
{
DECL_INITIAL (decl) = 0;
goto exit_rest_of_compilation;
} }
else if (TYPE_P (parent)) timevar_pop (TV_FINAL);
/* A function in a local class should be treated normally. */
break;
/* If requested, consider whether to make this function inline. */ ggc_collect ();
if ((DECL_INLINE (decl) && !flag_no_inline) }
|| flag_inline_functions)
{ #ifdef DELAY_SLOTS
timevar_push (TV_INTEGRATION); /* Run delay slot optimization. */
lose = function_cannot_inline_p (decl); static void
timevar_pop (TV_INTEGRATION); rest_of_handle_delay_slots (tree decl, rtx insns)
if (lose || ! optimize) {
timevar_push (TV_DBR_SCHED);
open_dump_file (DFI_dbr, decl);
dbr_schedule (insns, rtl_dump_file);
close_dump_file (DFI_dbr, print_rtl, insns);
timevar_pop (TV_DBR_SCHED);
ggc_collect ();
}
#endif
#ifdef STACK_REGS
/* Convert register usage from flat register file usage to a stack
register file. */
static void
rest_of_handle_stack_regs (tree decl, rtx insns)
{
timevar_push (TV_REG_STACK);
open_dump_file (DFI_stack, decl);
if (reg_to_stack (insns, rtl_dump_file) && optimize)
{ {
if (warn_inline && DECL_INLINE (decl)) if (cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
warning_with_decl (decl, lose); | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0))
DECL_ABSTRACT_ORIGIN (decl) = 0; && flag_reorder_blocks)
/* Don't really compile an extern inline function.
If we can't make it inline, pretend
it was only declared. */
if (DECL_EXTERNAL (decl))
{ {
DECL_INITIAL (decl) = 0; reorder_basic_blocks ();
goto exit_rest_of_compilation; cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
}
}
else {
/* ??? Note that we used to just make it look like if
the "inline" keyword was specified when we decide
to inline it (because of -finline-functions).
garloff@suse.de, 2002-04-24: Add another flag to
actually record this piece of information. */
if (!DECL_INLINE (decl))
DID_INLINE_FUNC (decl) = 1;
inlinable = DECL_INLINE (decl) = 1;
} }
} }
insns = get_insns (); close_dump_file (DFI_stack, print_rtl_with_bb, insns);
timevar_pop (TV_REG_STACK);
/* Dump the rtl code if we are dumping rtl. */ ggc_collect ();
}
#endif
if (open_dump_file (DFI_rtl, decl))
{
if (DECL_SAVED_INSNS (decl))
fprintf (rtl_dump_file, ";; (integrable)\n\n");
close_dump_file (DFI_rtl, print_rtl, insns);
}
/* Convert from NOTE_INSN_EH_REGION style notes, and do other /* Machine independent reorg pass. */
sorts of eh initialization. Delay this until after the static void
initial rtl dump so that we can see the original nesting. */ rest_of_handle_machine_reorg (tree decl, rtx insns)
convert_from_eh_region_ranges (); {
timevar_push (TV_MACH_DEP);
open_dump_file (DFI_mach, decl);
/* If function is inline, and we don't yet know whether to (*targetm.machine_dependent_reorg) ();
compile it by itself, defer decision till end of compilation.
wrapup_global_declarations will (indirectly) call
rest_of_compilation again for those functions that need to
be output. Also defer those functions that we are supposed
to defer. */
if (inlinable close_dump_file (DFI_mach, print_rtl, insns);
|| (DECL_INLINE (decl) timevar_pop (TV_MACH_DEP);
&& flag_inline_functions
&& ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
&& ! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
&& ! flag_keep_inline_functions)
|| DECL_EXTERNAL (decl))))
DECL_DEFER_OUTPUT (decl) = 1;
if (DECL_INLINE (decl)) ggc_collect ();
/* DWARF wants separate debugging info for abstract and }
concrete instances of all inline functions, including those
declared inline but not inlined, and those inlined even
though they weren't declared inline. Conveniently, that's
what DECL_INLINE means at this point. */
(*debug_hooks->deferred_inline_function) (decl);
if (DECL_DEFER_OUTPUT (decl))
{
/* If -Wreturn-type, we have to do a bit of compilation. We just
want to call cleanup the cfg to figure out whether or not we can
fall off the end of the function; we do the minimum amount of
work necessary to make that safe. */
if (warn_return_type)
{
int saved_optimize = optimize;
optimize = 0; /* Run new register allocator. Return TRUE if we must exit
rebuild_jump_labels (insns); rest_of_compilation upon return. */
find_exception_handler_labels (); static bool
find_basic_blocks (insns, max_reg_num (), rtl_dump_file); rest_of_handle_new_regalloc (tree decl, rtx insns, int *rebuild_notes)
cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP); {
optimize = saved_optimize; int failure;
/* CFG is no longer maintained up-to-date. */ delete_trivially_dead_insns (insns, max_reg_num ());
free_bb_for_insn (); reg_alloc ();
}
set_nothrow_function_flags (); timevar_pop (TV_LOCAL_ALLOC);
if (current_function_nothrow) if (dump_file[DFI_lreg].enabled)
/* Now we know that this can't throw; set the flag for the benefit {
of other functions later in this translation unit. */ timevar_push (TV_DUMP);
TREE_NOTHROW (current_function_decl) = 1;
timevar_push (TV_INTEGRATION); close_dump_file (DFI_lreg, NULL, NULL);
save_for_inline (decl); timevar_pop (TV_DUMP);
timevar_pop (TV_INTEGRATION);
DECL_SAVED_INSNS (decl)->inlinable = inlinable;
goto exit_rest_of_compilation;
} }
/* If specified extern inline but we aren't inlining it, we are /* XXX clean up the whole mess to bring live info in shape again. */
done. This goes for anything that gets here with DECL_EXTERNAL timevar_push (TV_GLOBAL_ALLOC);
set, not just things with DECL_INLINE. */ open_dump_file (DFI_greg, decl);
if (DECL_EXTERNAL (decl))
goto exit_rest_of_compilation;
}
/* If we're emitting a nested function, make sure its parent gets build_insn_chain (insns);
emitted as well. Doing otherwise confuses debug info. */ failure = reload (insns, 0);
timevar_pop (TV_GLOBAL_ALLOC);
if (dump_file[DFI_greg].enabled)
{ {
tree parent; timevar_push (TV_DUMP);
for (parent = DECL_CONTEXT (current_function_decl);
parent != NULL_TREE; dump_global_regs (rtl_dump_file);
parent = get_containing_scope (parent))
if (TREE_CODE (parent) == FUNCTION_DECL) close_dump_file (DFI_greg, print_rtl_with_bb, insns);
TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1; timevar_pop (TV_DUMP);
} }
/* We are now committed to emitting code for this function. Do any if (failure)
preparation, such as emitting abstract debug info for the inline return true;
before it gets mangled by optimization. */
if (DECL_INLINE (decl))
(*debug_hooks->outlining_inline_function) (decl);
/* Remove any notes we don't need. That will make iterating reload_completed = 1;
over the instruction sequence faster, and allow the garbage *rebuild_notes = 0;
collector to reclaim the memory used by the notes. */
remove_unnecessary_notes (); return false;
reorder_blocks (); }
/* Run old register allocator. Return TRUE if we must exit
rest_of_compilation upon return. */
static bool
rest_of_handle_old_regalloc (tree decl, rtx insns, int *rebuild_notes)
{
int failure;
/* Allocate the reg_renumber array. */
allocate_reg_info (max_regno, FALSE, TRUE);
/* And the reg_equiv_memory_loc array. */
reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
allocate_initial_values (reg_equiv_memory_loc);
regclass (insns, max_reg_num (), rtl_dump_file);
*rebuild_notes = local_alloc ();
timevar_pop (TV_LOCAL_ALLOC);
if (dump_file[DFI_lreg].enabled)
{
timevar_push (TV_DUMP);
dump_flow_info (rtl_dump_file);
dump_local_alloc (rtl_dump_file);
close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
timevar_pop (TV_DUMP);
}
ggc_collect (); ggc_collect ();
/* Initialize some variables used by the optimizers. */ timevar_push (TV_GLOBAL_ALLOC);
init_function_for_compilation (); open_dump_file (DFI_greg, decl);
if (! DECL_DEFER_OUTPUT (decl)) /* If optimizing, allocate remaining pseudo-regs. Do the reload
TREE_ASM_WRITTEN (decl) = 1; pass fixing up any insns that are invalid. */
/* Now that integrate will no longer see our rtl, we need not if (optimize)
distinguish between the return value of this function and the failure = global_alloc (rtl_dump_file);
return value of called functions. Also, we can remove all SETs else
of subregs of hard registers; they are only here because of {
integrate. Also, we can now initialize pseudos intended to build_insn_chain (insns);
carry magic hard reg data throughout the function. */ failure = reload (insns, 0);
rtx_equal_function_value_matters = 0; }
purge_hard_subreg_sets (get_insns ());
/* Early return if there were errors. We can run afoul of our timevar_pop (TV_GLOBAL_ALLOC);
consistency checks, and there's not really much point in fixing them.
Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */ if (dump_file[DFI_greg].enabled)
if (((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type) {
|| errorcount || sorrycount) timevar_push (TV_DUMP);
goto exit_rest_of_compilation;
dump_global_regs (rtl_dump_file);
close_dump_file (DFI_greg, print_rtl_with_bb, insns);
timevar_pop (TV_DUMP);
}
return failure;
}
/* Run the regrename and cprop passes. */
static void
rest_of_handle_regrename (tree decl, rtx insns)
{
timevar_push (TV_RENAME_REGISTERS);
open_dump_file (DFI_rnreg, decl);
if (flag_rename_registers)
regrename_optimize ();
if (flag_cprop_registers)
copyprop_hardreg_forward ();
close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
timevar_pop (TV_RENAME_REGISTERS);
}
/* Reorder basic blocks. */
static void
rest_of_handle_reorder_blocks (tree decl, rtx insns)
{
timevar_push (TV_REORDER_BLOCKS);
open_dump_file (DFI_bbro, decl);
/* Last attempt to optimize CFG, as scheduling, peepholing and insn
splitting possibly introduced more crossjumping opportunities. */
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE
| (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
if (flag_sched2_use_traces && flag_schedule_insns_after_reload)
tracer ();
if (flag_reorder_blocks)
reorder_basic_blocks ();
if (flag_reorder_blocks
|| (flag_sched2_use_traces && flag_schedule_insns_after_reload))
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
close_dump_file (DFI_bbro, print_rtl_with_bb, insns);
timevar_pop (TV_REORDER_BLOCKS);
}
/* Run instruction scheduler. */
static void
rest_of_handle_sched (tree decl, rtx insns)
{
timevar_push (TV_SCHED);
#ifdef INSN_SCHEDULING
/* Print function header into sched dump now
because doing the sched analysis makes some of the dump. */
if (optimize > 0 && flag_schedule_insns)
{
open_dump_file (DFI_sched, decl);
/* Do control and data sched analysis,
and write some of the results to dump file. */
schedule_insns (rtl_dump_file);
close_dump_file (DFI_sched, print_rtl_with_bb, insns);
}
#endif
timevar_pop (TV_SCHED);
ggc_collect ();
}
#ifdef INSN_SCHEDULING
/* Run second scheduling pass after reload. */
static void
rest_of_handle_sched2 (tree decl, rtx insns)
{
timevar_push (TV_SCHED2);
open_dump_file (DFI_sched2, decl);
/* Do control and data sched analysis again,
and write some more of the results to dump file. */
split_all_insns (1);
if (flag_sched2_use_superblocks || flag_sched2_use_traces)
{
schedule_ebbs (rtl_dump_file);
/* No liveness updating code yet, but it should be easy to do.
reg-stack recompute the liveness when needed for now. */
count_or_remove_death_notes (NULL, 1);
cleanup_cfg (CLEANUP_EXPENSIVE);
}
else
schedule_insns (rtl_dump_file);
close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
timevar_pop (TV_SCHED2);
ggc_collect ();
}
#endif
/* Register allocation pre-pass, to reduce number of moves necessary
for two-address machines. */
static void
rest_of_handle_regmove (tree decl, rtx insns)
{
timevar_push (TV_REGMOVE);
open_dump_file (DFI_regmove, decl);
regmove_optimize (insns, max_reg_num (), rtl_dump_file);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
timevar_pop (TV_REGMOVE);
ggc_collect ();
}
/* Run tracer. */
static void
rest_of_handle_tracer (tree decl, rtx insns)
{
timevar_push (TV_TRACER);
open_dump_file (DFI_tracer, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
tracer ();
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0);
close_dump_file (DFI_tracer, print_rtl_with_bb, get_insns ());
timevar_pop (TV_TRACER);
}
/* If-conversion and CFG cleanup. */
static void
rest_of_handle_if_conversion (tree decl, rtx insns)
{
open_dump_file (DFI_ce1, decl);
if (flag_if_conversion)
{
timevar_push (TV_IFCVT);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0);
if_convert (0);
timevar_pop (TV_IFCVT);
}
timevar_push (TV_JUMP); timevar_push (TV_JUMP);
open_dump_file (DFI_sibling, decl); cleanup_cfg (CLEANUP_EXPENSIVE);
insns = get_insns (); reg_scan (insns, max_reg_num (), 0);
rebuild_jump_labels (insns); timevar_pop (TV_JUMP);
find_exception_handler_labels (); close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
find_basic_blocks (insns, max_reg_num (), rtl_dump_file); }
delete_unreachable_blocks (); /* Rerun if-conversion, as combine may have simplified things enough
to now meet sequence length restrictions. */
static void
rest_of_handle_if_after_combine (tree decl, rtx insns)
{
timevar_push (TV_IFCVT);
open_dump_file (DFI_ce2, decl);
/* We have to issue these warnings now already, because CFG cleanups no_new_pseudos = 0;
further down may destroy the required information. */ if_convert (1);
check_function_return_warnings (); no_new_pseudos = 1;
close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
timevar_pop (TV_IFCVT);
}
/* Do branch profiling and static profile estimation passes. */
static void
rest_of_handle_branch_prob (tree decl, rtx insns)
{
struct loops loops;
timevar_push (TV_BRANCH_PROB);
open_dump_file (DFI_bp, decl);
if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
branch_prob ();
/* Discover and record the loop depth at the head of each basic
block. The loop infrastructure does the real job for us. */
flow_loops_find (&loops, LOOP_TREE);
if (rtl_dump_file)
flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
/* Estimate using heuristics if no profiling info is available. */
if (flag_guess_branch_prob)
estimate_probability (&loops);
flow_loops_free (&loops);
close_dump_file (DFI_bp, print_rtl_with_bb, insns);
timevar_pop (TV_BRANCH_PROB);
}
/* Do control and data flow analysis; write some of the results to the
dump file. */
static void
rest_of_handle_cfg (tree decl, rtx insns)
{
open_dump_file (DFI_cfg, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
if (optimize)
cleanup_cfg (CLEANUP_EXPENSIVE
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
/* It may make more sense to mark constant functions after dead code is
eliminated by life_analysis, but we need to do it early, as -fprofile-arcs
may insert code making function non-constant, but we still must consider
it as constant, otherwise -fbranch-probabilities will not read data back.
life_analysis rarely eliminates modification of external memory.
*/
if (optimize)
mark_constant_function ();
close_dump_file (DFI_cfg, print_rtl_with_bb, insns);
}
/* Purge addressofs. */
static void
rest_of_handle_addresof (tree decl, rtx insns)
{
open_dump_file (DFI_addressof, decl);
purge_addressof (insns);
if (optimize)
purge_all_dead_edges (0);
reg_scan (insns, max_reg_num (), 1);
/* Turn NOTE_INSN_PREDICTIONs into branch predictions. */ close_dump_file (DFI_addressof, print_rtl, insns);
if (flag_guess_branch_prob) }
{
timevar_push (TV_BRANCH_PROB);
note_prediction_to_br_prob ();
timevar_pop (TV_BRANCH_PROB);
}
/* We may have potential sibling or tail recursion sites. Select one /* We may have potential sibling or tail recursion sites. Select one
(of possibly multiple) methods of performing the call. */ (of possibly multiple) methods of performing the call. */
if (flag_optimize_sibling_calls) static void
{ rest_of_handle_sibling_calls (rtx insns)
{
rtx insn; rtx insn;
optimize_sibling_and_tail_recursive_calls (); optimize_sibling_and_tail_recursive_calls ();
...@@ -2692,98 +2921,185 @@ rest_of_compilation (decl) ...@@ -2692,98 +2921,185 @@ rest_of_compilation (decl)
if (GET_CODE (insn) == NOTE if (GET_CODE (insn) == NOTE
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION) && NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
delete_insn (insn); delete_insn (insn);
}
close_dump_file (DFI_sibling, print_rtl, get_insns ()); close_dump_file (DFI_sibling, print_rtl, get_insns ());
timevar_pop (TV_JUMP); }
scope_to_insns_initialize (); /* Perform jump bypassing and control flow optimizations. */
/* Complete generation of exception handling code. */ static void
if (doing_eh (0)) rest_of_handle_jump_bypass (tree decl, rtx insns)
{ {
timevar_push (TV_JUMP); timevar_push (TV_BYPASS);
open_dump_file (DFI_eh, decl); open_dump_file (DFI_bypass, decl);
finish_eh_generation (); cleanup_cfg (CLEANUP_EXPENSIVE);
close_dump_file (DFI_eh, print_rtl, get_insns ()); if (bypass_jumps (rtl_dump_file))
timevar_pop (TV_JUMP); {
rebuild_jump_labels (insns);
cleanup_cfg (CLEANUP_EXPENSIVE);
delete_trivially_dead_insns (insns, max_reg_num ());
} }
/* Delay emitting hard_reg_initial_value sets until after EH landing pad close_dump_file (DFI_bypass, print_rtl_with_bb, insns);
generation, which might create new sets. */ timevar_pop (TV_BYPASS);
emit_initial_value_sets ();
#ifdef FINALIZE_PIC ggc_collect ();
/* If we are doing position-independent code generation, now
is the time to output special prologues and epilogues. #ifdef ENABLE_CHECKING
We do not want to do this earlier, because it just clutters verify_flow_info ();
up inline functions with meaningless insns. */
if (flag_pic)
FINALIZE_PIC;
#endif #endif
}
/* Handle inlining of functions in rest_of_compilation. Return TRUE
if we must exit rest_of_compilation upon return. */
static bool
rest_of_handle_inlining (tree decl)
{
rtx insns;
int inlinable = 0;
tree parent;
const char *lose;
/* If we are reconsidering an inline function at the end of
compilation, skip the stuff for making it inline. */
if (DECL_SAVED_INSNS (decl) != 0)
return 0;
/* If this is nested inside an inlined external function, pretend
it was only declared. Since we cannot inline such functions,
generating code for this one is not only not necessary but will
confuse some debugging output writers. */
for (parent = DECL_CONTEXT (current_function_decl);
parent != NULL_TREE;
parent = get_containing_scope (parent))
if (TREE_CODE (parent) == FUNCTION_DECL
&& DECL_INLINE (parent) && DECL_EXTERNAL (parent))
{
DECL_INITIAL (decl) = 0;
return true;
}
else if (TYPE_P (parent))
/* A function in a local class should be treated normally. */
break;
/* If requested, consider whether to make this function inline. */
if ((DECL_INLINE (decl) && !flag_no_inline)
|| flag_inline_functions)
{
timevar_push (TV_INTEGRATION);
lose = function_cannot_inline_p (decl);
timevar_pop (TV_INTEGRATION);
if (lose || ! optimize)
{
if (warn_inline && DECL_INLINE (decl))
warning_with_decl (decl, lose);
DECL_ABSTRACT_ORIGIN (decl) = 0;
/* Don't really compile an extern inline function.
If we can't make it inline, pretend
it was only declared. */
if (DECL_EXTERNAL (decl))
{
DECL_INITIAL (decl) = 0;
return true;
}
}
else {
/* ??? Note that we used to just make it look like if
the "inline" keyword was specified when we decide
to inline it (because of -finline-functions).
garloff@suse.de, 2002-04-24: Add another flag to
actually record this piece of information. */
if (!DECL_INLINE (decl))
DID_INLINE_FUNC (decl) = 1;
inlinable = DECL_INLINE (decl) = 1;
}
}
insns = get_insns (); insns = get_insns ();
/* Copy any shared structure that should not be shared. */ /* Dump the rtl code if we are dumping rtl. */
unshare_all_rtl (current_function_decl, insns);
#ifdef SETJMP_VIA_SAVE_AREA if (open_dump_file (DFI_rtl, decl))
/* This must be performed before virtual register instantiation. {
Please be aware the everything in the compiler that can look if (DECL_SAVED_INSNS (decl))
at the RTL up to this point must understand that REG_SAVE_AREA fprintf (rtl_dump_file, ";; (integrable)\n\n");
is just like a use of the REG contained inside. */ close_dump_file (DFI_rtl, print_rtl, insns);
if (current_function_calls_alloca) }
optimize_save_area_alloca (insns);
#endif
/* Instantiate all virtual registers. */ /* Convert from NOTE_INSN_EH_REGION style notes, and do other
instantiate_virtual_regs (current_function_decl, insns); sorts of eh initialization. Delay this until after the
initial rtl dump so that we can see the original nesting. */
convert_from_eh_region_ranges ();
open_dump_file (DFI_jump, decl); /* If function is inline, and we don't yet know whether to
compile it by itself, defer decision till end of compilation.
wrapup_global_declarations will (indirectly) call
rest_of_compilation again for those functions that need to
be output. Also defer those functions that we are supposed
to defer. */
/* Always do one jump optimization pass to ensure that JUMP_LABEL fields if (inlinable
are initialized and to compute whether control can drop off the end || (DECL_INLINE (decl)
of the function. */ && flag_inline_functions
&& ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
&& ! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
&& ! flag_keep_inline_functions)
|| DECL_EXTERNAL (decl))))
DECL_DEFER_OUTPUT (decl) = 1;
timevar_push (TV_JUMP); if (DECL_INLINE (decl))
/* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this /* DWARF wants separate debugging info for abstract and
before jump optimization switches branch directions. */ concrete instances of all inline functions, including those
if (flag_guess_branch_prob) declared inline but not inlined, and those inlined even
expected_value_to_br_prob (); though they weren't declared inline. Conveniently, that's
what DECL_INLINE means at this point. */
(*debug_hooks->deferred_inline_function) (decl);
reg_scan (insns, max_reg_num (), 0); if (DECL_DEFER_OUTPUT (decl))
{
/* If -Wreturn-type, we have to do a bit of compilation. We just
want to call cleanup the cfg to figure out whether or not we can
fall off the end of the function; we do the minimum amount of
work necessary to make that safe. */
if (warn_return_type)
{
int saved_optimize = optimize;
optimize = 0;
rebuild_jump_labels (insns); rebuild_jump_labels (insns);
find_exception_handler_labels ();
find_basic_blocks (insns, max_reg_num (), rtl_dump_file); find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
delete_trivially_dead_insns (insns, max_reg_num ()); cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
if (rtl_dump_file) optimize = saved_optimize;
dump_flow_info (rtl_dump_file);
cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
if (optimize) /* CFG is no longer maintained up-to-date. */
{
free_bb_for_insn (); free_bb_for_insn ();
copy_loop_headers (insns);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
} }
purge_line_number_notes (insns);
timevar_pop (TV_JUMP); set_nothrow_function_flags ();
close_dump_file (DFI_jump, print_rtl, insns); if (current_function_nothrow)
/* Now we know that this can't throw; set the flag for the benefit
of other functions later in this translation unit. */
TREE_NOTHROW (current_function_decl) = 1;
/* Now is when we stop if -fsyntax-only and -Wreturn-type. */ timevar_push (TV_INTEGRATION);
if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl)) save_for_inline (decl);
{ timevar_pop (TV_INTEGRATION);
goto exit_rest_of_compilation; DECL_SAVED_INSNS (decl)->inlinable = inlinable;
return true;
} }
/* Long term, this should probably move before the jump optimizer too, /* If specified extern inline but we aren't inlining it, we are
but I didn't want to disturb the rtl_dump_and_exit and related done. This goes for anything that gets here with DECL_EXTERNAL
stuff at this time. */ set, not just things with DECL_INLINE. */
if (optimize > 0 && flag_ssa) return (bool) DECL_EXTERNAL (decl);
{ }
/* Convert to SSA form. */
/* Rest of compilation helper to convert the rtl to SSA form. */
static rtx
rest_of_handle_ssa (tree decl, rtx insns)
{
timevar_push (TV_TO_SSA); timevar_push (TV_TO_SSA);
open_dump_file (DFI_ssa, decl); open_dump_file (DFI_ssa, decl);
...@@ -2837,48 +3153,109 @@ rest_of_compilation (decl) ...@@ -2837,48 +3153,109 @@ rest_of_compilation (decl)
/* New registers have been created. Rescan their usage. */ /* New registers have been created. Rescan their usage. */
reg_scan (insns, max_reg_num (), 1); reg_scan (insns, max_reg_num (), 1);
close_dump_file (DFI_ussa, print_rtl_with_bb, insns); close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
timevar_pop (TV_FROM_SSA); timevar_pop (TV_FROM_SSA);
ggc_collect ();
return insns;
}
/* Try to identify useless null pointer tests and delete them. */
static void
rest_of_handle_null_pointer (tree decl, rtx insns)
{
open_dump_file (DFI_null, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
if (delete_null_pointer_checks (insns))
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
close_dump_file (DFI_null, print_rtl_with_bb, insns);
}
/* Try combining insns through substitution. */
static void
rest_of_handle_combine (tree decl, rtx insns)
{
int rebuild_jump_labels_after_combine = 0;
timevar_push (TV_COMBINE);
open_dump_file (DFI_combine, decl);
rebuild_jump_labels_after_combine
= combine_instructions (insns, max_reg_num ());
/* Combining insns may have turned an indirect jump into a
direct jump. Rebuild the JUMP_LABEL fields of jumping
instructions. */
if (rebuild_jump_labels_after_combine)
{
timevar_push (TV_JUMP);
rebuild_jump_labels (insns);
timevar_pop (TV_JUMP);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
}
close_dump_file (DFI_combine, print_rtl_with_bb, insns);
timevar_pop (TV_COMBINE);
ggc_collect (); ggc_collect ();
} }
timevar_push (TV_JUMP); /* Perform life analysis. */
static void
rest_of_handle_life (tree decl, rtx insns)
{
open_dump_file (DFI_life, decl);
regclass_init ();
#ifdef ENABLE_CHECKING
verify_flow_info ();
#endif
life_analysis (insns, rtl_dump_file, PROP_FINAL);
if (optimize) if (optimize)
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
timevar_pop (TV_FLOW);
/* Try to identify useless null pointer tests and delete them. */ if (warn_uninitialized)
if (flag_delete_null_pointer_checks)
{ {
open_dump_file (DFI_null, decl); uninitialized_vars_warning (DECL_INITIAL (decl));
if (rtl_dump_file) if (extra_warnings)
dump_flow_info (rtl_dump_file); setjmp_args_warning ();
}
if (delete_null_pointer_checks (insns))
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
close_dump_file (DFI_null, print_rtl_with_bb, insns); if (optimize)
{
if (!flag_new_regalloc && initialize_uninitialized_subregs ())
{
/* Insns were inserted, and possibly pseudos created, so
things might look a bit different. */
insns = get_insns ();
allocate_reg_life_data ();
update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
PROP_LOG_LINKS | PROP_REG_INFO | PROP_DEATH_NOTES);
}
} }
/* Jump optimization, and the removal of NULL pointer checks, may no_new_pseudos = 1;
have reduced the number of instructions substantially. CSE, and
future passes, allocate arrays whose dimensions involve the
maximum instruction UID, so if we can reduce the maximum UID
we'll save big on memory. */
renumber_insns (rtl_dump_file);
timevar_pop (TV_JUMP);
close_dump_file (DFI_jump, print_rtl_with_bb, insns); close_dump_file (DFI_life, print_rtl_with_bb, insns);
ggc_collect (); ggc_collect ();
}
/* Perform common subexpression elimination. /* Perform common subexpression elimination. Nonzero value from
Nonzero value from `cse_main' means that jumps were simplified `cse_main' means that jumps were simplified and some code may now
and some code may now be unreachable, so do be unreachable, so do jump optimization again. */
jump optimization again. */ static void
rest_of_handle_cse (tree decl, rtx insns)
{
int tem;
if (optimize > 0)
{
open_dump_file (DFI_cse, decl); open_dump_file (DFI_cse, decl);
if (rtl_dump_file) if (rtl_dump_file)
dump_flow_info (rtl_dump_file); dump_flow_info (rtl_dump_file);
...@@ -2915,25 +3292,42 @@ rest_of_compilation (decl) ...@@ -2915,25 +3292,42 @@ rest_of_compilation (decl)
timevar_pop (TV_CSE); timevar_pop (TV_CSE);
close_dump_file (DFI_cse, print_rtl_with_bb, insns); close_dump_file (DFI_cse, print_rtl_with_bb, insns);
} }
open_dump_file (DFI_addressof, decl); /* Run second CSE pass after loop optimizations. */
static void
rest_of_handle_cse2 (tree decl, rtx insns)
{
int tem;
purge_addressof (insns); timevar_push (TV_CSE2);
if (optimize) open_dump_file (DFI_cse2, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
/* CFG is no longer maintained up-to-date. */
tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file);
purge_all_dead_edges (0); purge_all_dead_edges (0);
reg_scan (insns, max_reg_num (), 1); delete_trivially_dead_insns (insns, max_reg_num ());
close_dump_file (DFI_addressof, print_rtl, insns);
if (tem)
{
timevar_push (TV_JUMP);
rebuild_jump_labels (insns);
cleanup_cfg (CLEANUP_EXPENSIVE);
timevar_pop (TV_JUMP);
}
reg_scan (insns, max_reg_num (), 0);
close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
ggc_collect (); ggc_collect ();
timevar_pop (TV_CSE2);
}
/* Perform global cse. */ /* Perform global cse. */
static void
if (optimize > 0 && flag_gcse) rest_of_handle_gcse (tree decl, rtx insns)
{ {
int save_csb, save_cfj; int save_csb, save_cfj;
int tem2 = 0; int tem2 = 0, tem;
timevar_push (TV_GCSE); timevar_push (TV_GCSE);
open_dump_file (DFI_gcse, decl); open_dump_file (DFI_gcse, decl);
...@@ -2993,18 +3387,19 @@ rest_of_compilation (decl) ...@@ -2993,18 +3387,19 @@ rest_of_compilation (decl)
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
verify_flow_info (); verify_flow_info ();
#endif #endif
} }
/* Move constant computations out of loops. */
if (optimize > 0 && flag_loop_optimize) /* Move constant computations out of loops. */
{ static void
rest_of_handle_loop_optimize (tree decl, rtx insns)
{
int do_unroll, do_prefetch; int do_unroll, do_prefetch;
timevar_push (TV_LOOP); timevar_push (TV_LOOP);
delete_dead_jumptables (); delete_dead_jumptables ();
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
open_dump_file (DFI_loop, decl); open_dump_file (DFI_loop, decl);
/* CFG is no longer maintained up-to-date. */ /* CFG is no longer maintained up-to-date. */
free_bb_for_insn (); free_bb_for_insn ();
...@@ -3013,6 +3408,7 @@ rest_of_compilation (decl) ...@@ -3013,6 +3408,7 @@ rest_of_compilation (decl)
else else
do_unroll = flag_old_unroll_loops ? LOOP_UNROLL : LOOP_AUTO_UNROLL; do_unroll = flag_old_unroll_loops ? LOOP_UNROLL : LOOP_AUTO_UNROLL;
do_prefetch = flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0; do_prefetch = flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0;
if (flag_rerun_loop_opt) if (flag_rerun_loop_opt)
{ {
cleanup_barriers (); cleanup_barriers ();
...@@ -3041,279 +3437,317 @@ rest_of_compilation (decl) ...@@ -3041,279 +3437,317 @@ rest_of_compilation (decl)
find_basic_blocks (insns, max_reg_num (), rtl_dump_file); find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
ggc_collect (); ggc_collect ();
} }
/* Perform jump bypassing and control flow optimizations. */ /* Perform loop optimalizations. It might be better to do them a bit
if (optimize > 0 && flag_gcse) sooner, but we want the profile feedback to work more
{ efficiently. */
timevar_push (TV_BYPASS); static void
open_dump_file (DFI_bypass, decl); rest_of_handle_loop2 (tree decl, rtx insns)
{
struct loops *loops;
timevar_push (TV_LOOP);
open_dump_file (DFI_loop2, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
cleanup_cfg (CLEANUP_EXPENSIVE); loops = loop_optimizer_init (rtl_dump_file);
tem = bypass_jumps (rtl_dump_file);
if (tem) if (loops)
{ {
rebuild_jump_labels (insns); /* The optimalizations: */
if (flag_unswitch_loops)
unswitch_loops (loops);
if (flag_peel_loops || flag_unroll_loops)
unroll_and_peel_loops (loops,
(flag_peel_loops ? UAP_PEEL : 0) |
(flag_unroll_loops ? UAP_UNROLL : 0) |
(flag_unroll_all_loops ? UAP_UNROLL_ALL : 0));
loop_optimizer_finalize (loops, rtl_dump_file);
}
cleanup_cfg (CLEANUP_EXPENSIVE); cleanup_cfg (CLEANUP_EXPENSIVE);
delete_trivially_dead_insns (insns, max_reg_num ()); delete_trivially_dead_insns (insns, max_reg_num ());
} reg_scan (insns, max_reg_num (), 0);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
close_dump_file (DFI_loop2, print_rtl_with_bb, get_insns ());
timevar_pop (TV_LOOP);
ggc_collect ();
}
close_dump_file (DFI_bypass, print_rtl_with_bb, insns); /* This is called from finish_function (within langhooks.parse_file)
timevar_pop (TV_BYPASS); after each top-level definition is parsed.
It is supposed to compile that function or variable
and output the assembler code for it.
After we return, the tree storage is freed. */
ggc_collect (); void
rest_of_compilation (decl)
tree decl;
{
rtx insns;
int rebuild_label_notes_after_reload;
#ifdef ENABLE_CHECKING timevar_push (TV_REST_OF_COMPILATION);
verify_flow_info ();
#endif
}
/* Do control and data flow analysis; wrote some of the results to /* Now that we're out of the frontend, we shouldn't have any more
the dump file. */ CONCATs anywhere. */
generating_concat_p = 0;
timevar_push (TV_FLOW); /* When processing delayed functions, prepare_function_start() won't
open_dump_file (DFI_cfg, decl); have been run to re-initialize it. */
if (rtl_dump_file) cse_not_expected = ! optimize;
dump_flow_info (rtl_dump_file);
if (optimize)
cleanup_cfg (CLEANUP_EXPENSIVE
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
/* It may make more sense to mark constant functions after dead code is /* First, make sure that NOTE_BLOCK is set correctly for each
eliminated by life_analysis, but we need to do it early, as -fprofile-arcs NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
may insert code making function non-constant, but we still must consider if (!cfun->x_whole_function_mode_p)
it as constant, otherwise -fbranch-probabilities will not read data back. identify_blocks ();
life_analysis rarely eliminates modification of external memory. /* In function-at-a-time mode, we do not attempt to keep the BLOCK
*/ tree in sensible shape. So, we just recalculate it here. */
if (optimize) if (cfun->x_whole_function_mode_p)
mark_constant_function (); reorder_blocks ();
close_dump_file (DFI_cfg, print_rtl_with_bb, insns); init_flow ();
/* Do branch profiling and static profile estimation passes. */ if (rest_of_handle_inlining (decl))
if (optimize > 0 goto exit_rest_of_compilation;
|| profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
/* If we're emitting a nested function, make sure its parent gets
emitted as well. Doing otherwise confuses debug info. */
{ {
struct loops loops; tree parent;
for (parent = DECL_CONTEXT (current_function_decl);
parent != NULL_TREE;
parent = get_containing_scope (parent))
if (TREE_CODE (parent) == FUNCTION_DECL)
TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
}
timevar_push (TV_BRANCH_PROB); /* We are now committed to emitting code for this function. Do any
open_dump_file (DFI_bp, decl); preparation, such as emitting abstract debug info for the inline
if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities) before it gets mangled by optimization. */
branch_prob (); if (DECL_INLINE (decl))
(*debug_hooks->outlining_inline_function) (decl);
/* Discover and record the loop depth at the head of each basic /* Remove any notes we don't need. That will make iterating
block. The loop infrastructure does the real job for us. */ over the instruction sequence faster, and allow the garbage
flow_loops_find (&loops, LOOP_TREE); collector to reclaim the memory used by the notes. */
remove_unnecessary_notes ();
reorder_blocks ();
if (rtl_dump_file) ggc_collect ();
flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
/* Initialize some variables used by the optimizers. */
init_function_for_compilation ();
if (! DECL_DEFER_OUTPUT (decl))
TREE_ASM_WRITTEN (decl) = 1;
/* Now that integrate will no longer see our rtl, we need not
distinguish between the return value of this function and the
return value of called functions. Also, we can remove all SETs
of subregs of hard registers; they are only here because of
integrate. Also, we can now initialize pseudos intended to
carry magic hard reg data throughout the function. */
rtx_equal_function_value_matters = 0;
purge_hard_subreg_sets (get_insns ());
/* Early return if there were errors. We can run afoul of our
consistency checks, and there's not really much point in fixing them.
Don't return yet if -Wreturn-type; we need to do cleanup_cfg. */
if (((rtl_dump_and_exit || flag_syntax_only) && !warn_return_type)
|| errorcount || sorrycount)
goto exit_rest_of_compilation;
timevar_push (TV_JUMP);
open_dump_file (DFI_sibling, decl);
insns = get_insns ();
rebuild_jump_labels (insns);
find_exception_handler_labels ();
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
delete_unreachable_blocks ();
/* Estimate using heuristics if no profiling info is available. */ /* We have to issue these warnings now already, because CFG cleanups
if (flag_guess_branch_prob) further down may destroy the required information. */
estimate_probability (&loops); check_function_return_warnings ();
flow_loops_free (&loops); /* Turn NOTE_INSN_PREDICTIONs into branch predictions. */
close_dump_file (DFI_bp, print_rtl_with_bb, insns); if (flag_guess_branch_prob)
{
timevar_push (TV_BRANCH_PROB);
note_prediction_to_br_prob ();
timevar_pop (TV_BRANCH_PROB); timevar_pop (TV_BRANCH_PROB);
} }
if (optimize > 0)
{ if (flag_optimize_sibling_calls)
open_dump_file (DFI_ce1, decl); rest_of_handle_sibling_calls (insns);
if (flag_if_conversion)
timevar_pop (TV_JUMP);
scope_to_insns_initialize ();
/* Complete generation of exception handling code. */
if (doing_eh (0))
{ {
timevar_push (TV_IFCVT);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0);
if_convert (0);
timevar_pop (TV_IFCVT);
}
timevar_push (TV_JUMP); timevar_push (TV_JUMP);
cleanup_cfg (CLEANUP_EXPENSIVE); open_dump_file (DFI_eh, decl);
reg_scan (insns, max_reg_num (), 0);
finish_eh_generation ();
close_dump_file (DFI_eh, print_rtl, get_insns ());
timevar_pop (TV_JUMP); timevar_pop (TV_JUMP);
close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
}
if (flag_tracer)
{
timevar_push (TV_TRACER);
open_dump_file (DFI_tracer, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
tracer ();
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0);
close_dump_file (DFI_tracer, print_rtl_with_bb, get_insns ());
timevar_pop (TV_TRACER);
} }
/* Perform loop optimalizations. It might be better to do them a bit /* Delay emitting hard_reg_initial_value sets until after EH landing pad
sooner, but we want the profile feedback to work more efficiently. */ generation, which might create new sets. */
if (optimize > 0 emit_initial_value_sets ();
&& (flag_unswitch_loops
|| flag_peel_loops
|| flag_unroll_loops))
{
struct loops *loops;
timevar_push (TV_LOOP);
open_dump_file (DFI_loop2, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
loops = loop_optimizer_init (rtl_dump_file); #ifdef FINALIZE_PIC
/* If we are doing position-independent code generation, now
is the time to output special prologues and epilogues.
We do not want to do this earlier, because it just clutters
up inline functions with meaningless insns. */
if (flag_pic)
FINALIZE_PIC;
#endif
if (loops) insns = get_insns ();
{
/* The optimalizations: */
if (flag_unswitch_loops)
unswitch_loops (loops);
if (flag_peel_loops || flag_unroll_loops) /* Copy any shared structure that should not be shared. */
unroll_and_peel_loops (loops, unshare_all_rtl (current_function_decl, insns);
(flag_peel_loops ? UAP_PEEL : 0) |
(flag_unroll_loops ? UAP_UNROLL : 0) |
(flag_unroll_all_loops ? UAP_UNROLL_ALL : 0));
loop_optimizer_finalize (loops, rtl_dump_file); #ifdef SETJMP_VIA_SAVE_AREA
} /* This must be performed before virtual register instantiation.
Please be aware the everything in the compiler that can look
at the RTL up to this point must understand that REG_SAVE_AREA
is just like a use of the REG contained inside. */
if (current_function_calls_alloca)
optimize_save_area_alloca (insns);
#endif
cleanup_cfg (CLEANUP_EXPENSIVE); /* Instantiate all virtual registers. */
delete_trivially_dead_insns (insns, max_reg_num ()); instantiate_virtual_regs (current_function_decl, insns);
reg_scan (insns, max_reg_num (), 0);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
close_dump_file (DFI_loop2, print_rtl_with_bb, get_insns ());
timevar_pop (TV_LOOP);
ggc_collect ();
}
if (flag_rerun_cse_after_loop) open_dump_file (DFI_jump, decl);
{
timevar_push (TV_CSE2); /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
open_dump_file (DFI_cse2, decl); are initialized and to compute whether control can drop off the end
of the function. */
timevar_push (TV_JUMP);
/* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
before jump optimization switches branch directions. */
if (flag_guess_branch_prob)
expected_value_to_br_prob ();
reg_scan (insns, max_reg_num (), 0);
rebuild_jump_labels (insns);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
delete_trivially_dead_insns (insns, max_reg_num ());
if (rtl_dump_file) if (rtl_dump_file)
dump_flow_info (rtl_dump_file); dump_flow_info (rtl_dump_file);
/* CFG is no longer maintained up-to-date. */ cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file); | (flag_thread_jumps ? CLEANUP_THREADING : 0));
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ());
if (tem) if (optimize)
{ {
timevar_push (TV_JUMP); free_bb_for_insn ();
rebuild_jump_labels (insns); copy_loop_headers (insns);
cleanup_cfg (CLEANUP_EXPENSIVE); find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
timevar_pop (TV_JUMP);
}
reg_scan (insns, max_reg_num (), 0);
close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
ggc_collect ();
timevar_pop (TV_CSE2);
} }
purge_line_number_notes (insns);
cse_not_expected = 1; timevar_pop (TV_JUMP);
close_dump_file (DFI_jump, print_rtl, insns);
open_dump_file (DFI_life, decl); /* Now is when we stop if -fsyntax-only and -Wreturn-type. */
regclass_init (); if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
goto exit_rest_of_compilation;
#ifdef ENABLE_CHECKING /* Long term, this should probably move before the jump optimizer too,
verify_flow_info (); but I didn't want to disturb the rtl_dump_and_exit and related
#endif stuff at this time. */
life_analysis (insns, rtl_dump_file, PROP_FINAL); if (optimize > 0 && flag_ssa)
if (optimize) insns = rest_of_handle_ssa (decl, insns);
cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
timevar_pop (TV_FLOW);
if (warn_uninitialized) timevar_push (TV_JUMP);
{
uninitialized_vars_warning (DECL_INITIAL (decl));
if (extra_warnings)
setjmp_args_warning ();
}
if (optimize) if (optimize)
{ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
if (!flag_new_regalloc && initialize_uninitialized_subregs ())
{
/* Insns were inserted, and possibly pseudos created, so
things might look a bit different. */
insns = get_insns ();
allocate_reg_life_data ();
update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
PROP_LOG_LINKS | PROP_REG_INFO | PROP_DEATH_NOTES);
}
}
no_new_pseudos = 1; if (flag_delete_null_pointer_checks)
rest_of_handle_null_pointer (decl, insns);
close_dump_file (DFI_life, print_rtl_with_bb, insns); /* Jump optimization, and the removal of NULL pointer checks, may
have reduced the number of instructions substantially. CSE, and
future passes, allocate arrays whose dimensions involve the
maximum instruction UID, so if we can reduce the maximum UID
we'll save big on memory. */
renumber_insns (rtl_dump_file);
timevar_pop (TV_JUMP);
ggc_collect (); close_dump_file (DFI_jump, print_rtl_with_bb, insns);
/* If -opt, try combining insns through substitution. */ ggc_collect ();
if (optimize > 0) if (optimize > 0)
{ rest_of_handle_cse (decl, insns);
int rebuild_jump_labels_after_combine = 0;
timevar_push (TV_COMBINE); rest_of_handle_addresof (decl, insns);
open_dump_file (DFI_combine, decl);
rebuild_jump_labels_after_combine ggc_collect ();
= combine_instructions (insns, max_reg_num ());
/* Combining insns may have turned an indirect jump into a if (optimize > 0)
direct jump. Rebuild the JUMP_LABEL fields of jumping
instructions. */
if (rebuild_jump_labels_after_combine)
{ {
timevar_push (TV_JUMP); if (flag_gcse)
rebuild_jump_labels (insns); rest_of_handle_gcse (decl, insns);
timevar_pop (TV_JUMP);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE); if (flag_loop_optimize)
rest_of_handle_loop_optimize (decl, insns);
if (flag_gcse)
rest_of_handle_jump_bypass (decl, insns);
} }
close_dump_file (DFI_combine, print_rtl_with_bb, insns); timevar_push (TV_FLOW);
timevar_pop (TV_COMBINE);
ggc_collect (); rest_of_handle_cfg (decl, insns);
}
/* Rerun if-conversion, as combine may have simplified things enough to if (optimize > 0
now meet sequence length restrictions. */ || profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
if (flag_if_conversion) rest_of_handle_branch_prob (decl, insns);
{
timevar_push (TV_IFCVT);
open_dump_file (DFI_ce2, decl);
no_new_pseudos = 0; if (optimize > 0)
if_convert (1); rest_of_handle_if_conversion (decl, insns);
no_new_pseudos = 1;
close_dump_file (DFI_ce2, print_rtl_with_bb, insns); if (flag_tracer)
timevar_pop (TV_IFCVT); rest_of_handle_tracer (decl, insns);
}
/* Register allocation pre-pass, to reduce number of moves if (optimize > 0
necessary for two-address machines. */ && (flag_unswitch_loops
if (optimize > 0 && (flag_regmove || flag_expensive_optimizations)) || flag_peel_loops
{ || flag_unroll_loops))
timevar_push (TV_REGMOVE); rest_of_handle_loop2 (decl, insns);
open_dump_file (DFI_regmove, decl);
regmove_optimize (insns, max_reg_num (), rtl_dump_file); if (flag_rerun_cse_after_loop)
rest_of_handle_cse2 (decl, insns);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE); cse_not_expected = 1;
close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
timevar_pop (TV_REGMOVE); rest_of_handle_life (decl, insns);
if (optimize > 0)
rest_of_handle_combine (decl, insns);
if (flag_if_conversion)
rest_of_handle_if_after_combine (decl, insns);
ggc_collect (); if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
} rest_of_handle_regmove (decl, insns);
/* Do unconditional splitting before register allocation to allow machine /* Do unconditional splitting before register allocation to allow machine
description to add extra information not needed previously. */ description to add extra information not needed previously. */
...@@ -3334,27 +3768,7 @@ rest_of_compilation (decl) ...@@ -3334,27 +3768,7 @@ rest_of_compilation (decl)
(see handling of reg_known_equiv in init_alias_analysis). */ (see handling of reg_known_equiv in init_alias_analysis). */
recompute_reg_usage (insns, !optimize_size); recompute_reg_usage (insns, !optimize_size);
timevar_push (TV_SCHED); rest_of_handle_sched (decl, insns);
#ifdef INSN_SCHEDULING
/* Print function header into sched dump now
because doing the sched analysis makes some of the dump. */
if (optimize > 0 && flag_schedule_insns)
{
open_dump_file (DFI_sched, decl);
/* Do control and data sched analysis,
and write some of the results to dump file. */
schedule_insns (rtl_dump_file);
close_dump_file (DFI_sched, print_rtl_with_bb, insns);
}
#endif
timevar_pop (TV_SCHED);
ggc_collect ();
/* Determine if the current function is a leaf before running reload /* Determine if the current function is a leaf before running reload
since this can impact optimizations done by the prologue and since this can impact optimizations done by the prologue and
...@@ -3364,104 +3778,16 @@ rest_of_compilation (decl) ...@@ -3364,104 +3778,16 @@ rest_of_compilation (decl)
timevar_push (TV_LOCAL_ALLOC); timevar_push (TV_LOCAL_ALLOC);
open_dump_file (DFI_lreg, decl); open_dump_file (DFI_lreg, decl);
/* Allocate pseudo-regs that are used only within 1 basic block.
RUN_JUMP_AFTER_RELOAD records whether or not we need to rerun the
jump optimizer after register allocation and reloading are finished. */
if (flag_new_regalloc) if (flag_new_regalloc)
{ {
delete_trivially_dead_insns (insns, max_reg_num ()); if (rest_of_handle_new_regalloc (decl, insns,
reg_alloc (); &rebuild_label_notes_after_reload))
timevar_pop (TV_LOCAL_ALLOC);
if (dump_file[DFI_lreg].enabled)
{
timevar_push (TV_DUMP);
close_dump_file (DFI_lreg, NULL, NULL);
timevar_pop (TV_DUMP);
}
/* XXX clean up the whole mess to bring live info in shape again. */
timevar_push (TV_GLOBAL_ALLOC);
open_dump_file (DFI_greg, decl);
build_insn_chain (insns);
failure = reload (insns, 0);
timevar_pop (TV_GLOBAL_ALLOC);
if (dump_file[DFI_greg].enabled)
{
timevar_push (TV_DUMP);
dump_global_regs (rtl_dump_file);
close_dump_file (DFI_greg, print_rtl_with_bb, insns);
timevar_pop (TV_DUMP);
}
if (failure)
goto exit_rest_of_compilation; goto exit_rest_of_compilation;
reload_completed = 1;
rebuild_label_notes_after_reload = 0;
}
else
{
/* Allocate the reg_renumber array. */
allocate_reg_info (max_regno, FALSE, TRUE);
/* And the reg_equiv_memory_loc array. */
reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
allocate_initial_values (reg_equiv_memory_loc);
regclass (insns, max_reg_num (), rtl_dump_file);
rebuild_label_notes_after_reload = local_alloc ();
timevar_pop (TV_LOCAL_ALLOC);
if (dump_file[DFI_lreg].enabled)
{
timevar_push (TV_DUMP);
dump_flow_info (rtl_dump_file);
dump_local_alloc (rtl_dump_file);
close_dump_file (DFI_lreg, print_rtl_with_bb, insns);
timevar_pop (TV_DUMP);
} }
ggc_collect ();
timevar_push (TV_GLOBAL_ALLOC);
open_dump_file (DFI_greg, decl);
/* If optimizing, allocate remaining pseudo-regs. Do the reload
pass fixing up any insns that are invalid. */
if (optimize)
failure = global_alloc (rtl_dump_file);
else else
{ {
build_insn_chain (insns); if (rest_of_handle_old_regalloc (decl, insns,
failure = reload (insns, 0); &rebuild_label_notes_after_reload))
}
timevar_pop (TV_GLOBAL_ALLOC);
if (dump_file[DFI_greg].enabled)
{
timevar_push (TV_DUMP);
dump_global_regs (rtl_dump_file);
close_dump_file (DFI_greg, print_rtl_with_bb, insns);
timevar_pop (TV_DUMP);
}
if (failure)
goto exit_rest_of_compilation; goto exit_rest_of_compilation;
} }
...@@ -3551,40 +3877,12 @@ rest_of_compilation (decl) ...@@ -3551,40 +3877,12 @@ rest_of_compilation (decl)
} }
#endif #endif
if (optimize > 0 && (flag_rename_registers || flag_cprop_registers))
{
timevar_push (TV_RENAME_REGISTERS);
open_dump_file (DFI_rnreg, decl);
if (flag_rename_registers)
regrename_optimize ();
if (flag_cprop_registers)
copyprop_hardreg_forward ();
close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
timevar_pop (TV_RENAME_REGISTERS);
}
if (optimize > 0) if (optimize > 0)
{ {
timevar_push (TV_REORDER_BLOCKS); if (flag_rename_registers || flag_cprop_registers)
open_dump_file (DFI_bbro, decl); rest_of_handle_regrename (decl, insns);
/* Last attempt to optimize CFG, as scheduling, peepholing and insn
splitting possibly introduced more crossjumping opportunities. */
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE
| (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
if (flag_sched2_use_traces && flag_schedule_insns_after_reload)
tracer ();
if (flag_reorder_blocks)
reorder_basic_blocks ();
if (flag_reorder_blocks
|| (flag_sched2_use_traces && flag_schedule_insns_after_reload))
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
close_dump_file (DFI_bbro, print_rtl_with_bb, insns); rest_of_handle_reorder_blocks (decl, insns);
timevar_pop (TV_REORDER_BLOCKS);
} }
if (flag_if_conversion2) if (flag_if_conversion2)
...@@ -3600,31 +3898,7 @@ rest_of_compilation (decl) ...@@ -3600,31 +3898,7 @@ rest_of_compilation (decl)
#ifdef INSN_SCHEDULING #ifdef INSN_SCHEDULING
if (optimize > 0 && flag_schedule_insns_after_reload) if (optimize > 0 && flag_schedule_insns_after_reload)
{ rest_of_handle_sched2 (decl, insns);
timevar_push (TV_SCHED2);
open_dump_file (DFI_sched2, decl);
/* Do control and data sched analysis again,
and write some more of the results to dump file. */
split_all_insns (1);
if (flag_sched2_use_superblocks || flag_sched2_use_traces)
{
schedule_ebbs (rtl_dump_file);
/* No liveness updating code yet, but it should be easy to do.
reg-stack recompute the liveness when needed for now. */
count_or_remove_death_notes (NULL, 1);
cleanup_cfg (CLEANUP_EXPENSIVE);
}
else
schedule_insns (rtl_dump_file);
close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
timevar_pop (TV_SCHED2);
ggc_collect ();
}
#endif #endif
#ifdef LEAF_REGISTERS #ifdef LEAF_REGISTERS
...@@ -3633,63 +3907,23 @@ rest_of_compilation (decl) ...@@ -3633,63 +3907,23 @@ rest_of_compilation (decl)
#endif #endif
#ifdef STACK_REGS #ifdef STACK_REGS
timevar_push (TV_REG_STACK); rest_of_handle_stack_regs (decl, insns);
open_dump_file (DFI_stack, decl);
if (reg_to_stack (insns, rtl_dump_file) && optimize)
{
if (cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
| (flag_crossjumping ? CLEANUP_CROSSJUMP : 0))
&& flag_reorder_blocks)
{
reorder_basic_blocks ();
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
}
}
close_dump_file (DFI_stack, print_rtl_with_bb, insns);
timevar_pop (TV_REG_STACK);
ggc_collect ();
#endif #endif
compute_alignments (); compute_alignments ();
/* CFG is no longer maintained up-to-date. */ /* CFG is no longer maintained up-to-date. */
free_bb_for_insn (); free_bb_for_insn ();
/* If a machine dependent reorganization is needed, call it. */
if (targetm.machine_dependent_reorg != 0) if (targetm.machine_dependent_reorg != 0)
{ rest_of_handle_machine_reorg (decl, insns);
timevar_push (TV_MACH_DEP);
open_dump_file (DFI_mach, decl);
(*targetm.machine_dependent_reorg) ();
close_dump_file (DFI_mach, print_rtl, insns);
timevar_pop (TV_MACH_DEP);
ggc_collect ();
}
purge_line_number_notes (insns); purge_line_number_notes (insns);
cleanup_barriers (); cleanup_barriers ();
/* If a scheduling pass for delayed branches is to be done,
call the scheduling code. */
#ifdef DELAY_SLOTS #ifdef DELAY_SLOTS
if (optimize > 0 && flag_delayed_branch) if (optimize > 0 && flag_delayed_branch)
{ rest_of_handle_delay_slots (decl, insns);
timevar_push (TV_DBR_SCHED);
open_dump_file (DFI_dbr, decl);
dbr_schedule (insns, rtl_dump_file);
close_dump_file (DFI_dbr, print_rtl, insns);
timevar_pop (TV_DBR_SCHED);
ggc_collect ();
}
#endif #endif
#if defined (HAVE_ATTR_length) && !defined (STACK_REGS) #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
...@@ -3711,54 +3945,7 @@ rest_of_compilation (decl) ...@@ -3711,54 +3945,7 @@ rest_of_compilation (decl)
of other functions later in this translation unit. */ of other functions later in this translation unit. */
TREE_NOTHROW (current_function_decl) = 1; TREE_NOTHROW (current_function_decl) = 1;
/* Now turn the rtl into assembler code. */ rest_of_handle_final (decl, insns);
timevar_push (TV_FINAL);
{
rtx x;
const char *fnname;
/* Get the function's name, as described by its RTL. This may be
different from the DECL_NAME name used in the source file. */
x = DECL_RTL (decl);
if (GET_CODE (x) != MEM)
abort ();
x = XEXP (x, 0);
if (GET_CODE (x) != SYMBOL_REF)
abort ();
fnname = XSTR (x, 0);
assemble_start_function (decl, fnname);
final_start_function (insns, asm_out_file, optimize);
final (insns, asm_out_file, optimize, 0);
final_end_function ();
#ifdef IA64_UNWIND_INFO
/* ??? The IA-64 ".handlerdata" directive must be issued before
the ".endp" directive that closes the procedure descriptor. */
output_function_exception_table ();
#endif
assemble_end_function (decl, fnname);
#ifndef IA64_UNWIND_INFO
/* Otherwise, it feels unclean to switch sections in the middle. */
output_function_exception_table ();
#endif
if (! quiet_flag)
fflush (asm_out_file);
/* Release all memory allocated by flow. */
free_basic_block_vars (0);
/* Release all memory held by regsets now. */
regset_release_memory ();
}
timevar_pop (TV_FINAL);
ggc_collect ();
/* Write DBX symbols if requested. */ /* Write DBX symbols if requested. */
...@@ -3843,6 +4030,7 @@ rest_of_compilation (decl) ...@@ -3843,6 +4030,7 @@ rest_of_compilation (decl)
timevar_pop (TV_REST_OF_COMPILATION); timevar_pop (TV_REST_OF_COMPILATION);
} }
/* Display help for generic options. */
static void static void
display_help () display_help ()
{ {
...@@ -3976,6 +4164,7 @@ display_help () ...@@ -3976,6 +4164,7 @@ display_help ()
display_target_options (); display_target_options ();
} }
/* Display help for target options. */
static void static void
display_target_options () display_target_options ()
{ {
......
gcc/toplev.h
...@@ -84,9 +84,6 @@ extern void output_clean_symbol_name PARAMS ((FILE *, const char *)); ...@@ -84,9 +84,6 @@ extern void output_clean_symbol_name PARAMS ((FILE *, const char *));
extern void output_quoted_string PARAMS ((FILE *, const char *)); extern void output_quoted_string PARAMS ((FILE *, const char *));
extern void output_file_directive PARAMS ((FILE *, const char *)); extern void output_file_directive PARAMS ((FILE *, const char *));
#endif #endif
extern void do_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
extern void botch PARAMS ((const char *))
ATTRIBUTE_NORETURN;
#ifdef BUFSIZ #ifdef BUFSIZ
/* N.B. Unlike all the others, fnotice is just gettext+fprintf, and /* N.B. Unlike all the others, fnotice is just gettext+fprintf, and
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment