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 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"
66 #include "diagnostic.h"
69 #include "dwarf2asm.h"
70 #include "integrate.h"
74 #include "langhooks.h"
75 #include "cfglayout.h"
77 #include "hosthooks.h"
81 #include "value-prof.h"
82 #include "alloc-pool.h"
83 #include "tree-pass.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 /* Describes a dump file. */
113 struct dump_file_info
115 /* The unique extension to apply, e.g. ".jump". */
116 const char *const extension
;
118 /* The -d<c> character that enables this dump file. */
119 char const debug_switch
;
121 /* True if there is a corresponding graph dump file. */
122 char const graph_dump_p
;
124 /* True if the user selected this dump. */
127 /* True if the files have been initialized (ie truncated). */
131 /* Enumerate the extant dump files. */
169 DFI_branch_target_load
,
178 /* Describes all the dump files. Should be kept in order of the
179 pass and in sync with dump_file_index above.
181 Remaining -d letters:
187 static struct dump_file_info dump_file_tbl
[DFI_MAX
] =
189 { "cgraph", 'U', 0, 0, 0 },
190 { "rtl", 'r', 0, 0, 0 },
191 { "sibling", 'i', 0, 0, 0 },
192 { "eh", 'h', 0, 0, 0 },
193 { "jump", 'j', 0, 0, 0 },
194 { "null", 'u', 0, 0, 0 },
195 { "cse", 's', 0, 0, 0 },
196 { "addressof", 'F', 0, 0, 0 },
197 { "gcse", 'G', 1, 0, 0 },
198 { "loop", 'L', 1, 0, 0 },
199 { "bypass", 'G', 1, 0, 0 }, /* Yes, duplicate enable switch. */
200 { "cfg", 'f', 1, 0, 0 },
201 { "bp", 'b', 1, 0, 0 },
202 { "vpt", 'V', 1, 0, 0 },
203 { "ce1", 'C', 1, 0, 0 },
204 { "tracer", 'T', 1, 0, 0 },
205 { "loop2", 'L', 1, 0, 0 },
206 { "web", 'Z', 0, 0, 0 },
207 { "cse2", 't', 1, 0, 0 },
208 { "life", 'f', 1, 0, 0 }, /* Yes, duplicate enable switch. */
209 { "combine", 'c', 1, 0, 0 },
210 { "ce2", 'C', 1, 0, 0 },
211 { "regmove", 'N', 1, 0, 0 },
212 { "sms", 'm', 0, 0, 0 },
213 { "sched", 'S', 1, 0, 0 },
214 { "lreg", 'l', 1, 0, 0 },
215 { "greg", 'g', 1, 0, 0 },
216 { "postreload", 'o', 1, 0, 0 },
217 { "gcse2", 'J', 0, 0, 0 },
218 { "flow2", 'w', 1, 0, 0 },
219 { "peephole2", 'z', 1, 0, 0 },
220 { "ce3", 'E', 1, 0, 0 },
221 { "rnreg", 'n', 1, 0, 0 },
222 { "bbro", 'B', 1, 0, 0 },
223 { "btl", 'd', 1, 0, 0 }, /* Yes, duplicate enable switch. */
224 { "sched2", 'R', 1, 0, 0 },
225 { "stack", 'k', 1, 0, 0 },
226 { "vartrack", 'V', 1, 0, 0 }, /* Yes, duplicate enable switch. */
227 { "mach", 'M', 1, 0, 0 },
228 { "dbr", 'd', 0, 0, 0 },
231 /* Routine to open a dump file. Return true if the dump file is enabled. */
234 open_dump_file (enum dump_file_index index
, tree decl
)
237 const char *open_arg
;
240 if (! dump_file_tbl
[index
].enabled
)
243 timevar_push (TV_DUMP
);
244 if (dump_file
!= NULL
)
247 sprintf (seq
, DUMPFILE_FORMAT
, index
);
249 if (! dump_file_tbl
[index
].initialized
)
251 /* If we've not initialized the files, do so now. */
252 if (graph_dump_format
!= no_graph
253 && dump_file_tbl
[index
].graph_dump_p
)
255 dump_name
= concat (seq
, dump_file_tbl
[index
].extension
, NULL
);
256 clean_graph_dump_file (dump_base_name
, dump_name
);
259 dump_file_tbl
[index
].initialized
= 1;
265 dump_name
= concat (dump_base_name
, seq
,
266 dump_file_tbl
[index
].extension
, NULL
);
268 dump_file
= fopen (dump_name
, open_arg
);
269 if (dump_file
== NULL
)
270 fatal_error ("can't open %s: %m", dump_name
);
275 fprintf (dump_file
, "\n;; Function %s%s\n\n",
276 lang_hooks
.decl_printable_name (decl
, 2),
277 cfun
->function_frequency
== FUNCTION_FREQUENCY_HOT
279 : cfun
->function_frequency
== FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
280 ? " (unlikely executed)"
283 timevar_pop (TV_DUMP
);
287 /* Routine to close a dump file. */
290 close_dump_file (enum dump_file_index index
,
291 void (*func
) (FILE *, rtx
),
297 timevar_push (TV_DUMP
);
299 && graph_dump_format
!= no_graph
300 && dump_file_tbl
[index
].graph_dump_p
)
305 sprintf (seq
, DUMPFILE_FORMAT
, index
);
306 suffix
= concat (seq
, dump_file_tbl
[index
].extension
, NULL
);
307 print_rtl_graph_with_bb (dump_base_name
, suffix
, insns
);
312 func (dump_file
, insns
);
318 timevar_pop (TV_DUMP
);
321 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
324 This does nothing for local (non-static) variables, unless the
325 variable is a register variable with an ASMSPEC. In that case, or
326 if the variable is not an automatic, it sets up the RTL and
327 outputs any assembler code (label definition, storage allocation
330 DECL is the declaration. If ASMSPEC is nonzero, it specifies
331 the assembler symbol name to be used. TOP_LEVEL is nonzero
332 if this declaration is not within a function. */
335 rest_of_decl_compilation (tree decl
,
340 /* We deferred calling assemble_alias so that we could collect
341 other attributes such as visibility. Emit the alias now. */
344 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
347 alias
= TREE_VALUE (TREE_VALUE (alias
));
348 alias
= get_identifier (TREE_STRING_POINTER (alias
));
349 assemble_alias (decl
, alias
);
353 /* Forward declarations for nested functions are not "external",
354 but we need to treat them as if they were. */
355 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
356 || TREE_CODE (decl
) == FUNCTION_DECL
)
358 timevar_push (TV_VARCONST
);
361 make_decl_rtl (decl
, asmspec
);
363 /* Don't output anything when a tentative file-scope definition
364 is seen. But at end of compilation, do output code for them.
366 We do output all variables when unit-at-a-time is active and rely on
367 callgraph code to defer them except for forward declarations
368 (see gcc.c-torture/compile/920624-1.c) */
370 || !DECL_DEFER_OUTPUT (decl
)
371 || (flag_unit_at_a_time
&& DECL_INITIAL (decl
)))
372 && !DECL_EXTERNAL (decl
))
374 if (flag_unit_at_a_time
&& !cgraph_global_info_ready
375 && TREE_CODE (decl
) != FUNCTION_DECL
&& top_level
)
376 cgraph_varpool_finalize_decl (decl
);
378 assemble_variable (decl
, top_level
, at_end
, 0);
381 #ifdef ASM_FINISH_DECLARE_OBJECT
382 if (decl
== last_assemble_variable_decl
)
384 ASM_FINISH_DECLARE_OBJECT (asm_out_file
, decl
,
389 timevar_pop (TV_VARCONST
);
391 else if (DECL_REGISTER (decl
) && asmspec
!= 0)
393 if (decode_reg_name (asmspec
) >= 0)
395 SET_DECL_RTL (decl
, NULL_RTX
);
396 make_decl_rtl (decl
, asmspec
);
400 error ("%Hinvalid register name `%s' for register variable",
401 &DECL_SOURCE_LOCATION (decl
), asmspec
);
402 DECL_REGISTER (decl
) = 0;
407 else if (TREE_CODE (decl
) == TYPE_DECL
)
409 timevar_push (TV_SYMOUT
);
410 debug_hooks
->type_decl (decl
, !top_level
);
411 timevar_pop (TV_SYMOUT
);
415 /* Called after finishing a record, union or enumeral type. */
418 rest_of_type_compilation (tree type
, int toplev
)
420 /* Avoid confusing the debug information machinery when there are
422 if (errorcount
!= 0 || sorrycount
!= 0)
425 timevar_push (TV_SYMOUT
);
426 debug_hooks
->type_decl (TYPE_STUB_DECL (type
), !toplev
);
427 timevar_pop (TV_SYMOUT
);
430 /* Turn the RTL into assembly. */
432 rest_of_handle_final (void)
434 timevar_push (TV_FINAL
);
439 /* Get the function's name, as described by its RTL. This may be
440 different from the DECL_NAME name used in the source file. */
442 x
= DECL_RTL (current_function_decl
);
446 if (GET_CODE (x
) != SYMBOL_REF
)
448 fnname
= XSTR (x
, 0);
450 assemble_start_function (current_function_decl
, fnname
);
451 final_start_function (get_insns (), asm_out_file
, optimize
);
452 final (get_insns (), asm_out_file
, optimize
, 0);
453 final_end_function ();
455 #ifdef IA64_UNWIND_INFO
456 /* ??? The IA-64 ".handlerdata" directive must be issued before
457 the ".endp" directive that closes the procedure descriptor. */
458 output_function_exception_table ();
461 assemble_end_function (current_function_decl
, fnname
);
463 #ifndef IA64_UNWIND_INFO
464 /* Otherwise, it feels unclean to switch sections in the middle. */
465 output_function_exception_table ();
469 fflush (asm_out_file
);
471 /* Release all memory allocated by flow. */
472 free_basic_block_vars ();
474 /* Release all memory held by regsets now. */
475 regset_release_memory ();
477 timevar_pop (TV_FINAL
);
483 /* Run delay slot optimization. */
485 rest_of_handle_delay_slots (void)
487 timevar_push (TV_DBR_SCHED
);
488 open_dump_file (DFI_dbr
, current_function_decl
);
490 dbr_schedule (get_insns (), dump_file
);
492 close_dump_file (DFI_dbr
, print_rtl
, get_insns ());
493 timevar_pop (TV_DBR_SCHED
);
500 /* Convert register usage from flat register file usage to a stack
503 rest_of_handle_stack_regs (void)
505 #if defined (HAVE_ATTR_length)
506 /* If flow2 creates new instructions which need splitting
507 and scheduling after reload is not done, they might not be
508 split until final which doesn't allow splitting
509 if HAVE_ATTR_length. */
510 #ifdef INSN_SCHEDULING
511 if (optimize
&& !flag_schedule_insns_after_reload
)
516 timevar_push (TV_SHORTEN_BRANCH
);
518 timevar_pop (TV_SHORTEN_BRANCH
);
522 timevar_push (TV_REG_STACK
);
523 open_dump_file (DFI_stack
, current_function_decl
);
525 if (reg_to_stack (dump_file
) && optimize
)
527 if (cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_POST_REGSTACK
528 | (flag_crossjumping
? CLEANUP_CROSSJUMP
: 0))
529 && (flag_reorder_blocks
|| flag_reorder_blocks_and_partition
))
531 reorder_basic_blocks ();
532 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_POST_REGSTACK
);
536 close_dump_file (DFI_stack
, print_rtl_with_bb
, get_insns ());
537 timevar_pop (TV_REG_STACK
);
543 /* Track the variables, ie. compute where the variable is stored at each position in function. */
545 rest_of_handle_variable_tracking (void)
547 timevar_push (TV_VAR_TRACKING
);
548 open_dump_file (DFI_vartrack
, current_function_decl
);
550 variable_tracking_main ();
552 close_dump_file (DFI_vartrack
, print_rtl_with_bb
, get_insns ());
553 timevar_pop (TV_VAR_TRACKING
);
556 /* Machine independent reorg pass. */
558 rest_of_handle_machine_reorg (void)
560 timevar_push (TV_MACH_DEP
);
561 open_dump_file (DFI_mach
, current_function_decl
);
563 targetm
.machine_dependent_reorg ();
565 close_dump_file (DFI_mach
, print_rtl
, get_insns ());
566 timevar_pop (TV_MACH_DEP
);
572 /* Run new register allocator. Return TRUE if we must exit
573 rest_of_compilation upon return. */
575 rest_of_handle_new_regalloc (void)
579 delete_trivially_dead_insns (get_insns (), max_reg_num ());
582 timevar_pop (TV_LOCAL_ALLOC
);
583 if (dump_file_tbl
[DFI_lreg
].enabled
)
585 timevar_push (TV_DUMP
);
587 close_dump_file (DFI_lreg
, NULL
, NULL
);
588 timevar_pop (TV_DUMP
);
591 /* XXX clean up the whole mess to bring live info in shape again. */
592 timevar_push (TV_GLOBAL_ALLOC
);
593 open_dump_file (DFI_greg
, current_function_decl
);
595 build_insn_chain (get_insns ());
596 failure
= reload (get_insns (), 0);
598 timevar_pop (TV_GLOBAL_ALLOC
);
600 if (dump_file_tbl
[DFI_greg
].enabled
)
602 timevar_push (TV_DUMP
);
604 dump_global_regs (dump_file
);
606 close_dump_file (DFI_greg
, print_rtl_with_bb
, get_insns ());
607 timevar_pop (TV_DUMP
);
613 reload_completed
= 1;
618 /* Run old register allocator. Return TRUE if we must exit
619 rest_of_compilation upon return. */
621 rest_of_handle_old_regalloc (void)
626 /* Allocate the reg_renumber array. */
627 allocate_reg_info (max_regno
, FALSE
, TRUE
);
629 /* And the reg_equiv_memory_loc array. */
630 VARRAY_GROW (reg_equiv_memory_loc_varray
, max_regno
);
631 reg_equiv_memory_loc
= &VARRAY_RTX (reg_equiv_memory_loc_varray
, 0);
633 allocate_initial_values (reg_equiv_memory_loc
);
635 regclass (get_insns (), max_reg_num (), dump_file
);
636 rebuild_notes
= local_alloc ();
638 timevar_pop (TV_LOCAL_ALLOC
);
640 /* Local allocation may have turned an indirect jump into a direct
641 jump. If so, we must rebuild the JUMP_LABEL fields of jumping
645 timevar_push (TV_JUMP
);
647 rebuild_jump_labels (get_insns ());
648 purge_all_dead_edges (0);
650 timevar_pop (TV_JUMP
);
653 if (dump_file_tbl
[DFI_lreg
].enabled
)
655 timevar_push (TV_DUMP
);
657 dump_flow_info (dump_file
);
658 dump_local_alloc (dump_file
);
660 close_dump_file (DFI_lreg
, print_rtl_with_bb
, get_insns ());
661 timevar_pop (TV_DUMP
);
666 timevar_push (TV_GLOBAL_ALLOC
);
667 open_dump_file (DFI_greg
, current_function_decl
);
669 /* If optimizing, allocate remaining pseudo-regs. Do the reload
670 pass fixing up any insns that are invalid. */
673 failure
= global_alloc (dump_file
);
676 build_insn_chain (get_insns ());
677 failure
= reload (get_insns (), 0);
680 timevar_pop (TV_GLOBAL_ALLOC
);
682 if (dump_file_tbl
[DFI_greg
].enabled
)
684 timevar_push (TV_DUMP
);
686 dump_global_regs (dump_file
);
688 close_dump_file (DFI_greg
, print_rtl_with_bb
, get_insns ());
689 timevar_pop (TV_DUMP
);
695 /* Run the regrename and cprop passes. */
697 rest_of_handle_regrename (void)
699 timevar_push (TV_RENAME_REGISTERS
);
700 open_dump_file (DFI_rnreg
, current_function_decl
);
702 if (flag_rename_registers
)
703 regrename_optimize ();
704 if (flag_cprop_registers
)
705 copyprop_hardreg_forward ();
707 close_dump_file (DFI_rnreg
, print_rtl_with_bb
, get_insns ());
708 timevar_pop (TV_RENAME_REGISTERS
);
711 /* Reorder basic blocks. */
713 rest_of_handle_reorder_blocks (void)
716 open_dump_file (DFI_bbro
, current_function_decl
);
718 /* Last attempt to optimize CFG, as scheduling, peepholing and insn
719 splitting possibly introduced more crossjumping opportunities. */
720 changed
= cleanup_cfg (CLEANUP_EXPENSIVE
721 | (!HAVE_conditional_execution
722 ? CLEANUP_UPDATE_LIFE
: 0));
724 if (flag_sched2_use_traces
&& flag_schedule_insns_after_reload
)
726 if (flag_reorder_blocks
|| flag_reorder_blocks_and_partition
)
727 reorder_basic_blocks ();
728 if (flag_reorder_blocks
|| flag_reorder_blocks_and_partition
729 || (flag_sched2_use_traces
&& flag_schedule_insns_after_reload
))
730 changed
|= cleanup_cfg (CLEANUP_EXPENSIVE
731 | (!HAVE_conditional_execution
732 ? CLEANUP_UPDATE_LIFE
: 0));
734 /* On conditional execution targets we can not update the life cheaply, so
735 we deffer the updating to after both cleanups. This may lose some cases
736 but should not be terribly bad. */
737 if (changed
&& HAVE_conditional_execution
)
738 update_life_info (NULL
, UPDATE_LIFE_GLOBAL_RM_NOTES
,
740 close_dump_file (DFI_bbro
, print_rtl_with_bb
, get_insns ());
743 #ifdef INSN_SCHEDULING
744 /* Run instruction scheduler. */
746 rest_of_handle_sched (void)
748 timevar_push (TV_SMS
);
749 if (optimize
> 0 && flag_modulo_sched
)
752 /* Perform SMS module scheduling. */
753 open_dump_file (DFI_sms
, current_function_decl
);
755 /* We want to be able to create new pseudos. */
757 sms_schedule (dump_file
);
758 close_dump_file (DFI_sms
, print_rtl
, get_insns ());
761 /* Update the life information, because we add pseudos. */
762 max_regno
= max_reg_num ();
763 allocate_reg_info (max_regno
, FALSE
, FALSE
);
764 update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES
,
766 | PROP_KILL_DEAD_CODE
767 | PROP_SCAN_DEAD_CODE
));
770 timevar_pop (TV_SMS
);
771 timevar_push (TV_SCHED
);
773 /* Print function header into sched dump now
774 because doing the sched analysis makes some of the dump. */
775 if (optimize
> 0 && flag_schedule_insns
)
777 open_dump_file (DFI_sched
, current_function_decl
);
779 /* Do control and data sched analysis,
780 and write some of the results to dump file. */
782 schedule_insns (dump_file
);
784 close_dump_file (DFI_sched
, print_rtl_with_bb
, get_insns ());
786 timevar_pop (TV_SCHED
);
791 /* Run second scheduling pass after reload. */
793 rest_of_handle_sched2 (void)
795 timevar_push (TV_SCHED2
);
796 open_dump_file (DFI_sched2
, current_function_decl
);
798 /* Do control and data sched analysis again,
799 and write some more of the results to dump file. */
803 if (flag_sched2_use_superblocks
|| flag_sched2_use_traces
)
805 schedule_ebbs (dump_file
);
806 /* No liveness updating code yet, but it should be easy to do.
807 reg-stack recomputes the liveness when needed for now. */
808 count_or_remove_death_notes (NULL
, 1);
809 cleanup_cfg (CLEANUP_EXPENSIVE
);
812 schedule_insns (dump_file
);
814 close_dump_file (DFI_sched2
, print_rtl_with_bb
, get_insns ());
815 timevar_pop (TV_SCHED2
);
822 rest_of_handle_gcse2 (void)
824 open_dump_file (DFI_gcse2
, current_function_decl
);
826 gcse_after_reload_main (get_insns (), dump_file
);
827 rebuild_jump_labels (get_insns ());
828 delete_trivially_dead_insns (get_insns (), max_reg_num ());
829 close_dump_file (DFI_gcse2
, print_rtl_with_bb
, get_insns ());
833 #ifdef ENABLE_CHECKING
838 /* Register allocation pre-pass, to reduce number of moves necessary
839 for two-address machines. */
841 rest_of_handle_regmove (void)
843 timevar_push (TV_REGMOVE
);
844 open_dump_file (DFI_regmove
, current_function_decl
);
846 regmove_optimize (get_insns (), max_reg_num (), dump_file
);
848 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_UPDATE_LIFE
);
849 close_dump_file (DFI_regmove
, print_rtl_with_bb
, get_insns ());
850 timevar_pop (TV_REGMOVE
);
857 rest_of_handle_tracer (void)
859 open_dump_file (DFI_tracer
, current_function_decl
);
861 dump_flow_info (dump_file
);
863 cleanup_cfg (CLEANUP_EXPENSIVE
);
864 reg_scan (get_insns (), max_reg_num (), 0);
865 close_dump_file (DFI_tracer
, print_rtl_with_bb
, get_insns ());
868 /* If-conversion and CFG cleanup. */
870 rest_of_handle_if_conversion (void)
872 open_dump_file (DFI_ce1
, current_function_decl
);
873 if (flag_if_conversion
)
875 timevar_push (TV_IFCVT
);
877 dump_flow_info (dump_file
);
878 cleanup_cfg (CLEANUP_EXPENSIVE
);
879 reg_scan (get_insns (), max_reg_num (), 0);
881 timevar_pop (TV_IFCVT
);
883 timevar_push (TV_JUMP
);
884 cleanup_cfg (CLEANUP_EXPENSIVE
);
885 reg_scan (get_insns (), max_reg_num (), 0);
886 timevar_pop (TV_JUMP
);
887 close_dump_file (DFI_ce1
, print_rtl_with_bb
, get_insns ());
890 /* Rerun if-conversion, as combine may have simplified things enough
891 to now meet sequence length restrictions. */
893 rest_of_handle_if_after_combine (void)
895 timevar_push (TV_IFCVT
);
896 open_dump_file (DFI_ce2
, current_function_decl
);
902 close_dump_file (DFI_ce2
, print_rtl_with_bb
, get_insns ());
903 timevar_pop (TV_IFCVT
);
907 rest_of_handle_web (void)
909 open_dump_file (DFI_web
, current_function_decl
);
910 timevar_push (TV_WEB
);
912 delete_trivially_dead_insns (get_insns (), max_reg_num ());
913 cleanup_cfg (CLEANUP_EXPENSIVE
);
915 timevar_pop (TV_WEB
);
916 close_dump_file (DFI_web
, print_rtl_with_bb
, get_insns ());
917 reg_scan (get_insns (), max_reg_num (), 0);
920 /* Do branch profiling and static profile estimation passes. */
922 rest_of_handle_branch_prob (void)
925 timevar_push (TV_BRANCH_PROB
);
926 open_dump_file (DFI_bp
, current_function_decl
);
928 if (profile_arc_flag
|| flag_test_coverage
|| flag_branch_probabilities
)
931 /* Discover and record the loop depth at the head of each basic
932 block. The loop infrastructure does the real job for us. */
933 flow_loops_find (&loops
, LOOP_TREE
);
936 flow_loops_dump (&loops
, dump_file
, NULL
, 0);
938 /* Estimate using heuristics if no profiling info is available. */
939 if (flag_guess_branch_prob
)
940 estimate_probability (&loops
);
942 flow_loops_free (&loops
);
943 free_dominance_info (CDI_DOMINATORS
);
944 close_dump_file (DFI_bp
, print_rtl_with_bb
, get_insns ());
945 timevar_pop (TV_BRANCH_PROB
);
948 /* Do optimizations based on expression value profiles. */
950 rest_of_handle_value_profile_transformations (void)
952 open_dump_file (DFI_vpt
, current_function_decl
);
953 timevar_push (TV_VPT
);
955 if (value_profile_transformations ())
956 cleanup_cfg (CLEANUP_EXPENSIVE
);
958 timevar_pop (TV_VPT
);
959 close_dump_file (DFI_vpt
, print_rtl_with_bb
, get_insns ());
962 /* Do control and data flow analysis; write some of the results to the
965 rest_of_handle_cfg (void)
967 open_dump_file (DFI_cfg
, current_function_decl
);
969 dump_flow_info (dump_file
);
971 cleanup_cfg (CLEANUP_EXPENSIVE
972 | (flag_thread_jumps
? CLEANUP_THREADING
: 0));
974 /* It may make more sense to mark constant functions after dead code is
975 eliminated by life_analysis, but we need to do it early, as -fprofile-arcs
976 may insert code making function non-constant, but we still must consider
977 it as constant, otherwise -fbranch-probabilities will not read data back.
979 life_analysis rarely eliminates modification of external memory.
983 /* Alias analysis depends on this information and mark_constant_function
984 depends on alias analysis. */
985 reg_scan (get_insns (), max_reg_num (), 1);
986 mark_constant_function ();
989 close_dump_file (DFI_cfg
, print_rtl_with_bb
, get_insns ());
992 /* Purge addressofs. */
994 rest_of_handle_addressof (void)
996 open_dump_file (DFI_addressof
, current_function_decl
);
998 purge_addressof (get_insns ());
999 if (optimize
&& purge_all_dead_edges (0))
1000 delete_unreachable_blocks ();
1001 reg_scan (get_insns (), max_reg_num (), 1);
1003 close_dump_file (DFI_addressof
, print_rtl
, get_insns ());
1006 /* Perform jump bypassing and control flow optimizations. */
1008 rest_of_handle_jump_bypass (void)
1010 timevar_push (TV_BYPASS
);
1011 open_dump_file (DFI_bypass
, current_function_decl
);
1013 cleanup_cfg (CLEANUP_EXPENSIVE
);
1014 reg_scan (get_insns (), max_reg_num (), 1);
1016 if (bypass_jumps (dump_file
))
1018 rebuild_jump_labels (get_insns ());
1019 cleanup_cfg (CLEANUP_EXPENSIVE
);
1020 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1023 close_dump_file (DFI_bypass
, print_rtl_with_bb
, get_insns ());
1024 timevar_pop (TV_BYPASS
);
1028 #ifdef ENABLE_CHECKING
1029 verify_flow_info ();
1033 /* Try combining insns through substitution. */
1035 rest_of_handle_combine (void)
1037 int rebuild_jump_labels_after_combine
= 0;
1039 timevar_push (TV_COMBINE
);
1040 open_dump_file (DFI_combine
, current_function_decl
);
1042 rebuild_jump_labels_after_combine
1043 = combine_instructions (get_insns (), max_reg_num ());
1045 /* Combining get_insns () may have turned an indirect jump into a
1046 direct jump. Rebuild the JUMP_LABEL fields of jumping
1048 if (rebuild_jump_labels_after_combine
)
1050 timevar_push (TV_JUMP
);
1051 rebuild_jump_labels (get_insns ());
1052 timevar_pop (TV_JUMP
);
1054 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_UPDATE_LIFE
);
1057 close_dump_file (DFI_combine
, print_rtl_with_bb
, get_insns ());
1058 timevar_pop (TV_COMBINE
);
1063 /* Perform life analysis. */
1065 rest_of_handle_life (void)
1067 open_dump_file (DFI_life
, current_function_decl
);
1070 #ifdef ENABLE_CHECKING
1071 verify_flow_info ();
1073 life_analysis (dump_file
, PROP_FINAL
);
1075 cleanup_cfg ((optimize
? CLEANUP_EXPENSIVE
: 0) | CLEANUP_UPDATE_LIFE
1077 | (flag_thread_jumps
? CLEANUP_THREADING
: 0));
1078 timevar_pop (TV_FLOW
);
1082 setjmp_vars_warning (DECL_INITIAL (current_function_decl
));
1083 setjmp_args_warning ();
1088 if (!flag_new_regalloc
&& initialize_uninitialized_subregs ())
1090 /* Insns were inserted, and possibly pseudos created, so
1091 things might look a bit different. */
1092 allocate_reg_life_data ();
1093 update_life_info (NULL
, UPDATE_LIFE_GLOBAL_RM_NOTES
,
1094 PROP_LOG_LINKS
| PROP_REG_INFO
| PROP_DEATH_NOTES
);
1100 close_dump_file (DFI_life
, print_rtl_with_bb
, get_insns ());
1105 /* Perform common subexpression elimination. Nonzero value from
1106 `cse_main' means that jumps were simplified and some code may now
1107 be unreachable, so do jump optimization again. */
1109 rest_of_handle_cse (void)
1112 open_dump_file (DFI_cse
, current_function_decl
);
1114 dump_flow_info (dump_file
);
1115 timevar_push (TV_CSE
);
1117 reg_scan (get_insns (), max_reg_num (), 1);
1119 tem
= cse_main (get_insns (), max_reg_num (), 0, dump_file
);
1121 rebuild_jump_labels (get_insns ());
1122 if (purge_all_dead_edges (0))
1123 delete_unreachable_blocks ();
1125 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1127 /* If we are not running more CSE passes, then we are no longer
1128 expecting CSE to be run. But always rerun it in a cheap mode. */
1129 cse_not_expected
= !flag_rerun_cse_after_loop
&& !flag_gcse
;
1131 if (tem
|| optimize
> 1)
1132 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_PRE_LOOP
);
1134 timevar_pop (TV_CSE
);
1135 close_dump_file (DFI_cse
, print_rtl_with_bb
, get_insns ());
1138 /* Run second CSE pass after loop optimizations. */
1140 rest_of_handle_cse2 (void)
1143 timevar_push (TV_CSE2
);
1144 open_dump_file (DFI_cse2
, current_function_decl
);
1146 dump_flow_info (dump_file
);
1147 /* CFG is no longer maintained up-to-date. */
1148 tem
= cse_main (get_insns (), max_reg_num (), 1, dump_file
);
1150 /* Run a pass to eliminate duplicated assignments to condition code
1151 registers. We have to run this after bypass_jumps, because it
1152 makes it harder for that pass to determine whether a jump can be
1154 cse_condition_code_reg ();
1156 purge_all_dead_edges (0);
1157 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1161 timevar_push (TV_JUMP
);
1162 rebuild_jump_labels (get_insns ());
1163 cleanup_cfg (CLEANUP_EXPENSIVE
);
1164 timevar_pop (TV_JUMP
);
1166 reg_scan (get_insns (), max_reg_num (), 0);
1167 close_dump_file (DFI_cse2
, print_rtl_with_bb
, get_insns ());
1169 timevar_pop (TV_CSE2
);
1172 /* Perform global cse. */
1174 rest_of_handle_gcse (void)
1176 int save_csb
, save_cfj
;
1178 timevar_push (TV_GCSE
);
1179 open_dump_file (DFI_gcse
, current_function_decl
);
1181 tem
= gcse_main (get_insns (), dump_file
);
1182 rebuild_jump_labels (get_insns ());
1183 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1185 save_csb
= flag_cse_skip_blocks
;
1186 save_cfj
= flag_cse_follow_jumps
;
1187 flag_cse_skip_blocks
= flag_cse_follow_jumps
= 0;
1189 /* If -fexpensive-optimizations, re-run CSE to clean up things done
1191 if (flag_expensive_optimizations
)
1193 timevar_push (TV_CSE
);
1194 reg_scan (get_insns (), max_reg_num (), 1);
1195 tem2
= cse_main (get_insns (), max_reg_num (), 0, dump_file
);
1196 purge_all_dead_edges (0);
1197 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1198 timevar_pop (TV_CSE
);
1199 cse_not_expected
= !flag_rerun_cse_after_loop
;
1202 /* If gcse or cse altered any jumps, rerun jump optimizations to clean
1203 things up. Then possibly re-run CSE again. */
1207 timevar_push (TV_JUMP
);
1208 rebuild_jump_labels (get_insns ());
1209 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_PRE_LOOP
);
1210 timevar_pop (TV_JUMP
);
1212 if (flag_expensive_optimizations
)
1214 timevar_push (TV_CSE
);
1215 reg_scan (get_insns (), max_reg_num (), 1);
1216 tem2
= cse_main (get_insns (), max_reg_num (), 0, dump_file
);
1217 purge_all_dead_edges (0);
1218 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1219 timevar_pop (TV_CSE
);
1223 close_dump_file (DFI_gcse
, print_rtl_with_bb
, get_insns ());
1224 timevar_pop (TV_GCSE
);
1227 flag_cse_skip_blocks
= save_csb
;
1228 flag_cse_follow_jumps
= save_cfj
;
1229 #ifdef ENABLE_CHECKING
1230 verify_flow_info ();
1234 /* Move constant computations out of loops. */
1236 rest_of_handle_loop_optimize (void)
1238 int do_unroll
, do_prefetch
;
1240 timevar_push (TV_LOOP
);
1241 delete_dead_jumptables ();
1242 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_PRE_LOOP
);
1243 open_dump_file (DFI_loop
, current_function_decl
);
1245 /* CFG is no longer maintained up-to-date. */
1246 free_bb_for_insn ();
1248 if (flag_unroll_loops
)
1249 do_unroll
= LOOP_AUTO_UNROLL
; /* Having two unrollers is useless. */
1251 do_unroll
= flag_old_unroll_loops
? LOOP_UNROLL
: LOOP_AUTO_UNROLL
;
1252 do_prefetch
= flag_prefetch_loop_arrays
? LOOP_PREFETCH
: 0;
1254 if (flag_rerun_loop_opt
)
1256 cleanup_barriers ();
1258 /* We only want to perform unrolling once. */
1259 loop_optimize (get_insns (), dump_file
, do_unroll
);
1262 /* The first call to loop_optimize makes some instructions
1263 trivially dead. We delete those instructions now in the
1264 hope that doing so will make the heuristics in loop work
1265 better and possibly speed up compilation. */
1266 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1268 /* The regscan pass is currently necessary as the alias
1269 analysis code depends on this information. */
1270 reg_scan (get_insns (), max_reg_num (), 1);
1272 cleanup_barriers ();
1273 loop_optimize (get_insns (), dump_file
, do_unroll
| do_prefetch
);
1275 /* Loop can create trivially dead instructions. */
1276 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1277 close_dump_file (DFI_loop
, print_rtl
, get_insns ());
1278 timevar_pop (TV_LOOP
);
1279 find_basic_blocks (get_insns (), max_reg_num (), dump_file
);
1284 /* Perform loop optimizations. It might be better to do them a bit
1285 sooner, but we want the profile feedback to work more
1288 rest_of_handle_loop2 (void)
1290 struct loops
*loops
;
1293 if (!flag_move_loop_invariants
1294 && !flag_unswitch_loops
1296 && !flag_unroll_loops
1297 && !flag_branch_on_count_reg
)
1300 timevar_push (TV_LOOP
);
1301 open_dump_file (DFI_loop2
, current_function_decl
);
1303 dump_flow_info (dump_file
);
1305 /* Initialize structures for layout changes. */
1306 cfg_layout_initialize ();
1308 loops
= loop_optimizer_init (dump_file
);
1312 /* The optimizations: */
1313 if (flag_move_loop_invariants
)
1314 move_loop_invariants (loops
);
1316 if (flag_unswitch_loops
)
1317 unswitch_loops (loops
);
1319 if (flag_peel_loops
|| flag_unroll_loops
)
1320 unroll_and_peel_loops (loops
,
1321 (flag_peel_loops
? UAP_PEEL
: 0) |
1322 (flag_unroll_loops
? UAP_UNROLL
: 0) |
1323 (flag_unroll_all_loops
? UAP_UNROLL_ALL
: 0));
1325 #ifdef HAVE_doloop_end
1326 if (flag_branch_on_count_reg
&& HAVE_doloop_end
)
1327 doloop_optimize_loops (loops
);
1328 #endif /* HAVE_doloop_end */
1330 loop_optimizer_finalize (loops
, dump_file
);
1333 /* Finalize layout changes. */
1335 if (bb
->next_bb
!= EXIT_BLOCK_PTR
)
1336 bb
->rbi
->next
= bb
->next_bb
;
1337 cfg_layout_finalize ();
1339 cleanup_cfg (CLEANUP_EXPENSIVE
);
1340 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1341 reg_scan (get_insns (), max_reg_num (), 0);
1343 dump_flow_info (dump_file
);
1344 close_dump_file (DFI_loop2
, print_rtl_with_bb
, get_insns ());
1345 timevar_pop (TV_LOOP
);
1349 /* This is called from finish_function (within langhooks.parse_file)
1350 after each top-level definition is parsed.
1351 It is supposed to compile that function or variable
1352 and output the assembler code for it.
1353 After we return, the tree storage is freed. */
1356 rest_of_compilation (void)
1358 /* There's no need to defer outputting this function any more; we
1359 know we want to output it. */
1360 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
1362 /* There's no need to defer outputting this function any more; we
1363 know we want to output it. */
1364 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
1366 /* Register rtl specific functions for cfg. */
1367 rtl_register_cfg_hooks ();
1369 /* Now that we're out of the frontend, we shouldn't have any more
1370 CONCATs anywhere. */
1371 generating_concat_p
= 0;
1373 /* When processing delayed functions, prepare_function_start() won't
1374 have been run to re-initialize it. */
1375 cse_not_expected
= ! optimize
;
1377 finalize_block_changes ();
1379 /* Dump the rtl code if we are dumping rtl. */
1380 if (open_dump_file (DFI_rtl
, current_function_decl
))
1381 close_dump_file (DFI_rtl
, print_rtl
, get_insns ());
1383 /* Convert from NOTE_INSN_EH_REGION style notes, and do other
1384 sorts of eh initialization. Delay this until after the
1385 initial rtl dump so that we can see the original nesting. */
1386 convert_from_eh_region_ranges ();
1388 /* If we're emitting a nested function, make sure its parent gets
1389 emitted as well. Doing otherwise confuses debug info. */
1392 for (parent
= DECL_CONTEXT (current_function_decl
);
1393 parent
!= NULL_TREE
;
1394 parent
= get_containing_scope (parent
))
1395 if (TREE_CODE (parent
) == FUNCTION_DECL
)
1396 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
1399 /* We are now committed to emitting code for this function. Do any
1400 preparation, such as emitting abstract debug info for the inline
1401 before it gets mangled by optimization. */
1402 if (cgraph_function_possibly_inlined_p (current_function_decl
))
1403 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
1405 /* Remove any notes we don't need. That will make iterating
1406 over the instruction sequence faster, and allow the garbage
1407 collector to reclaim the memory used by the notes. */
1408 remove_unnecessary_notes ();
1412 /* Initialize some variables used by the optimizers. */
1413 init_function_for_compilation ();
1415 TREE_ASM_WRITTEN (current_function_decl
) = 1;
1417 /* Now that integrate will no longer see our rtl, we need not
1418 distinguish between the return value of this function and the
1419 return value of called functions. Also, we can remove all SETs
1420 of subregs of hard registers; they are only here because of
1421 integrate. Also, we can now initialize pseudos intended to
1422 carry magic hard reg data throughout the function. */
1423 rtx_equal_function_value_matters
= 0;
1424 purge_hard_subreg_sets (get_insns ());
1426 /* Early return if there were errors. We can run afoul of our
1427 consistency checks, and there's not really much point in fixing them. */
1428 if (rtl_dump_and_exit
|| flag_syntax_only
|| errorcount
|| sorrycount
)
1429 goto exit_rest_of_compilation
;
1431 timevar_push (TV_JUMP
);
1432 open_dump_file (DFI_sibling
, current_function_decl
);
1434 /* ??? We may get called either via tree_rest_of_compilation when the CFG
1435 is already built or directly (for instance from coverage code).
1436 The direct callers shall be updated. */
1437 if (!basic_block_info
)
1440 rebuild_jump_labels (get_insns ());
1441 find_exception_handler_labels ();
1442 find_basic_blocks (get_insns (), max_reg_num (), dump_file
);
1444 delete_unreachable_blocks ();
1445 #ifdef ENABLE_CHECKING
1449 /* Turn NOTE_INSN_PREDICTIONs into branch predictions. */
1450 if (flag_guess_branch_prob
)
1452 timevar_push (TV_BRANCH_PROB
);
1453 note_prediction_to_br_prob ();
1454 timevar_pop (TV_BRANCH_PROB
);
1457 timevar_pop (TV_JUMP
);
1459 if (cfun
->tail_call_emit
)
1460 fixup_tail_calls ();
1462 insn_locators_initialize ();
1463 /* Complete generation of exception handling code. */
1466 timevar_push (TV_JUMP
);
1467 open_dump_file (DFI_eh
, current_function_decl
);
1469 finish_eh_generation ();
1471 close_dump_file (DFI_eh
, print_rtl
, get_insns ());
1472 timevar_pop (TV_JUMP
);
1475 /* Delay emitting hard_reg_initial_value sets until after EH landing pad
1476 generation, which might create new sets. */
1477 emit_initial_value_sets ();
1480 /* If we are doing position-independent code generation, now
1481 is the time to output special prologues and epilogues.
1482 We do not want to do this earlier, because it just clutters
1483 up inline functions with meaningless insns. */
1488 /* Copy any shared structure that should not be shared. */
1491 #ifdef SETJMP_VIA_SAVE_AREA
1492 /* This must be performed before virtual register instantiation.
1493 Please be aware that everything in the compiler that can look
1494 at the RTL up to this point must understand that REG_SAVE_AREA
1495 is just like a use of the REG contained inside. */
1496 if (current_function_calls_alloca
)
1497 optimize_save_area_alloca (get_insns ());
1500 /* Instantiate all virtual registers. */
1501 instantiate_virtual_regs ();
1503 open_dump_file (DFI_jump
, current_function_decl
);
1505 /* Always do one jump optimization pass to ensure that JUMP_LABEL fields
1506 are initialized and to compute whether control can drop off the end
1509 timevar_push (TV_JUMP
);
1510 /* Turn NOTE_INSN_EXPECTED_VALUE into REG_BR_PROB. Do this
1511 before jump optimization switches branch directions. */
1512 if (flag_guess_branch_prob
)
1513 expected_value_to_br_prob ();
1515 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1516 reg_scan (get_insns(), max_reg_num (), 0);
1518 dump_flow_info (dump_file
);
1519 cleanup_cfg ((optimize
? CLEANUP_EXPENSIVE
: 0) | CLEANUP_PRE_LOOP
1520 | (flag_thread_jumps
? CLEANUP_THREADING
: 0));
1522 create_loop_notes ();
1524 purge_line_number_notes (get_insns ());
1526 close_dump_file (DFI_jump
, print_rtl
, get_insns ());
1529 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_PRE_LOOP
);
1531 /* Jump optimization, and the removal of NULL pointer checks, may
1532 have reduced the number of instructions substantially. CSE, and
1533 future passes, allocate arrays whose dimensions involve the
1534 maximum instruction UID, so if we can reduce the maximum UID
1535 we'll save big on memory. */
1536 renumber_insns (dump_file
);
1537 timevar_pop (TV_JUMP
);
1539 close_dump_file (DFI_jump
, print_rtl_with_bb
, get_insns ());
1544 rest_of_handle_cse ();
1546 rest_of_handle_addressof ();
1553 rest_of_handle_gcse ();
1555 if (flag_loop_optimize
)
1556 rest_of_handle_loop_optimize ();
1559 rest_of_handle_jump_bypass ();
1562 timevar_push (TV_FLOW
);
1564 rest_of_handle_cfg ();
1566 if (!flag_tree_based_profiling
1567 && (optimize
> 0 || profile_arc_flag
1568 || flag_test_coverage
|| flag_branch_probabilities
))
1570 rtl_register_profile_hooks ();
1571 rtl_register_value_prof_hooks ();
1572 rest_of_handle_branch_prob ();
1574 if (flag_branch_probabilities
1575 && flag_profile_values
1576 && flag_value_profile_transformations
)
1577 rest_of_handle_value_profile_transformations ();
1579 /* Remove the death notes created for vpt. */
1580 if (flag_profile_values
)
1581 count_or_remove_death_notes (NULL
, 1);
1585 rest_of_handle_if_conversion ();
1588 rest_of_handle_tracer ();
1591 && flag_loop_optimize2
)
1592 rest_of_handle_loop2 ();
1595 rest_of_handle_web ();
1597 if (flag_rerun_cse_after_loop
)
1598 rest_of_handle_cse2 ();
1600 cse_not_expected
= 1;
1602 rest_of_handle_life ();
1605 rest_of_handle_combine ();
1607 if (flag_if_conversion
)
1608 rest_of_handle_if_after_combine ();
1610 /* The optimization to partition hot/cold basic blocks into separate
1611 sections of the .o file does not work well with exception handling.
1612 Don't call it if there are exceptions. */
1614 if (flag_reorder_blocks_and_partition
&& !flag_exceptions
)
1617 partition_hot_cold_basic_blocks ();
1618 allocate_reg_life_data ();
1619 update_life_info (NULL
, UPDATE_LIFE_GLOBAL_RM_NOTES
,
1620 PROP_LOG_LINKS
| PROP_REG_INFO
| PROP_DEATH_NOTES
);
1624 if (optimize
> 0 && (flag_regmove
|| flag_expensive_optimizations
))
1625 rest_of_handle_regmove ();
1627 /* Do unconditional splitting before register allocation to allow machine
1628 description to add extra information not needed previously. */
1629 split_all_insns (1);
1631 #ifdef OPTIMIZE_MODE_SWITCHING
1632 timevar_push (TV_MODE_SWITCH
);
1635 optimize_mode_switching (NULL
);
1638 timevar_pop (TV_MODE_SWITCH
);
1641 /* Any of the several passes since flow1 will have munged register
1642 lifetime data a bit. We need it to be up to date for scheduling
1643 (see handling of reg_known_equiv in init_alias_analysis). */
1644 recompute_reg_usage (get_insns (), !optimize_size
);
1646 #ifdef INSN_SCHEDULING
1647 rest_of_handle_sched ();
1650 /* Determine if the current function is a leaf before running reload
1651 since this can impact optimizations done by the prologue and
1652 epilogue thus changing register elimination offsets. */
1653 current_function_is_leaf
= leaf_function_p ();
1655 timevar_push (TV_LOCAL_ALLOC
);
1656 open_dump_file (DFI_lreg
, current_function_decl
);
1658 if (flag_new_regalloc
)
1660 if (rest_of_handle_new_regalloc ())
1661 goto exit_rest_of_compilation
;
1665 if (rest_of_handle_old_regalloc ())
1666 goto exit_rest_of_compilation
;
1671 open_dump_file (DFI_postreload
, current_function_decl
);
1673 /* Do a very simple CSE pass over just the hard registers. */
1676 timevar_push (TV_RELOAD_CSE_REGS
);
1677 reload_cse_regs (get_insns ());
1678 /* reload_cse_regs can eliminate potentially-trapping MEMs.
1679 Remove any EH edges associated with them. */
1680 if (flag_non_call_exceptions
)
1681 purge_all_dead_edges (0);
1682 timevar_pop (TV_RELOAD_CSE_REGS
);
1685 close_dump_file (DFI_postreload
, print_rtl_with_bb
, get_insns ());
1687 if (optimize
> 0 && flag_gcse_after_reload
)
1688 rest_of_handle_gcse2 ();
1690 /* Re-create the death notes which were deleted during reload. */
1691 timevar_push (TV_FLOW2
);
1692 open_dump_file (DFI_flow2
, current_function_decl
);
1694 #ifdef ENABLE_CHECKING
1695 verify_flow_info ();
1698 /* If optimizing, then go ahead and split get_insns () now. */
1702 split_all_insns (0);
1704 if (flag_branch_target_load_optimize
)
1706 open_dump_file (DFI_branch_target_load
, current_function_decl
);
1708 branch_target_load_optimize (/*after_prologue_epilogue_gen=*/false);
1710 close_dump_file (DFI_branch_target_load
, print_rtl_with_bb
, get_insns ());
1715 if (! targetm
.late_rtl_prologue_epilogue
)
1718 cleanup_cfg (CLEANUP_EXPENSIVE
);
1720 /* On some machines, the prologue and epilogue code, or parts thereof,
1721 can be represented as RTL. Doing so lets us schedule insns between
1722 it and the rest of the code and also allows delayed branch
1723 scheduling to operate in the epilogue. */
1724 thread_prologue_and_epilogue_insns (get_insns ());
1725 epilogue_completed
= 1;
1730 life_analysis (dump_file
, PROP_POSTRELOAD
);
1731 cleanup_cfg (CLEANUP_EXPENSIVE
| CLEANUP_UPDATE_LIFE
1732 | (flag_crossjumping
? CLEANUP_CROSSJUMP
: 0));
1734 /* This is kind of a heuristic. We need to run combine_stack_adjustments
1735 even for machines with possibly nonzero RETURN_POPS_ARGS
1736 and ACCUMULATE_OUTGOING_ARGS. We expect that only ports having
1737 push instructions will have popping returns. */
1738 #ifndef PUSH_ROUNDING
1739 if (!ACCUMULATE_OUTGOING_ARGS
)
1741 combine_stack_adjustments ();
1746 flow2_completed
= 1;
1748 close_dump_file (DFI_flow2
, print_rtl_with_bb
, get_insns ());
1749 timevar_pop (TV_FLOW2
);
1751 #ifdef HAVE_peephole2
1752 if (optimize
> 0 && flag_peephole2
)
1754 timevar_push (TV_PEEPHOLE2
);
1755 open_dump_file (DFI_peephole2
, current_function_decl
);
1757 peephole2_optimize (dump_file
);
1759 close_dump_file (DFI_peephole2
, print_rtl_with_bb
, get_insns ());
1760 timevar_pop (TV_PEEPHOLE2
);
1764 open_dump_file (DFI_ce3
, current_function_decl
);
1766 /* Last attempt to optimize CFG, as scheduling, peepholing and insn
1767 splitting possibly introduced more crossjumping opportunities. */
1768 cleanup_cfg (CLEANUP_EXPENSIVE
1769 | CLEANUP_UPDATE_LIFE
1770 | (flag_crossjumping
? CLEANUP_CROSSJUMP
: 0));
1771 if (flag_if_conversion2
)
1773 timevar_push (TV_IFCVT2
);
1777 timevar_pop (TV_IFCVT2
);
1779 close_dump_file (DFI_ce3
, print_rtl_with_bb
, get_insns ());
1783 if (flag_rename_registers
|| flag_cprop_registers
)
1784 rest_of_handle_regrename ();
1786 rest_of_handle_reorder_blocks ();
1789 if (flag_branch_target_load_optimize2
)
1791 /* Leave this a warning for now so that it is possible to experiment
1792 with running this pass twice. In 3.6, we should either make this
1793 an error, or use separate dump files. */
1794 if (flag_branch_target_load_optimize
)
1795 warning ("branch target register load optimization is not intended "
1798 open_dump_file (DFI_branch_target_load
, current_function_decl
);
1800 branch_target_load_optimize (/*after_prologue_epilogue_gen=*/true);
1802 close_dump_file (DFI_branch_target_load
, print_rtl_with_bb
, get_insns ());
1807 #ifdef LEAF_REGISTERS
1808 current_function_uses_only_leaf_regs
1809 = optimize
> 0 && only_leaf_regs_used () && leaf_function_p ();
1812 if (targetm
.late_rtl_prologue_epilogue
)
1814 /* On some machines, the prologue and epilogue code, or parts thereof,
1815 can be represented as RTL. Doing so lets us schedule insns between
1816 it and the rest of the code and also allows delayed branch
1817 scheduling to operate in the epilogue. */
1818 thread_prologue_and_epilogue_insns (get_insns ());
1819 epilogue_completed
= 1;
1821 life_analysis (dump_file
, PROP_POSTRELOAD
);
1824 #ifdef INSN_SCHEDULING
1825 if (optimize
> 0 && flag_schedule_insns_after_reload
)
1826 rest_of_handle_sched2 ();
1830 rest_of_handle_stack_regs ();
1833 compute_alignments ();
1835 if (flag_var_tracking
)
1836 rest_of_handle_variable_tracking ();
1838 /* CFG is no longer maintained up-to-date. */
1839 free_bb_for_insn ();
1841 if (targetm
.machine_dependent_reorg
!= 0)
1842 rest_of_handle_machine_reorg ();
1844 purge_line_number_notes (get_insns ());
1845 cleanup_barriers ();
1848 if (optimize
> 0 && flag_delayed_branch
)
1849 rest_of_handle_delay_slots ();
1852 #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
1853 timevar_push (TV_SHORTEN_BRANCH
);
1854 split_all_insns_noflow ();
1855 timevar_pop (TV_SHORTEN_BRANCH
);
1858 convert_to_eh_region_ranges ();
1860 /* Shorten branches. */
1861 timevar_push (TV_SHORTEN_BRANCH
);
1862 shorten_branches (get_insns ());
1863 timevar_pop (TV_SHORTEN_BRANCH
);
1865 set_nothrow_function_flags ();
1866 if (current_function_nothrow
)
1867 /* Now we know that this can't throw; set the flag for the benefit
1868 of other functions later in this translation unit. */
1869 TREE_NOTHROW (current_function_decl
) = 1;
1871 rest_of_handle_final ();
1873 /* Write DBX symbols if requested. */
1875 /* Note that for those inline functions where we don't initially
1876 know for certain that we will be generating an out-of-line copy,
1877 the first invocation of this routine (rest_of_compilation) will
1878 skip over this code by doing a `goto exit_rest_of_compilation;'.
1879 Later on, wrapup_global_declarations will (indirectly) call
1880 rest_of_compilation again for those inline functions that need
1881 to have out-of-line copies generated. During that call, we
1882 *will* be routed past here. */
1884 timevar_push (TV_SYMOUT
);
1885 (*debug_hooks
->function_decl
) (current_function_decl
);
1886 timevar_pop (TV_SYMOUT
);
1888 exit_rest_of_compilation
:
1890 coverage_end_function ();
1892 /* In case the function was not output,
1893 don't leave any temporary anonymous types
1894 queued up for sdb output. */
1895 #ifdef SDB_DEBUGGING_INFO
1896 if (write_symbols
== SDB_DEBUG
)
1897 sdbout_types (NULL_TREE
);
1900 reload_completed
= 0;
1901 epilogue_completed
= 0;
1902 flow2_completed
= 0;
1905 timevar_push (TV_FINAL
);
1907 /* Clear out the insn_length contents now that they are no
1909 init_insn_lengths ();
1911 /* Show no temporary slots allocated. */
1914 free_basic_block_vars ();
1915 free_bb_for_insn ();
1917 timevar_pop (TV_FINAL
);
1919 if (targetm
.binds_local_p (current_function_decl
))
1921 int pref
= cfun
->preferred_stack_boundary
;
1922 if (cfun
->recursive_call_emit
1923 && cfun
->stack_alignment_needed
> cfun
->preferred_stack_boundary
)
1924 pref
= cfun
->stack_alignment_needed
;
1925 cgraph_rtl_info (current_function_decl
)->preferred_incoming_stack_boundary
1929 /* Make sure volatile mem refs aren't considered valid operands for
1930 arithmetic insns. We must call this here if this is a nested inline
1931 function, since the above code leaves us in the init_recog state
1932 (from final.c), and the function context push/pop code does not
1933 save/restore volatile_ok.
1935 ??? Maybe it isn't necessary for expand_start_function to call this
1936 anymore if we do it here? */
1938 init_recog_no_volatile ();
1940 /* We're done with this function. Free up memory if we can. */
1941 free_after_parsing (cfun
);
1945 init_optimization_passes (void)
1947 open_dump_file (DFI_cgraph
, NULL
);
1948 cgraph_dump_file
= dump_file
;
1953 finish_optimization_passes (void)
1955 if (profile_arc_flag
|| flag_test_coverage
|| flag_branch_probabilities
)
1957 timevar_push (TV_DUMP
);
1958 open_dump_file (DFI_bp
, NULL
);
1962 close_dump_file (DFI_bp
, NULL
, NULL_RTX
);
1963 timevar_pop (TV_DUMP
);
1966 if (optimize
> 0 && open_dump_file (DFI_combine
, NULL
))
1968 timevar_push (TV_DUMP
);
1969 dump_combine_total_stats (dump_file
);
1970 close_dump_file (DFI_combine
, NULL
, NULL_RTX
);
1971 timevar_pop (TV_DUMP
);
1974 dump_file
= cgraph_dump_file
;
1975 cgraph_dump_file
= NULL
;
1976 close_dump_file (DFI_cgraph
, NULL
, NULL_RTX
);
1978 /* Do whatever is necessary to finish printing the graphs. */
1979 if (graph_dump_format
!= no_graph
)
1983 for (i
= 0; i
< (int) DFI_MAX
; ++i
)
1984 if (dump_file_tbl
[i
].initialized
&& dump_file_tbl
[i
].graph_dump_p
)
1989 sprintf (seq
, DUMPFILE_FORMAT
, i
);
1990 suffix
= concat (seq
, dump_file_tbl
[i
].extension
, NULL
);
1991 finish_graph_dump_file (dump_base_name
, suffix
);
1999 enable_rtl_dump_file (int letter
)
2001 bool matched
= false;
2006 for (i
= 0; i
< (int) DFI_MAX
; ++i
)
2007 dump_file_tbl
[i
].enabled
= 1;
2012 for (i
= 0; i
< (int) DFI_MAX
; ++i
)
2013 if (letter
== dump_file_tbl
[i
].debug_switch
)
2015 dump_file_tbl
[i
].enabled
= 1;
2023 struct tree_opt_pass pass_rest_of_compilation
=
2025 "rest of compilation", /* name */
2027 rest_of_compilation
, /* execute */
2030 0, /* static_pass_number */
2031 TV_REST_OF_COMPILATION
, /* tv_id */
2032 PROP_rtl
, /* properties_required */
2033 0, /* properties_provided */
2034 PROP_rtl
, /* properties_destroyed */
2035 0, /* todo_flags_start */
2036 TODO_ggc_collect
/* todo_flags_finish */