1 /* Driver of optimization process
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This module implements main driver of compilation process.
23 The main scope of this file is to act as an interface in between
24 tree based frontends and the backend.
26 The front-end is supposed to use following functionality:
30 This function is called once front-end has parsed whole body of function
31 and it is certain that the function body nor the declaration will change.
33 (There is one exception needed for implementing GCC extern inline
36 - varpool_finalize_decl
38 This function has same behavior as the above but is used for static
43 Insert new toplevel ASM statement
45 - finalize_compilation_unit
47 This function is called once (source level) compilation unit is finalized
48 and it will no longer change.
50 The symbol table is constructed starting from the trivially needed
51 symbols finalized by the frontend. Functions are lowered into
52 GIMPLE representation and callgraph/reference lists are constructed.
53 Those are used to discover other necessary functions and variables.
55 At the end the bodies of unreachable functions are removed.
57 The function can be called multiple times when multiple source level
58 compilation units are combined.
62 This passes control to the back-end. Optimizations are performed and
63 final assembler is generated. This is done in the following way. Note
64 that with link time optimization the process is split into three
65 stages (compile time, linktime analysis and parallel linktime as
70 1) Inter-procedural optimization.
73 This part is further split into:
75 a) early optimizations. These are local passes executed in
76 the topological order on the callgraph.
78 The purpose of early optimiations is to optimize away simple
79 things that may otherwise confuse IP analysis. Very simple
80 propagation across the callgraph is done i.e. to discover
81 functions without side effects and simple inlining is performed.
83 b) early small interprocedural passes.
85 Those are interprocedural passes executed only at compilation
86 time. These include, for example, transational memory lowering,
87 unreachable code removal and other simple transformations.
89 c) IP analysis stage. All interprocedural passes do their
92 Interprocedural passes differ from small interprocedural
93 passes by their ability to operate across whole program
94 at linktime. Their analysis stage is performed early to
95 both reduce linking times and linktime memory usage by
96 not having to represent whole program in memory.
98 d) LTO sreaming. When doing LTO, everything important gets
99 streamed into the object file.
101 Compile time and or linktime analysis stage (WPA):
103 At linktime units gets streamed back and symbol table is
104 merged. Function bodies are not streamed in and not
106 e) IP propagation stage. All IP passes execute their
107 IP propagation. This is done based on the earlier analysis
108 without having function bodies at hand.
109 f) Ltrans streaming. When doing WHOPR LTO, the program
110 is partitioned and streamed into multple object files.
112 Compile time and/or parallel linktime stage (ltrans)
114 Each of the object files is streamed back and compiled
115 separately. Now the function bodies becomes available
118 2) Virtual clone materialization
119 (cgraph_materialize_clone)
121 IP passes can produce copies of existing functoins (such
122 as versioned clones or inline clones) without actually
123 manipulating their bodies by creating virtual clones in
124 the callgraph. At this time the virtual clones are
125 turned into real functions
128 All IP passes transform function bodies based on earlier
129 decision of the IP propagation.
131 4) late small IP passes
133 Simple IP passes working within single program partition.
136 (expand_all_functions)
138 At this stage functions that needs to be output into
139 assembler are identified and compiled in topological order
140 6) Output of variables and aliases
141 Now it is known what variable references was not optimized
142 out and thus all variables are output to the file.
144 Note that with -fno-toplevel-reorder passes 5 and 6
145 are combined together in cgraph_output_in_order.
147 Finally there are functions to manipulate the callgraph from
149 - cgraph_add_new_function is used to add backend produced
150 functions introduced after the unit is finalized.
151 The functions are enqueue for later processing and inserted
152 into callgraph with cgraph_process_new_functions.
154 - cgraph_function_versioning
156 produces a copy of function into new one (a version)
157 and apply simple transformations
162 #include "coretypes.h"
166 #include "stor-layout.h"
167 #include "stringpool.h"
170 #include "basic-block.h"
171 #include "tree-ssa-alias.h"
172 #include "internal-fn.h"
173 #include "gimple-fold.h"
174 #include "gimple-expr.h"
177 #include "gimplify.h"
178 #include "gimple-iterator.h"
179 #include "gimplify-me.h"
180 #include "gimple-ssa.h"
181 #include "tree-cfg.h"
182 #include "tree-into-ssa.h"
183 #include "tree-ssa.h"
184 #include "tree-inline.h"
185 #include "langhooks.h"
190 #include "diagnostic.h"
195 #include "hash-set.h"
197 #include "machmode.h"
198 #include "hard-reg-set.h"
200 #include "function.h"
201 #include "ipa-prop.h"
202 #include "tree-iterator.h"
203 #include "tree-pass.h"
204 #include "tree-dump.h"
205 #include "gimple-pretty-print.h"
207 #include "coverage.h"
209 #include "ipa-inline.h"
210 #include "ipa-utils.h"
211 #include "lto-streamer.h"
214 #include "regset.h" /* FIXME: For reg_obstack. */
216 #include "pass_manager.h"
217 #include "tree-nested.h"
218 #include "gimplify.h"
221 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
222 secondary queue used during optimization to accommodate passes that
223 may generate new functions that need to be optimized and expanded. */
224 vec
<cgraph_node
*> cgraph_new_nodes
;
226 static void expand_all_functions (void);
227 static void mark_functions_to_output (void);
228 static void handle_alias_pairs (void);
230 /* Used for vtable lookup in thunk adjusting. */
231 static GTY (()) tree vtable_entry_type
;
233 /* Determine if symbol declaration is needed. That is, visible to something
234 either outside this translation unit, something magic in the system
237 symtab_node::needed_p (void)
239 /* Double check that no one output the function into assembly file
241 gcc_checking_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
)
242 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)));
247 if (DECL_EXTERNAL (decl
))
250 /* If the user told us it is used, then it must be so. */
254 /* ABI forced symbols are needed when they are external. */
255 if (forced_by_abi
&& TREE_PUBLIC (decl
))
258 /* Keep constructors, destructors and virtual functions. */
259 if (TREE_CODE (decl
) == FUNCTION_DECL
260 && (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
)))
263 /* Externally visible variables must be output. The exception is
264 COMDAT variables that must be output only when they are needed. */
265 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
271 /* Head and terminator of the queue of nodes to be processed while building
274 static symtab_node symtab_terminator
;
275 static symtab_node
*queued_nodes
= &symtab_terminator
;
277 /* Add NODE to queue starting at QUEUED_NODES.
278 The queue is linked via AUX pointers and terminated by pointer to 1. */
281 enqueue_node (symtab_node
*node
)
285 gcc_checking_assert (queued_nodes
);
286 node
->aux
= queued_nodes
;
290 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
291 functions into callgraph in a way so they look like ordinary reachable
292 functions inserted into callgraph already at construction time. */
295 symbol_table::process_new_functions (void)
299 if (!cgraph_new_nodes
.exists ())
302 handle_alias_pairs ();
303 /* Note that this queue may grow as its being processed, as the new
304 functions may generate new ones. */
305 for (unsigned i
= 0; i
< cgraph_new_nodes
.length (); i
++)
307 cgraph_node
*node
= cgraph_new_nodes
[i
];
312 /* At construction time we just need to finalize function and move
313 it into reachable functions list. */
315 cgraph_node::finalize_function (fndecl
, false);
316 call_cgraph_insertion_hooks (node
);
322 /* When IPA optimization already started, do all essential
323 transformations that has been already performed on the whole
324 cgraph but not on this function. */
326 gimple_register_cfg_hooks ();
329 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
331 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
332 g
->get_passes ()->execute_early_local_passes ();
333 else if (inline_summary_vec
!= NULL
)
334 compute_inline_parameters (node
, true);
335 free_dominance_info (CDI_POST_DOMINATORS
);
336 free_dominance_info (CDI_DOMINATORS
);
338 call_cgraph_insertion_hooks (node
);
342 /* Functions created during expansion shall be compiled
345 call_cgraph_insertion_hooks (node
);
355 cgraph_new_nodes
.release ();
358 /* As an GCC extension we allow redefinition of the function. The
359 semantics when both copies of bodies differ is not well defined.
360 We replace the old body with new body so in unit at a time mode
361 we always use new body, while in normal mode we may end up with
362 old body inlined into some functions and new body expanded and
365 ??? It may make more sense to use one body for inlining and other
366 body for expanding the function but this is difficult to do. */
369 cgraph_node::reset (void)
371 /* If process is set, then we have already begun whole-unit analysis.
372 This is *not* testing for whether we've already emitted the function.
373 That case can be sort-of legitimately seen with real function redefinition
374 errors. I would argue that the front end should never present us with
375 such a case, but don't enforce that for now. */
376 gcc_assert (!process
);
378 /* Reset our data structures so we can analyze the function again. */
379 memset (&local
, 0, sizeof (local
));
380 memset (&global
, 0, sizeof (global
));
381 memset (&rtl
, 0, sizeof (rtl
));
386 cpp_implicit_alias
= false;
389 remove_all_references ();
392 /* Return true when there are references to the node. */
395 symtab_node::referred_to_p (void)
399 /* See if there are any references at all. */
400 if (iterate_referring (0, ref
))
402 /* For functions check also calls. */
403 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (this);
404 if (cn
&& cn
->callers
)
409 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
410 logic in effect. If NO_COLLECT is true, then our caller cannot stand to have
411 the garbage collector run at the moment. We would need to either create
412 a new GC context, or just not compile right now. */
415 cgraph_node::finalize_function (tree decl
, bool no_collect
)
417 cgraph_node
*node
= cgraph_node::get_create (decl
);
419 if (node
->definition
)
421 /* Nested functions should only be defined once. */
422 gcc_assert (!DECL_CONTEXT (decl
)
423 || TREE_CODE (DECL_CONTEXT (decl
)) != FUNCTION_DECL
);
425 node
->local
.redefined_extern_inline
= true;
428 notice_global_symbol (decl
);
429 node
->definition
= true;
430 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
432 /* With -fkeep-inline-functions we are keeping all inline functions except
433 for extern inline ones. */
434 if (flag_keep_inline_functions
435 && DECL_DECLARED_INLINE_P (decl
)
436 && !DECL_EXTERNAL (decl
)
437 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
438 node
->force_output
= 1;
440 /* When not optimizing, also output the static functions. (see
441 PR24561), but don't do so for always_inline functions, functions
442 declared inline and nested functions. These were optimized out
443 in the original implementation and it is unclear whether we want
444 to change the behavior here. */
446 && !node
->cpp_implicit_alias
447 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
448 && !DECL_DECLARED_INLINE_P (decl
)
449 && !(DECL_CONTEXT (decl
)
450 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
))
451 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
452 node
->force_output
= 1;
454 /* If we've not yet emitted decl, tell the debug info about it. */
455 if (!TREE_ASM_WRITTEN (decl
))
456 (*debug_hooks
->deferred_inline_function
) (decl
);
458 /* Possibly warn about unused parameters. */
459 if (warn_unused_parameter
)
460 do_warn_unused_parameter (decl
);
465 if (symtab
->state
== CONSTRUCTION
466 && (node
->needed_p () || node
->referred_to_p ()))
470 /* Add the function FNDECL to the call graph.
471 Unlike finalize_function, this function is intended to be used
472 by middle end and allows insertion of new function at arbitrary point
473 of compilation. The function can be either in high, low or SSA form
476 The function is assumed to be reachable and have address taken (so no
477 API breaking optimizations are performed on it).
479 Main work done by this function is to enqueue the function for later
480 processing to avoid need the passes to be re-entrant. */
483 cgraph_node::add_new_function (tree fndecl
, bool lowered
)
485 gcc::pass_manager
*passes
= g
->get_passes ();
487 switch (symtab
->state
)
490 cgraph_node::finalize_function (fndecl
, false);
493 /* Just enqueue function to be processed at nearest occurrence. */
494 node
= cgraph_node::get_create (fndecl
);
496 node
->lowered
= true;
497 cgraph_new_nodes
.safe_push (node
);
503 /* Bring the function into finalized state and enqueue for later
504 analyzing and compilation. */
505 node
= cgraph_node::get_create (fndecl
);
506 node
->local
.local
= false;
507 node
->definition
= true;
508 node
->force_output
= true;
509 if (!lowered
&& symtab
->state
== EXPANSION
)
511 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
512 gimple_register_cfg_hooks ();
513 bitmap_obstack_initialize (NULL
);
514 execute_pass_list (cfun
, passes
->all_lowering_passes
);
515 passes
->execute_early_local_passes ();
516 bitmap_obstack_release (NULL
);
522 node
->lowered
= true;
523 cgraph_new_nodes
.safe_push (node
);
527 /* At the very end of compilation we have to do all the work up
529 node
= cgraph_node::create (fndecl
);
531 node
->lowered
= true;
532 node
->definition
= true;
534 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
535 gimple_register_cfg_hooks ();
536 bitmap_obstack_initialize (NULL
);
537 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
538 g
->get_passes ()->execute_early_local_passes ();
539 bitmap_obstack_release (NULL
);
548 /* Set a personality if required and we already passed EH lowering. */
550 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl
))
551 == eh_personality_lang
))
552 DECL_FUNCTION_PERSONALITY (fndecl
) = lang_hooks
.eh_personality ();
555 /* Analyze the function scheduled to be output. */
557 cgraph_node::analyze (void)
559 tree decl
= this->decl
;
560 location_t saved_loc
= input_location
;
561 input_location
= DECL_SOURCE_LOCATION (decl
);
565 create_edge (cgraph_node::get (thunk
.alias
),
566 NULL
, 0, CGRAPH_FREQ_BASE
);
567 if (!expand_thunk (false, false))
575 resolve_alias (cgraph_node::get (alias_target
));
576 else if (dispatcher_function
)
578 /* Generate the dispatcher body of multi-versioned functions. */
579 cgraph_function_version_info
*dispatcher_version_info
580 = function_version ();
581 if (dispatcher_version_info
!= NULL
582 && (dispatcher_version_info
->dispatcher_resolver
585 tree resolver
= NULL_TREE
;
586 gcc_assert (targetm
.generate_version_dispatcher_body
);
587 resolver
= targetm
.generate_version_dispatcher_body (this);
588 gcc_assert (resolver
!= NULL_TREE
);
593 push_cfun (DECL_STRUCT_FUNCTION (decl
));
595 assign_assembler_name_if_neeeded (decl
);
597 /* Make sure to gimplify bodies only once. During analyzing a
598 function we lower it, which will require gimplified nested
599 functions, so we can end up here with an already gimplified
601 if (!gimple_has_body_p (decl
))
602 gimplify_function_tree (decl
);
603 dump_function (TDI_generic
, decl
);
605 /* Lower the function. */
609 lower_nested_functions (decl
);
610 gcc_assert (!nested
);
612 gimple_register_cfg_hooks ();
613 bitmap_obstack_initialize (NULL
);
614 execute_pass_list (cfun
, g
->get_passes ()->all_lowering_passes
);
615 free_dominance_info (CDI_POST_DOMINATORS
);
616 free_dominance_info (CDI_DOMINATORS
);
618 bitmap_obstack_release (NULL
);
626 input_location
= saved_loc
;
629 /* C++ frontend produce same body aliases all over the place, even before PCH
630 gets streamed out. It relies on us linking the aliases with their function
631 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
632 first produce aliases without links, but once C++ FE is sure he won't sream
633 PCH we build the links via this function. */
636 symbol_table::process_same_body_aliases (void)
639 FOR_EACH_SYMBOL (node
)
640 if (node
->cpp_implicit_alias
&& !node
->analyzed
)
642 (TREE_CODE (node
->alias_target
) == VAR_DECL
643 ? (symtab_node
*)varpool_node::get_create (node
->alias_target
)
644 : (symtab_node
*)cgraph_node::get_create (node
->alias_target
));
645 cpp_implicit_aliases_done
= true;
648 /* Process attributes common for vars and functions. */
651 process_common_attributes (symtab_node
*node
, tree decl
)
653 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
655 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
657 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
658 "%<weakref%> attribute should be accompanied with"
659 " an %<alias%> attribute");
660 DECL_WEAK (decl
) = 0;
661 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
662 DECL_ATTRIBUTES (decl
));
665 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl
)))
666 node
->no_reorder
= 1;
669 /* Look for externally_visible and used attributes and mark cgraph nodes
672 We cannot mark the nodes at the point the attributes are processed (in
673 handle_*_attribute) because the copy of the declarations available at that
674 point may not be canonical. For example, in:
677 void f() __attribute__((used));
679 the declaration we see in handle_used_attribute will be the second
680 declaration -- but the front end will subsequently merge that declaration
681 with the original declaration and discard the second declaration.
683 Furthermore, we can't mark these nodes in finalize_function because:
686 void f() __attribute__((externally_visible));
690 So, we walk the nodes at the end of the translation unit, applying the
691 attributes at that point. */
694 process_function_and_variable_attributes (cgraph_node
*first
,
695 varpool_node
*first_var
)
700 for (node
= symtab
->first_function (); node
!= first
;
701 node
= symtab
->next_function (node
))
703 tree decl
= node
->decl
;
704 if (DECL_PRESERVE_P (decl
))
705 node
->mark_force_output ();
706 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
708 if (! TREE_PUBLIC (node
->decl
))
709 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
710 "%<externally_visible%>"
711 " attribute have effect only on public objects");
713 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
714 && (node
->definition
&& !node
->alias
))
716 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
717 "%<weakref%> attribute ignored"
718 " because function is defined");
719 DECL_WEAK (decl
) = 0;
720 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
721 DECL_ATTRIBUTES (decl
));
724 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
725 && !DECL_DECLARED_INLINE_P (decl
)
726 /* redefining extern inline function makes it DECL_UNINLINABLE. */
727 && !DECL_UNINLINABLE (decl
))
728 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
729 "always_inline function might not be inlinable");
731 process_common_attributes (node
, decl
);
733 for (vnode
= symtab
->first_variable (); vnode
!= first_var
;
734 vnode
= symtab
->next_variable (vnode
))
736 tree decl
= vnode
->decl
;
737 if (DECL_EXTERNAL (decl
)
738 && DECL_INITIAL (decl
))
739 varpool_node::finalize_decl (decl
);
740 if (DECL_PRESERVE_P (decl
))
741 vnode
->force_output
= true;
742 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
744 if (! TREE_PUBLIC (vnode
->decl
))
745 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
746 "%<externally_visible%>"
747 " attribute have effect only on public objects");
749 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
751 && DECL_INITIAL (decl
))
753 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
754 "%<weakref%> attribute ignored"
755 " because variable is initialized");
756 DECL_WEAK (decl
) = 0;
757 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
758 DECL_ATTRIBUTES (decl
));
760 process_common_attributes (vnode
, decl
);
764 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
765 middle end to output the variable to asm file, if needed or externally
769 varpool_node::finalize_decl (tree decl
)
771 varpool_node
*node
= varpool_node::get_create (decl
);
773 gcc_assert (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
));
775 if (node
->definition
)
777 notice_global_symbol (decl
);
778 node
->definition
= true;
779 if (TREE_THIS_VOLATILE (decl
) || DECL_PRESERVE_P (decl
)
780 /* Traditionally we do not eliminate static variables when not
781 optimizing and when not doing toplevel reoder. */
783 || ((!flag_toplevel_reorder
784 && !DECL_COMDAT (node
->decl
)
785 && !DECL_ARTIFICIAL (node
->decl
))))
786 node
->force_output
= true;
788 if (symtab
->state
== CONSTRUCTION
789 && (node
->needed_p () || node
->referred_to_p ()))
791 if (symtab
->state
>= IPA_SSA
)
793 /* Some frontends produce various interface variables after compilation
795 if (symtab
->state
== FINISHED
796 || (!flag_toplevel_reorder
797 && symtab
->state
== EXPANSION
))
798 node
->assemble_decl ();
801 /* EDGE is an polymorphic call. Mark all possible targets as reachable
802 and if there is only one target, perform trivial devirtualization.
803 REACHABLE_CALL_TARGETS collects target lists we already walked to
804 avoid udplicate work. */
807 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
813 vec
<cgraph_node
*>targets
814 = possible_polymorphic_call_targets
815 (edge
, &final
, &cache_token
);
817 if (!reachable_call_targets
->add (cache_token
))
819 if (symtab
->dump_file
)
820 dump_possible_polymorphic_call_targets
821 (symtab
->dump_file
, edge
);
823 for (i
= 0; i
< targets
.length (); i
++)
825 /* Do not bother to mark virtual methods in anonymous namespace;
826 either we will find use of virtual table defining it, or it is
828 if (targets
[i
]->definition
830 (TREE_TYPE (targets
[i
]->decl
))
832 && !type_in_anonymous_namespace_p
834 (TREE_TYPE (targets
[i
]->decl
))))
835 enqueue_node (targets
[i
]);
839 /* Very trivial devirtualization; when the type is
840 final or anonymous (so we know all its derivation)
841 and there is only one possible virtual call target,
842 make the edge direct. */
845 if (targets
.length () <= 1 && dbg_cnt (devirt
))
848 if (targets
.length () == 1)
851 target
= cgraph_node::create
852 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
854 if (symtab
->dump_file
)
856 fprintf (symtab
->dump_file
,
857 "Devirtualizing call: ");
858 print_gimple_stmt (symtab
->dump_file
,
862 if (dump_enabled_p ())
864 location_t locus
= gimple_location_safe (edge
->call_stmt
);
865 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
866 "devirtualizing call in %s to %s\n",
867 edge
->caller
->name (), target
->name ());
870 edge
->make_direct (target
);
871 edge
->redirect_call_stmt_to_callee ();
872 if (symtab
->dump_file
)
874 fprintf (symtab
->dump_file
,
875 "Devirtualized as: ");
876 print_gimple_stmt (symtab
->dump_file
,
885 /* Discover all functions and variables that are trivially needed, analyze
886 them as well as all functions and variables referred by them */
889 analyze_functions (void)
891 /* Keep track of already processed nodes when called multiple times for
892 intermodule optimization. */
893 static cgraph_node
*first_analyzed
;
894 cgraph_node
*first_handled
= first_analyzed
;
895 static varpool_node
*first_analyzed_var
;
896 varpool_node
*first_handled_var
= first_analyzed_var
;
897 hash_set
<void *> reachable_call_targets
;
904 location_t saved_loc
= input_location
;
906 bitmap_obstack_initialize (NULL
);
907 symtab
->state
= CONSTRUCTION
;
908 input_location
= UNKNOWN_LOCATION
;
910 /* Ugly, but the fixup can not happen at a time same body alias is created;
911 C++ FE is confused about the COMDAT groups being right. */
912 if (symtab
->cpp_implicit_aliases_done
)
913 FOR_EACH_SYMBOL (node
)
914 if (node
->cpp_implicit_alias
)
915 node
->fixup_same_cpp_alias_visibility (node
->get_alias_target ());
916 if (optimize
&& flag_devirtualize
)
917 build_type_inheritance_graph ();
919 /* Analysis adds static variables that in turn adds references to new functions.
920 So we need to iterate the process until it stabilize. */
924 process_function_and_variable_attributes (first_analyzed
,
927 /* First identify the trivially needed symbols. */
928 for (node
= symtab
->first_symbol ();
929 node
!= first_analyzed
930 && node
!= first_analyzed_var
; node
= node
->next
)
932 /* Convert COMDAT group designators to IDENTIFIER_NODEs. */
933 node
->get_comdat_group_id ();
934 if (node
->needed_p ())
937 if (!changed
&& symtab
->dump_file
)
938 fprintf (symtab
->dump_file
, "Trivially needed symbols:");
940 if (symtab
->dump_file
)
941 fprintf (symtab
->dump_file
, " %s", node
->asm_name ());
942 if (!changed
&& symtab
->dump_file
)
943 fprintf (symtab
->dump_file
, "\n");
945 if (node
== first_analyzed
946 || node
== first_analyzed_var
)
949 symtab
->process_new_functions ();
950 first_analyzed_var
= symtab
->first_variable ();
951 first_analyzed
= symtab
->first_function ();
953 if (changed
&& symtab
->dump_file
)
954 fprintf (symtab
->dump_file
, "\n");
956 /* Lower representation, build callgraph edges and references for all trivially
957 needed symbols and all symbols referred by them. */
958 while (queued_nodes
!= &symtab_terminator
)
962 queued_nodes
= (symtab_node
*)queued_nodes
->aux
;
963 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
964 if (cnode
&& cnode
->definition
)
967 tree decl
= cnode
->decl
;
969 /* ??? It is possible to create extern inline function
970 and later using weak alias attribute to kill its body.
971 See gcc.c-torture/compile/20011119-1.c */
972 if (!DECL_STRUCT_FUNCTION (decl
)
974 && !cnode
->thunk
.thunk_p
975 && !cnode
->dispatcher_function
)
978 cnode
->local
.redefined_extern_inline
= true;
982 if (!cnode
->analyzed
)
985 for (edge
= cnode
->callees
; edge
; edge
= edge
->next_callee
)
986 if (edge
->callee
->definition
)
987 enqueue_node (edge
->callee
);
988 if (optimize
&& flag_devirtualize
)
992 for (edge
= cnode
->indirect_calls
; edge
; edge
= next
)
994 next
= edge
->next_callee
;
995 if (edge
->indirect_info
->polymorphic
)
996 walk_polymorphic_call_targets (&reachable_call_targets
,
1001 /* If decl is a clone of an abstract function,
1002 mark that abstract function so that we don't release its body.
1003 The DECL_INITIAL() of that abstract function declaration
1004 will be later needed to output debug info. */
1005 if (DECL_ABSTRACT_ORIGIN (decl
))
1007 cgraph_node
*origin_node
1008 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (decl
));
1009 origin_node
->used_as_abstract_origin
= true;
1014 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
1015 if (vnode
&& vnode
->definition
&& !vnode
->analyzed
)
1019 if (node
->same_comdat_group
)
1022 for (next
= node
->same_comdat_group
;
1024 next
= next
->same_comdat_group
)
1025 enqueue_node (next
);
1027 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
1028 if (ref
->referred
->definition
)
1029 enqueue_node (ref
->referred
);
1030 symtab
->process_new_functions ();
1033 if (optimize
&& flag_devirtualize
)
1034 update_type_inheritance_graph ();
1036 /* Collect entry points to the unit. */
1037 if (symtab
->dump_file
)
1039 fprintf (symtab
->dump_file
, "\n\nInitial ");
1040 symtab_node::dump_table (symtab
->dump_file
);
1043 if (symtab
->dump_file
)
1044 fprintf (symtab
->dump_file
, "\nRemoving unused symbols:");
1046 for (node
= symtab
->first_symbol ();
1047 node
!= first_handled
1048 && node
!= first_handled_var
; node
= next
)
1051 if (!node
->aux
&& !node
->referred_to_p ())
1053 if (symtab
->dump_file
)
1054 fprintf (symtab
->dump_file
, " %s", node
->name ());
1058 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
1060 tree decl
= node
->decl
;
1062 if (cnode
->definition
&& !gimple_has_body_p (decl
)
1064 && !cnode
->thunk
.thunk_p
)
1067 gcc_assert (!cnode
->definition
|| cnode
->thunk
.thunk_p
1069 || gimple_has_body_p (decl
));
1070 gcc_assert (cnode
->analyzed
== cnode
->definition
);
1074 for (;node
; node
= node
->next
)
1076 first_analyzed
= symtab
->first_function ();
1077 first_analyzed_var
= symtab
->first_variable ();
1078 if (symtab
->dump_file
)
1080 fprintf (symtab
->dump_file
, "\n\nReclaimed ");
1081 symtab_node::dump_table (symtab
->dump_file
);
1083 bitmap_obstack_release (NULL
);
1085 /* Initialize assembler name hash, in particular we want to trigger C++
1086 mangling and same body alias creation before we free DECL_ARGUMENTS
1089 symtab
->symtab_initialize_asm_name_hash ();
1091 input_location
= saved_loc
;
1094 /* Translate the ugly representation of aliases as alias pairs into nice
1095 representation in callgraph. We don't handle all cases yet,
1099 handle_alias_pairs (void)
1104 for (i
= 0; alias_pairs
&& alias_pairs
->iterate (i
, &p
);)
1106 symtab_node
*target_node
= symtab_node::get_for_asmname (p
->target
);
1108 /* Weakrefs with target not defined in current unit are easy to handle:
1109 they behave just as external variables except we need to note the
1110 alias flag to later output the weakref pseudo op into asm file. */
1112 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
)
1114 symtab_node
*node
= symtab_node::get (p
->decl
);
1117 node
->alias_target
= p
->target
;
1118 node
->weakref
= true;
1121 alias_pairs
->unordered_remove (i
);
1124 else if (!target_node
)
1126 error ("%q+D aliased to undefined symbol %qE", p
->decl
, p
->target
);
1127 symtab_node
*node
= symtab_node::get (p
->decl
);
1129 node
->alias
= false;
1130 alias_pairs
->unordered_remove (i
);
1134 if (DECL_EXTERNAL (target_node
->decl
)
1135 /* We use local aliases for C++ thunks to force the tailcall
1136 to bind locally. This is a hack - to keep it working do
1137 the following (which is not strictly correct). */
1138 && (TREE_CODE (target_node
->decl
) != FUNCTION_DECL
1139 || ! DECL_VIRTUAL_P (target_node
->decl
))
1140 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
1142 error ("%q+D aliased to external symbol %qE",
1143 p
->decl
, p
->target
);
1146 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1147 && target_node
&& is_a
<cgraph_node
*> (target_node
))
1149 cgraph_node
*src_node
= cgraph_node::get (p
->decl
);
1150 if (src_node
&& src_node
->definition
)
1152 cgraph_node::create_alias (p
->decl
, target_node
->decl
);
1153 alias_pairs
->unordered_remove (i
);
1155 else if (TREE_CODE (p
->decl
) == VAR_DECL
1156 && target_node
&& is_a
<varpool_node
*> (target_node
))
1158 varpool_node::create_alias (p
->decl
, target_node
->decl
);
1159 alias_pairs
->unordered_remove (i
);
1163 error ("%q+D alias in between function and variable is not supported",
1165 warning (0, "%q+D aliased declaration",
1167 alias_pairs
->unordered_remove (i
);
1170 vec_free (alias_pairs
);
1174 /* Figure out what functions we want to assemble. */
1177 mark_functions_to_output (void)
1180 #ifdef ENABLE_CHECKING
1181 bool check_same_comdat_groups
= false;
1183 FOR_EACH_FUNCTION (node
)
1184 gcc_assert (!node
->process
);
1187 FOR_EACH_FUNCTION (node
)
1189 tree decl
= node
->decl
;
1191 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1195 /* We need to output all local functions that are used and not
1196 always inlined, as well as those that are reachable from
1197 outside the current compilation unit. */
1199 && !node
->thunk
.thunk_p
1201 && !node
->global
.inlined_to
1202 && !TREE_ASM_WRITTEN (decl
)
1203 && !DECL_EXTERNAL (decl
))
1206 if (node
->same_comdat_group
)
1209 for (next
= dyn_cast
<cgraph_node
*> (node
->same_comdat_group
);
1211 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
1212 if (!next
->thunk
.thunk_p
&& !next
->alias
1213 && !next
->comdat_local_p ())
1217 else if (node
->same_comdat_group
)
1219 #ifdef ENABLE_CHECKING
1220 check_same_comdat_groups
= true;
1225 /* We should've reclaimed all functions that are not needed. */
1226 #ifdef ENABLE_CHECKING
1227 if (!node
->global
.inlined_to
1228 && gimple_has_body_p (decl
)
1229 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1230 are inside partition, we can end up not removing the body since we no longer
1231 have analyzed node pointing to it. */
1232 && !node
->in_other_partition
1235 && !DECL_EXTERNAL (decl
))
1238 internal_error ("failed to reclaim unneeded function");
1241 gcc_assert (node
->global
.inlined_to
1242 || !gimple_has_body_p (decl
)
1243 || node
->in_other_partition
1245 || DECL_ARTIFICIAL (decl
)
1246 || DECL_EXTERNAL (decl
));
1251 #ifdef ENABLE_CHECKING
1252 if (check_same_comdat_groups
)
1253 FOR_EACH_FUNCTION (node
)
1254 if (node
->same_comdat_group
&& !node
->process
)
1256 tree decl
= node
->decl
;
1257 if (!node
->global
.inlined_to
1258 && gimple_has_body_p (decl
)
1259 /* FIXME: in an ltrans unit when the offline copy is outside a
1260 partition but inline copies are inside a partition, we can
1261 end up not removing the body since we no longer have an
1262 analyzed node pointing to it. */
1263 && !node
->in_other_partition
1265 && !DECL_EXTERNAL (decl
))
1268 internal_error ("failed to reclaim unneeded function in same "
1275 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1276 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1278 Set current_function_decl and cfun to newly constructed empty function body.
1279 return basic block in the function body. */
1282 init_lowered_empty_function (tree decl
, bool in_ssa
)
1286 current_function_decl
= decl
;
1287 allocate_struct_function (decl
, false);
1288 gimple_register_cfg_hooks ();
1289 init_empty_tree_cfg ();
1293 init_tree_ssa (cfun
);
1294 init_ssa_operands (cfun
);
1295 cfun
->gimple_df
->in_ssa_p
= true;
1296 cfun
->curr_properties
|= PROP_ssa
;
1299 DECL_INITIAL (decl
) = make_node (BLOCK
);
1301 DECL_SAVED_TREE (decl
) = error_mark_node
;
1302 cfun
->curr_properties
|= (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_gimple_any
1303 | PROP_cfg
| PROP_loops
);
1305 set_loops_for_fn (cfun
, ggc_cleared_alloc
<loops
> ());
1306 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
1307 loops_for_fn (cfun
)->state
|= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
1309 /* Create BB for body of the function and connect it properly. */
1310 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
1311 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), bb
, EDGE_FALLTHRU
);
1312 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1313 add_bb_to_loop (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
1318 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1319 offset indicated by VIRTUAL_OFFSET, if that is
1320 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1321 zero for a result adjusting thunk. */
1324 thunk_adjust (gimple_stmt_iterator
* bsi
,
1325 tree ptr
, bool this_adjusting
,
1326 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1332 && fixed_offset
!= 0)
1334 stmt
= gimple_build_assign
1335 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1338 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1341 /* If there's a virtual offset, look up that value in the vtable and
1342 adjust the pointer again. */
1349 if (!vtable_entry_type
)
1351 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1352 TREE_TYPE (vfunc_type
) = integer_type_node
;
1353 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1354 layout_type (vfunc_type
);
1356 vtable_entry_type
= build_pointer_type (vfunc_type
);
1360 create_tmp_reg (build_pointer_type
1361 (build_pointer_type (vtable_entry_type
)), "vptr");
1363 /* The vptr is always at offset zero in the object. */
1364 stmt
= gimple_build_assign (vtabletmp
,
1365 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1367 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1369 /* Form the vtable address. */
1370 vtabletmp2
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1372 stmt
= gimple_build_assign (vtabletmp2
,
1373 build_simple_mem_ref (vtabletmp
));
1374 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1376 /* Find the entry with the vcall offset. */
1377 stmt
= gimple_build_assign (vtabletmp2
,
1378 fold_build_pointer_plus_loc (input_location
,
1381 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1383 /* Get the offset itself. */
1384 vtabletmp3
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1386 stmt
= gimple_build_assign (vtabletmp3
,
1387 build_simple_mem_ref (vtabletmp2
));
1388 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1390 /* Adjust the `this' pointer. */
1391 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, vtabletmp3
);
1392 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1393 GSI_CONTINUE_LINKING
);
1397 && fixed_offset
!= 0)
1398 /* Adjust the pointer by the constant. */
1402 if (TREE_CODE (ptr
) == VAR_DECL
)
1406 ptrtmp
= create_tmp_reg (TREE_TYPE (ptr
), "ptr");
1407 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1408 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1410 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1411 ptrtmp
, fixed_offset
);
1414 /* Emit the statement and gimplify the adjustment expression. */
1415 ret
= create_tmp_reg (TREE_TYPE (ptr
), "adjusted_this");
1416 stmt
= gimple_build_assign (ret
, ptr
);
1417 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1422 /* Expand thunk NODE to gimple if possible.
1423 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1424 no assembler is produced.
1425 When OUTPUT_ASM_THUNK is true, also produce assembler for
1426 thunks that are not lowered. */
1429 cgraph_node::expand_thunk (bool output_asm_thunks
, bool force_gimple_thunk
)
1431 bool this_adjusting
= thunk
.this_adjusting
;
1432 HOST_WIDE_INT fixed_offset
= thunk
.fixed_offset
;
1433 HOST_WIDE_INT virtual_value
= thunk
.virtual_value
;
1434 tree virtual_offset
= NULL
;
1435 tree alias
= callees
->callee
->decl
;
1436 tree thunk_fndecl
= decl
;
1440 if (!force_gimple_thunk
&& this_adjusting
1441 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1442 virtual_value
, alias
))
1446 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1448 if (!output_asm_thunks
)
1456 a
= DECL_ARGUMENTS (thunk_fndecl
);
1458 current_function_decl
= thunk_fndecl
;
1460 /* Ensure thunks are emitted in their correct sections. */
1461 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1463 DECL_RESULT (thunk_fndecl
)
1464 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1465 RESULT_DECL
, 0, restype
);
1466 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1467 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1469 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1471 fn_block
= make_node (BLOCK
);
1472 BLOCK_VARS (fn_block
) = a
;
1473 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1474 init_function_start (thunk_fndecl
);
1476 insn_locations_init ();
1477 set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl
));
1478 prologue_location
= curr_insn_location ();
1479 assemble_start_function (thunk_fndecl
, fnname
);
1481 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1482 fixed_offset
, virtual_value
, alias
);
1484 assemble_end_function (thunk_fndecl
, fnname
);
1485 insn_locations_finalize ();
1486 init_insn_lengths ();
1487 free_after_compilation (cfun
);
1489 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1490 thunk
.thunk_p
= false;
1496 basic_block bb
, then_bb
, else_bb
, return_bb
;
1497 gimple_stmt_iterator bsi
;
1509 a
= DECL_ARGUMENTS (thunk_fndecl
);
1511 current_function_decl
= thunk_fndecl
;
1513 /* Ensure thunks are emitted in their correct sections. */
1514 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1516 DECL_IGNORED_P (thunk_fndecl
) = 1;
1517 bitmap_obstack_initialize (NULL
);
1519 if (thunk
.virtual_offset_p
)
1520 virtual_offset
= size_int (virtual_value
);
1522 /* Build the return declaration for the function. */
1523 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1524 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1526 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1527 DECL_ARTIFICIAL (resdecl
) = 1;
1528 DECL_IGNORED_P (resdecl
) = 1;
1529 DECL_RESULT (thunk_fndecl
) = resdecl
;
1530 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1533 resdecl
= DECL_RESULT (thunk_fndecl
);
1535 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
, true);
1537 bsi
= gsi_start_bb (bb
);
1539 /* Build call to the function being thunked. */
1540 if (!VOID_TYPE_P (restype
))
1542 if (DECL_BY_REFERENCE (resdecl
))
1543 restmp
= gimple_fold_indirect_ref (resdecl
);
1544 else if (!is_gimple_reg_type (restype
))
1547 add_local_decl (cfun
, restmp
);
1548 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1551 restmp
= create_tmp_reg (restype
, "retval");
1554 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1556 auto_vec
<tree
> vargs (nargs
);
1558 vargs
.quick_push (thunk_adjust (&bsi
, a
, 1, fixed_offset
,
1561 vargs
.quick_push (a
);
1564 for (i
= 1, arg
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1567 if (!is_gimple_val (arg
))
1569 tmp
= create_tmp_reg (TYPE_MAIN_VARIANT
1570 (TREE_TYPE (arg
)), "arg");
1571 gimple stmt
= gimple_build_assign (tmp
, arg
);
1572 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1574 vargs
.quick_push (tmp
);
1576 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1577 callees
->call_stmt
= call
;
1578 gimple_call_set_from_thunk (call
, true);
1581 gimple_call_set_lhs (call
, restmp
);
1582 gcc_assert (useless_type_conversion_p (TREE_TYPE (restmp
),
1583 TREE_TYPE (TREE_TYPE (alias
))));
1585 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1586 if (!(gimple_call_flags (call
) & ECF_NORETURN
))
1588 if (restmp
&& !this_adjusting
1589 && (fixed_offset
|| virtual_offset
))
1591 tree true_label
= NULL_TREE
;
1593 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1596 /* If the return type is a pointer, we need to
1597 protect against NULL. We know there will be an
1598 adjustment, because that's why we're emitting a
1600 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1601 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1602 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1603 add_bb_to_loop (then_bb
, bb
->loop_father
);
1604 add_bb_to_loop (return_bb
, bb
->loop_father
);
1605 add_bb_to_loop (else_bb
, bb
->loop_father
);
1606 remove_edge (single_succ_edge (bb
));
1607 true_label
= gimple_block_label (then_bb
);
1608 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1609 build_zero_cst (TREE_TYPE (restmp
)),
1610 NULL_TREE
, NULL_TREE
);
1611 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1612 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1613 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1614 make_edge (return_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1615 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1616 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1617 bsi
= gsi_last_bb (then_bb
);
1620 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1621 fixed_offset
, virtual_offset
);
1625 bsi
= gsi_last_bb (else_bb
);
1626 stmt
= gimple_build_assign (restmp
,
1627 build_zero_cst (TREE_TYPE (restmp
)));
1628 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1629 bsi
= gsi_last_bb (return_bb
);
1633 gimple_call_set_tail (call
, true);
1635 /* Build return value. */
1636 ret
= gimple_build_return (restmp
);
1637 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1641 gimple_call_set_tail (call
, true);
1642 remove_edge (single_succ_edge (bb
));
1645 cfun
->gimple_df
->in_ssa_p
= true;
1646 /* FIXME: C++ FE should stop setting TREE_ASM_WRITTEN on thunks. */
1647 TREE_ASM_WRITTEN (thunk_fndecl
) = false;
1648 delete_unreachable_blocks ();
1649 update_ssa (TODO_update_ssa
);
1650 #ifdef ENABLE_CHECKING
1651 verify_flow_info ();
1653 free_dominance_info (CDI_DOMINATORS
);
1655 /* Since we want to emit the thunk, we explicitly mark its name as
1657 thunk
.thunk_p
= false;
1659 bitmap_obstack_release (NULL
);
1661 current_function_decl
= NULL
;
1666 /* Assemble thunks and aliases associated to node. */
1669 cgraph_node::assemble_thunks_and_aliases (void)
1674 for (e
= callers
; e
;)
1675 if (e
->caller
->thunk
.thunk_p
)
1677 cgraph_node
*thunk
= e
->caller
;
1680 thunk
->expand_thunk (true, false);
1681 thunk
->assemble_thunks_and_aliases ();
1686 FOR_EACH_ALIAS (this, ref
)
1688 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1689 bool saved_written
= TREE_ASM_WRITTEN (decl
);
1691 /* Force assemble_alias to really output the alias this time instead
1692 of buffering it in same alias pairs. */
1693 TREE_ASM_WRITTEN (decl
) = 1;
1694 do_assemble_alias (alias
->decl
,
1695 DECL_ASSEMBLER_NAME (decl
));
1696 alias
->assemble_thunks_and_aliases ();
1697 TREE_ASM_WRITTEN (decl
) = saved_written
;
1701 /* Expand function specified by node. */
1704 cgraph_node::expand (void)
1706 location_t saved_loc
;
1708 /* We ought to not compile any inline clones. */
1709 gcc_assert (!global
.inlined_to
);
1711 announce_function (decl
);
1713 gcc_assert (lowered
);
1716 /* Generate RTL for the body of DECL. */
1718 timevar_push (TV_REST_OF_COMPILATION
);
1720 gcc_assert (symtab
->global_info_ready
);
1722 /* Initialize the default bitmap obstack. */
1723 bitmap_obstack_initialize (NULL
);
1725 /* Initialize the RTL code for the function. */
1726 current_function_decl
= decl
;
1727 saved_loc
= input_location
;
1728 input_location
= DECL_SOURCE_LOCATION (decl
);
1729 init_function_start (decl
);
1731 gimple_register_cfg_hooks ();
1733 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
1735 execute_all_ipa_transforms ();
1737 /* Perform all tree transforms and optimizations. */
1739 /* Signal the start of passes. */
1740 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
1742 execute_pass_list (cfun
, g
->get_passes ()->all_passes
);
1744 /* Signal the end of passes. */
1745 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
1747 bitmap_obstack_release (®_obstack
);
1749 /* Release the default bitmap obstack. */
1750 bitmap_obstack_release (NULL
);
1752 /* If requested, warn about function definitions where the function will
1753 return a value (usually of some struct or union type) which itself will
1754 take up a lot of stack space. */
1755 if (warn_larger_than
&& !DECL_EXTERNAL (decl
) && TREE_TYPE (decl
))
1757 tree ret_type
= TREE_TYPE (TREE_TYPE (decl
));
1759 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
1760 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
1761 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
1764 unsigned int size_as_int
1765 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
1767 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
1768 warning (OPT_Wlarger_than_
, "size of return value of %q+D is %u bytes",
1771 warning (OPT_Wlarger_than_
, "size of return value of %q+D is larger than %wd bytes",
1772 decl
, larger_than_size
);
1776 gimple_set_body (decl
, NULL
);
1777 if (DECL_STRUCT_FUNCTION (decl
) == 0
1778 && !cgraph_node::get (decl
)->origin
)
1780 /* Stop pointing to the local nodes about to be freed.
1781 But DECL_INITIAL must remain nonzero so we know this
1782 was an actual function definition.
1783 For a nested function, this is done in c_pop_function_context.
1784 If rest_of_compilation set this to 0, leave it 0. */
1785 if (DECL_INITIAL (decl
) != 0)
1786 DECL_INITIAL (decl
) = error_mark_node
;
1789 input_location
= saved_loc
;
1792 timevar_pop (TV_REST_OF_COMPILATION
);
1794 /* Make sure that BE didn't give up on compiling. */
1795 gcc_assert (TREE_ASM_WRITTEN (decl
));
1797 current_function_decl
= NULL
;
1799 /* It would make a lot more sense to output thunks before function body to get more
1800 forward and lest backwarding jumps. This however would need solving problem
1801 with comdats. See PR48668. Also aliases must come after function itself to
1802 make one pass assemblers, like one on AIX, happy. See PR 50689.
1803 FIXME: Perhaps thunks should be move before function IFF they are not in comdat
1805 assemble_thunks_and_aliases ();
1807 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1808 points to the dead function body. */
1810 remove_all_references ();
1813 /* Node comparer that is responsible for the order that corresponds
1814 to time when a function was launched for the first time. */
1817 node_cmp (const void *pa
, const void *pb
)
1819 const cgraph_node
*a
= *(const cgraph_node
* const *) pa
;
1820 const cgraph_node
*b
= *(const cgraph_node
* const *) pb
;
1822 /* Functions with time profile must be before these without profile. */
1823 if (!a
->tp_first_run
|| !b
->tp_first_run
)
1824 return a
->tp_first_run
- b
->tp_first_run
;
1826 return a
->tp_first_run
!= b
->tp_first_run
1827 ? b
->tp_first_run
- a
->tp_first_run
1828 : b
->order
- a
->order
;
1831 /* Expand all functions that must be output.
1833 Attempt to topologically sort the nodes so function is output when
1834 all called functions are already assembled to allow data to be
1835 propagated across the callgraph. Use a stack to get smaller distance
1836 between a function and its callees (later we may choose to use a more
1837 sophisticated algorithm for function reordering; we will likely want
1838 to use subsections to make the output functions appear in top-down
1842 expand_all_functions (void)
1845 cgraph_node
**order
= XCNEWVEC (cgraph_node
*,
1846 symtab
->cgraph_count
);
1847 unsigned int expanded_func_count
= 0, profiled_func_count
= 0;
1848 int order_pos
, new_order_pos
= 0;
1851 order_pos
= ipa_reverse_postorder (order
);
1852 gcc_assert (order_pos
== symtab
->cgraph_count
);
1854 /* Garbage collector may remove inline clones we eliminate during
1855 optimization. So we must be sure to not reference them. */
1856 for (i
= 0; i
< order_pos
; i
++)
1857 if (order
[i
]->process
)
1858 order
[new_order_pos
++] = order
[i
];
1860 if (flag_profile_reorder_functions
)
1861 qsort (order
, new_order_pos
, sizeof (cgraph_node
*), node_cmp
);
1863 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1869 expanded_func_count
++;
1870 if(node
->tp_first_run
)
1871 profiled_func_count
++;
1873 if (symtab
->dump_file
)
1874 fprintf (symtab
->dump_file
,
1875 "Time profile order in expand_all_functions:%s:%d\n",
1876 node
->asm_name (), node
->tp_first_run
);
1883 fprintf (dump_file
, "Expanded functions with time profile (%s):%u/%u\n",
1884 main_input_filename
, profiled_func_count
, expanded_func_count
);
1886 if (symtab
->dump_file
&& flag_profile_reorder_functions
)
1887 fprintf (symtab
->dump_file
, "Expanded functions with time profile:%u/%u\n",
1888 profiled_func_count
, expanded_func_count
);
1890 symtab
->process_new_functions ();
1891 free_gimplify_stack ();
1896 /* This is used to sort the node types by the cgraph order number. */
1898 enum cgraph_order_sort_kind
1900 ORDER_UNDEFINED
= 0,
1906 struct cgraph_order_sort
1908 enum cgraph_order_sort_kind kind
;
1917 /* Output all functions, variables, and asm statements in the order
1918 according to their order fields, which is the order in which they
1919 appeared in the file. This implements -fno-toplevel-reorder. In
1920 this mode we may output functions and variables which don't really
1922 When NO_REORDER is true only do this for symbols marked no reorder. */
1925 output_in_order (bool no_reorder
)
1928 cgraph_order_sort
*nodes
;
1933 max
= symtab
->order
;
1934 nodes
= XCNEWVEC (cgraph_order_sort
, max
);
1936 FOR_EACH_DEFINED_FUNCTION (pf
)
1938 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
1940 if (no_reorder
&& !pf
->no_reorder
)
1943 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1944 nodes
[i
].kind
= ORDER_FUNCTION
;
1949 FOR_EACH_DEFINED_VARIABLE (pv
)
1950 if (!DECL_EXTERNAL (pv
->decl
))
1952 if (no_reorder
&& !pv
->no_reorder
)
1955 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1956 nodes
[i
].kind
= ORDER_VAR
;
1960 for (pa
= symtab
->first_asm_symbol (); pa
; pa
= pa
->next
)
1963 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1964 nodes
[i
].kind
= ORDER_ASM
;
1968 /* In toplevel reorder mode we output all statics; mark them as needed. */
1970 for (i
= 0; i
< max
; ++i
)
1971 if (nodes
[i
].kind
== ORDER_VAR
)
1972 nodes
[i
].u
.v
->finalize_named_section_flags ();
1974 for (i
= 0; i
< max
; ++i
)
1976 switch (nodes
[i
].kind
)
1978 case ORDER_FUNCTION
:
1979 nodes
[i
].u
.f
->process
= 0;
1980 nodes
[i
].u
.f
->expand ();
1984 nodes
[i
].u
.v
->assemble_decl ();
1988 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1991 case ORDER_UNDEFINED
:
1999 symtab
->clear_asm_symbols ();
2007 gcc::pass_manager
*passes
= g
->get_passes ();
2010 current_function_decl
= NULL
;
2011 gimple_register_cfg_hooks ();
2012 bitmap_obstack_initialize (NULL
);
2014 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2018 execute_ipa_pass_list (passes
->all_small_ipa_passes
);
2023 /* This extra symtab_remove_unreachable_nodes pass tends to catch some
2024 devirtualization and other changes where removal iterate. */
2025 symtab
->remove_unreachable_nodes (true, symtab
->dump_file
);
2027 /* If pass_all_early_optimizations was not scheduled, the state of
2028 the cgraph will not be properly updated. Update it now. */
2029 if (symtab
->state
< IPA_SSA
)
2030 symtab
->state
= IPA_SSA
;
2034 /* Generate coverage variables and constructors. */
2037 /* Process new functions added. */
2039 current_function_decl
= NULL
;
2040 symtab
->process_new_functions ();
2042 execute_ipa_summary_passes
2043 ((ipa_opt_pass_d
*) passes
->all_regular_ipa_passes
);
2046 /* Some targets need to handle LTO assembler output specially. */
2047 if (flag_generate_lto
)
2048 targetm
.asm_out
.lto_start ();
2051 ipa_write_summaries ();
2053 if (flag_generate_lto
)
2054 targetm
.asm_out
.lto_end ();
2056 if (!flag_ltrans
&& (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
))
2057 execute_ipa_pass_list (passes
->all_regular_ipa_passes
);
2058 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2060 bitmap_obstack_release (NULL
);
2064 /* Return string alias is alias of. */
2067 get_alias_symbol (tree decl
)
2069 tree alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
2070 return get_identifier (TREE_STRING_POINTER
2071 (TREE_VALUE (TREE_VALUE (alias
))));
2075 /* Weakrefs may be associated to external decls and thus not output
2076 at expansion time. Emit all necessary aliases. */
2079 symbol_table::output_weakrefs (void)
2082 FOR_EACH_SYMBOL (node
)
2084 && !TREE_ASM_WRITTEN (node
->decl
)
2089 /* Weakrefs are special by not requiring target definition in current
2090 compilation unit. It is thus bit hard to work out what we want to
2092 When alias target is defined, we need to fetch it from symtab reference,
2093 otherwise it is pointed to by alias_target. */
2094 if (node
->alias_target
)
2095 target
= (DECL_P (node
->alias_target
)
2096 ? DECL_ASSEMBLER_NAME (node
->alias_target
)
2097 : node
->alias_target
);
2098 else if (node
->analyzed
)
2099 target
= DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
);
2103 target
= get_alias_symbol (node
->decl
);
2105 do_assemble_alias (node
->decl
, target
);
2109 /* Perform simple optimizations based on callgraph. */
2112 symbol_table::compile (void)
2117 #ifdef ENABLE_CHECKING
2118 symtab_node::verify_symtab_nodes ();
2121 timevar_push (TV_CGRAPHOPT
);
2122 if (pre_ipa_mem_report
)
2124 fprintf (stderr
, "Memory consumption before IPA\n");
2125 dump_memory_report (false);
2128 fprintf (stderr
, "Performing interprocedural optimizations\n");
2131 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2133 lto_streamer_hooks_init ();
2135 /* Don't run the IPA passes if there was any error or sorry messages. */
2139 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2141 || (!in_lto_p
&& flag_lto
&& !flag_fat_lto_objects
))
2143 timevar_pop (TV_CGRAPHOPT
);
2147 /* This pass remove bodies of extern inline functions we never inlined.
2148 Do this later so other IPA passes see what is really going on.
2149 FIXME: This should be run just after inlining by pasmanager. */
2150 remove_unreachable_nodes (false, dump_file
);
2151 global_info_ready
= true;
2154 fprintf (dump_file
, "Optimized ");
2155 symtab_node:: dump_table (dump_file
);
2157 if (post_ipa_mem_report
)
2159 fprintf (stderr
, "Memory consumption after IPA\n");
2160 dump_memory_report (false);
2162 timevar_pop (TV_CGRAPHOPT
);
2164 /* Output everything. */
2165 (*debug_hooks
->assembly_start
) ();
2167 fprintf (stderr
, "Assembling functions:\n");
2168 #ifdef ENABLE_CHECKING
2169 symtab_node::verify_symtab_nodes ();
2172 materialize_all_clones ();
2173 bitmap_obstack_initialize (NULL
);
2174 execute_ipa_pass_list (g
->get_passes ()->all_late_ipa_passes
);
2175 bitmap_obstack_release (NULL
);
2176 mark_functions_to_output ();
2178 /* When weakref support is missing, we autmatically translate all
2179 references to NODE to references to its ultimate alias target.
2180 The renaming mechanizm uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2183 Set up this mapping before we output any assembler but once we are sure
2184 that all symbol renaming is done.
2186 FIXME: All this uglyness can go away if we just do renaming at gimple
2187 level by physically rewritting the IL. At the moment we can only redirect
2188 calls, so we need infrastructure for renaming references as well. */
2189 #ifndef ASM_OUTPUT_WEAKREF
2192 FOR_EACH_SYMBOL (node
)
2194 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->decl
)))
2196 IDENTIFIER_TRANSPARENT_ALIAS
2197 (DECL_ASSEMBLER_NAME (node
->decl
)) = 1;
2198 TREE_CHAIN (DECL_ASSEMBLER_NAME (node
->decl
))
2199 = (node
->alias_target
? node
->alias_target
2200 : DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
));
2206 if (!flag_toplevel_reorder
)
2207 output_in_order (false);
2210 /* Output first asm statements and anything ordered. The process
2211 flag is cleared for these nodes, so we skip them later. */
2212 output_in_order (true);
2213 expand_all_functions ();
2214 output_variables ();
2217 process_new_functions ();
2223 fprintf (dump_file
, "\nFinal ");
2224 symtab_node::dump_table (dump_file
);
2226 #ifdef ENABLE_CHECKING
2227 symtab_node::verify_symtab_nodes ();
2228 /* Double check that all inline clones are gone and that all
2229 function bodies have been released from memory. */
2233 bool error_found
= false;
2235 FOR_EACH_DEFINED_FUNCTION (node
)
2236 if (node
->global
.inlined_to
2237 || gimple_has_body_p (node
->decl
))
2243 internal_error ("nodes with unreleased memory found");
2249 /* Analyze the whole compilation unit once it is parsed completely. */
2252 symbol_table::finalize_compilation_unit (void)
2254 timevar_push (TV_CGRAPH
);
2256 /* If we're here there's no current function anymore. Some frontends
2257 are lazy in clearing these. */
2258 current_function_decl
= NULL
;
2261 /* Do not skip analyzing the functions if there were errors, we
2262 miss diagnostics for following functions otherwise. */
2264 /* Emit size functions we didn't inline. */
2265 finalize_size_functions ();
2267 /* Mark alias targets necessary and emit diagnostics. */
2268 handle_alias_pairs ();
2272 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2276 if (flag_dump_passes
)
2279 /* Gimplify and lower all functions, compute reachability and
2280 remove unreachable nodes. */
2281 analyze_functions ();
2283 /* Mark alias targets necessary and emit diagnostics. */
2284 handle_alias_pairs ();
2286 /* Gimplify and lower thunks. */
2287 analyze_functions ();
2289 /* Finally drive the pass manager. */
2292 timevar_pop (TV_CGRAPH
);
2295 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
2296 kind of wrapper method. */
2299 cgraph_node::create_wrapper (cgraph_node
*target
)
2301 /* Preserve DECL_RESULT so we get right by reference flag. */
2302 tree decl_result
= DECL_RESULT (decl
);
2304 /* Remove the function's body but keep arguments to be reused
2306 release_body (true);
2309 DECL_RESULT (decl
) = decl_result
;
2310 DECL_INITIAL (decl
) = NULL
;
2311 allocate_struct_function (decl
, false);
2314 /* Turn alias into thunk and expand it into GIMPLE representation. */
2316 thunk
.thunk_p
= true;
2317 thunk
.this_adjusting
= false;
2319 cgraph_edge
*e
= create_edge (target
, NULL
, 0, CGRAPH_FREQ_BASE
);
2321 expand_thunk (false, true);
2322 e
->call_stmt_cannot_inline_p
= true;
2324 /* Inline summary set-up. */
2326 inline_analyze_function (this);
2329 #include "gt-cgraphunit.h"