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 1221 additions and 990 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
...@@ -93,7 +93,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA ...@@ -93,7 +93,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "xcoffout.h" /* Needed for external data #include "xcoffout.h" /* Needed for external data
declarations for e.g. AIX 4.x. */ declarations for e.g. AIX 4.x. */
#endif #endif
/* Carry information from ASM_DECLARE_OBJECT_NAME /* Carry information from ASM_DECLARE_OBJECT_NAME
to ASM_FINISH_DECLARE_OBJECT. */ to ASM_FINISH_DECLARE_OBJECT. */
...@@ -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;
...@@ -149,7 +186,7 @@ const char *progname; ...@@ -149,7 +186,7 @@ const char *progname;
/* Copy of arguments to toplev_main. */ /* Copy of arguments to toplev_main. */
int save_argc; int save_argc;
char **save_argv; char **save_argv;
/* Name of top-level original source file (what was input to cpp). /* Name of top-level original source file (what was input to cpp).
This comes from the #-command at the beginning of the actual input. This comes from the #-command at the beginning of the actual input.
If there isn't any there, then this is the cc1 input file name. */ If there isn't any there, then this is the cc1 input file name. */
...@@ -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. */
...@@ -1437,7 +1473,7 @@ static const struct ...@@ -1437,7 +1473,7 @@ static const struct
} }
target_options[] = TARGET_OPTIONS; target_options[] = TARGET_OPTIONS;
#endif #endif
/* Options controlling warnings. */ /* Options controlling warnings. */
/* Don't print warning messages. -w. */ /* Don't print warning messages. -w. */
...@@ -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. */
...@@ -1693,26 +1730,7 @@ read_integral_parameter (p, pname, defval) ...@@ -1693,26 +1730,7 @@ 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.
...@@ -1877,7 +1895,7 @@ output_file_directive (asm_file, input_name) ...@@ -1877,7 +1895,7 @@ output_file_directive (asm_file, input_name)
#endif #endif
#endif #endif
} }
/* Routine to open a dump file. Return true if the dump file is enabled. */ /* Routine to open a dump file. Return true if the dump file is enabled. */
static int static int
...@@ -2283,7 +2301,7 @@ compile_file () ...@@ -2283,7 +2301,7 @@ compile_file ()
timevar_pop (TV_DUMP); timevar_pop (TV_DUMP);
} }
} }
/* This is called from various places for FUNCTION_DECL, VAR_DECL, /* This is called from various places for FUNCTION_DECL, VAR_DECL,
and TYPE_DECL nodes. and TYPE_DECL nodes.
...@@ -2424,499 +2442,451 @@ rest_of_type_compilation (type, toplev) ...@@ -2424,499 +2442,451 @@ 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
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;
goto exit_rest_of_compilation;
}
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. */ /* Release all memory held by regsets now. */
if ((DECL_INLINE (decl) && !flag_no_inline) regset_release_memory ();
|| flag_inline_functions) }
{ timevar_pop (TV_FINAL);
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;
goto exit_rest_of_compilation;
}
}
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 (); ggc_collect ();
}
/* Dump the rtl code if we are dumping rtl. */ #ifdef DELAY_SLOTS
/* Run delay slot optimization. */
static void
rest_of_handle_delay_slots (tree decl, rtx insns)
{
timevar_push (TV_DBR_SCHED);
open_dump_file (DFI_dbr, decl);
if (open_dump_file (DFI_rtl, decl)) dbr_schedule (insns, rtl_dump_file);
{
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 close_dump_file (DFI_dbr, print_rtl, insns);
sorts of eh initialization. Delay this until after the timevar_pop (TV_DBR_SCHED);
initial rtl dump so that we can see the original nesting. */
convert_from_eh_region_ranges ();
/* 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. */
if (inlinable
|| (DECL_INLINE (decl)
&& 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))
/* 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; ggc_collect ();
rebuild_jump_labels (insns); }
find_exception_handler_labels (); #endif
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
optimize = saved_optimize;
/* CFG is no longer maintained up-to-date. */ #ifdef STACK_REGS
free_bb_for_insn (); /* 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);
set_nothrow_function_flags (); if (reg_to_stack (insns, rtl_dump_file) && optimize)
if (current_function_nothrow) {
/* Now we know that this can't throw; set the flag for the benefit if (cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
of other functions later in this translation unit. */ | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0))
TREE_NOTHROW (current_function_decl) = 1; && flag_reorder_blocks)
{
timevar_push (TV_INTEGRATION); reorder_basic_blocks ();
save_for_inline (decl); cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
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
done. This goes for anything that gets here with DECL_EXTERNAL
set, not just things with DECL_INLINE. */
if (DECL_EXTERNAL (decl))
goto exit_rest_of_compilation;
} }
/* If we're emitting a nested function, make sure its parent gets close_dump_file (DFI_stack, print_rtl_with_bb, insns);
emitted as well. Doing otherwise confuses debug info. */ timevar_pop (TV_REG_STACK);
{
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;
}
/* We are now committed to emitting code for this function. Do any
preparation, such as emitting abstract debug info for the inline
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
over the instruction sequence faster, and allow the garbage
collector to reclaim the memory used by the notes. */
remove_unnecessary_notes ();
reorder_blocks ();
ggc_collect (); ggc_collect ();
}
#endif
/* Initialize some variables used by the optimizers. */
init_function_for_compilation ();
if (! DECL_DEFER_OUTPUT (decl)) /* Machine independent reorg pass. */
TREE_ASM_WRITTEN (decl) = 1; static void
rest_of_handle_machine_reorg (tree decl, rtx insns)
{
timevar_push (TV_MACH_DEP);
open_dump_file (DFI_mach, decl);
/* Now that integrate will no longer see our rtl, we need not (*targetm.machine_dependent_reorg) ();
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 close_dump_file (DFI_mach, print_rtl, insns);
consistency checks, and there's not really much point in fixing them. timevar_pop (TV_MACH_DEP);
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); ggc_collect ();
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 ();
/* We have to issue these warnings now already, because CFG cleanups /* Run new register allocator. Return TRUE if we must exit
further down may destroy the required information. */ rest_of_compilation upon return. */
check_function_return_warnings (); static bool
rest_of_handle_new_regalloc (tree decl, rtx insns, int *rebuild_notes)
{
int failure;
/* Turn NOTE_INSN_PREDICTIONs into branch predictions. */ delete_trivially_dead_insns (insns, max_reg_num ());
if (flag_guess_branch_prob) reg_alloc ();
{
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 timevar_pop (TV_LOCAL_ALLOC);
(of possibly multiple) methods of performing the call. */ if (dump_file[DFI_lreg].enabled)
if (flag_optimize_sibling_calls)
{ {
rtx insn; timevar_push (TV_DUMP);
optimize_sibling_and_tail_recursive_calls ();
/* Recompute the CFG as sibling optimization clobbers it randomly. */ close_dump_file (DFI_lreg, NULL, NULL);
free_bb_for_insn (); timevar_pop (TV_DUMP);
find_exception_handler_labels (); }
rebuild_jump_labels (insns);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
/* There is pass ordering problem - we must lower NOTE_INSN_PREDICTION /* XXX clean up the whole mess to bring live info in shape again. */
notes before simplifying cfg and we must do lowering after sibcall timevar_push (TV_GLOBAL_ALLOC);
that unhides parts of RTL chain and cleans up the CFG. open_dump_file (DFI_greg, decl);
Until sibcall is replaced by tree-level optimizer, lets just build_insn_chain (insns);
sweep away the NOTE_INSN_PREDICTION notes that leaked out. */ failure = reload (insns, 0);
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
if (GET_CODE (insn) == NOTE
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
delete_insn (insn);
}
close_dump_file (DFI_sibling, print_rtl, get_insns ());
timevar_pop (TV_JUMP);
scope_to_insns_initialize (); timevar_pop (TV_GLOBAL_ALLOC);
/* Complete generation of exception handling code. */
if (doing_eh (0)) if (dump_file[DFI_greg].enabled)
{ {
timevar_push (TV_JUMP); timevar_push (TV_DUMP);
open_dump_file (DFI_eh, decl);
finish_eh_generation (); dump_global_regs (rtl_dump_file);
close_dump_file (DFI_eh, print_rtl, get_insns ()); close_dump_file (DFI_greg, print_rtl_with_bb, insns);
timevar_pop (TV_JUMP); timevar_pop (TV_DUMP);
} }
/* Delay emitting hard_reg_initial_value sets until after EH landing pad if (failure)
generation, which might create new sets. */ return true;
emit_initial_value_sets ();
#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
insns = get_insns (); reload_completed = 1;
*rebuild_notes = 0;
/* Copy any shared structure that should not be shared. */ return false;
unshare_all_rtl (current_function_decl, insns); }
#ifdef SETJMP_VIA_SAVE_AREA /* Run old register allocator. Return TRUE if we must exit
/* This must be performed before virtual register instantiation. rest_of_compilation upon return. */
Please be aware the everything in the compiler that can look static bool
at the RTL up to this point must understand that REG_SAVE_AREA rest_of_handle_old_regalloc (tree decl, rtx insns, int *rebuild_notes)
is just like a use of the REG contained inside. */ {
if (current_function_calls_alloca) int failure;
optimize_save_area_alloca (insns);
#endif
/* Instantiate all virtual registers. */ /* Allocate the reg_renumber array. */
instantiate_virtual_regs (current_function_decl, insns); allocate_reg_info (max_regno, FALSE, TRUE);
open_dump_file (DFI_jump, decl); /* And the reg_equiv_memory_loc array. */
reg_equiv_memory_loc = (rtx *) xcalloc (max_regno, sizeof (rtx));
/* Always do one jump optimization pass to ensure that JUMP_LABEL fields allocate_initial_values (reg_equiv_memory_loc);
are initialized and to compute whether control can drop off the end
of the function. */
timevar_push (TV_JUMP); regclass (insns, max_reg_num (), rtl_dump_file);
/* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this *rebuild_notes = local_alloc ();
before jump optimization switches branch directions. */
if (flag_guess_branch_prob)
expected_value_to_br_prob ();
reg_scan (insns, max_reg_num (), 0); timevar_pop (TV_LOCAL_ALLOC);
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)
dump_flow_info (rtl_dump_file);
cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
if (optimize) if (dump_file[DFI_lreg].enabled)
{ {
free_bb_for_insn (); timevar_push (TV_DUMP);
copy_loop_headers (insns);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file); 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);
} }
purge_line_number_notes (insns);
timevar_pop (TV_JUMP); ggc_collect ();
close_dump_file (DFI_jump, print_rtl, insns);
/* Now is when we stop if -fsyntax-only and -Wreturn-type. */ timevar_push (TV_GLOBAL_ALLOC);
if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl)) 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
{ {
goto exit_rest_of_compilation; build_insn_chain (insns);
failure = reload (insns, 0);
} }
/* Long term, this should probably move before the jump optimizer too, timevar_pop (TV_GLOBAL_ALLOC);
but I didn't want to disturb the rtl_dump_and_exit and related
stuff at this time. */
if (optimize > 0 && flag_ssa)
{
/* Convert to SSA form. */
timevar_push (TV_TO_SSA); if (dump_file[DFI_greg].enabled)
open_dump_file (DFI_ssa, decl); {
timevar_push (TV_DUMP);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); dump_global_regs (rtl_dump_file);
convert_to_ssa ();
close_dump_file (DFI_ssa, print_rtl_with_bb, insns); close_dump_file (DFI_greg, print_rtl_with_bb, insns);
timevar_pop (TV_TO_SSA); timevar_pop (TV_DUMP);
}
/* Perform sparse conditional constant propagation, if requested. */ return failure;
if (flag_ssa_ccp) }
{
timevar_push (TV_SSA_CCP);
open_dump_file (DFI_ssa_ccp, decl);
ssa_const_prop (); /* 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);
close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ()); if (flag_rename_registers)
timevar_pop (TV_SSA_CCP); regrename_optimize ();
} if (flag_cprop_registers)
copyprop_hardreg_forward ();
/* It would be useful to cleanup the CFG at this point, but block close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
merging and possibly other transformations might leave a PHI timevar_pop (TV_RENAME_REGISTERS);
node in the middle of a basic block, which is a strict no-no. */ }
/* The SSA implementation uses basic block numbers in its phi /* Reorder basic blocks. */
nodes. Thus, changing the control-flow graph or the basic static void
blocks, e.g., calling find_basic_blocks () or cleanup_cfg (), rest_of_handle_reorder_blocks (tree decl, rtx insns)
may cause problems. */ {
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
if (flag_ssa_dce) /* Print function header into sched dump now
{ because doing the sched analysis makes some of the dump. */
/* Remove dead code. */ if (optimize > 0 && flag_schedule_insns)
{
open_dump_file (DFI_sched, decl);
timevar_push (TV_SSA_DCE); /* Do control and data sched analysis,
open_dump_file (DFI_ssa_dce, decl); and write some of the results to dump file. */
insns = get_insns (); schedule_insns (rtl_dump_file);
ssa_eliminate_dead_code ();
close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns); close_dump_file (DFI_sched, print_rtl_with_bb, insns);
timevar_pop (TV_SSA_DCE); }
} #endif
timevar_pop (TV_SCHED);
/* Convert from SSA form. */ ggc_collect ();
}
timevar_push (TV_FROM_SSA); #ifdef INSN_SCHEDULING
open_dump_file (DFI_ussa, decl); /* 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);
convert_from_ssa (); /* Do control and data sched analysis again,
/* New registers have been created. Rescan their usage. */ and write some more of the results to dump file. */
reg_scan (insns, max_reg_num (), 1);
close_dump_file (DFI_ussa, print_rtl_with_bb, insns); split_all_insns (1);
timevar_pop (TV_FROM_SSA);
ggc_collect (); 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);
timevar_push (TV_JUMP); close_dump_file (DFI_sched2, print_rtl_with_bb, insns);
if (optimize) timevar_pop (TV_SCHED2);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
/* Try to identify useless null pointer tests and delete them. */
if (flag_delete_null_pointer_checks)
{
open_dump_file (DFI_null, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
if (delete_null_pointer_checks (insns)) ggc_collect ();
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); }
#endif
close_dump_file (DFI_null, print_rtl_with_bb, insns); /* 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);
/* Jump optimization, and the removal of NULL pointer checks, may regmove_optimize (insns, max_reg_num (), rtl_dump_file);
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); cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
timevar_pop (TV_REGMOVE);
ggc_collect (); ggc_collect ();
}
/* Perform common subexpression elimination. /* Run tracer. */
Nonzero value from `cse_main' means that jumps were simplified static void
and some code may now be unreachable, so do rest_of_handle_tracer (tree decl, rtx insns)
jump optimization again. */ {
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 (optimize > 0) /* 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)
{ {
open_dump_file (DFI_cse, decl); timevar_push (TV_IFCVT);
if (rtl_dump_file) if (rtl_dump_file)
dump_flow_info (rtl_dump_file); dump_flow_info (rtl_dump_file);
timevar_push (TV_CSE); cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0);
if_convert (0);
timevar_pop (TV_IFCVT);
}
timevar_push (TV_JUMP);
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0);
timevar_pop (TV_JUMP);
close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
}
reg_scan (insns, max_reg_num (), 1); /* 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);
tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file); no_new_pseudos = 0;
if (tem) if_convert (1);
rebuild_jump_labels (insns); no_new_pseudos = 1;
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ()); close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
timevar_pop (TV_IFCVT);
}
/* If we are not running more CSE passes, then we are no longer /* Do branch profiling and static profile estimation passes. */
expecting CSE to be run. But always rerun it in a cheap mode. */ static void
cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse; rest_of_handle_branch_prob (tree decl, rtx insns)
{
struct loops loops;
if (tem || optimize > 1) timevar_push (TV_BRANCH_PROB);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); open_dump_file (DFI_bp, decl);
/* Try to identify useless null pointer tests and delete them. */ if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
if (flag_delete_null_pointer_checks) branch_prob ();
{
timevar_push (TV_JUMP);
if (delete_null_pointer_checks (insns)) /* Discover and record the loop depth at the head of each basic
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); block. The loop infrastructure does the real job for us. */
timevar_pop (TV_JUMP); flow_loops_find (&loops, LOOP_TREE);
}
if (rtl_dump_file)
flow_loops_dump (&loops, rtl_dump_file, NULL, 0);
/* The second pass of jump optimization is likely to have /* Estimate using heuristics if no profiling info is available. */
removed a bunch more instructions. */ if (flag_guess_branch_prob)
renumber_insns (rtl_dump_file); estimate_probability (&loops);
timevar_pop (TV_CSE); flow_loops_free (&loops);
close_dump_file (DFI_cse, print_rtl_with_bb, insns); 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); open_dump_file (DFI_addressof, decl);
purge_addressof (insns); purge_addressof (insns);
...@@ -2925,395 +2895,859 @@ rest_of_compilation (decl) ...@@ -2925,395 +2895,859 @@ rest_of_compilation (decl)
reg_scan (insns, max_reg_num (), 1); reg_scan (insns, max_reg_num (), 1);
close_dump_file (DFI_addressof, print_rtl, insns); close_dump_file (DFI_addressof, print_rtl, insns);
}
ggc_collect (); /* We may have potential sibling or tail recursion sites. Select one
(of possibly multiple) methods of performing the call. */
static void
rest_of_handle_sibling_calls (rtx insns)
{
rtx insn;
optimize_sibling_and_tail_recursive_calls ();
/* Recompute the CFG as sibling optimization clobbers it randomly. */
free_bb_for_insn ();
find_exception_handler_labels ();
rebuild_jump_labels (insns);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
/* Perform global cse. */ /* There is pass ordering problem - we must lower NOTE_INSN_PREDICTION
notes before simplifying cfg and we must do lowering after sibcall
that unhides parts of RTL chain and cleans up the CFG.
if (optimize > 0 && flag_gcse) Until sibcall is replaced by tree-level optimizer, lets just
{ sweep away the NOTE_INSN_PREDICTION notes that leaked out. */
int save_csb, save_cfj; for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
int tem2 = 0; if (GET_CODE (insn) == NOTE
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
delete_insn (insn);
close_dump_file (DFI_sibling, print_rtl, get_insns ());
}
/* Perform jump bypassing and control flow optimizations. */
static void
rest_of_handle_jump_bypass (tree decl, rtx insns)
{
timevar_push (TV_BYPASS);
open_dump_file (DFI_bypass, decl);
timevar_push (TV_GCSE); cleanup_cfg (CLEANUP_EXPENSIVE);
open_dump_file (DFI_gcse, decl);
tem = gcse_main (insns, rtl_dump_file); if (bypass_jumps (rtl_dump_file))
{
rebuild_jump_labels (insns); rebuild_jump_labels (insns);
cleanup_cfg (CLEANUP_EXPENSIVE);
delete_trivially_dead_insns (insns, max_reg_num ()); delete_trivially_dead_insns (insns, max_reg_num ());
}
save_csb = flag_cse_skip_blocks; close_dump_file (DFI_bypass, print_rtl_with_bb, insns);
save_cfj = flag_cse_follow_jumps; timevar_pop (TV_BYPASS);
flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
/* Instantiate any remaining CONSTANT_P_RTX nodes. */ ggc_collect ();
if (current_function_calls_constant_p)
purge_builtin_constant_p ();
/* If -fexpensive-optimizations, re-run CSE to clean up things done #ifdef ENABLE_CHECKING
by gcse. */ verify_flow_info ();
if (flag_expensive_optimizations) #endif
{ }
timevar_push (TV_CSE);
reg_scan (insns, max_reg_num (), 1);
tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ());
timevar_pop (TV_CSE);
cse_not_expected = !flag_rerun_cse_after_loop;
}
/* If gcse or cse altered any jumps, rerun jump optimizations to clean /* Handle inlining of functions in rest_of_compilation. Return TRUE
things up. Then possibly re-run CSE again. */ if we must exit rest_of_compilation upon return. */
while (tem || tem2) static bool
{ rest_of_handle_inlining (tree decl)
tem = tem2 = 0; {
timevar_push (TV_JUMP); rtx insns;
rebuild_jump_labels (insns); int inlinable = 0;
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); tree parent;
timevar_pop (TV_JUMP); 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 (flag_expensive_optimizations) /* 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))
{ {
timevar_push (TV_CSE); DECL_INITIAL (decl) = 0;
reg_scan (insns, max_reg_num (), 1); return true;
tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ());
timevar_pop (TV_CSE);
} }
} }
else {
close_dump_file (DFI_gcse, print_rtl_with_bb, insns); /* ??? Note that we used to just make it look like if
timevar_pop (TV_GCSE); the "inline" keyword was specified when we decide
to inline it (because of -finline-functions).
ggc_collect (); garloff@suse.de, 2002-04-24: Add another flag to
flag_cse_skip_blocks = save_csb; actually record this piece of information. */
flag_cse_follow_jumps = save_cfj; if (!DECL_INLINE (decl))
#ifdef ENABLE_CHECKING DID_INLINE_FUNC (decl) = 1;
verify_flow_info (); inlinable = DECL_INLINE (decl) = 1;
#endif }
} }
/* Move constant computations out of loops. */ insns = get_insns ();
/* Dump the rtl code if we are dumping rtl. */
if (optimize > 0 && flag_loop_optimize) if (open_dump_file (DFI_rtl, decl))
{ {
int do_unroll, do_prefetch; if (DECL_SAVED_INSNS (decl))
fprintf (rtl_dump_file, ";; (integrable)\n\n");
close_dump_file (DFI_rtl, print_rtl, insns);
}
timevar_push (TV_LOOP); /* Convert from NOTE_INSN_EH_REGION style notes, and do other
delete_dead_jumptables (); sorts of eh initialization. Delay this until after the
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP); initial rtl dump so that we can see the original nesting. */
open_dump_file (DFI_loop, decl); convert_from_eh_region_ranges ();
/* CFG is no longer maintained up-to-date. */
free_bb_for_insn (); /* 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. */
if (inlinable
|| (DECL_INLINE (decl)
&& 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 (flag_unroll_loops) if (DECL_INLINE (decl))
do_unroll = 0; /* Having two unrollers is useless. */ /* DWARF wants separate debugging info for abstract and
else concrete instances of all inline functions, including those
do_unroll = flag_old_unroll_loops ? LOOP_UNROLL : LOOP_AUTO_UNROLL; declared inline but not inlined, and those inlined even
do_prefetch = flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0; though they weren't declared inline. Conveniently, that's
if (flag_rerun_loop_opt) 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)
{ {
cleanup_barriers (); int saved_optimize = optimize;
/* We only want to perform unrolling once. */ optimize = 0;
loop_optimize (insns, rtl_dump_file, do_unroll); rebuild_jump_labels (insns);
do_unroll = 0; find_exception_handler_labels ();
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
/* The first call to loop_optimize makes some instructions cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
trivially dead. We delete those instructions now in the optimize = saved_optimize;
hope that doing so will make the heuristics in loop work
better and possibly speed up compilation. */
delete_trivially_dead_insns (insns, max_reg_num ());
/* The regscan pass is currently necessary as the alias /* CFG is no longer maintained up-to-date. */
analysis code depends on this information. */ free_bb_for_insn ();
reg_scan (insns, max_reg_num (), 1);
} }
cleanup_barriers ();
loop_optimize (insns, rtl_dump_file, do_unroll | LOOP_BCT | do_prefetch);
/* Loop can create trivially dead instructions. */
delete_trivially_dead_insns (insns, max_reg_num ());
close_dump_file (DFI_loop, print_rtl, insns);
timevar_pop (TV_LOOP);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
ggc_collect (); set_nothrow_function_flags ();
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;
timevar_push (TV_INTEGRATION);
save_for_inline (decl);
timevar_pop (TV_INTEGRATION);
DECL_SAVED_INSNS (decl)->inlinable = inlinable;
return true;
} }
/* Perform jump bypassing and control flow optimizations. */ /* If specified extern inline but we aren't inlining it, we are
if (optimize > 0 && flag_gcse) done. This goes for anything that gets here with DECL_EXTERNAL
{ set, not just things with DECL_INLINE. */
timevar_push (TV_BYPASS); return (bool) DECL_EXTERNAL (decl);
open_dump_file (DFI_bypass, decl); }
cleanup_cfg (CLEANUP_EXPENSIVE); /* Rest of compilation helper to convert the rtl to SSA form. */
tem = bypass_jumps (rtl_dump_file); static rtx
rest_of_handle_ssa (tree decl, rtx insns)
{
timevar_push (TV_TO_SSA);
open_dump_file (DFI_ssa, decl);
if (tem) cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
{ convert_to_ssa ();
rebuild_jump_labels (insns);
cleanup_cfg (CLEANUP_EXPENSIVE);
delete_trivially_dead_insns (insns, max_reg_num ());
}
close_dump_file (DFI_bypass, print_rtl_with_bb, insns); close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
timevar_pop (TV_BYPASS); timevar_pop (TV_TO_SSA);
ggc_collect (); /* Perform sparse conditional constant propagation, if requested. */
if (flag_ssa_ccp)
{
timevar_push (TV_SSA_CCP);
open_dump_file (DFI_ssa_ccp, decl);
#ifdef ENABLE_CHECKING ssa_const_prop ();
verify_flow_info ();
#endif close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
timevar_pop (TV_SSA_CCP);
} }
/* Do control and data flow analysis; wrote some of the results to /* It would be useful to cleanup the CFG at this point, but block
the dump file. */ merging and possibly other transformations might leave a PHI
node in the middle of a basic block, which is a strict no-no. */
timevar_push (TV_FLOW); /* The SSA implementation uses basic block numbers in its phi
open_dump_file (DFI_cfg, decl); nodes. Thus, changing the control-flow graph or the basic
if (rtl_dump_file) blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
dump_flow_info (rtl_dump_file); may cause problems. */
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 if (flag_ssa_dce)
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 /* Remove dead code. */
it as constant, otherwise -fbranch-probabilities will not read data back.
life_analysis rarely eliminates modification of external memory. timevar_push (TV_SSA_DCE);
*/ open_dump_file (DFI_ssa_dce, decl);
if (optimize)
mark_constant_function ();
close_dump_file (DFI_cfg, print_rtl_with_bb, insns); insns = get_insns ();
ssa_eliminate_dead_code ();
/* Do branch profiling and static profile estimation passes. */ close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
if (optimize > 0 timevar_pop (TV_SSA_DCE);
|| profile_arc_flag || flag_test_coverage || flag_branch_probabilities) }
{
struct loops loops;
timevar_push (TV_BRANCH_PROB); /* Convert from SSA form. */
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 timevar_push (TV_FROM_SSA);
block. The loop infrastructure does the real job for us. */ open_dump_file (DFI_ussa, decl);
flow_loops_find (&loops, LOOP_TREE);
if (rtl_dump_file) convert_from_ssa ();
flow_loops_dump (&loops, rtl_dump_file, NULL, 0); /* New registers have been created. Rescan their usage. */
reg_scan (insns, max_reg_num (), 1);
/* Estimate using heuristics if no profiling info is available. */ close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
if (flag_guess_branch_prob) timevar_pop (TV_FROM_SSA);
estimate_probability (&loops);
flow_loops_free (&loops); ggc_collect ();
close_dump_file (DFI_bp, print_rtl_with_bb, insns);
timevar_pop (TV_BRANCH_PROB); 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);
} }
if (optimize > 0)
close_dump_file (DFI_combine, print_rtl_with_bb, insns);
timevar_pop (TV_COMBINE);
ggc_collect ();
}
/* 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)
cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
timevar_pop (TV_FLOW);
if (warn_uninitialized)
{ {
open_dump_file (DFI_ce1, decl); uninitialized_vars_warning (DECL_INITIAL (decl));
if (flag_if_conversion) if (extra_warnings)
setjmp_args_warning ();
}
if (optimize)
{
if (!flag_new_regalloc && initialize_uninitialized_subregs ())
{ {
timevar_push (TV_IFCVT); /* Insns were inserted, and possibly pseudos created, so
if (rtl_dump_file) things might look a bit different. */
dump_flow_info (rtl_dump_file); insns = get_insns ();
cleanup_cfg (CLEANUP_EXPENSIVE); allocate_reg_life_data ();
reg_scan (insns, max_reg_num (), 0); update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
if_convert (0); PROP_LOG_LINKS | PROP_REG_INFO | PROP_DEATH_NOTES);
timevar_pop (TV_IFCVT);
} }
}
no_new_pseudos = 1;
close_dump_file (DFI_life, print_rtl_with_bb, insns);
ggc_collect ();
}
/* 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. */
static void
rest_of_handle_cse (tree decl, rtx insns)
{
int tem;
open_dump_file (DFI_cse, decl);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
timevar_push (TV_CSE);
reg_scan (insns, max_reg_num (), 1);
tem = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
if (tem)
rebuild_jump_labels (insns);
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ());
/* If we are not running more CSE passes, then we are no longer
expecting CSE to be run. But always rerun it in a cheap mode. */
cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
if (tem || optimize > 1)
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
/* Try to identify useless null pointer tests and delete them. */
if (flag_delete_null_pointer_checks)
{
timevar_push (TV_JUMP); timevar_push (TV_JUMP);
cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0); if (delete_null_pointer_checks (insns))
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
timevar_pop (TV_JUMP); timevar_pop (TV_JUMP);
close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
} }
if (flag_tracer)
/* The second pass of jump optimization is likely to have
removed a bunch more instructions. */
renumber_insns (rtl_dump_file);
timevar_pop (TV_CSE);
close_dump_file (DFI_cse, print_rtl_with_bb, insns);
}
/* Run second CSE pass after loop optimizations. */
static void
rest_of_handle_cse2 (tree decl, rtx insns)
{
int tem;
timevar_push (TV_CSE2);
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);
delete_trivially_dead_insns (insns, max_reg_num ());
if (tem)
{ {
timevar_push (TV_TRACER); timevar_push (TV_JUMP);
open_dump_file (DFI_tracer, decl); rebuild_jump_labels (insns);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
tracer ();
cleanup_cfg (CLEANUP_EXPENSIVE); cleanup_cfg (CLEANUP_EXPENSIVE);
reg_scan (insns, max_reg_num (), 0); timevar_pop (TV_JUMP);
close_dump_file (DFI_tracer, print_rtl_with_bb, get_insns ());
timevar_pop (TV_TRACER);
} }
reg_scan (insns, max_reg_num (), 0);
close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
ggc_collect ();
timevar_pop (TV_CSE2);
}
/* Perform loop optimalizations. It might be better to do them a bit /* Perform global cse. */
sooner, but we want the profile feedback to work more efficiently. */ static void
if (optimize > 0 rest_of_handle_gcse (tree decl, rtx insns)
&& (flag_unswitch_loops {
|| flag_peel_loops int save_csb, save_cfj;
|| flag_unroll_loops)) int tem2 = 0, tem;
{
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); timevar_push (TV_GCSE);
open_dump_file (DFI_gcse, decl);
if (loops) tem = gcse_main (insns, rtl_dump_file);
{ rebuild_jump_labels (insns);
/* The optimalizations: */ delete_trivially_dead_insns (insns, max_reg_num ());
if (flag_unswitch_loops)
unswitch_loops (loops);
if (flag_peel_loops || flag_unroll_loops) save_csb = flag_cse_skip_blocks;
unroll_and_peel_loops (loops, save_cfj = flag_cse_follow_jumps;
(flag_peel_loops ? UAP_PEEL : 0) | flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
(flag_unroll_loops ? UAP_UNROLL : 0) |
(flag_unroll_all_loops ? UAP_UNROLL_ALL : 0));
loop_optimizer_finalize (loops, rtl_dump_file); /* Instantiate any remaining CONSTANT_P_RTX nodes. */
} if (current_function_calls_constant_p)
purge_builtin_constant_p ();
cleanup_cfg (CLEANUP_EXPENSIVE); /* If -fexpensive-optimizations, re-run CSE to clean up things done
by gcse. */
if (flag_expensive_optimizations)
{
timevar_push (TV_CSE);
reg_scan (insns, max_reg_num (), 1);
tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ()); delete_trivially_dead_insns (insns, max_reg_num ());
reg_scan (insns, max_reg_num (), 0); timevar_pop (TV_CSE);
if (rtl_dump_file) cse_not_expected = !flag_rerun_cse_after_loop;
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) /* If gcse or cse altered any jumps, rerun jump optimizations to clean
things up. Then possibly re-run CSE again. */
while (tem || tem2)
{ {
timevar_push (TV_CSE2); tem = tem2 = 0;
open_dump_file (DFI_cse2, decl); timevar_push (TV_JUMP);
if (rtl_dump_file) rebuild_jump_labels (insns);
dump_flow_info (rtl_dump_file); cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
/* CFG is no longer maintained up-to-date. */ timevar_pop (TV_JUMP);
tem = cse_main (insns, max_reg_num (), 1, rtl_dump_file);
purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ());
if (tem) if (flag_expensive_optimizations)
{ {
timevar_push (TV_JUMP); timevar_push (TV_CSE);
rebuild_jump_labels (insns); reg_scan (insns, max_reg_num (), 1);
cleanup_cfg (CLEANUP_EXPENSIVE); tem2 = cse_main (insns, max_reg_num (), 0, rtl_dump_file);
timevar_pop (TV_JUMP); purge_all_dead_edges (0);
delete_trivially_dead_insns (insns, max_reg_num ());
timevar_pop (TV_CSE);
} }
reg_scan (insns, max_reg_num (), 0);
close_dump_file (DFI_cse2, print_rtl_with_bb, insns);
ggc_collect ();
timevar_pop (TV_CSE2);
} }
cse_not_expected = 1; close_dump_file (DFI_gcse, print_rtl_with_bb, insns);
timevar_pop (TV_GCSE);
open_dump_file (DFI_life, decl);
regclass_init ();
ggc_collect ();
flag_cse_skip_blocks = save_csb;
flag_cse_follow_jumps = save_cfj;
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
verify_flow_info (); verify_flow_info ();
#endif #endif
life_analysis (insns, rtl_dump_file, PROP_FINAL); }
if (optimize)
cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_UPDATE_LIFE /* Move constant computations out of loops. */
| (flag_thread_jumps ? CLEANUP_THREADING : 0)); static void
timevar_pop (TV_FLOW); rest_of_handle_loop_optimize (tree decl, rtx insns)
{
int do_unroll, do_prefetch;
timevar_push (TV_LOOP);
delete_dead_jumptables ();
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
open_dump_file (DFI_loop, decl);
/* CFG is no longer maintained up-to-date. */
free_bb_for_insn ();
if (flag_unroll_loops)
do_unroll = 0; /* Having two unrollers is useless. */
else
do_unroll = flag_old_unroll_loops ? LOOP_UNROLL : LOOP_AUTO_UNROLL;
do_prefetch = flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0;
if (flag_rerun_loop_opt)
{
cleanup_barriers ();
/* We only want to perform unrolling once. */
loop_optimize (insns, rtl_dump_file, do_unroll);
do_unroll = 0;
/* The first call to loop_optimize makes some instructions
trivially dead. We delete those instructions now in the
hope that doing so will make the heuristics in loop work
better and possibly speed up compilation. */
delete_trivially_dead_insns (insns, max_reg_num ());
/* The regscan pass is currently necessary as the alias
analysis code depends on this information. */
reg_scan (insns, max_reg_num (), 1);
}
cleanup_barriers ();
loop_optimize (insns, rtl_dump_file, do_unroll | LOOP_BCT | do_prefetch);
/* Loop can create trivially dead instructions. */
delete_trivially_dead_insns (insns, max_reg_num ());
close_dump_file (DFI_loop, print_rtl, insns);
timevar_pop (TV_LOOP);
find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
ggc_collect ();
}
/* Perform loop optimalizations. It might be better to do them a bit
sooner, but we want the profile feedback to work more
efficiently. */
static void
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);
loops = loop_optimizer_init (rtl_dump_file);
if (loops)
{
/* 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);
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 ();
}
/* This is called from finish_function (within langhooks.parse_file)
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. */
void
rest_of_compilation (decl)
tree decl;
{
rtx insns;
int rebuild_label_notes_after_reload;
timevar_push (TV_REST_OF_COMPILATION);
/* Now that we're out of the frontend, we shouldn't have any more
CONCATs anywhere. */
generating_concat_p = 0;
/* When processing delayed functions, prepare_function_start() won't
have been run to re-initialize it. */
cse_not_expected = ! optimize;
/* First, make sure that NOTE_BLOCK is set correctly for each
NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
if (!cfun->x_whole_function_mode_p)
identify_blocks ();
/* 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 (cfun->x_whole_function_mode_p)
reorder_blocks ();
init_flow ();
if (rest_of_handle_inlining (decl))
goto exit_rest_of_compilation;
/* If we're emitting a nested function, make sure its parent gets
emitted as well. Doing otherwise confuses debug info. */
{
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;
}
/* We are now committed to emitting code for this function. Do any
preparation, such as emitting abstract debug info for the inline
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
over the instruction sequence faster, and allow the garbage
collector to reclaim the memory used by the notes. */
remove_unnecessary_notes ();
reorder_blocks ();
ggc_collect ();
/* 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 ();
/* We have to issue these warnings now already, because CFG cleanups
further down may destroy the required information. */
check_function_return_warnings ();
/* Turn NOTE_INSN_PREDICTIONs into branch predictions. */
if (flag_guess_branch_prob)
{
timevar_push (TV_BRANCH_PROB);
note_prediction_to_br_prob ();
timevar_pop (TV_BRANCH_PROB);
}
if (flag_optimize_sibling_calls)
rest_of_handle_sibling_calls (insns);
timevar_pop (TV_JUMP);
scope_to_insns_initialize ();
/* Complete generation of exception handling code. */
if (doing_eh (0))
{
timevar_push (TV_JUMP);
open_dump_file (DFI_eh, decl);
finish_eh_generation ();
close_dump_file (DFI_eh, print_rtl, get_insns ());
timevar_pop (TV_JUMP);
}
/* Delay emitting hard_reg_initial_value sets until after EH landing pad
generation, which might create new sets. */
emit_initial_value_sets ();
#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
insns = get_insns ();
/* Copy any shared structure that should not be shared. */
unshare_all_rtl (current_function_decl, insns);
#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
/* Instantiate all virtual registers. */
instantiate_virtual_regs (current_function_decl, insns);
open_dump_file (DFI_jump, decl);
/* Always do one jump optimization pass to ensure that JUMP_LABEL fields
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)
dump_flow_info (rtl_dump_file);
cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
| (flag_thread_jumps ? CLEANUP_THREADING : 0));
if (warn_uninitialized) if (optimize)
{ {
uninitialized_vars_warning (DECL_INITIAL (decl)); free_bb_for_insn ();
if (extra_warnings) copy_loop_headers (insns);
setjmp_args_warning (); find_basic_blocks (insns, max_reg_num (), rtl_dump_file);
} }
purge_line_number_notes (insns);
timevar_pop (TV_JUMP);
close_dump_file (DFI_jump, print_rtl, insns);
/* Now is when we stop if -fsyntax-only and -Wreturn-type. */
if (rtl_dump_and_exit || flag_syntax_only || DECL_DEFER_OUTPUT (decl))
goto exit_rest_of_compilation;
/* Long term, this should probably move before the jump optimizer too,
but I didn't want to disturb the rtl_dump_and_exit and related
stuff at this time. */
if (optimize > 0 && flag_ssa)
insns = rest_of_handle_ssa (decl, insns);
timevar_push (TV_JUMP);
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);
close_dump_file (DFI_jump, print_rtl_with_bb, insns);
ggc_collect (); ggc_collect ();
/* If -opt, try combining insns through substitution. */ if (optimize > 0)
rest_of_handle_cse (decl, insns);
rest_of_handle_addresof (decl, insns);
ggc_collect ();
if (optimize > 0) if (optimize > 0)
{ {
int rebuild_jump_labels_after_combine = 0; if (flag_gcse)
rest_of_handle_gcse (decl, insns);
timevar_push (TV_COMBINE); if (flag_loop_optimize)
open_dump_file (DFI_combine, decl); rest_of_handle_loop_optimize (decl, insns);
rebuild_jump_labels_after_combine if (flag_gcse)
= combine_instructions (insns, max_reg_num ()); rest_of_handle_jump_bypass (decl, insns);
}
/* Combining insns may have turned an indirect jump into a timevar_push (TV_FLOW);
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); rest_of_handle_cfg (decl, insns);
}
close_dump_file (DFI_combine, print_rtl_with_bb, insns); if (optimize > 0
timevar_pop (TV_COMBINE); || profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
rest_of_handle_branch_prob (decl, insns);
ggc_collect (); if (optimize > 0)
} rest_of_handle_if_conversion (decl, insns);
/* Rerun if-conversion, as combine may have simplified things enough to if (flag_tracer)
now meet sequence length restrictions. */ rest_of_handle_tracer (decl, insns);
if (flag_if_conversion)
{
timevar_push (TV_IFCVT);
open_dump_file (DFI_ce2, decl);
no_new_pseudos = 0; if (optimize > 0
if_convert (1); && (flag_unswitch_loops
no_new_pseudos = 1; || flag_peel_loops
|| flag_unroll_loops))
rest_of_handle_loop2 (decl, insns);
close_dump_file (DFI_ce2, print_rtl_with_bb, insns); if (flag_rerun_cse_after_loop)
timevar_pop (TV_IFCVT); rest_of_handle_cse2 (decl, insns);
}
/* Register allocation pre-pass, to reduce number of moves cse_not_expected = 1;
necessary for two-address machines. */
if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
{
timevar_push (TV_REGMOVE);
open_dump_file (DFI_regmove, decl);
regmove_optimize (insns, max_reg_num (), rtl_dump_file); rest_of_handle_life (decl, insns);
cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE); if (optimize > 0)
close_dump_file (DFI_regmove, print_rtl_with_bb, insns); rest_of_handle_combine (decl, insns);
timevar_pop (TV_REGMOVE);
ggc_collect (); if (flag_if_conversion)
} rest_of_handle_if_after_combine (decl, insns);
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))
goto exit_rest_of_compilation;
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;
reload_completed = 1;
rebuild_label_notes_after_reload = 0;
} }
else else
{ {
/* Allocate the reg_renumber array. */ if (rest_of_handle_old_regalloc (decl, insns,
allocate_reg_info (max_regno, FALSE, TRUE); &rebuild_label_notes_after_reload))
/* 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
{
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;
} }
...@@ -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) rest_of_handle_reorder_blocks (decl, insns);
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);
} }
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. */
...@@ -3842,7 +4029,8 @@ rest_of_compilation (decl) ...@@ -3842,7 +4029,8 @@ 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 ()
{ {
...@@ -4045,7 +4234,7 @@ display_target_options () ...@@ -4045,7 +4234,7 @@ display_target_options ()
} }
} }
} }
/* Parse a -d... command line switch. */ /* Parse a -d... command line switch. */
static void static void
...@@ -4662,7 +4851,7 @@ independent_decode_option (argc, argv) ...@@ -4662,7 +4851,7 @@ independent_decode_option (argc, argv)
return 1; return 1;
} }
/* Decode -m switches. */ /* Decode -m switches. */
/* Decode the switch -mNAME. */ /* Decode the switch -mNAME. */
...@@ -4717,7 +4906,7 @@ set_target_switch (name) ...@@ -4717,7 +4906,7 @@ set_target_switch (name)
if (!valid_target_option) if (!valid_target_option)
error ("invalid option `%s'", name); error ("invalid option `%s'", name);
} }
/* Print version information to FILE. /* Print version information to FILE.
Each line begins with INDENT (for the case where FILE is the Each line begins with INDENT (for the case where FILE is the
assembler output file). */ assembler output file). */
...@@ -4858,7 +5047,7 @@ print_switch_values (file, pos, max, indent, sep, term) ...@@ -4858,7 +5047,7 @@ print_switch_values (file, pos, max, indent, sep, term)
fprintf (file, "%s", term); fprintf (file, "%s", term);
} }
/* Open assembly code output file. Do this even if -fsyntax-only is /* Open assembly code output file. Do this even if -fsyntax-only is
on, because then the driver will have provided the name of a on, because then the driver will have provided the name of a
temporary file or bit bucket for us. NAME is the file specified on temporary file or bit bucket for us. NAME is the file specified on
...@@ -4913,7 +5102,7 @@ init_asm_output (name) ...@@ -4913,7 +5102,7 @@ init_asm_output (name)
#endif #endif
} }
} }
/* Initialization of the front end environment, before command line /* Initialization of the front end environment, before command line
options are parsed. Signal handlers, internationalization etc. options are parsed. Signal handlers, internationalization etc.
ARGV0 is main's argv[0]. */ ARGV0 is main's argv[0]. */
...@@ -4967,7 +5156,7 @@ general_init (argv0) ...@@ -4967,7 +5156,7 @@ general_init (argv0)
init_stringpool (); init_stringpool ();
init_ttree (); init_ttree ();
} }
/* Parse command line options and set default flag values, called /* Parse command line options and set default flag values, called
after language-independent option-independent initialization. Do after language-independent option-independent initialization. Do
minimal options processing. Outputting diagnostics is OK, but GC minimal options processing. Outputting diagnostics is OK, but GC
...@@ -5217,7 +5406,7 @@ parse_options_and_default_flags (argc, argv) ...@@ -5217,7 +5406,7 @@ parse_options_and_default_flags (argc, argv)
if (flag_really_no_inline == 2) if (flag_really_no_inline == 2)
flag_really_no_inline = flag_no_inline; flag_really_no_inline = flag_no_inline;
} }
/* Process the options that have been parsed. */ /* Process the options that have been parsed. */
static void static void
process_options () process_options ()
...@@ -5428,7 +5617,7 @@ process_options () ...@@ -5428,7 +5617,7 @@ process_options ()
if (flag_signaling_nans) if (flag_signaling_nans)
flag_trapping_math = 1; flag_trapping_math = 1;
} }
/* Initialize the compiler back end. */ /* Initialize the compiler back end. */
static void static void
backend_init () backend_init ()
...@@ -5459,7 +5648,7 @@ backend_init () ...@@ -5459,7 +5648,7 @@ backend_init ()
init_caller_save (); init_caller_save ();
expand_dummy_function_end (); expand_dummy_function_end ();
} }
/* Language-dependent initialization. Returns nonzero on success. */ /* Language-dependent initialization. Returns nonzero on success. */
static int static int
lang_dependent_init (name) lang_dependent_init (name)
...@@ -5505,7 +5694,7 @@ lang_dependent_init (name) ...@@ -5505,7 +5694,7 @@ lang_dependent_init (name)
return 1; return 1;
} }
/* Clean up: close opened files, etc. */ /* Clean up: close opened files, etc. */
static void static void
...@@ -5562,7 +5751,7 @@ finalize () ...@@ -5562,7 +5751,7 @@ finalize ()
/* Language-specific end of compilation actions. */ /* Language-specific end of compilation actions. */
(*lang_hooks.finish) (); (*lang_hooks.finish) ();
} }
/* Initialize the compiler, and compile the input file. */ /* Initialize the compiler, and compile the input file. */
static void static void
do_compile () do_compile ()
...@@ -5593,7 +5782,7 @@ do_compile () ...@@ -5593,7 +5782,7 @@ do_compile ()
timevar_stop (TV_TOTAL); timevar_stop (TV_TOTAL);
timevar_print (stderr); timevar_print (stderr);
} }
/* Entry point of cc1, cc1plus, jc1, f771, etc. /* Entry point of cc1, cc1plus, jc1, f771, etc.
Decode command args, then call compile_file. Decode command args, then call compile_file.
Exit code is FATAL_EXIT_CODE if can't open files or if there were Exit code is FATAL_EXIT_CODE if can't open files or if there were
......
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