1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This is the top level of cc1/c++.
23 It parses command args, opens files, invokes the various passes
24 in the proper order, and counts the time used by each.
25 Error messages and low-level interface to malloc also handled here. */
28 #undef FLOAT /* This is for hpux. They should change hpux. */
29 #undef FFS /* Some systems define this in param.h. */
31 #include "coretypes.h"
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
39 #ifdef HAVE_SYS_TIMES_H
40 # include <sys/times.h>
49 #include "insn-attr.h"
50 #include "insn-config.h"
51 #include "insn-flags.h"
52 #include "hard-reg-set.h"
59 #include "basic-block.h"
65 #include "diagnostic.h"
68 #include "dwarf2asm.h"
69 #include "integrate.h"
73 #include "langhooks.h"
74 #include "cfglayout.h"
76 #include "hosthooks.h"
80 #include "value-prof.h"
81 #include "alloc-pool.h"
82 #include "tree-pass.h"
83 #include "tree-dump.h"
85 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
86 #include "dwarf2out.h"
89 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
93 #ifdef SDB_DEBUGGING_INFO
97 #ifdef XCOFF_DEBUGGING_INFO
98 #include "xcoffout.h" /* Needed for external data
99 declarations for e.g. AIX 4.x. */
102 #ifndef HAVE_conditional_execution
103 #define HAVE_conditional_execution 0
106 /* Format to use to print dumpfile index value */
107 #ifndef DUMPFILE_FORMAT
108 #define DUMPFILE_FORMAT ".%02d."
111 static int initializing_dump = 0;
113 /* Routine to open a dump file. Return true if the dump file is enabled. */
116 open_dump_file (enum tree_dump_index index, tree decl)
118 if (! dump_enabled_p (index))
121 timevar_push (TV_DUMP);
123 if (dump_file != NULL || dump_file_name != NULL)
126 dump_file_name = get_dump_file_name (index);
127 initializing_dump = !dump_initialized_p (index);
128 dump_file = dump_begin (index, NULL);
130 if (dump_file == NULL)
131 fatal_error ("can't open %s: %m", dump_file_name);
134 fprintf (dump_file, "\n;; Function %s%s\n\n",
135 lang_hooks.decl_printable_name (decl, 2),
136 cfun->function_frequency == FUNCTION_FREQUENCY_HOT
138 : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
139 ? " (unlikely executed)"
142 timevar_pop (TV_DUMP);
146 /* Routine to close a dump file. */
149 close_dump_file (enum tree_dump_index index,
150 void (*func) (FILE *, rtx),
156 timevar_push (TV_DUMP);
158 && graph_dump_format != no_graph)
160 /* If we've not initialized the files, do so now. */
161 if (initializing_dump)
162 clean_graph_dump_file (dump_file_name);
164 print_rtl_graph_with_bb (dump_file_name, insns);
168 func (dump_file, insns);
170 dump_end (index, dump_file);
171 free ((char *) dump_file_name);
174 dump_file_name = NULL;
175 timevar_pop (TV_DUMP);
178 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
181 This does nothing for local (non-static) variables, unless the
182 variable is a register variable with DECL_ASSEMBLER_NAME set. In
183 that case, or if the variable is not an automatic, it sets up the
184 RTL and outputs any assembler code (label definition, storage
185 allocation and initialization).
187 DECL is the declaration. TOP_LEVEL is nonzero
188 if this declaration is not within a function. */
191 rest_of_decl_compilation (tree decl,
195 /* We deferred calling assemble_alias so that we could collect
196 other attributes such as visibility. Emit the alias now. */
199 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
202 alias = TREE_VALUE (TREE_VALUE (alias));
203 alias = get_identifier (TREE_STRING_POINTER (alias));
204 assemble_alias (decl, alias);
208 /* Can't defer this, because it needs to happen before any
209 later function definitions are processed. */
210 if (DECL_REGISTER (decl) && DECL_ASSEMBLER_NAME_SET_P (decl))
211 make_decl_rtl (decl);
213 /* Forward declarations for nested functions are not "external",
214 but we need to treat them as if they were. */
215 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
216 || TREE_CODE (decl) == FUNCTION_DECL)
218 timevar_push (TV_VARCONST);
220 /* Don't output anything when a tentative file-scope definition
221 is seen. But at end of compilation, do output code for them.
223 We do output all variables when unit-at-a-time is active and rely on
224 callgraph code to defer them except for forward declarations
225 (see gcc.c-torture/compile/920624-1.c) */
227 || !DECL_DEFER_OUTPUT (decl)
228 || DECL_INITIAL (decl))
229 && !DECL_EXTERNAL (decl))
231 if (flag_unit_at_a_time && !cgraph_global_info_ready
232 && TREE_CODE (decl) != FUNCTION_DECL && top_level)
233 cgraph_varpool_finalize_decl (decl);
235 assemble_variable (decl, top_level, at_end, 0);
238 #ifdef ASM_FINISH_DECLARE_OBJECT
239 if (decl == last_assemble_variable_decl)
241 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
246 timevar_pop (TV_VARCONST);
248 else if (TREE_CODE (decl) == TYPE_DECL)
250 timevar_push (TV_SYMOUT);
251 debug_hooks->type_decl (decl, !top_level);
252 timevar_pop (TV_SYMOUT);
255 /* Let cgraph know about the existance of variables. */
256 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
257 cgraph_varpool_node (decl);
260 /* Called after finishing a record, union or enumeral type. */
263 rest_of_type_compilation (tree type, int toplev)
265 /* Avoid confusing the debug information machinery when there are
267 if (errorcount != 0 || sorrycount != 0)
270 timevar_push (TV_SYMOUT);
271 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
272 timevar_pop (TV_SYMOUT);
275 /* Turn the RTL into assembly. */
277 rest_of_handle_final (void)
279 timevar_push (TV_FINAL);
284 /* Get the function's name, as described by its RTL. This may be
285 different from the DECL_NAME name used in the source file. */
287 x = DECL_RTL (current_function_decl);
291 if (GET_CODE (x) != SYMBOL_REF)
293 fnname = XSTR (x, 0);
295 assemble_start_function (current_function_decl, fnname);
296 final_start_function (get_insns (), asm_out_file, optimize);
297 final (get_insns (), asm_out_file, optimize);
298 final_end_function ();
300 #ifdef TARGET_UNWIND_INFO
301 /* ??? The IA-64 ".handlerdata" directive must be issued before
302 the ".endp" directive that closes the procedure descriptor. */
303 output_function_exception_table ();
306 assemble_end_function (current_function_decl, fnname);
308 #ifndef TARGET_UNWIND_INFO
309 /* Otherwise, it feels unclean to switch sections in the middle. */
310 output_function_exception_table ();
313 user_defined_section_attribute = false;
316 fflush (asm_out_file);
318 /* Release all memory allocated by flow. */
319 free_basic_block_vars ();
322 /* Write DBX symbols if requested. */
324 /* Note that for those inline functions where we don't initially
325 know for certain that we will be generating an out-of-line copy,
326 the first invocation of this routine (rest_of_compilation) will
327 skip over this code by doing a `goto exit_rest_of_compilation;'.
328 Later on, wrapup_global_declarations will (indirectly) call
329 rest_of_compilation again for those inline functions that need
330 to have out-of-line copies generated. During that call, we
331 *will* be routed past here. */
333 timevar_push (TV_SYMOUT);
334 (*debug_hooks->function_decl) (current_function_decl);
335 if (unlikely_text_section_name)
336 free (unlikely_text_section_name);
337 timevar_pop (TV_SYMOUT);
340 timevar_pop (TV_FINAL);
344 /* Run delay slot optimization. */
346 rest_of_handle_delay_slots (void)
348 timevar_push (TV_DBR_SCHED);
349 open_dump_file (DFI_dbr, current_function_decl);
351 dbr_schedule (get_insns (), dump_file);
353 close_dump_file (DFI_dbr, print_rtl, get_insns ());
357 timevar_pop (TV_DBR_SCHED);
362 /* Convert register usage from flat register file usage to a stack
365 rest_of_handle_stack_regs (void)
367 #if defined (HAVE_ATTR_length)
368 /* If flow2 creates new instructions which need splitting
369 and scheduling after reload is not done, they might not be
370 split until final which doesn't allow splitting
371 if HAVE_ATTR_length. */
372 #ifdef INSN_SCHEDULING
373 if (optimize && !flag_schedule_insns_after_reload)
378 timevar_push (TV_SHORTEN_BRANCH);
380 timevar_pop (TV_SHORTEN_BRANCH);
384 timevar_push (TV_REG_STACK);
385 open_dump_file (DFI_stack, current_function_decl);
387 if (reg_to_stack (dump_file) && optimize)
389 if (cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK
390 | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0))
391 && (flag_reorder_blocks || flag_reorder_blocks_and_partition))
393 reorder_basic_blocks (0);
394 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_POST_REGSTACK);
398 close_dump_file (DFI_stack, print_rtl_with_bb, get_insns ());
401 timevar_pop (TV_REG_STACK);
405 /* Track the variables, i.e. compute where the variable is stored at each position in function. */
407 rest_of_handle_variable_tracking (void)
409 timevar_push (TV_VAR_TRACKING);
410 open_dump_file (DFI_vartrack, current_function_decl);
412 variable_tracking_main ();
414 close_dump_file (DFI_vartrack, print_rtl_with_bb, get_insns ());
415 timevar_pop (TV_VAR_TRACKING);
418 /* Machine dependent reorg pass. */
420 rest_of_handle_machine_reorg (void)
422 timevar_push (TV_MACH_DEP);
423 open_dump_file (DFI_mach, current_function_decl);
425 targetm.machine_dependent_reorg ();
427 close_dump_file (DFI_mach, print_rtl, get_insns ());
430 timevar_pop (TV_MACH_DEP);
434 /* Run old register allocator. Return TRUE if we must exit
435 rest_of_compilation upon return. */
437 rest_of_handle_old_regalloc (void)
442 timevar_push (TV_LOCAL_ALLOC);
443 open_dump_file (DFI_lreg, current_function_decl);
445 /* Allocate the reg_renumber array. */
446 allocate_reg_info (max_regno, FALSE, TRUE);
448 /* And the reg_equiv_memory_loc array. */
449 VARRAY_GROW (reg_equiv_memory_loc_varray, max_regno);
450 reg_equiv_memory_loc = &VARRAY_RTX (reg_equiv_memory_loc_varray, 0);
452 allocate_initial_values (reg_equiv_memory_loc);
454 regclass (get_insns (), max_reg_num (), dump_file);
455 rebuild_notes = local_alloc ();
457 timevar_pop (TV_LOCAL_ALLOC);
459 /* Local allocation may have turned an indirect jump into a direct
460 jump. If so, we must rebuild the JUMP_LABEL fields of jumping
464 timevar_push (TV_JUMP);
466 rebuild_jump_labels (get_insns ());
467 purge_all_dead_edges (0);
468 delete_unreachable_blocks ();
470 timevar_pop (TV_JUMP);
473 if (dump_enabled_p (DFI_lreg))
475 timevar_push (TV_DUMP);
476 dump_flow_info (dump_file);
477 dump_local_alloc (dump_file);
478 timevar_pop (TV_DUMP);
481 close_dump_file (DFI_lreg, print_rtl_with_bb, get_insns ());
485 timevar_push (TV_GLOBAL_ALLOC);
486 open_dump_file (DFI_greg, current_function_decl);
488 /* If optimizing, allocate remaining pseudo-regs. Do the reload
489 pass fixing up any insns that are invalid. */
492 failure = global_alloc (dump_file);
495 build_insn_chain (get_insns ());
496 failure = reload (get_insns (), 0);
499 if (dump_enabled_p (DFI_greg))
501 timevar_push (TV_DUMP);
502 dump_global_regs (dump_file);
503 timevar_pop (TV_DUMP);
505 close_dump_file (DFI_greg, print_rtl_with_bb, get_insns ());
510 timevar_pop (TV_GLOBAL_ALLOC);
515 /* Run the regrename and cprop passes. */
517 rest_of_handle_regrename (void)
519 timevar_push (TV_RENAME_REGISTERS);
520 open_dump_file (DFI_rnreg, current_function_decl);
522 if (flag_rename_registers)
523 regrename_optimize ();
524 if (flag_cprop_registers)
525 copyprop_hardreg_forward ();
527 close_dump_file (DFI_rnreg, print_rtl_with_bb, get_insns ());
528 timevar_pop (TV_RENAME_REGISTERS);
531 /* Reorder basic blocks. */
533 rest_of_handle_reorder_blocks (void)
536 unsigned int liveness_flags;
538 open_dump_file (DFI_bbro, current_function_decl);
540 /* Last attempt to optimize CFG, as scheduling, peepholing and insn
541 splitting possibly introduced more crossjumping opportunities. */
542 liveness_flags = (!HAVE_conditional_execution ? CLEANUP_UPDATE_LIFE : 0);
543 changed = cleanup_cfg (CLEANUP_EXPENSIVE | liveness_flags);
545 if (flag_sched2_use_traces && flag_schedule_insns_after_reload)
546 tracer (liveness_flags);
547 if (flag_reorder_blocks || flag_reorder_blocks_and_partition)
548 reorder_basic_blocks (liveness_flags);
549 if (flag_reorder_blocks || flag_reorder_blocks_and_partition
550 || (flag_sched2_use_traces && flag_schedule_insns_after_reload))
551 changed |= cleanup_cfg (CLEANUP_EXPENSIVE | liveness_flags);
553 /* On conditional execution targets we can not update the life cheaply, so
554 we deffer the updating to after both cleanups. This may lose some cases
555 but should not be terribly bad. */
556 if (changed && HAVE_conditional_execution)
557 update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
559 close_dump_file (DFI_bbro, print_rtl_with_bb, get_insns ());
562 /* Partition hot and cold basic blocks. */
564 rest_of_handle_partition_blocks (void)
567 partition_hot_cold_basic_blocks ();
568 allocate_reg_life_data ();
569 update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
570 PROP_LOG_LINKS | PROP_REG_INFO | PROP_DEATH_NOTES);
574 #ifdef INSN_SCHEDULING
575 /* Run instruction scheduler. */
576 /* Perform SMS module scheduling. */
578 rest_of_handle_sms (void)
582 timevar_push (TV_SMS);
583 open_dump_file (DFI_sms, current_function_decl);
585 /* We want to be able to create new pseudos. */
587 sms_schedule (dump_file);
588 close_dump_file (DFI_sms, print_rtl, get_insns ());
591 /* Update the life information, because we add pseudos. */
592 max_regno = max_reg_num ();
593 allocate_reg_info (max_regno, FALSE, FALSE);
594 blocks = sbitmap_alloc (last_basic_block);
595 sbitmap_ones (blocks);
596 update_life_info (blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
599 | PROP_KILL_DEAD_CODE
600 | PROP_SCAN_DEAD_CODE));
605 timevar_pop (TV_SMS);
608 /* Run instruction scheduler. */
610 rest_of_handle_sched (void)
612 timevar_push (TV_SCHED);
614 /* Print function header into sched dump now
615 because doing the sched analysis makes some of the dump. */
616 open_dump_file (DFI_sched, current_function_decl);
618 /* Do control and data sched analysis,
619 and write some of the results to dump file. */
621 schedule_insns (dump_file);
623 close_dump_file (DFI_sched, print_rtl_with_bb, get_insns ());
626 timevar_pop (TV_SCHED);
629 /* Run second scheduling pass after reload. */
631 rest_of_handle_sched2 (void)
633 timevar_push (TV_SCHED2);
634 open_dump_file (DFI_sched2, current_function_decl);
636 /* Do control and data sched analysis again,
637 and write some more of the results to dump file. */
641 if (flag_sched2_use_superblocks || flag_sched2_use_traces)
643 schedule_ebbs (dump_file);
644 /* No liveness updating code yet, but it should be easy to do.
645 reg-stack recomputes the liveness when needed for now. */
646 count_or_remove_death_notes (NULL, 1);
647 cleanup_cfg (CLEANUP_EXPENSIVE);
650 schedule_insns (dump_file);
652 close_dump_file (DFI_sched2, print_rtl_with_bb, get_insns ());
656 timevar_pop (TV_SCHED2);
661 rest_of_handle_gcse2 (void)
663 timevar_push (TV_GCSE_AFTER_RELOAD);
664 open_dump_file (DFI_gcse2, current_function_decl);
666 gcse_after_reload_main (get_insns ());
667 rebuild_jump_labels (get_insns ());
668 delete_trivially_dead_insns (get_insns (), max_reg_num ());
669 close_dump_file (DFI_gcse2, print_rtl_with_bb, get_insns ());
673 #ifdef ENABLE_CHECKING
677 timevar_pop (TV_GCSE_AFTER_RELOAD);
680 /* Register allocation pre-pass, to reduce number of moves necessary
681 for two-address machines. */
683 rest_of_handle_regmove (void)
685 timevar_push (TV_REGMOVE);
686 open_dump_file (DFI_regmove, current_function_decl);
688 regmove_optimize (get_insns (), max_reg_num (), dump_file);
690 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
691 close_dump_file (DFI_regmove, print_rtl_with_bb, get_insns ());
694 timevar_pop (TV_REGMOVE);
699 rest_of_handle_tracer (void)
701 open_dump_file (DFI_tracer, current_function_decl);
703 dump_flow_info (dump_file);
705 cleanup_cfg (CLEANUP_EXPENSIVE);
706 reg_scan (get_insns (), max_reg_num ());
707 close_dump_file (DFI_tracer, print_rtl_with_bb, get_insns ());
710 /* If-conversion and CFG cleanup. */
712 rest_of_handle_if_conversion (void)
714 timevar_push (TV_IFCVT);
715 open_dump_file (DFI_ce1, current_function_decl);
717 if (flag_if_conversion)
720 dump_flow_info (dump_file);
721 cleanup_cfg (CLEANUP_EXPENSIVE);
722 reg_scan (get_insns (), max_reg_num ());
726 timevar_push (TV_JUMP);
727 cleanup_cfg (CLEANUP_EXPENSIVE);
728 reg_scan (get_insns (), max_reg_num ());
729 timevar_pop (TV_JUMP);
731 close_dump_file (DFI_ce1, print_rtl_with_bb, get_insns ());
732 timevar_pop (TV_IFCVT);
735 /* Rerun if-conversion, as combine may have simplified things enough
736 to now meet sequence length restrictions. */
738 rest_of_handle_if_after_combine (void)
740 timevar_push (TV_IFCVT);
741 open_dump_file (DFI_ce2, current_function_decl);
747 close_dump_file (DFI_ce2, print_rtl_with_bb, get_insns ());
748 timevar_pop (TV_IFCVT);
752 rest_of_handle_if_after_reload (void)
754 timevar_push (TV_IFCVT2);
755 open_dump_file (DFI_ce3, current_function_decl);
757 /* Last attempt to optimize CFG, as scheduling, peepholing and insn
758 splitting possibly introduced more crossjumping opportunities. */
759 cleanup_cfg (CLEANUP_EXPENSIVE
760 | CLEANUP_UPDATE_LIFE
761 | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
762 if (flag_if_conversion2)
764 close_dump_file (DFI_ce3, print_rtl_with_bb, get_insns ());
765 timevar_pop (TV_IFCVT2);
769 rest_of_handle_web (void)
771 open_dump_file (DFI_web, current_function_decl);
772 timevar_push (TV_WEB);
774 delete_trivially_dead_insns (get_insns (), max_reg_num ());
775 cleanup_cfg (CLEANUP_EXPENSIVE);
777 timevar_pop (TV_WEB);
778 close_dump_file (DFI_web, print_rtl_with_bb, get_insns ());
779 reg_scan (get_insns (), max_reg_num ());
782 /* Do branch profiling and static profile estimation passes. */
784 rest_of_handle_branch_prob (void)
788 timevar_push (TV_BRANCH_PROB);
789 open_dump_file (DFI_bp, current_function_decl);
791 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
794 /* Discover and record the loop depth at the head of each basic
795 block. The loop infrastructure does the real job for us. */
796 flow_loops_find (&loops);
799 flow_loops_dump (&loops, dump_file, NULL, 0);
801 /* Estimate using heuristics if no profiling info is available. */
802 if (flag_guess_branch_prob)
803 estimate_probability (&loops);
805 flow_loops_free (&loops);
806 free_dominance_info (CDI_DOMINATORS);
807 close_dump_file (DFI_bp, print_rtl_with_bb, get_insns ());
808 timevar_pop (TV_BRANCH_PROB);
811 /* Do optimizations based on expression value profiles. */
813 rest_of_handle_value_profile_transformations (void)
815 open_dump_file (DFI_vpt, current_function_decl);
816 timevar_push (TV_VPT);
818 if (value_profile_transformations ())
819 cleanup_cfg (CLEANUP_EXPENSIVE);
821 timevar_pop (TV_VPT);
822 close_dump_file (DFI_vpt, print_rtl_with_bb, get_insns ());
825 /* Do control and data flow analysis; write some of the results to the
828 rest_of_handle_cfg (void)
830 open_dump_file (DFI_cfg, current_function_decl);
832 dump_flow_info (dump_file);
834 cleanup_cfg (CLEANUP_EXPENSIVE
835 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
837 /* It may make more sense to mark constant functions after dead code is
838 eliminated by life_analysis, but we need to do it early, as -fprofile-arcs
839 may insert code making function non-constant, but we still must consider
840 it as constant, otherwise -fbranch-probabilities will not read data back.
842 life_analysis rarely eliminates modification of external memory.
844 FIXME: now with tree based profiling we are in the trap described above
845 again. It seems to be easiest to disable the optimization for time
846 being before the problem is either solved by moving the transformation
847 to the IPA level (we need the CFG for this) or the very early optimization
848 passes are made to ignore the const/pure flags so code does not change. */
850 && (!flag_tree_based_profiling
851 || (!profile_arc_flag && !flag_branch_probabilities)))
853 /* Alias analysis depends on this information and mark_constant_function
854 depends on alias analysis. */
855 reg_scan (get_insns (), max_reg_num ());
856 mark_constant_function ();
859 close_dump_file (DFI_cfg, print_rtl_with_bb, get_insns ());
862 /* Perform jump bypassing and control flow optimizations. */
864 rest_of_handle_jump_bypass (void)
866 timevar_push (TV_BYPASS);
867 open_dump_file (DFI_bypass, current_function_decl);
869 cleanup_cfg (CLEANUP_EXPENSIVE);
870 reg_scan (get_insns (), max_reg_num ());
872 if (bypass_jumps (dump_file))
874 rebuild_jump_labels (get_insns ());
875 cleanup_cfg (CLEANUP_EXPENSIVE);
876 delete_trivially_dead_insns (get_insns (), max_reg_num ());
879 close_dump_file (DFI_bypass, print_rtl_with_bb, get_insns ());
880 timevar_pop (TV_BYPASS);
884 #ifdef ENABLE_CHECKING
889 /* Try combining insns through substitution. */
891 rest_of_handle_combine (void)
893 int rebuild_jump_labels_after_combine = 0;
895 timevar_push (TV_COMBINE);
896 open_dump_file (DFI_combine, current_function_decl);
898 rebuild_jump_labels_after_combine
899 = combine_instructions (get_insns (), max_reg_num ());
901 /* Combining insns may have turned an indirect jump into a
902 direct jump. Rebuild the JUMP_LABEL fields of jumping
904 if (rebuild_jump_labels_after_combine)
906 timevar_push (TV_JUMP);
907 rebuild_jump_labels (get_insns ());
908 timevar_pop (TV_JUMP);
910 delete_dead_jumptables ();
911 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE);
914 close_dump_file (DFI_combine, print_rtl_with_bb, get_insns ());
915 timevar_pop (TV_COMBINE);
920 /* Perform life analysis. */
922 rest_of_handle_life (void)
924 open_dump_file (DFI_life, current_function_decl);
927 #ifdef ENABLE_CHECKING
930 life_analysis (dump_file, PROP_FINAL);
932 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE | CLEANUP_LOG_LINKS
933 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
937 setjmp_vars_warning (DECL_INITIAL (current_function_decl));
938 setjmp_args_warning ();
943 if (initialize_uninitialized_subregs ())
945 /* Insns were inserted, and possibly pseudos created, so
946 things might look a bit different. */
947 allocate_reg_life_data ();
948 update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
949 PROP_LOG_LINKS | PROP_REG_INFO | PROP_DEATH_NOTES);
955 close_dump_file (DFI_life, print_rtl_with_bb, get_insns ());
960 /* Perform common subexpression elimination. Nonzero value from
961 `cse_main' means that jumps were simplified and some code may now
962 be unreachable, so do jump optimization again. */
964 rest_of_handle_cse (void)
968 open_dump_file (DFI_cse, current_function_decl);
970 dump_flow_info (dump_file);
971 timevar_push (TV_CSE);
973 reg_scan (get_insns (), max_reg_num ());
975 tem = cse_main (get_insns (), max_reg_num (), dump_file);
977 rebuild_jump_labels (get_insns ());
978 if (purge_all_dead_edges (0))
979 delete_unreachable_blocks ();
981 delete_trivially_dead_insns (get_insns (), max_reg_num ());
983 /* If we are not running more CSE passes, then we are no longer
984 expecting CSE to be run. But always rerun it in a cheap mode. */
985 cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
988 delete_dead_jumptables ();
990 if (tem || optimize > 1)
991 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
993 timevar_pop (TV_CSE);
994 close_dump_file (DFI_cse, print_rtl_with_bb, get_insns ());
999 /* Run second CSE pass after loop optimizations. */
1001 rest_of_handle_cse2 (void)
1005 timevar_push (TV_CSE2);
1006 open_dump_file (DFI_cse2, current_function_decl);
1008 dump_flow_info (dump_file);
1009 /* CFG is no longer maintained up-to-date. */
1010 tem = cse_main (get_insns (), max_reg_num (), dump_file);
1012 /* Run a pass to eliminate duplicated assignments to condition code
1013 registers. We have to run this after bypass_jumps, because it
1014 makes it harder for that pass to determine whether a jump can be
1016 cse_condition_code_reg ();
1018 purge_all_dead_edges (0);
1019 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1023 timevar_push (TV_JUMP);
1024 rebuild_jump_labels (get_insns ());
1025 delete_dead_jumptables ();
1026 cleanup_cfg (CLEANUP_EXPENSIVE);
1027 timevar_pop (TV_JUMP);
1029 reg_scan (get_insns (), max_reg_num ());
1030 close_dump_file (DFI_cse2, print_rtl_with_bb, get_insns ());
1031 timevar_pop (TV_CSE2);
1036 /* Perform global cse. */
1038 rest_of_handle_gcse (void)
1040 int save_csb, save_cfj;
1043 timevar_push (TV_GCSE);
1044 open_dump_file (DFI_gcse, current_function_decl);
1046 tem = gcse_main (get_insns (), dump_file);
1047 rebuild_jump_labels (get_insns ());
1048 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1050 save_csb = flag_cse_skip_blocks;
1051 save_cfj = flag_cse_follow_jumps;
1052 flag_cse_skip_blocks = flag_cse_follow_jumps = 0;
1054 /* If -fexpensive-optimizations, re-run CSE to clean up things done
1056 if (flag_expensive_optimizations)
1058 timevar_push (TV_CSE);
1059 reg_scan (get_insns (), max_reg_num ());
1060 tem2 = cse_main (get_insns (), max_reg_num (), dump_file);
1061 purge_all_dead_edges (0);
1062 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1063 timevar_pop (TV_CSE);
1064 cse_not_expected = !flag_rerun_cse_after_loop;
1067 /* If gcse or cse altered any jumps, rerun jump optimizations to clean
1071 timevar_push (TV_JUMP);
1072 rebuild_jump_labels (get_insns ());
1073 delete_dead_jumptables ();
1074 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
1075 timevar_pop (TV_JUMP);
1078 close_dump_file (DFI_gcse, print_rtl_with_bb, get_insns ());
1079 timevar_pop (TV_GCSE);
1082 flag_cse_skip_blocks = save_csb;
1083 flag_cse_follow_jumps = save_cfj;
1084 #ifdef ENABLE_CHECKING
1085 verify_flow_info ();
1089 /* Move constant computations out of loops. */
1091 rest_of_handle_loop_optimize (void)
1095 timevar_push (TV_LOOP);
1096 open_dump_file (DFI_loop, current_function_decl);
1098 /* CFG is no longer maintained up-to-date. */
1099 free_bb_for_insn ();
1100 profile_status = PROFILE_ABSENT;
1102 do_prefetch = flag_prefetch_loop_arrays ? LOOP_PREFETCH : 0;
1104 if (flag_rerun_loop_opt)
1106 cleanup_barriers ();
1108 /* We only want to perform unrolling once. */
1109 loop_optimize (get_insns (), dump_file, 0);
1111 /* The first call to loop_optimize makes some instructions
1112 trivially dead. We delete those instructions now in the
1113 hope that doing so will make the heuristics in loop work
1114 better and possibly speed up compilation. */
1115 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1117 /* The regscan pass is currently necessary as the alias
1118 analysis code depends on this information. */
1119 reg_scan (get_insns (), max_reg_num ());
1121 cleanup_barriers ();
1122 loop_optimize (get_insns (), dump_file, do_prefetch);
1124 /* Loop can create trivially dead instructions. */
1125 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1126 find_basic_blocks (get_insns ());
1127 close_dump_file (DFI_loop, print_rtl, get_insns ());
1128 timevar_pop (TV_LOOP);
1133 /* Perform loop optimizations. It might be better to do them a bit
1134 sooner, but we want the profile feedback to work more
1137 rest_of_handle_loop2 (void)
1139 struct loops *loops;
1142 if (!flag_move_loop_invariants
1143 && !flag_unswitch_loops
1145 && !flag_unroll_loops
1146 && !flag_branch_on_count_reg)
1149 timevar_push (TV_LOOP);
1150 open_dump_file (DFI_loop2, current_function_decl);
1152 dump_flow_info (dump_file);
1154 /* Initialize structures for layout changes. */
1155 cfg_layout_initialize (0);
1157 loops = loop_optimizer_init (dump_file);
1161 /* The optimizations: */
1162 if (flag_move_loop_invariants)
1163 move_loop_invariants (loops);
1165 if (flag_unswitch_loops)
1166 unswitch_loops (loops);
1168 if (flag_peel_loops || flag_unroll_loops)
1169 unroll_and_peel_loops (loops,
1170 (flag_peel_loops ? UAP_PEEL : 0) |
1171 (flag_unroll_loops ? UAP_UNROLL : 0) |
1172 (flag_unroll_all_loops ? UAP_UNROLL_ALL : 0));
1174 #ifdef HAVE_doloop_end
1175 if (flag_branch_on_count_reg && HAVE_doloop_end)
1176 doloop_optimize_loops (loops);
1177 #endif /* HAVE_doloop_end */
1179 loop_optimizer_finalize (loops, dump_file);
1182 free_dominance_info (CDI_DOMINATORS);
1184 /* Finalize layout changes. */
1186 if (bb->next_bb != EXIT_BLOCK_PTR)
1187 bb->rbi->next = bb->next_bb;
1188 cfg_layout_finalize ();
1190 cleanup_cfg (CLEANUP_EXPENSIVE);
1191 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1192 reg_scan (get_insns (), max_reg_num ());
1194 dump_flow_info (dump_file);
1195 close_dump_file (DFI_loop2, print_rtl_with_bb, get_insns ());
1196 timevar_pop (TV_LOOP);
1201 rest_of_handle_branch_target_load_optimize (void)
1203 static int warned = 0;
1205 /* Leave this a warning for now so that it is possible to experiment
1206 with running this pass twice. In 3.6, we should either make this
1207 an error, or use separate dump files. */
1208 if (flag_branch_target_load_optimize
1209 && flag_branch_target_load_optimize2
1212 warning ("branch target register load optimization is not intended "
1218 open_dump_file (DFI_branch_target_load, current_function_decl);
1219 branch_target_load_optimize (epilogue_completed);
1220 close_dump_file (DFI_branch_target_load, print_rtl_with_bb, get_insns ());
1224 #ifdef OPTIMIZE_MODE_SWITCHING
1226 rest_of_handle_mode_switching (void)
1228 timevar_push (TV_MODE_SWITCH);
1231 optimize_mode_switching (NULL);
1234 timevar_pop (TV_MODE_SWITCH);
1239 rest_of_handle_jump (void)
1243 timevar_push (TV_JUMP);
1244 open_dump_file (DFI_sibling, current_function_decl);
1246 delete_unreachable_blocks ();
1247 #ifdef ENABLE_CHECKING
1248 verify_flow_info ();
1251 if (cfun->tail_call_emit)
1252 fixup_tail_calls ();
1254 close_dump_file (DFI_sibling, print_rtl, get_insns ());
1255 timevar_pop (TV_JUMP);
1259 rest_of_handle_eh (void)
1261 insn_locators_initialize ();
1262 /* Complete generation of exception handling code. */
1265 timevar_push (TV_JUMP);
1266 open_dump_file (DFI_eh, current_function_decl);
1268 cleanup_cfg (CLEANUP_PRE_LOOP | CLEANUP_NO_INSN_DEL);
1270 finish_eh_generation ();
1272 cleanup_cfg (CLEANUP_PRE_LOOP | CLEANUP_NO_INSN_DEL);
1274 close_dump_file (DFI_eh, print_rtl, get_insns ());
1275 timevar_pop (TV_JUMP);
1280 rest_of_handle_stack_adjustments (void)
1282 life_analysis (dump_file, PROP_POSTRELOAD);
1283 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_UPDATE_LIFE
1284 | (flag_crossjumping ? CLEANUP_CROSSJUMP : 0));
1286 /* This is kind of a heuristic. We need to run combine_stack_adjustments
1287 even for machines with possibly nonzero RETURN_POPS_ARGS
1288 and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
1289 push instructions will have popping returns. */
1290 #ifndef PUSH_ROUNDING
1291 if (!ACCUMULATE_OUTGOING_ARGS)
1293 combine_stack_adjustments ();
1297 rest_of_handle_flow2 (void)
1299 timevar_push (TV_FLOW2);
1300 open_dump_file (DFI_flow2, current_function_decl);
1302 /* Re-create the death notes which were deleted during reload. */
1303 #ifdef ENABLE_CHECKING
1304 verify_flow_info ();
1307 /* If optimizing, then go ahead and split insns now. */
1311 split_all_insns (0);
1313 if (flag_branch_target_load_optimize)
1315 close_dump_file (DFI_flow2, print_rtl_with_bb, get_insns ());
1316 rest_of_handle_branch_target_load_optimize ();
1317 open_dump_file (DFI_flow2, current_function_decl);
1321 cleanup_cfg (CLEANUP_EXPENSIVE);
1323 /* On some machines, the prologue and epilogue code, or parts thereof,
1324 can be represented as RTL. Doing so lets us schedule insns between
1325 it and the rest of the code and also allows delayed branch
1326 scheduling to operate in the epilogue. */
1327 thread_prologue_and_epilogue_insns (get_insns ());
1328 epilogue_completed = 1;
1331 rest_of_handle_stack_adjustments ();
1333 flow2_completed = 1;
1335 close_dump_file (DFI_flow2, print_rtl_with_bb, get_insns ());
1336 timevar_pop (TV_FLOW2);
1343 rest_of_handle_jump2 (void)
1345 open_dump_file (DFI_jump, current_function_decl);
1347 /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
1348 are initialized and to compute whether control can drop off the end
1351 timevar_push (TV_JUMP);
1352 /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
1353 before jump optimization switches branch directions. */
1354 if (flag_guess_branch_prob)
1355 expected_value_to_br_prob ();
1357 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1358 reg_scan (get_insns (), max_reg_num ());
1360 dump_flow_info (dump_file);
1361 cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0) | CLEANUP_PRE_LOOP
1362 | (flag_thread_jumps ? CLEANUP_THREADING : 0));
1364 create_loop_notes ();
1366 purge_line_number_notes (get_insns ());
1369 cleanup_cfg (CLEANUP_EXPENSIVE | CLEANUP_PRE_LOOP);
1371 /* Jump optimization, and the removal of NULL pointer checks, may
1372 have reduced the number of instructions substantially. CSE, and
1373 future passes, allocate arrays whose dimensions involve the
1374 maximum instruction UID, so if we can reduce the maximum UID
1375 we'll save big on memory. */
1376 renumber_insns (dump_file);
1378 close_dump_file (DFI_jump, print_rtl_with_bb, get_insns ());
1379 timevar_pop (TV_JUMP);
1384 #ifdef HAVE_peephole2
1386 rest_of_handle_peephole2 (void)
1388 timevar_push (TV_PEEPHOLE2);
1389 open_dump_file (DFI_peephole2, current_function_decl);
1391 peephole2_optimize (dump_file);
1393 close_dump_file (DFI_peephole2, print_rtl_with_bb, get_insns ());
1394 timevar_pop (TV_PEEPHOLE2);
1399 rest_of_handle_postreload (void)
1401 timevar_push (TV_RELOAD_CSE_REGS);
1402 open_dump_file (DFI_postreload, current_function_decl);
1404 /* Do a very simple CSE pass over just the hard registers. */
1405 reload_cse_regs (get_insns ());
1406 /* reload_cse_regs can eliminate potentially-trapping MEMs.
1407 Remove any EH edges associated with them. */
1408 if (flag_non_call_exceptions)
1409 purge_all_dead_edges (0);
1411 close_dump_file (DFI_postreload, print_rtl_with_bb, get_insns ());
1412 timevar_pop (TV_RELOAD_CSE_REGS);
1416 rest_of_handle_shorten_branches (void)
1418 /* Shorten branches. */
1419 timevar_push (TV_SHORTEN_BRANCH);
1420 shorten_branches (get_insns ());
1421 timevar_pop (TV_SHORTEN_BRANCH);
1425 rest_of_clean_state (void)
1428 coverage_end_function ();
1430 /* It is very important to decompose the RTL instruction chain here:
1431 debug information keeps pointing into CODE_LABEL insns inside the function
1432 body. If these remain pointing to the other insns, we end up preserving
1433 whole RTL chain and attached detailed debug info in memory. */
1434 for (insn = get_insns (); insn; insn = next)
1436 next = NEXT_INSN (insn);
1437 NEXT_INSN (insn) = NULL;
1438 PREV_INSN (insn) = NULL;
1441 /* In case the function was not output,
1442 don't leave any temporary anonymous types
1443 queued up for sdb output. */
1444 #ifdef SDB_DEBUGGING_INFO
1445 if (write_symbols == SDB_DEBUG)
1446 sdbout_types (NULL_TREE);
1449 reload_completed = 0;
1450 epilogue_completed = 0;
1451 flow2_completed = 0;
1454 timevar_push (TV_FINAL);
1456 /* Clear out the insn_length contents now that they are no
1458 init_insn_lengths ();
1460 /* Show no temporary slots allocated. */
1463 free_basic_block_vars ();
1464 free_bb_for_insn ();
1466 timevar_pop (TV_FINAL);
1468 if (targetm.binds_local_p (current_function_decl))
1470 int pref = cfun->preferred_stack_boundary;
1471 if (cfun->stack_alignment_needed > cfun->preferred_stack_boundary)
1472 pref = cfun->stack_alignment_needed;
1473 cgraph_rtl_info (current_function_decl)->preferred_incoming_stack_boundary
1477 /* Make sure volatile mem refs aren't considered valid operands for
1478 arithmetic insns. We must call this here if this is a nested inline
1479 function, since the above code leaves us in the init_recog state
1480 (from final.c), and the function context push/pop code does not
1481 save/restore volatile_ok.
1483 ??? Maybe it isn't necessary for expand_start_function to call this
1484 anymore if we do it here? */
1486 init_recog_no_volatile ();
1488 /* We're done with this function. Free up memory if we can. */
1489 free_after_parsing (cfun);
1490 free_after_compilation (cfun);
1494 /* This function is called from the pass manager in tree-optimize.c
1495 after all tree passes have finished for a single function, and we
1496 have expanded the function body from trees to RTL.
1497 Once we are here, we have decided that we're supposed to output
1498 that function, i.e. that we should write assembler code for it.
1500 We run a series of low-level passes here on the function's RTL
1501 representation. Each pass is called via a rest_of_* function. */
1504 rest_of_compilation (void)
1506 /* If we're emitting a nested function, make sure its parent gets
1507 emitted as well. Doing otherwise confuses debug info. */
1510 for (parent = DECL_CONTEXT (current_function_decl);
1511 parent != NULL_TREE;
1512 parent = get_containing_scope (parent))
1513 if (TREE_CODE (parent) == FUNCTION_DECL)
1514 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
1517 /* We are now committed to emitting code for this function. Do any
1518 preparation, such as emitting abstract debug info for the inline
1519 before it gets mangled by optimization. */
1520 if (cgraph_function_possibly_inlined_p (current_function_decl))
1521 (*debug_hooks->outlining_inline_function) (current_function_decl);
1523 /* Remove any notes we don't need. That will make iterating
1524 over the instruction sequence faster, and allow the garbage
1525 collector to reclaim the memory used by the notes. */
1526 remove_unnecessary_notes ();
1528 /* Initialize some variables used by the optimizers. */
1529 init_function_for_compilation ();
1531 TREE_ASM_WRITTEN (current_function_decl) = 1;
1533 /* Early return if there were errors. We can run afoul of our
1534 consistency checks, and there's not really much point in fixing them. */
1535 if (rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount)
1536 goto exit_rest_of_compilation;
1538 rest_of_handle_jump ();
1540 rest_of_handle_eh ();
1542 /* Delay emitting hard_reg_initial_value sets until after EH landing pad
1543 generation, which might create new sets. */
1544 emit_initial_value_sets ();
1547 /* If we are doing position-independent code generation, now
1548 is the time to output special prologues and epilogues.
1549 We do not want to do this earlier, because it just clutters
1550 up inline functions with meaningless insns. */
1555 /* Copy any shared structure that should not be shared. */
1558 #ifdef SETJMP_VIA_SAVE_AREA
1559 /* This must be performed before virtual register instantiation.
1560 Please be aware that everything in the compiler that can look
1561 at the RTL up to this point must understand that REG_SAVE_AREA
1562 is just like a use of the REG contained inside. */
1563 if (current_function_calls_alloca)
1564 optimize_save_area_alloca ();
1567 /* Instantiate all virtual registers. */
1568 instantiate_virtual_regs ();
1570 rest_of_handle_jump2 ();
1573 rest_of_handle_cse ();
1578 rest_of_handle_gcse ();
1580 if (flag_loop_optimize)
1581 rest_of_handle_loop_optimize ();
1584 rest_of_handle_jump_bypass ();
1587 timevar_push (TV_FLOW);
1588 rest_of_handle_cfg ();
1590 if (!flag_tree_based_profiling
1591 && (optimize > 0 || profile_arc_flag
1592 || flag_test_coverage || flag_branch_probabilities))
1594 rtl_register_profile_hooks ();
1595 rtl_register_value_prof_hooks ();
1596 rest_of_handle_branch_prob ();
1598 if (flag_branch_probabilities
1599 && flag_profile_values
1600 && (flag_value_profile_transformations
1601 || flag_speculative_prefetching))
1602 rest_of_handle_value_profile_transformations ();
1604 /* Remove the death notes created for vpt. */
1605 if (flag_profile_values)
1606 count_or_remove_death_notes (NULL, 1);
1610 rest_of_handle_if_conversion ();
1612 if (optimize > 0 && flag_tracer)
1613 rest_of_handle_tracer ();
1616 && flag_loop_optimize2)
1617 rest_of_handle_loop2 ();
1619 if (optimize > 0 && flag_web)
1620 rest_of_handle_web ();
1622 if (optimize > 0 && flag_rerun_cse_after_loop)
1623 rest_of_handle_cse2 ();
1625 cse_not_expected = 1;
1627 rest_of_handle_life ();
1628 timevar_pop (TV_FLOW);
1631 rest_of_handle_combine ();
1633 if (optimize > 0 && flag_if_conversion)
1634 rest_of_handle_if_after_combine ();
1636 /* The optimization to partition hot/cold basic blocks into separate
1637 sections of the .o file does not work well with linkonce or with
1638 user defined section attributes. Don't call it if either case
1641 if (flag_reorder_blocks_and_partition
1642 && !DECL_ONE_ONLY (current_function_decl)
1643 && !user_defined_section_attribute)
1644 rest_of_handle_partition_blocks ();
1646 if (optimize > 0 && flag_regmove)
1647 rest_of_handle_regmove ();
1649 /* Do unconditional splitting before register allocation to allow machine
1650 description to add extra information not needed previously. */
1651 split_all_insns (1);
1653 #ifdef OPTIMIZE_MODE_SWITCHING
1654 rest_of_handle_mode_switching ();
1657 /* Any of the several passes since flow1 will have munged register
1658 lifetime data a bit. We need it to be up to date for scheduling
1659 (see handling of reg_known_equiv in init_alias_analysis). */
1660 recompute_reg_usage ();
1662 #ifdef INSN_SCHEDULING
1663 if (optimize > 0 && flag_modulo_sched)
1664 rest_of_handle_sms ();
1666 if (flag_schedule_insns)
1667 rest_of_handle_sched ();
1670 /* Determine if the current function is a leaf before running reload
1671 since this can impact optimizations done by the prologue and
1672 epilogue thus changing register elimination offsets. */
1673 current_function_is_leaf = leaf_function_p ();
1675 if (rest_of_handle_old_regalloc ())
1676 goto exit_rest_of_compilation;
1679 rest_of_handle_postreload ();
1681 if (optimize > 0 && flag_gcse_after_reload)
1682 rest_of_handle_gcse2 ();
1684 rest_of_handle_flow2 ();
1686 #ifdef HAVE_peephole2
1687 if (optimize > 0 && flag_peephole2)
1688 rest_of_handle_peephole2 ();
1692 rest_of_handle_if_after_reload ();
1696 if (flag_rename_registers || flag_cprop_registers)
1697 rest_of_handle_regrename ();
1699 rest_of_handle_reorder_blocks ();
1702 if (flag_branch_target_load_optimize2)
1703 rest_of_handle_branch_target_load_optimize ();
1705 #ifdef LEAF_REGISTERS
1706 current_function_uses_only_leaf_regs
1707 = optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
1710 #ifdef INSN_SCHEDULING
1711 if (optimize > 0 && flag_schedule_insns_after_reload)
1712 rest_of_handle_sched2 ();
1716 rest_of_handle_stack_regs ();
1719 compute_alignments ();
1721 /* Aggressively duplicate basic blocks ending in computed gotos to the
1722 tails of their predecessors, unless we are optimizing for size. */
1723 if (flag_expensive_optimizations && !optimize_size)
1724 duplicate_computed_gotos ();
1726 if (flag_var_tracking)
1727 rest_of_handle_variable_tracking ();
1729 /* CFG is no longer maintained up-to-date. */
1730 free_bb_for_insn ();
1732 if (targetm.machine_dependent_reorg != 0)
1733 rest_of_handle_machine_reorg ();
1735 purge_line_number_notes (get_insns ());
1736 cleanup_barriers ();
1739 if (flag_delayed_branch)
1740 rest_of_handle_delay_slots ();
1743 #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
1744 timevar_push (TV_SHORTEN_BRANCH);
1745 split_all_insns_noflow ();
1746 timevar_pop (TV_SHORTEN_BRANCH);
1749 convert_to_eh_region_ranges ();
1751 rest_of_handle_shorten_branches ();
1753 set_nothrow_function_flags ();
1755 rest_of_handle_final ();
1757 exit_rest_of_compilation:
1759 rest_of_clean_state ();
1763 finish_optimization_passes (void)
1765 enum tree_dump_index i;
1766 struct dump_file_info *dfi;
1769 timevar_push (TV_DUMP);
1770 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
1772 open_dump_file (DFI_bp, NULL);
1774 close_dump_file (DFI_bp, NULL, NULL_RTX);
1777 if (optimize > 0 && open_dump_file (DFI_combine, NULL))
1779 dump_combine_total_stats (dump_file);
1780 close_dump_file (DFI_combine, NULL, NULL_RTX);
1783 /* Do whatever is necessary to finish printing the graphs. */
1784 if (graph_dump_format != no_graph)
1785 for (i = DFI_MIN; (dfi = get_dump_file_info (i)) != NULL; ++i)
1786 if (dump_initialized_p (i)
1787 && (dfi->flags & TDF_RTL) != 0
1788 && (name = get_dump_file_name (i)) != NULL)
1790 finish_graph_dump_file (name);
1794 timevar_pop (TV_DUMP);
1797 struct tree_opt_pass pass_rest_of_compilation =
1801 rest_of_compilation, /* execute */
1804 0, /* static_pass_number */
1805 TV_REST_OF_COMPILATION, /* tv_id */
1806 PROP_rtl, /* properties_required */
1807 0, /* properties_provided */
1808 PROP_rtl, /* properties_destroyed */
1809 0, /* todo_flags_start */
1810 TODO_ggc_collect, /* todo_flags_finish */