This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [janitor] toplev.c cleanups
- From: Aldy Hernandez <aldyh at redhat dot com>
- To: Geoff Keating <geoffk at geoffk dot org>
- Cc: Zack Weinberg <zack at codesourcery dot com>, gcc-patches at gcc dot gnu dot org
- Date: Sat, 31 May 2003 19:44:37 -0400
- Subject: Re: [janitor] toplev.c cleanups
On Thursday, May 29, 2003, at 06:47 PM, Geoff Keating wrote:
This is kind of hard to review properly, but I like the idea, I don't
think the patch is making anything worse, and I'm going to trust that
you didn't accidentally delete any important optimisation passes :-).
So the patch is OK.
Yes, I know this is very hard to review properly-- probably more time
consuming than hard, that's why I didn't touch any logic. If I need to
do that, I'll do in subsequent patches that can be more straightforward
to review.
Further testing revealed a small thinko in the last patch. Below is
the patch I'm committing.
Tested on x86 linux.
Thanks.
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.
Index: toplev.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/toplev.c,v
retrieving revision 1.757
diff -c -p -r1.757 toplev.c
*** toplev.c 14 May 2003 07:29:41 -0000 1.757
--- toplev.c 31 May 2003 23:42:02 -0000
*************** Software Foundation, 59 Temple Place - S
*** 93,99 ****
#include "xcoffout.h" /* Needed for external data
declarations for e.g. AIX 4.x. */
#endif
!
/* Carry information from ASM_DECLARE_OBJECT_NAME
to ASM_FINISH_DECLARE_OBJECT. */
--- 93,99 ----
#include "xcoffout.h" /* Needed for external data
declarations for e.g. AIX 4.x. */
#endif
!
/* Carry information from ASM_DECLARE_OBJECT_NAME
to ASM_FINISH_DECLARE_OBJECT. */
*************** static int print_single_switch PARAMS ((
*** 133,138 ****
--- 133,175 ----
static void print_switch_values PARAMS ((FILE *, int, int, 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). */
static int set_yydebug;
*************** const char *progname;
*** 149,155 ****
/* Copy of arguments to toplev_main. */
int save_argc;
char **save_argv;
!
/* Name of top-level original source file (what was input to cpp).
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. */
--- 186,192 ----
/* Copy of arguments to toplev_main. */
int save_argc;
char **save_argv;
!
/* Name of top-level original source file (what was input to cpp).
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. */
*************** int mem_report = 0;
*** 438,444 ****
and to print them when we are done. */
int flag_detailed_statistics = 0;
-
/* -f flags. */
/* Nonzero means `char' should be signed. */
--- 475,480 ----
*************** static const struct
*** 1431,1437 ****
}
target_options[] = TARGET_OPTIONS;
#endif
!
/* Options controlling warnings. */
/* Don't print warning messages. -w. */
--- 1467,1473 ----
}
target_options[] = TARGET_OPTIONS;
#endif
!
/* Options controlling warnings. */
/* Don't print warning messages. -w. */
*************** static const lang_independent_options W_
*** 1590,1595 ****
--- 1626,1632 ----
N_ ("Warn about code which might break the strict aliasing rules")
}
};
+ /* Initialize unused warning flags. */
void
set_Wunused (setting)
int setting;
*************** set_Wunused (setting)
*** 1607,1612 ****
--- 1644,1650 ----
warn_unused_value = setting;
}
+ /* Initialize more unused warning flags. */
static void
set_Wextra (setting)
int setting;
*************** fast_math_flags_set_p ()
*** 1649,1655 ****
&& !flag_errno_math);
}
-
/* Output files for assembler code (real compiler output)
and debugging dumps. */
--- 1687,1692 ----
*************** read_integral_parameter (p, pname, defva
*** 1687,1712 ****
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,
if X is a power of 2. Otherwise, returns -1.
--- 1724,1730 ----
*************** output_file_directive (asm_file, input_n
*** 1871,1877 ****
#endif
#endif
}
!
/* Routine to open a dump file. Return true if the dump file is
enabled. */
static int
--- 1889,1895 ----
#endif
#endif
}
!
/* Routine to open a dump file. Return true if the dump file is
enabled. */
static int
*************** compile_file ()
*** 2277,2283 ****
timevar_pop (TV_DUMP);
}
}
!
/* This is called from various places for FUNCTION_DECL, VAR_DECL,
and TYPE_DECL nodes.
--- 2295,2301 ----
timevar_pop (TV_DUMP);
}
}
!
/* This is called from various places for FUNCTION_DECL, VAR_DECL,
and TYPE_DECL nodes.
*************** rest_of_type_compilation (type, toplev)
*** 2418,2916 ****
timevar_pop (TV_SYMOUT);
}
! /* 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 tem;
! int failure = 0;
! 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 we are reconsidering an inline function
! at the end of compilation, skip the stuff for making it inline.
*/
! if (DECL_SAVED_INSNS (decl) == 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.
*/
! 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;
! 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 ();
! /* Dump the rtl code if we are dumping rtl. */
! 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
! 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 ();
!
! /* 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;
! rebuild_jump_labels (insns);
! find_exception_handler_labels ();
! 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. */
! free_bb_for_insn ();
! }
! 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;
! 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
! 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);
}
! /* We may have potential sibling or tail recursion sites. Select
one
! (of possibly multiple) methods of performing the call. */
! if (flag_optimize_sibling_calls)
! {
! 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);
! /* 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.
!
! Until sibcall is replaced by tree-level optimizer, lets just
! sweep away the NOTE_INSN_PREDICTION notes that leaked out.
*/
! 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 ();
! /* 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 (optimize)
{
! 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);
! 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)
{
! /* Convert to SSA form. */
! timevar_push (TV_TO_SSA);
! open_dump_file (DFI_ssa, decl);
! cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
! convert_to_ssa ();
! close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
! timevar_pop (TV_TO_SSA);
! /* Perform sparse conditional constant propagation, if
requested. */
! if (flag_ssa_ccp)
! {
! timevar_push (TV_SSA_CCP);
! open_dump_file (DFI_ssa_ccp, decl);
! ssa_const_prop ();
! close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
! timevar_pop (TV_SSA_CCP);
! }
! /* It would be useful to cleanup the CFG at this point, but
block
! merging and possibly other transformations might leave a PHI
! node in the middle of a basic block, which is a strict no-no. */
!
! /* The SSA implementation uses basic block numbers in its phi
! nodes. Thus, changing the control-flow graph or the basic
! blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
! may cause problems. */
! if (flag_ssa_dce)
! {
! /* Remove dead code. */
! timevar_push (TV_SSA_DCE);
! open_dump_file (DFI_ssa_dce, decl);
! insns = get_insns ();
! ssa_eliminate_dead_code ();
! close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
! timevar_pop (TV_SSA_DCE);
! }
! /* Convert from SSA form. */
! timevar_push (TV_FROM_SSA);
! open_dump_file (DFI_ussa, decl);
! convert_from_ssa ();
! /* New registers have been created. Rescan their usage. */
! reg_scan (insns, max_reg_num (), 1);
! close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
! timevar_pop (TV_FROM_SSA);
! ggc_collect ();
! }
! timevar_push (TV_JUMP);
! if (optimize)
! 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))
! cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
! close_dump_file (DFI_null, 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 ();
! /* Perform common subexpression elimination.
! Nonzero value from `cse_main' means that jumps were simplified
! and some code may now be unreachable, so do
! jump optimization again. */
! if (optimize > 0)
{
! 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);
! if (delete_null_pointer_checks (insns))
! cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
! timevar_pop (TV_JUMP);
! }
! /* 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);
! }
open_dump_file (DFI_addressof, decl);
purge_addressof (insns);
--- 2436,2886 ----
timevar_pop (TV_SYMOUT);
}
! /* Turn the RTL into assembly. */
! static void
! rest_of_handle_final (tree decl, rtx 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 ();
! }
! #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);
! 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 (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
! /* Machine independent reorg pass. */
! static void
! rest_of_handle_machine_reorg (tree decl, rtx 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 ();
! }
! /* Run new register allocator. Return TRUE if we must exit
! rest_of_compilation upon return. */
! static bool
! rest_of_handle_new_regalloc (tree decl, rtx insns, int *rebuild_notes)
! {
! int failure;
! delete_trivially_dead_insns (insns, max_reg_num ());
! reg_alloc ();
!
! 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)
! return true;
! reload_completed = 1;
! *rebuild_notes = 0;
! return false;
! }
! /* 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 ();
! 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);
! }
! 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);
! 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 ());
! }
! /* 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);
! no_new_pseudos = 0;
! if_convert (1);
! 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);
*************** rest_of_compilation (decl)
*** 2919,3313 ****
reg_scan (insns, max_reg_num (), 1);
close_dump_file (DFI_addressof, print_rtl, insns);
! ggc_collect ();
! /* Perform global cse. */
! if (optimize > 0 && flag_gcse)
! {
! int save_csb, save_cfj;
! int tem2 = 0;
! timevar_push (TV_GCSE);
! open_dump_file (DFI_gcse, decl);
! tem = gcse_main (insns, rtl_dump_file);
rebuild_jump_labels (insns);
delete_trivially_dead_insns (insns, max_reg_num ());
! save_csb = flag_cse_skip_blocks;
! save_cfj = flag_cse_follow_jumps;
! flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
!
! /* Instantiate any remaining CONSTANT_P_RTX nodes. */
! if (current_function_calls_constant_p)
! purge_builtin_constant_p ();
! /* 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 ());
! timevar_pop (TV_CSE);
! cse_not_expected = !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)
! {
! tem = tem2 = 0;
! timevar_push (TV_JUMP);
! rebuild_jump_labels (insns);
! cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
! timevar_pop (TV_JUMP);
! 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 ());
! timevar_pop (TV_CSE);
}
}
!
! close_dump_file (DFI_gcse, print_rtl_with_bb, insns);
! timevar_pop (TV_GCSE);
!
! ggc_collect ();
! flag_cse_skip_blocks = save_csb;
! flag_cse_follow_jumps = save_cfj;
! #ifdef ENABLE_CHECKING
! verify_flow_info ();
! #endif
}
! /* Move constant computations out of loops. */
! if (optimize > 0 && flag_loop_optimize)
! {
! 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 jump bypassing and control flow optimizations. */
! if (optimize > 0 && flag_gcse)
! {
! timevar_push (TV_BYPASS);
! open_dump_file (DFI_bypass, decl);
! cleanup_cfg (CLEANUP_EXPENSIVE);
! tem = bypass_jumps (rtl_dump_file);
! if (tem)
! {
! 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);
! timevar_pop (TV_BYPASS);
! ggc_collect ();
! #ifdef ENABLE_CHECKING
! verify_flow_info ();
! #endif
}
! /* Do control and data flow analysis; wrote some of the results to
! the dump file. */
! timevar_push (TV_FLOW);
! 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);
! /* Do branch profiling and static profile estimation passes. */
! if (optimize > 0
! || profile_arc_flag || flag_test_coverage ||
flag_branch_probabilities)
! {
! 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);
! }
! if (optimize > 0)
! {
! 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);
! 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 ());
}
! 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
! sooner, but we want the profile feedback to work more
efficiently. */
! if (optimize > 0
! && (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);
! 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 ();
}
! if (flag_rerun_cse_after_loop)
{
! 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_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 ();
- timevar_pop (TV_CSE2);
}
! cse_not_expected = 1;
! 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)
! {
! uninitialized_vars_warning (DECL_INITIAL (decl));
! if (extra_warnings)
! setjmp_args_warning ();
! }
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);
! }
! }
! no_new_pseudos = 1;
! close_dump_file (DFI_life, print_rtl_with_bb, insns);
ggc_collect ();
! /* If -opt, try combining insns through substitution. */
if (optimize > 0)
{
! 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 ();
! }
! /* Rerun if-conversion, as combine may have simplified things
enough to
! now meet sequence length restrictions. */
! if (flag_if_conversion)
! {
! timevar_push (TV_IFCVT);
! open_dump_file (DFI_ce2, decl);
! no_new_pseudos = 0;
! if_convert (1);
! no_new_pseudos = 1;
! close_dump_file (DFI_ce2, print_rtl_with_bb, insns);
! timevar_pop (TV_IFCVT);
! }
! /* Register allocation pre-pass, to reduce number of moves
! 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);
! cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
! close_dump_file (DFI_regmove, print_rtl_with_bb, insns);
! timevar_pop (TV_REGMOVE);
! ggc_collect ();
! }
/* Do unconditional splitting before register allocation to allow
machine
description to add extra information not needed previously. */
--- 2889,3747 ----
reg_scan (insns, max_reg_num (), 1);
close_dump_file (DFI_addressof, print_rtl, insns);
+ }
! /* 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);
! /* 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.
!
! Until sibcall is replaced by tree-level optimizer, lets just
! sweep away the NOTE_INSN_PREDICTION notes that leaked out. */
! 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 ());
! }
! /* 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);
! cleanup_cfg (CLEANUP_EXPENSIVE);
!
! if (bypass_jumps (rtl_dump_file))
! {
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);
! timevar_pop (TV_BYPASS);
! ggc_collect ();
! #ifdef ENABLE_CHECKING
! verify_flow_info ();
! #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 ();
! /* Dump the rtl code if we are dumping rtl. */
! 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
! 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 ();
!
! /* 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;
! rebuild_jump_labels (insns);
! find_exception_handler_labels ();
! 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. */
! free_bb_for_insn ();
}
! 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;
}
! /* 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. */
! return (bool) DECL_EXTERNAL (decl);
! }
! /* 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);
! open_dump_file (DFI_ssa, decl);
! cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
! convert_to_ssa ();
! close_dump_file (DFI_ssa, print_rtl_with_bb, insns);
! timevar_pop (TV_TO_SSA);
! /* Perform sparse conditional constant propagation, if requested.
*/
! if (flag_ssa_ccp)
! {
! timevar_push (TV_SSA_CCP);
! open_dump_file (DFI_ssa_ccp, decl);
! ssa_const_prop ();
!
! close_dump_file (DFI_ssa_ccp, print_rtl_with_bb, get_insns ());
! timevar_pop (TV_SSA_CCP);
}
! /* It would be useful to cleanup the CFG at this point, but block
! merging and possibly other transformations might leave a PHI
! node in the middle of a basic block, which is a strict no-no. */
! /* The SSA implementation uses basic block numbers in its phi
! nodes. Thus, changing the control-flow graph or the basic
! blocks, e.g., calling find_basic_blocks () or cleanup_cfg (),
! may cause problems. */
! if (flag_ssa_dce)
! {
! /* Remove dead code. */
! timevar_push (TV_SSA_DCE);
! open_dump_file (DFI_ssa_dce, decl);
! insns = get_insns ();
! ssa_eliminate_dead_code ();
! close_dump_file (DFI_ssa_dce, print_rtl_with_bb, insns);
! timevar_pop (TV_SSA_DCE);
! }
! /* Convert from SSA form. */
! timevar_push (TV_FROM_SSA);
! open_dump_file (DFI_ussa, decl);
! convert_from_ssa ();
! /* New registers have been created. Rescan their usage. */
! reg_scan (insns, max_reg_num (), 1);
! close_dump_file (DFI_ussa, print_rtl_with_bb, insns);
! 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 ();
! }
!
! /* 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)
{
! uninitialized_vars_warning (DECL_INITIAL (decl));
! if (extra_warnings)
! setjmp_args_warning ();
}
! 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);
! }
! }
!
! 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);
+ if (delete_null_pointer_checks (insns))
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ timevar_pop (TV_JUMP);
+ }
+
+ /* 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_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 ();
+ timevar_pop (TV_CSE2);
+ }
! /* Perform global cse. */
! static void
! rest_of_handle_gcse (tree decl, rtx insns)
! {
! int save_csb, save_cfj;
! int tem2 = 0, tem;
!
! timevar_push (TV_GCSE);
! open_dump_file (DFI_gcse, decl);
!
! tem = gcse_main (insns, rtl_dump_file);
! rebuild_jump_labels (insns);
! delete_trivially_dead_insns (insns, max_reg_num ());
!
! save_csb = flag_cse_skip_blocks;
! save_cfj = flag_cse_follow_jumps;
! flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
!
! /* Instantiate any remaining CONSTANT_P_RTX nodes. */
! if (current_function_calls_constant_p)
! purge_builtin_constant_p ();
!
! /* 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 ());
+ timevar_pop (TV_CSE);
+ cse_not_expected = !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)
+ {
+ tem = tem2 = 0;
+ timevar_push (TV_JUMP);
+ rebuild_jump_labels (insns);
+ cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
+ timevar_pop (TV_JUMP);
! 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 ());
! timevar_pop (TV_CSE);
}
}
! close_dump_file (DFI_gcse, print_rtl_with_bb, insns);
! timevar_pop (TV_GCSE);
!
! ggc_collect ();
! flag_cse_skip_blocks = save_csb;
! flag_cse_follow_jumps = save_cfj;
! #ifdef ENABLE_CHECKING
! verify_flow_info ();
! #endif
! }
!
! /* Move constant computations out of loops. */
! static void
! 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 (optimize)
! {
! 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);
! 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)
! cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
! if (flag_delete_null_pointer_checks)
! rest_of_handle_null_pointer (decl, 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 ();
! if (optimize > 0)
! rest_of_handle_cse (decl, insns);
!
! rest_of_handle_addresof (decl, insns);
!
! ggc_collect ();
if (optimize > 0)
{
! if (flag_gcse)
! rest_of_handle_gcse (decl, insns);
! if (flag_loop_optimize)
! rest_of_handle_loop_optimize (decl, insns);
! if (flag_gcse)
! rest_of_handle_jump_bypass (decl, insns);
! }
! timevar_push (TV_FLOW);
! rest_of_handle_cfg (decl, insns);
!
! if (optimize > 0
! || profile_arc_flag || flag_test_coverage ||
flag_branch_probabilities)
! rest_of_handle_branch_prob (decl, insns);
! if (optimize > 0)
! rest_of_handle_if_conversion (decl, insns);
! if (flag_tracer)
! rest_of_handle_tracer (decl, insns);
! if (optimize > 0
! && (flag_unswitch_loops
! || flag_peel_loops
! || flag_unroll_loops))
! rest_of_handle_loop2 (decl, insns);
! if (flag_rerun_cse_after_loop)
! rest_of_handle_cse2 (decl, insns);
! cse_not_expected = 1;
! 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);
! if (optimize > 0 && (flag_regmove || flag_expensive_optimizations))
! rest_of_handle_regmove (decl, insns);
/* Do unconditional splitting before register allocation to allow
machine
description to add extra information not needed previously. */
*************** rest_of_compilation (decl)
*** 3328,3354 ****
(see handling of reg_known_equiv in init_alias_analysis). */
recompute_reg_usage (insns, !optimize_size);
! 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 ();
/* Determine if the current function is a leaf before running reload
since this can impact optimizations done by the prologue and
--- 3762,3768 ----
(see handling of reg_known_equiv in init_alias_analysis). */
recompute_reg_usage (insns, !optimize_size);
! rest_of_handle_sched (decl, insns);
/* Determine if the current function is a leaf before running reload
since this can impact optimizations done by the prologue and
*************** rest_of_compilation (decl)
*** 3358,3461 ****
timevar_push (TV_LOCAL_ALLOC);
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)
{
! delete_trivially_dead_insns (insns, max_reg_num ());
! reg_alloc ();
!
! 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
{
! /* 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
! {
! 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;
}
--- 3772,3787 ----
timevar_push (TV_LOCAL_ALLOC);
open_dump_file (DFI_lreg, decl);
if (flag_new_regalloc)
{
! if (rest_of_handle_new_regalloc (decl, insns,
! &rebuild_label_notes_after_reload))
! goto exit_rest_of_compilation;
}
else
{
! if (rest_of_handle_old_regalloc (decl, insns,
! &rebuild_label_notes_after_reload))
goto exit_rest_of_compilation;
}
*************** rest_of_compilation (decl)
*** 3545,3584 ****
}
#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)
{
! 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);
}
if (flag_if_conversion2)
--- 3871,3882 ----
}
#endif
if (optimize > 0)
{
! if (flag_rename_registers || flag_cprop_registers)
! rest_of_handle_regrename (decl, insns);
! rest_of_handle_reorder_blocks (decl, insns);
}
if (flag_if_conversion2)
*************** rest_of_compilation (decl)
*** 3594,3624 ****
#ifdef INSN_SCHEDULING
if (optimize > 0 && flag_schedule_insns_after_reload)
! {
! 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
#ifdef LEAF_REGISTERS
--- 3892,3898 ----
#ifdef INSN_SCHEDULING
if (optimize > 0 && flag_schedule_insns_after_reload)
! rest_of_handle_sched2 (decl, insns);
#endif
#ifdef LEAF_REGISTERS
*************** rest_of_compilation (decl)
*** 3627,3689 ****
#endif
#ifdef STACK_REGS
! timevar_push (TV_REG_STACK);
! 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
compute_alignments ();
/* CFG is no longer maintained up-to-date. */
free_bb_for_insn ();
- /* If a machine dependent reorganization is needed, call it. */
if (targetm.machine_dependent_reorg != 0)
! {
! 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);
cleanup_barriers ();
- /* If a scheduling pass for delayed branches is to be done,
- call the scheduling code. */
-
#ifdef DELAY_SLOTS
if (optimize > 0 && flag_delayed_branch)
! {
! 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
#if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
--- 3901,3923 ----
#endif
#ifdef STACK_REGS
! rest_of_handle_stack_regs (decl, insns);
#endif
+
compute_alignments ();
/* CFG is no longer maintained up-to-date. */
free_bb_for_insn ();
if (targetm.machine_dependent_reorg != 0)
! rest_of_handle_machine_reorg (decl, insns);
purge_line_number_notes (insns);
cleanup_barriers ();
#ifdef DELAY_SLOTS
if (optimize > 0 && flag_delayed_branch)
! rest_of_handle_delay_slots (decl, insns);
#endif
#if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
*************** rest_of_compilation (decl)
*** 3705,3758 ****
of other functions later in this translation unit. */
TREE_NOTHROW (current_function_decl) = 1;
! /* Now turn the rtl into assembler code. */
!
! 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. */
--- 3939,3945 ----
of other functions later in this translation unit. */
TREE_NOTHROW (current_function_decl) = 1;
! rest_of_handle_final (decl, insns);
/* Write DBX symbols if requested. */
*************** rest_of_compilation (decl)
*** 3836,3842 ****
timevar_pop (TV_REST_OF_COMPILATION);
}
!
static void
display_help ()
{
--- 4023,4030 ----
timevar_pop (TV_REST_OF_COMPILATION);
}
!
! /* Display help for generic options. */
static void
display_help ()
{
*************** display_help ()
*** 3970,3975 ****
--- 4158,4164 ----
display_target_options ();
}
+ /* Display help for target options. */
static void
display_target_options ()
{
*************** display_target_options ()
*** 4039,4045 ****
}
}
}
!
/* Parse a -d... command line switch. */
static void
--- 4228,4234 ----
}
}
}
!
/* Parse a -d... command line switch. */
static void
*************** independent_decode_option (argc, argv)
*** 4656,4662 ****
return 1;
}
!
/* Decode -m switches. */
/* Decode the switch -mNAME. */
--- 4845,4851 ----
return 1;
}
!
/* Decode -m switches. */
/* Decode the switch -mNAME. */
*************** set_target_switch (name)
*** 4711,4717 ****
if (!valid_target_option)
error ("invalid option `%s'", name);
}
!
/* Print version information to FILE.
Each line begins with INDENT (for the case where FILE is the
assembler output file). */
--- 4900,4906 ----
if (!valid_target_option)
error ("invalid option `%s'", name);
}
!
/* Print version information to FILE.
Each line begins with INDENT (for the case where FILE is the
assembler output file). */
*************** print_switch_values (file, pos, max, ind
*** 4852,4858 ****
fprintf (file, "%s", term);
}
!
/* Open assembly code output file. Do this even if -fsyntax-only is
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
--- 5041,5047 ----
fprintf (file, "%s", term);
}
!
/* Open assembly code output file. Do this even if -fsyntax-only is
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
*************** init_asm_output (name)
*** 4907,4913 ****
#endif
}
}
!
/* Initialization of the front end environment, before command line
options are parsed. Signal handlers, internationalization etc.
ARGV0 is main's argv[0]. */
--- 5096,5102 ----
#endif
}
}
!
/* Initialization of the front end environment, before command line
options are parsed. Signal handlers, internationalization etc.
ARGV0 is main's argv[0]. */
*************** general_init (argv0)
*** 4961,4967 ****
init_stringpool ();
init_ttree ();
}
!
/* Parse command line options and set default flag values, called
after language-independent option-independent initialization. Do
minimal options processing. Outputting diagnostics is OK, but GC
--- 5150,5156 ----
init_stringpool ();
init_ttree ();
}
!
/* Parse command line options and set default flag values, called
after language-independent option-independent initialization. Do
minimal options processing. Outputting diagnostics is OK, but GC
*************** parse_options_and_default_flags (argc, a
*** 5211,5217 ****
if (flag_really_no_inline == 2)
flag_really_no_inline = flag_no_inline;
}
!
/* Process the options that have been parsed. */
static void
process_options ()
--- 5400,5406 ----
if (flag_really_no_inline == 2)
flag_really_no_inline = flag_no_inline;
}
!
/* Process the options that have been parsed. */
static void
process_options ()
*************** process_options ()
*** 5422,5428 ****
if (flag_signaling_nans)
flag_trapping_math = 1;
}
!
/* Initialize the compiler back end. */
static void
backend_init ()
--- 5611,5617 ----
if (flag_signaling_nans)
flag_trapping_math = 1;
}
!
/* Initialize the compiler back end. */
static void
backend_init ()
*************** backend_init ()
*** 5453,5459 ****
init_caller_save ();
expand_dummy_function_end ();
}
!
/* Language-dependent initialization. Returns nonzero on success. */
static int
lang_dependent_init (name)
--- 5642,5648 ----
init_caller_save ();
expand_dummy_function_end ();
}
!
/* Language-dependent initialization. Returns nonzero on success. */
static int
lang_dependent_init (name)
*************** lang_dependent_init (name)
*** 5499,5505 ****
return 1;
}
!
/* Clean up: close opened files, etc. */
static void
--- 5688,5694 ----
return 1;
}
!
/* Clean up: close opened files, etc. */
static void
*************** finalize ()
*** 5556,5562 ****
/* Language-specific end of compilation actions. */
(*lang_hooks.finish) ();
}
!
/* Initialize the compiler, and compile the input file. */
static void
do_compile ()
--- 5745,5751 ----
/* Language-specific end of compilation actions. */
(*lang_hooks.finish) ();
}
!
/* Initialize the compiler, and compile the input file. */
static void
do_compile ()
*************** do_compile ()
*** 5587,5593 ****
timevar_stop (TV_TOTAL);
timevar_print (stderr);
}
!
/* Entry point of cc1, cc1plus, jc1, f771, etc.
Decode command args, then call compile_file.
Exit code is FATAL_EXIT_CODE if can't open files or if there were
--- 5776,5782 ----
timevar_stop (TV_TOTAL);
timevar_print (stderr);
}
!
/* Entry point of cc1, cc1plus, jc1, f771, etc.
Decode command args, then call compile_file.
Exit code is FATAL_EXIT_CODE if can't open files or if there were
Index: toplev.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/toplev.h,v
retrieving revision 1.93
diff -c -p -r1.93 toplev.h
*** toplev.h 13 May 2003 18:06:46 -0000 1.93
--- toplev.h 31 May 2003 23:42:02 -0000
*************** extern void output_clean_symbol_name
*** 84,92 ****
extern void output_quoted_string PARAMS ((FILE *, const char *));
extern void output_file_directive PARAMS ((FILE *, const char *));
#endif
- extern void do_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
- extern void botch PARAMS ((const char *))
- ATTRIBUTE_NORETURN;
#ifdef BUFSIZ
/* N.B. Unlike all the others, fnotice is just gettext+fprintf, and
--- 84,89 ----