1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3 2011 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This module implements main driver of compilation process as well as
23 few basic interprocedural optimizers.
25 The main scope of this file is to act as an interface in between
26 tree based frontends and the backend (and middle end)
28 The front-end is supposed to use following functionality:
30 - cgraph_finalize_function
32 This function is called once front-end has parsed whole body of function
33 and it is certain that the function body nor the declaration will change.
35 (There is one exception needed for implementing GCC extern inline
38 - varpool_finalize_variable
40 This function has same behavior as the above but is used for static
43 - cgraph_finalize_compilation_unit
45 This function is called once (source level) compilation unit is finalized
46 and it will no longer change.
48 In the call-graph construction and local function analysis takes
49 place here. Bodies of unreachable functions are released to
50 conserve memory usage.
52 The function can be called multiple times when multiple source level
53 compilation units are combined (such as in C frontend)
57 In this unit-at-a-time compilation the intra procedural analysis takes
58 place here. In particular the static functions whose address is never
59 taken are marked as local. Backend can then use this information to
60 modify calling conventions, do better inlining or similar optimizations.
62 - cgraph_mark_needed_node
63 - varpool_mark_needed_node
65 When function or variable is referenced by some hidden way the call-graph
66 data structure must be updated accordingly by this function.
67 There should be little need to call this function and all the references
68 should be made explicit to cgraph code. At present these functions are
69 used by C++ frontend to explicitly mark the keyed methods.
71 - analyze_expr callback
73 This function is responsible for lowering tree nodes not understood by
74 generic code into understandable ones or alternatively marking
75 callgraph and varpool nodes referenced by the as needed.
77 ??? On the tree-ssa genericizing should take place here and we will avoid
78 need for these hooks (replacing them by genericizing hook)
80 Analyzing of all functions is deferred
81 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
83 In cgraph_finalize_compilation_unit the reachable functions are
84 analyzed. During analysis the call-graph edges from reachable
85 functions are constructed and their destinations are marked as
86 reachable. References to functions and variables are discovered too
87 and variables found to be needed output to the assembly file. Via
88 mark_referenced call in assemble_variable functions referenced by
89 static variables are noticed too.
91 The intra-procedural information is produced and its existence
92 indicated by global_info_ready. Once this flag is set it is impossible
93 to change function from !reachable to reachable and thus
94 assemble_variable no longer call mark_referenced.
96 Finally the call-graph is topologically sorted and all reachable functions
97 that has not been completely inlined or are not external are output.
99 ??? It is possible that reference to function or variable is optimized
100 out. We can not deal with this nicely because topological order is not
101 suitable for it. For tree-ssa we may consider another pass doing
102 optimization and re-discovering reachable functions.
104 ??? Reorganize code so variables are output very last and only if they
105 really has been referenced by produced code, so we catch more cases
106 where reference has been optimized out. */
111 #include "coretypes.h"
115 #include "tree-flow.h"
116 #include "tree-inline.h"
117 #include "langhooks.h"
118 #include "pointer-set.h"
125 #include "diagnostic.h"
126 #include "tree-pretty-print.h"
127 #include "gimple-pretty-print.h"
132 #include "function.h"
133 #include "ipa-prop.h"
135 #include "tree-iterator.h"
136 #include "tree-pass.h"
137 #include "tree-dump.h"
139 #include "coverage.h"
142 static void cgraph_expand_all_functions (void);
143 static void cgraph_mark_functions_to_output (void);
144 static void cgraph_expand_function (struct cgraph_node *);
145 static void cgraph_output_pending_asms (void);
147 FILE *cgraph_dump_file;
149 /* Used for vtable lookup in thunk adjusting. */
150 static GTY (()) tree vtable_entry_type;
152 /* Determine if function DECL is needed. That is, visible to something
153 either outside this translation unit, something magic in the system
157 cgraph_decide_is_function_needed (struct cgraph_node *node, tree decl)
159 /* If the user told us it is used, then it must be so. */
160 if (node->local.externally_visible)
163 /* ??? If the assembler name is set by hand, it is possible to assemble
164 the name later after finalizing the function and the fact is noticed
165 in assemble_name then. This is arguably a bug. */
166 if (DECL_ASSEMBLER_NAME_SET_P (decl)
167 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
170 /* With -fkeep-inline-functions we are keeping all inline functions except
171 for extern inline ones. */
172 if (flag_keep_inline_functions
173 && DECL_DECLARED_INLINE_P (decl)
174 && !DECL_EXTERNAL (decl)
175 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl)))
178 /* If we decided it was needed before, but at the time we didn't have
179 the body of the function available, then it's still needed. We have
180 to go back and re-check its dependencies now. */
184 /* Externally visible functions must be output. The exception is
185 COMDAT functions that must be output only when they are needed.
187 When not optimizing, also output the static functions. (see
188 PR24561), but don't do so for always_inline functions, functions
189 declared inline and nested functions. These were optimized out
190 in the original implementation and it is unclear whether we want
191 to change the behavior here. */
192 if (((TREE_PUBLIC (decl)
194 && !node->local.disregard_inline_limits
195 && !DECL_DECLARED_INLINE_P (decl)
196 && !(DECL_CONTEXT (decl)
197 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)))
198 && !flag_whole_program
200 && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
206 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
207 functions into callgraph in a way so they look like ordinary reachable
208 functions inserted into callgraph already at construction time. */
211 cgraph_process_new_functions (void)
215 struct cgraph_node *node;
217 varpool_analyze_pending_decls ();
218 /* Note that this queue may grow as its being processed, as the new
219 functions may generate new ones. */
220 while (cgraph_new_nodes)
222 node = cgraph_new_nodes;
224 cgraph_new_nodes = cgraph_new_nodes->next_needed;
225 switch (cgraph_state)
227 case CGRAPH_STATE_CONSTRUCTION:
228 /* At construction time we just need to finalize function and move
229 it into reachable functions list. */
231 node->next_needed = NULL;
232 cgraph_finalize_function (fndecl, false);
233 cgraph_mark_reachable_node (node);
237 case CGRAPH_STATE_IPA:
238 case CGRAPH_STATE_IPA_SSA:
239 /* When IPA optimization already started, do all essential
240 transformations that has been already performed on the whole
241 cgraph but not on this function. */
243 gimple_register_cfg_hooks ();
245 cgraph_analyze_function (node);
246 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
247 current_function_decl = fndecl;
248 if ((cgraph_state == CGRAPH_STATE_IPA_SSA
249 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
250 /* When not optimizing, be sure we run early local passes anyway
253 execute_pass_list (pass_early_local_passes.pass.sub);
255 compute_inline_parameters (node);
256 free_dominance_info (CDI_POST_DOMINATORS);
257 free_dominance_info (CDI_DOMINATORS);
259 current_function_decl = NULL;
262 case CGRAPH_STATE_EXPANSION:
263 /* Functions created during expansion shall be compiled
266 cgraph_expand_function (node);
273 cgraph_call_function_insertion_hooks (node);
274 varpool_analyze_pending_decls ();
279 /* As an GCC extension we allow redefinition of the function. The
280 semantics when both copies of bodies differ is not well defined.
281 We replace the old body with new body so in unit at a time mode
282 we always use new body, while in normal mode we may end up with
283 old body inlined into some functions and new body expanded and
286 ??? It may make more sense to use one body for inlining and other
287 body for expanding the function but this is difficult to do. */
290 cgraph_reset_node (struct cgraph_node *node)
292 /* If node->process is set, then we have already begun whole-unit analysis.
293 This is *not* testing for whether we've already emitted the function.
294 That case can be sort-of legitimately seen with real function redefinition
295 errors. I would argue that the front end should never present us with
296 such a case, but don't enforce that for now. */
297 gcc_assert (!node->process);
299 /* Reset our data structures so we can analyze the function again. */
300 memset (&node->local, 0, sizeof (node->local));
301 memset (&node->global, 0, sizeof (node->global));
302 memset (&node->rtl, 0, sizeof (node->rtl));
303 node->analyzed = false;
304 node->local.redefined_extern_inline = true;
305 node->local.finalized = false;
307 cgraph_node_remove_callees (node);
309 /* We may need to re-queue the node for assembling in case
310 we already proceeded it and ignored as not needed or got
311 a re-declaration in IMA mode. */
314 struct cgraph_node *n;
316 for (n = cgraph_nodes_queue; n; n = n->next_needed)
325 cgraph_lower_function (struct cgraph_node *node)
331 lower_nested_functions (node->decl);
332 gcc_assert (!node->nested);
334 tree_lowering_passes (node->decl);
335 node->lowered = true;
338 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
339 logic in effect. If NESTED is true, then our caller cannot stand to have
340 the garbage collector run at the moment. We would need to either create
341 a new GC context, or just not compile right now. */
344 cgraph_finalize_function (tree decl, bool nested)
346 struct cgraph_node *node = cgraph_get_create_node (decl);
348 if (node->local.finalized)
349 cgraph_reset_node (node);
351 node->pid = cgraph_max_pid ++;
352 notice_global_symbol (decl);
353 node->local.finalized = true;
354 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
355 node->finalized_by_frontend = true;
357 if (cgraph_decide_is_function_needed (node, decl))
358 cgraph_mark_needed_node (node);
360 /* Since we reclaim unreachable nodes at the end of every language
361 level unit, we need to be conservative about possible entry points
363 if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
364 || DECL_STATIC_CONSTRUCTOR (decl)
365 || DECL_STATIC_DESTRUCTOR (decl)
366 /* COMDAT virtual functions may be referenced by vtable from
367 other compilation unit. Still we want to devirtualize calls
368 to those so we need to analyze them.
369 FIXME: We should introduce may edges for this purpose and update
370 their handling in unreachable function removal and inliner too. */
371 || (DECL_VIRTUAL_P (decl) && (DECL_COMDAT (decl) || DECL_EXTERNAL (decl))))
372 cgraph_mark_reachable_node (node);
374 /* If we've not yet emitted decl, tell the debug info about it. */
375 if (!TREE_ASM_WRITTEN (decl))
376 (*debug_hooks->deferred_inline_function) (decl);
378 /* Possibly warn about unused parameters. */
379 if (warn_unused_parameter)
380 do_warn_unused_parameter (decl);
386 /* C99 extern inline keywords allow changing of declaration after function
387 has been finalized. We need to re-decide if we want to mark the function as
391 cgraph_mark_if_needed (tree decl)
393 struct cgraph_node *node = cgraph_get_node (decl);
394 if (node->local.finalized && cgraph_decide_is_function_needed (node, decl))
395 cgraph_mark_needed_node (node);
398 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
400 clone_of_p (struct cgraph_node *node, struct cgraph_node *node2)
402 while (node != node2 && node2)
403 node2 = node2->clone_of;
404 return node2 != NULL;
407 /* Verify edge E count and frequency. */
410 verify_edge_count_and_frequency (struct cgraph_edge *e)
412 bool error_found = false;
415 error ("caller edge count is negative");
418 if (e->frequency < 0)
420 error ("caller edge frequency is negative");
423 if (e->frequency > CGRAPH_FREQ_MAX)
425 error ("caller edge frequency is too large");
428 if (gimple_has_body_p (e->caller->decl)
429 && !e->caller->global.inlined_to
431 != compute_call_stmt_bb_frequency (e->caller->decl,
432 gimple_bb (e->call_stmt))))
434 error ("caller edge frequency %i does not match BB frequency %i",
436 compute_call_stmt_bb_frequency (e->caller->decl,
437 gimple_bb (e->call_stmt)));
443 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
445 cgraph_debug_gimple_stmt (struct function *this_cfun, gimple stmt)
447 /* debug_gimple_stmt needs correct cfun */
448 if (cfun != this_cfun)
449 set_cfun (this_cfun);
450 debug_gimple_stmt (stmt);
453 /* Verify cgraph nodes of given cgraph node. */
455 verify_cgraph_node (struct cgraph_node *node)
457 struct cgraph_edge *e;
458 struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
459 basic_block this_block;
460 gimple_stmt_iterator gsi;
461 bool error_found = false;
466 timevar_push (TV_CGRAPH_VERIFY);
467 for (e = node->callees; e; e = e->next_callee)
470 error ("aux field set for edge %s->%s",
471 identifier_to_locale (cgraph_node_name (e->caller)),
472 identifier_to_locale (cgraph_node_name (e->callee)));
477 error ("execution count is negative");
480 if (node->global.inlined_to && node->local.externally_visible)
482 error ("externally visible inline clone");
485 if (node->global.inlined_to && node->address_taken)
487 error ("inline clone with address taken");
490 if (node->global.inlined_to && node->needed)
492 error ("inline clone is needed");
495 for (e = node->indirect_calls; e; e = e->next_callee)
499 error ("aux field set for indirect edge from %s",
500 identifier_to_locale (cgraph_node_name (e->caller)));
503 if (!e->indirect_unknown_callee
504 || !e->indirect_info)
506 error ("An indirect edge from %s is not marked as indirect or has "
507 "associated indirect_info, the corresponding statement is: ",
508 identifier_to_locale (cgraph_node_name (e->caller)));
509 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
513 for (e = node->callers; e; e = e->next_caller)
515 if (verify_edge_count_and_frequency (e))
517 if (!e->inline_failed)
519 if (node->global.inlined_to
520 != (e->caller->global.inlined_to
521 ? e->caller->global.inlined_to : e->caller))
523 error ("inlined_to pointer is wrong");
526 if (node->callers->next_caller)
528 error ("multiple inline callers");
533 if (node->global.inlined_to)
535 error ("inlined_to pointer set for noninline callers");
539 for (e = node->indirect_calls; e; e = e->next_callee)
540 if (verify_edge_count_and_frequency (e))
542 if (!node->callers && node->global.inlined_to)
544 error ("inlined_to pointer is set but no predecessors found");
547 if (node->global.inlined_to == node)
549 error ("inlined_to pointer refers to itself");
553 if (!cgraph_get_node (node->decl))
555 error ("node not found in cgraph_hash");
561 struct cgraph_node *n;
562 for (n = node->clone_of->clones; n; n = n->next_sibling_clone)
567 error ("node has wrong clone_of");
573 struct cgraph_node *n;
574 for (n = node->clones; n; n = n->next_sibling_clone)
575 if (n->clone_of != node)
579 error ("node has wrong clone list");
583 if ((node->prev_sibling_clone || node->next_sibling_clone) && !node->clone_of)
585 error ("node is in clone list but it is not clone");
588 if (!node->prev_sibling_clone && node->clone_of && node->clone_of->clones != node)
590 error ("node has wrong prev_clone pointer");
593 if (node->prev_sibling_clone && node->prev_sibling_clone->next_sibling_clone != node)
595 error ("double linked list of clones corrupted");
598 if (node->same_comdat_group)
600 struct cgraph_node *n = node->same_comdat_group;
602 if (!DECL_ONE_ONLY (node->decl))
604 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
609 error ("node is alone in a comdat group");
614 if (!n->same_comdat_group)
616 error ("same_comdat_group is not a circular list");
620 n = n->same_comdat_group;
625 if (node->analyzed && gimple_has_body_p (node->decl)
626 && !TREE_ASM_WRITTEN (node->decl)
627 && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to)
632 /* The nodes we're interested in are never shared, so walk
633 the tree ignoring duplicates. */
634 struct pointer_set_t *visited_nodes = pointer_set_create ();
635 /* Reach the trees by walking over the CFG, and note the
636 enclosing basic-blocks in the call edges. */
637 FOR_EACH_BB_FN (this_block, this_cfun)
638 for (gsi = gsi_start_bb (this_block);
642 gimple stmt = gsi_stmt (gsi);
643 if (is_gimple_call (stmt))
645 struct cgraph_edge *e = cgraph_edge (node, stmt);
646 tree decl = gimple_call_fndecl (stmt);
651 error ("shared call_stmt:");
652 cgraph_debug_gimple_stmt (this_cfun, stmt);
655 if (!e->indirect_unknown_callee)
657 struct cgraph_node *n;
659 if (e->callee->same_body_alias)
661 error ("edge points to same body alias:");
662 debug_tree (e->callee->decl);
665 else if (!e->callee->global.inlined_to
667 && cgraph_get_node (decl)
668 && (e->callee->former_clone_of
669 != cgraph_get_node (decl)->decl)
670 && !clone_of_p (cgraph_get_node (decl),
673 error ("edge points to wrong declaration:");
674 debug_tree (e->callee->decl);
675 fprintf (stderr," Instead of:");
680 && (n = cgraph_get_node_or_alias (decl))
681 && (n->same_body_alias
682 && n->thunk.thunk_p))
684 error ("a call to thunk improperly represented "
685 "in the call graph:");
686 cgraph_debug_gimple_stmt (this_cfun, stmt);
692 error ("an indirect edge with unknown callee "
693 "corresponding to a call_stmt with "
694 "a known declaration:");
696 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
702 error ("missing callgraph edge for call stmt:");
703 cgraph_debug_gimple_stmt (this_cfun, stmt);
708 pointer_set_destroy (visited_nodes);
711 /* No CFG available?! */
714 for (e = node->callees; e; e = e->next_callee)
718 error ("edge %s->%s has no corresponding call_stmt",
719 identifier_to_locale (cgraph_node_name (e->caller)),
720 identifier_to_locale (cgraph_node_name (e->callee)));
721 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
726 for (e = node->indirect_calls; e; e = e->next_callee)
730 error ("an indirect edge from %s has no corresponding call_stmt",
731 identifier_to_locale (cgraph_node_name (e->caller)));
732 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
740 dump_cgraph_node (stderr, node);
741 internal_error ("verify_cgraph_node failed");
743 timevar_pop (TV_CGRAPH_VERIFY);
746 /* Verify whole cgraph structure. */
750 struct cgraph_node *node;
755 for (node = cgraph_nodes; node; node = node->next)
756 verify_cgraph_node (node);
759 /* Output all asm statements we have stored up to be output. */
762 cgraph_output_pending_asms (void)
764 struct cgraph_asm_node *can;
769 for (can = cgraph_asm_nodes; can; can = can->next)
770 assemble_asm (can->asm_str);
771 cgraph_asm_nodes = NULL;
774 /* Analyze the function scheduled to be output. */
776 cgraph_analyze_function (struct cgraph_node *node)
778 tree save = current_function_decl;
779 tree decl = node->decl;
781 current_function_decl = decl;
782 push_cfun (DECL_STRUCT_FUNCTION (decl));
784 assign_assembler_name_if_neeeded (node->decl);
786 /* disregard_inline_limits affects topological order of the early optimization,
787 so we need to compute it ahead of rest of inline parameters. */
788 node->local.disregard_inline_limits
789 = DECL_DISREGARD_INLINE_LIMITS (node->decl);
791 /* Make sure to gimplify bodies only once. During analyzing a
792 function we lower it, which will require gimplified nested
793 functions, so we can end up here with an already gimplified
795 if (!gimple_body (decl))
796 gimplify_function_tree (decl);
797 dump_function (TDI_generic, decl);
799 cgraph_lower_function (node);
800 node->analyzed = true;
803 current_function_decl = save;
806 /* Process attributes common for vars and functions. */
809 process_common_attributes (tree decl)
811 tree weakref = lookup_attribute ("weakref", DECL_ATTRIBUTES (decl));
813 if (weakref && !lookup_attribute ("alias", DECL_ATTRIBUTES (decl)))
815 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wattributes,
816 "%<weakref%> attribute should be accompanied with"
817 " an %<alias%> attribute");
818 DECL_WEAK (decl) = 0;
819 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
820 DECL_ATTRIBUTES (decl));
824 /* Look for externally_visible and used attributes and mark cgraph nodes
827 We cannot mark the nodes at the point the attributes are processed (in
828 handle_*_attribute) because the copy of the declarations available at that
829 point may not be canonical. For example, in:
832 void f() __attribute__((used));
834 the declaration we see in handle_used_attribute will be the second
835 declaration -- but the front end will subsequently merge that declaration
836 with the original declaration and discard the second declaration.
838 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
841 void f() __attribute__((externally_visible));
845 So, we walk the nodes at the end of the translation unit, applying the
846 attributes at that point. */
849 process_function_and_variable_attributes (struct cgraph_node *first,
850 struct varpool_node *first_var)
852 struct cgraph_node *node;
853 struct varpool_node *vnode;
855 for (node = cgraph_nodes; node != first; node = node->next)
857 tree decl = node->decl;
858 if (DECL_PRESERVE_P (decl))
859 cgraph_mark_needed_node (node);
860 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
861 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))
862 && TREE_PUBLIC (node->decl))
864 if (node->local.finalized)
865 cgraph_mark_needed_node (node);
867 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
869 if (! TREE_PUBLIC (node->decl))
870 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
871 "%<externally_visible%>"
872 " attribute have effect only on public objects");
873 else if (node->local.finalized)
874 cgraph_mark_needed_node (node);
876 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
877 && node->local.finalized)
879 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
880 "%<weakref%> attribute ignored"
881 " because function is defined");
882 DECL_WEAK (decl) = 0;
883 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
884 DECL_ATTRIBUTES (decl));
886 process_common_attributes (decl);
888 for (vnode = varpool_nodes; vnode != first_var; vnode = vnode->next)
890 tree decl = vnode->decl;
891 if (DECL_PRESERVE_P (decl))
893 vnode->force_output = true;
894 if (vnode->finalized)
895 varpool_mark_needed_node (vnode);
897 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
898 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))
899 && TREE_PUBLIC (vnode->decl))
901 if (vnode->finalized)
902 varpool_mark_needed_node (vnode);
904 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
906 if (! TREE_PUBLIC (vnode->decl))
907 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
908 "%<externally_visible%>"
909 " attribute have effect only on public objects");
910 else if (vnode->finalized)
911 varpool_mark_needed_node (vnode);
913 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
915 && DECL_INITIAL (decl))
917 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
918 "%<weakref%> attribute ignored"
919 " because variable is initialized");
920 DECL_WEAK (decl) = 0;
921 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
922 DECL_ATTRIBUTES (decl));
924 process_common_attributes (decl);
928 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
929 each reachable functions) and build cgraph.
930 The function can be called multiple times after inserting new nodes
931 into beginning of queue. Just the new part of queue is re-scanned then. */
934 cgraph_analyze_functions (void)
936 /* Keep track of already processed nodes when called multiple times for
937 intermodule optimization. */
938 static struct cgraph_node *first_analyzed;
939 struct cgraph_node *first_processed = first_analyzed;
940 static struct varpool_node *first_analyzed_var;
941 struct cgraph_node *node, *next;
943 bitmap_obstack_initialize (NULL);
944 process_function_and_variable_attributes (first_processed,
946 first_processed = cgraph_nodes;
947 first_analyzed_var = varpool_nodes;
948 varpool_analyze_pending_decls ();
949 if (cgraph_dump_file)
951 fprintf (cgraph_dump_file, "Initial entry points:");
952 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
954 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
955 fprintf (cgraph_dump_file, "\n");
957 cgraph_process_new_functions ();
959 /* Propagate reachability flag and lower representation of all reachable
960 functions. In the future, lowering will introduce new functions and
961 new entry points on the way (by template instantiation and virtual
962 method table generation for instance). */
963 while (cgraph_nodes_queue)
965 struct cgraph_edge *edge;
966 tree decl = cgraph_nodes_queue->decl;
968 node = cgraph_nodes_queue;
969 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
970 node->next_needed = NULL;
972 /* ??? It is possible to create extern inline function and later using
973 weak alias attribute to kill its body. See
974 gcc.c-torture/compile/20011119-1.c */
975 if (!DECL_STRUCT_FUNCTION (decl))
977 cgraph_reset_node (node);
982 cgraph_analyze_function (node);
984 for (edge = node->callees; edge; edge = edge->next_callee)
985 if (!edge->callee->reachable)
986 cgraph_mark_reachable_node (edge->callee);
988 if (node->same_comdat_group)
990 for (next = node->same_comdat_group;
992 next = next->same_comdat_group)
993 cgraph_mark_reachable_node (next);
996 /* If decl is a clone of an abstract function, mark that abstract
997 function so that we don't release its body. The DECL_INITIAL() of that
998 abstract function declaration will be later needed to output debug
1000 if (DECL_ABSTRACT_ORIGIN (decl))
1002 struct cgraph_node *origin_node;
1003 origin_node = cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl));
1004 origin_node->abstract_and_needed = true;
1007 /* We finalize local static variables during constructing callgraph
1008 edges. Process their attributes too. */
1009 process_function_and_variable_attributes (first_processed,
1010 first_analyzed_var);
1011 first_processed = cgraph_nodes;
1012 first_analyzed_var = varpool_nodes;
1013 varpool_analyze_pending_decls ();
1014 cgraph_process_new_functions ();
1017 /* Collect entry points to the unit. */
1018 if (cgraph_dump_file)
1020 fprintf (cgraph_dump_file, "Unit entry points:");
1021 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1023 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1024 fprintf (cgraph_dump_file, "\n\nInitial ");
1025 dump_cgraph (cgraph_dump_file);
1026 dump_varpool (cgraph_dump_file);
1029 if (cgraph_dump_file)
1030 fprintf (cgraph_dump_file, "\nReclaiming functions:");
1032 for (node = cgraph_nodes; node != first_analyzed; node = next)
1034 tree decl = node->decl;
1037 if (node->local.finalized && !gimple_has_body_p (decl))
1038 cgraph_reset_node (node);
1040 if (!node->reachable && gimple_has_body_p (decl))
1042 if (cgraph_dump_file)
1043 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1044 cgraph_remove_node (node);
1048 node->next_needed = NULL;
1049 gcc_assert (!node->local.finalized || gimple_has_body_p (decl));
1050 gcc_assert (node->analyzed == node->local.finalized);
1052 if (cgraph_dump_file)
1054 fprintf (cgraph_dump_file, "\n\nReclaimed ");
1055 dump_cgraph (cgraph_dump_file);
1056 dump_varpool (cgraph_dump_file);
1058 bitmap_obstack_release (NULL);
1059 first_analyzed = cgraph_nodes;
1064 /* Analyze the whole compilation unit once it is parsed completely. */
1067 cgraph_finalize_compilation_unit (void)
1069 timevar_push (TV_CGRAPH);
1071 /* If we're here there's no current function anymore. Some frontends
1072 are lazy in clearing these. */
1073 current_function_decl = NULL;
1076 /* Do not skip analyzing the functions if there were errors, we
1077 miss diagnostics for following functions otherwise. */
1079 /* Emit size functions we didn't inline. */
1080 finalize_size_functions ();
1082 /* Mark alias targets necessary and emit diagnostics. */
1083 finish_aliases_1 ();
1087 fprintf (stderr, "\nAnalyzing compilation unit\n");
1091 /* Gimplify and lower all functions, compute reachability and
1092 remove unreachable nodes. */
1093 cgraph_analyze_functions ();
1095 /* Mark alias targets necessary and emit diagnostics. */
1096 finish_aliases_1 ();
1098 /* Gimplify and lower thunks. */
1099 cgraph_analyze_functions ();
1101 /* Finally drive the pass manager. */
1104 timevar_pop (TV_CGRAPH);
1108 /* Figure out what functions we want to assemble. */
1111 cgraph_mark_functions_to_output (void)
1113 struct cgraph_node *node;
1114 #ifdef ENABLE_CHECKING
1115 bool check_same_comdat_groups = false;
1117 for (node = cgraph_nodes; node; node = node->next)
1118 gcc_assert (!node->process);
1121 for (node = cgraph_nodes; node; node = node->next)
1123 tree decl = node->decl;
1124 struct cgraph_edge *e;
1126 gcc_assert (!node->process || node->same_comdat_group);
1130 for (e = node->callers; e; e = e->next_caller)
1131 if (e->inline_failed)
1134 /* We need to output all local functions that are used and not
1135 always inlined, as well as those that are reachable from
1136 outside the current compilation unit. */
1138 && !node->global.inlined_to
1139 && (!cgraph_only_called_directly_p (node)
1140 || (e && node->reachable))
1141 && !TREE_ASM_WRITTEN (decl)
1142 && !DECL_EXTERNAL (decl))
1145 if (node->same_comdat_group)
1147 struct cgraph_node *next;
1148 for (next = node->same_comdat_group;
1150 next = next->same_comdat_group)
1154 else if (node->same_comdat_group)
1156 #ifdef ENABLE_CHECKING
1157 check_same_comdat_groups = true;
1162 /* We should've reclaimed all functions that are not needed. */
1163 #ifdef ENABLE_CHECKING
1164 if (!node->global.inlined_to
1165 && gimple_has_body_p (decl)
1166 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1167 are inside partition, we can end up not removing the body since we no longer
1168 have analyzed node pointing to it. */
1169 && !node->in_other_partition
1170 && !DECL_EXTERNAL (decl))
1172 dump_cgraph_node (stderr, node);
1173 internal_error ("failed to reclaim unneeded function");
1176 gcc_assert (node->global.inlined_to
1177 || !gimple_has_body_p (decl)
1178 || node->in_other_partition
1179 || DECL_EXTERNAL (decl));
1184 #ifdef ENABLE_CHECKING
1185 if (check_same_comdat_groups)
1186 for (node = cgraph_nodes; node; node = node->next)
1187 if (node->same_comdat_group && !node->process)
1189 tree decl = node->decl;
1190 if (!node->global.inlined_to
1191 && gimple_has_body_p (decl)
1192 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1193 are inside partition, we can end up not removing the body since we no longer
1194 have analyzed node pointing to it. */
1195 && !node->in_other_partition
1196 && !DECL_EXTERNAL (decl))
1198 dump_cgraph_node (stderr, node);
1199 internal_error ("failed to reclaim unneeded function");
1205 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1206 in lowered gimple form.
1208 Set current_function_decl and cfun to newly constructed empty function body.
1209 return basic block in the function body. */
1212 init_lowered_empty_function (tree decl)
1216 current_function_decl = decl;
1217 allocate_struct_function (decl, false);
1218 gimple_register_cfg_hooks ();
1219 init_empty_tree_cfg ();
1220 init_tree_ssa (cfun);
1221 init_ssa_operands ();
1222 cfun->gimple_df->in_ssa_p = true;
1223 DECL_INITIAL (decl) = make_node (BLOCK);
1225 DECL_SAVED_TREE (decl) = error_mark_node;
1226 cfun->curr_properties |=
1227 (PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_referenced_vars |
1230 /* Create BB for body of the function and connect it properly. */
1231 bb = create_basic_block (NULL, (void *) 0, ENTRY_BLOCK_PTR);
1232 make_edge (ENTRY_BLOCK_PTR, bb, 0);
1233 make_edge (bb, EXIT_BLOCK_PTR, 0);
1238 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1239 offset indicated by VIRTUAL_OFFSET, if that is
1240 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1241 zero for a result adjusting thunk. */
1244 thunk_adjust (gimple_stmt_iterator * bsi,
1245 tree ptr, bool this_adjusting,
1246 HOST_WIDE_INT fixed_offset, tree virtual_offset)
1252 && fixed_offset != 0)
1254 stmt = gimple_build_assign (ptr,
1255 fold_build2_loc (input_location,
1257 TREE_TYPE (ptr), ptr,
1258 size_int (fixed_offset)));
1259 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1262 /* If there's a virtual offset, look up that value in the vtable and
1263 adjust the pointer again. */
1271 if (!vtable_entry_type)
1273 tree vfunc_type = make_node (FUNCTION_TYPE);
1274 TREE_TYPE (vfunc_type) = integer_type_node;
1275 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
1276 layout_type (vfunc_type);
1278 vtable_entry_type = build_pointer_type (vfunc_type);
1282 create_tmp_var (build_pointer_type
1283 (build_pointer_type (vtable_entry_type)), "vptr");
1285 /* The vptr is always at offset zero in the object. */
1286 stmt = gimple_build_assign (vtabletmp,
1287 build1 (NOP_EXPR, TREE_TYPE (vtabletmp),
1289 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1290 mark_symbols_for_renaming (stmt);
1291 find_referenced_vars_in (stmt);
1293 /* Form the vtable address. */
1294 vtabletmp2 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp)),
1296 stmt = gimple_build_assign (vtabletmp2,
1297 build_simple_mem_ref (vtabletmp));
1298 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1299 mark_symbols_for_renaming (stmt);
1300 find_referenced_vars_in (stmt);
1302 /* Find the entry with the vcall offset. */
1303 stmt = gimple_build_assign (vtabletmp2,
1304 fold_build2_loc (input_location,
1306 TREE_TYPE (vtabletmp2),
1308 fold_convert (sizetype,
1310 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1312 /* Get the offset itself. */
1313 vtabletmp3 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2)),
1315 stmt = gimple_build_assign (vtabletmp3,
1316 build_simple_mem_ref (vtabletmp2));
1317 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1318 mark_symbols_for_renaming (stmt);
1319 find_referenced_vars_in (stmt);
1321 /* Cast to sizetype. */
1322 offsettmp = create_tmp_var (sizetype, "offset");
1323 stmt = gimple_build_assign (offsettmp, fold_convert (sizetype, vtabletmp3));
1324 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1325 mark_symbols_for_renaming (stmt);
1326 find_referenced_vars_in (stmt);
1328 /* Adjust the `this' pointer. */
1329 ptr = fold_build2_loc (input_location,
1330 POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
1335 && fixed_offset != 0)
1336 /* Adjust the pointer by the constant. */
1340 if (TREE_CODE (ptr) == VAR_DECL)
1344 ptrtmp = create_tmp_var (TREE_TYPE (ptr), "ptr");
1345 stmt = gimple_build_assign (ptrtmp, ptr);
1346 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1347 mark_symbols_for_renaming (stmt);
1348 find_referenced_vars_in (stmt);
1350 ptr = fold_build2_loc (input_location,
1351 POINTER_PLUS_EXPR, TREE_TYPE (ptrtmp), ptrtmp,
1352 size_int (fixed_offset));
1355 /* Emit the statement and gimplify the adjustment expression. */
1356 ret = create_tmp_var (TREE_TYPE (ptr), "adjusted_this");
1357 stmt = gimple_build_assign (ret, ptr);
1358 mark_symbols_for_renaming (stmt);
1359 find_referenced_vars_in (stmt);
1360 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1365 /* Produce assembler for thunk NODE. */
1368 assemble_thunk (struct cgraph_node *node)
1370 bool this_adjusting = node->thunk.this_adjusting;
1371 HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset;
1372 HOST_WIDE_INT virtual_value = node->thunk.virtual_value;
1373 tree virtual_offset = NULL;
1374 tree alias = node->thunk.alias;
1375 tree thunk_fndecl = node->decl;
1376 tree a = DECL_ARGUMENTS (thunk_fndecl);
1378 current_function_decl = thunk_fndecl;
1380 /* Ensure thunks are emitted in their correct sections. */
1381 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
1384 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
1385 virtual_value, alias))
1390 DECL_RESULT (thunk_fndecl)
1391 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl),
1392 RESULT_DECL, 0, integer_type_node);
1393 fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl));
1395 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1397 fn_block = make_node (BLOCK);
1398 BLOCK_VARS (fn_block) = a;
1399 DECL_INITIAL (thunk_fndecl) = fn_block;
1400 init_function_start (thunk_fndecl);
1402 assemble_start_function (thunk_fndecl, fnname);
1404 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
1405 fixed_offset, virtual_value, alias);
1407 assemble_end_function (thunk_fndecl, fnname);
1408 init_insn_lengths ();
1409 free_after_compilation (cfun);
1411 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1416 basic_block bb, then_bb, else_bb, return_bb;
1417 gimple_stmt_iterator bsi;
1423 VEC(tree, heap) *vargs;
1428 DECL_IGNORED_P (thunk_fndecl) = 1;
1429 bitmap_obstack_initialize (NULL);
1431 if (node->thunk.virtual_offset_p)
1432 virtual_offset = size_int (virtual_value);
1434 /* Build the return declaration for the function. */
1435 restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1436 if (DECL_RESULT (thunk_fndecl) == NULL_TREE)
1438 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
1439 DECL_ARTIFICIAL (resdecl) = 1;
1440 DECL_IGNORED_P (resdecl) = 1;
1441 DECL_RESULT (thunk_fndecl) = resdecl;
1444 resdecl = DECL_RESULT (thunk_fndecl);
1446 bb = then_bb = else_bb = return_bb = init_lowered_empty_function (thunk_fndecl);
1448 bsi = gsi_start_bb (bb);
1450 /* Build call to the function being thunked. */
1451 if (!VOID_TYPE_P (restype))
1453 if (!is_gimple_reg_type (restype))
1456 add_local_decl (cfun, restmp);
1457 BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp;
1460 restmp = create_tmp_var_raw (restype, "retval");
1463 for (arg = a; arg; arg = DECL_CHAIN (arg))
1465 vargs = VEC_alloc (tree, heap, nargs);
1467 VEC_quick_push (tree, vargs,
1472 VEC_quick_push (tree, vargs, a);
1473 for (i = 1, arg = DECL_CHAIN (a); i < nargs; i++, arg = DECL_CHAIN (arg))
1474 VEC_quick_push (tree, vargs, arg);
1475 call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
1476 VEC_free (tree, heap, vargs);
1477 gimple_call_set_cannot_inline (call, true);
1478 gimple_call_set_from_thunk (call, true);
1480 gimple_call_set_lhs (call, restmp);
1481 gsi_insert_after (&bsi, call, GSI_NEW_STMT);
1482 mark_symbols_for_renaming (call);
1483 find_referenced_vars_in (call);
1486 if (restmp && !this_adjusting)
1488 tree true_label = NULL_TREE;
1490 if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
1493 /* If the return type is a pointer, we need to
1494 protect against NULL. We know there will be an
1495 adjustment, because that's why we're emitting a
1497 then_bb = create_basic_block (NULL, (void *) 0, bb);
1498 return_bb = create_basic_block (NULL, (void *) 0, then_bb);
1499 else_bb = create_basic_block (NULL, (void *) 0, else_bb);
1500 remove_edge (single_succ_edge (bb));
1501 true_label = gimple_block_label (then_bb);
1502 stmt = gimple_build_cond (NE_EXPR, restmp,
1503 build_zero_cst (TREE_TYPE (restmp)),
1504 NULL_TREE, NULL_TREE);
1505 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1506 make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1507 make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1508 make_edge (return_bb, EXIT_BLOCK_PTR, 0);
1509 make_edge (then_bb, return_bb, EDGE_FALLTHRU);
1510 make_edge (else_bb, return_bb, EDGE_FALLTHRU);
1511 bsi = gsi_last_bb (then_bb);
1514 restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0,
1515 fixed_offset, virtual_offset);
1519 bsi = gsi_last_bb (else_bb);
1520 stmt = gimple_build_assign (restmp,
1521 build_zero_cst (TREE_TYPE (restmp)));
1522 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1523 bsi = gsi_last_bb (return_bb);
1527 gimple_call_set_tail (call, true);
1529 /* Build return value. */
1530 ret = gimple_build_return (restmp);
1531 gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
1533 delete_unreachable_blocks ();
1534 update_ssa (TODO_update_ssa);
1536 cgraph_remove_same_body_alias (node);
1537 /* Since we want to emit the thunk, we explicitly mark its name as
1539 cgraph_add_new_function (thunk_fndecl, true);
1540 bitmap_obstack_release (NULL);
1542 current_function_decl = NULL;
1545 /* Expand function specified by NODE. */
1548 cgraph_expand_function (struct cgraph_node *node)
1550 tree decl = node->decl;
1552 /* We ought to not compile any inline clones. */
1553 gcc_assert (!node->global.inlined_to);
1555 announce_function (decl);
1557 if (node->same_body)
1559 struct cgraph_node *alias, *next;
1560 bool saved_alias = node->alias;
1561 for (alias = node->same_body;
1562 alias && alias->next; alias = alias->next)
1564 /* Walk aliases in the order they were created; it is possible that
1565 thunks refers to the aliases made earlier. */
1566 for (; alias; alias = next)
1568 next = alias->previous;
1569 if (!alias->thunk.thunk_p)
1570 assemble_alias (alias->decl,
1571 DECL_ASSEMBLER_NAME (alias->thunk.alias));
1573 assemble_thunk (alias);
1575 node->alias = saved_alias;
1576 cgraph_process_new_functions ();
1579 gcc_assert (node->lowered);
1581 /* Generate RTL for the body of DECL. */
1582 tree_rest_of_compilation (decl);
1584 /* Make sure that BE didn't give up on compiling. */
1585 gcc_assert (TREE_ASM_WRITTEN (decl));
1586 current_function_decl = NULL;
1587 gcc_assert (!cgraph_preserve_function_body_p (decl));
1588 cgraph_release_function_body (node);
1589 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1590 points to the dead function body. */
1591 cgraph_node_remove_callees (node);
1593 cgraph_function_flags_ready = true;
1596 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1599 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason)
1601 *reason = e->inline_failed;
1602 return !e->inline_failed;
1607 /* Expand all functions that must be output.
1609 Attempt to topologically sort the nodes so function is output when
1610 all called functions are already assembled to allow data to be
1611 propagated across the callgraph. Use a stack to get smaller distance
1612 between a function and its callees (later we may choose to use a more
1613 sophisticated algorithm for function reordering; we will likely want
1614 to use subsections to make the output functions appear in top-down
1618 cgraph_expand_all_functions (void)
1620 struct cgraph_node *node;
1621 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1622 int order_pos, new_order_pos = 0;
1625 order_pos = cgraph_postorder (order);
1626 gcc_assert (order_pos == cgraph_n_nodes);
1628 /* Garbage collector may remove inline clones we eliminate during
1629 optimization. So we must be sure to not reference them. */
1630 for (i = 0; i < order_pos; i++)
1631 if (order[i]->process)
1632 order[new_order_pos++] = order[i];
1634 for (i = new_order_pos - 1; i >= 0; i--)
1639 gcc_assert (node->reachable);
1641 cgraph_expand_function (node);
1644 cgraph_process_new_functions ();
1650 /* This is used to sort the node types by the cgraph order number. */
1652 enum cgraph_order_sort_kind
1654 ORDER_UNDEFINED = 0,
1660 struct cgraph_order_sort
1662 enum cgraph_order_sort_kind kind;
1665 struct cgraph_node *f;
1666 struct varpool_node *v;
1667 struct cgraph_asm_node *a;
1671 /* Output all functions, variables, and asm statements in the order
1672 according to their order fields, which is the order in which they
1673 appeared in the file. This implements -fno-toplevel-reorder. In
1674 this mode we may output functions and variables which don't really
1675 need to be output. */
1678 cgraph_output_in_order (void)
1681 struct cgraph_order_sort *nodes;
1683 struct cgraph_node *pf;
1684 struct varpool_node *pv;
1685 struct cgraph_asm_node *pa;
1688 nodes = XCNEWVEC (struct cgraph_order_sort, max);
1690 varpool_analyze_pending_decls ();
1692 for (pf = cgraph_nodes; pf; pf = pf->next)
1697 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1698 nodes[i].kind = ORDER_FUNCTION;
1703 for (pv = varpool_nodes_queue; pv; pv = pv->next_needed)
1706 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1707 nodes[i].kind = ORDER_VAR;
1711 for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1714 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1715 nodes[i].kind = ORDER_ASM;
1719 /* In toplevel reorder mode we output all statics; mark them as needed. */
1720 for (i = 0; i < max; ++i)
1722 if (nodes[i].kind == ORDER_VAR)
1724 varpool_mark_needed_node (nodes[i].u.v);
1727 varpool_empty_needed_queue ();
1729 for (i = 0; i < max; ++i)
1730 if (nodes[i].kind == ORDER_VAR)
1731 varpool_finalize_named_section_flags (nodes[i].u.v);
1733 for (i = 0; i < max; ++i)
1735 switch (nodes[i].kind)
1737 case ORDER_FUNCTION:
1738 nodes[i].u.f->process = 0;
1739 cgraph_expand_function (nodes[i].u.f);
1743 varpool_assemble_decl (nodes[i].u.v);
1747 assemble_asm (nodes[i].u.a->asm_str);
1750 case ORDER_UNDEFINED:
1758 cgraph_asm_nodes = NULL;
1762 /* Return true when function body of DECL still needs to be kept around
1763 for later re-use. */
1765 cgraph_preserve_function_body_p (tree decl)
1767 struct cgraph_node *node;
1769 gcc_assert (cgraph_global_info_ready);
1770 /* Look if there is any clone around. */
1771 node = cgraph_get_node (decl);
1781 current_function_decl = NULL;
1782 gimple_register_cfg_hooks ();
1783 bitmap_obstack_initialize (NULL);
1785 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
1789 execute_ipa_pass_list (all_small_ipa_passes);
1794 /* If pass_all_early_optimizations was not scheduled, the state of
1795 the cgraph will not be properly updated. Update it now. */
1796 if (cgraph_state < CGRAPH_STATE_IPA_SSA)
1797 cgraph_state = CGRAPH_STATE_IPA_SSA;
1801 /* Generate coverage variables and constructors. */
1804 /* Process new functions added. */
1806 current_function_decl = NULL;
1807 cgraph_process_new_functions ();
1809 execute_ipa_summary_passes
1810 ((struct ipa_opt_pass_d *) all_regular_ipa_passes);
1813 /* Some targets need to handle LTO assembler output specially. */
1814 if (flag_generate_lto)
1815 targetm.asm_out.lto_start ();
1817 execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes);
1820 ipa_write_summaries ();
1822 if (flag_generate_lto)
1823 targetm.asm_out.lto_end ();
1826 execute_ipa_pass_list (all_regular_ipa_passes);
1827 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
1829 bitmap_obstack_release (NULL);
1833 /* Perform simple optimizations based on callgraph. */
1836 cgraph_optimize (void)
1841 #ifdef ENABLE_CHECKING
1845 /* Frontend may output common variables after the unit has been finalized.
1846 It is safe to deal with them here as they are always zero initialized. */
1847 varpool_analyze_pending_decls ();
1849 timevar_push (TV_CGRAPHOPT);
1850 if (pre_ipa_mem_report)
1852 fprintf (stderr, "Memory consumption before IPA\n");
1853 dump_memory_report (false);
1856 fprintf (stderr, "Performing interprocedural optimizations\n");
1857 cgraph_state = CGRAPH_STATE_IPA;
1859 /* Don't run the IPA passes if there was any error or sorry messages. */
1863 /* Do nothing else if any IPA pass found errors. */
1866 timevar_pop (TV_CGRAPHOPT);
1870 /* This pass remove bodies of extern inline functions we never inlined.
1871 Do this later so other IPA passes see what is really going on. */
1872 cgraph_remove_unreachable_nodes (false, dump_file);
1873 cgraph_global_info_ready = true;
1874 if (cgraph_dump_file)
1876 fprintf (cgraph_dump_file, "Optimized ");
1877 dump_cgraph (cgraph_dump_file);
1878 dump_varpool (cgraph_dump_file);
1880 if (post_ipa_mem_report)
1882 fprintf (stderr, "Memory consumption after IPA\n");
1883 dump_memory_report (false);
1885 timevar_pop (TV_CGRAPHOPT);
1887 /* Output everything. */
1888 (*debug_hooks->assembly_start) ();
1890 fprintf (stderr, "Assembling functions:\n");
1891 #ifdef ENABLE_CHECKING
1895 cgraph_materialize_all_clones ();
1896 cgraph_mark_functions_to_output ();
1898 cgraph_state = CGRAPH_STATE_EXPANSION;
1899 if (!flag_toplevel_reorder)
1900 cgraph_output_in_order ();
1903 cgraph_output_pending_asms ();
1905 cgraph_expand_all_functions ();
1906 varpool_remove_unreferenced_decls ();
1908 varpool_assemble_pending_decls ();
1910 cgraph_process_new_functions ();
1911 cgraph_state = CGRAPH_STATE_FINISHED;
1913 if (cgraph_dump_file)
1915 fprintf (cgraph_dump_file, "\nFinal ");
1916 dump_cgraph (cgraph_dump_file);
1917 dump_varpool (cgraph_dump_file);
1919 #ifdef ENABLE_CHECKING
1921 /* Double check that all inline clones are gone and that all
1922 function bodies have been released from memory. */
1925 struct cgraph_node *node;
1926 bool error_found = false;
1928 for (node = cgraph_nodes; node; node = node->next)
1930 && (node->global.inlined_to
1931 || gimple_has_body_p (node->decl)))
1934 dump_cgraph_node (stderr, node);
1937 internal_error ("nodes with unreleased memory found");
1945 if (!cgraph_dump_file)
1946 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1949 /* The edges representing the callers of the NEW_VERSION node were
1950 fixed by cgraph_function_versioning (), now the call_expr in their
1951 respective tree code should be updated to call the NEW_VERSION. */
1954 update_call_expr (struct cgraph_node *new_version)
1956 struct cgraph_edge *e;
1958 gcc_assert (new_version);
1960 /* Update the call expr on the edges to call the new version. */
1961 for (e = new_version->callers; e; e = e->next_caller)
1963 struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
1964 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
1965 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
1970 /* Create a new cgraph node which is the new version of
1971 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1972 edges which should be redirected to point to
1973 NEW_VERSION. ALL the callees edges of OLD_VERSION
1974 are cloned to the new version node. Return the new
1977 If non-NULL BLOCK_TO_COPY determine what basic blocks
1978 was copied to prevent duplications of calls that are dead
1981 static struct cgraph_node *
1982 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
1984 VEC(cgraph_edge_p,heap) *redirect_callers,
1987 struct cgraph_node *new_version;
1988 struct cgraph_edge *e;
1991 gcc_assert (old_version);
1993 new_version = cgraph_create_node (new_decl);
1995 new_version->analyzed = true;
1996 new_version->local = old_version->local;
1997 new_version->local.externally_visible = false;
1998 new_version->local.local = true;
1999 new_version->local.vtable_method = false;
2000 new_version->global = old_version->global;
2001 new_version->rtl = old_version->rtl;
2002 new_version->reachable = true;
2003 new_version->count = old_version->count;
2005 for (e = old_version->callees; e; e=e->next_callee)
2007 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
2008 cgraph_clone_edge (e, new_version, e->call_stmt,
2009 e->lto_stmt_uid, REG_BR_PROB_BASE,
2011 e->loop_nest, true);
2012 for (e = old_version->indirect_calls; e; e=e->next_callee)
2014 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
2015 cgraph_clone_edge (e, new_version, e->call_stmt,
2016 e->lto_stmt_uid, REG_BR_PROB_BASE,
2018 e->loop_nest, true);
2019 FOR_EACH_VEC_ELT (cgraph_edge_p, redirect_callers, i, e)
2021 /* Redirect calls to the old version node to point to its new
2023 cgraph_redirect_edge_callee (e, new_version);
2029 /* Perform function versioning.
2030 Function versioning includes copying of the tree and
2031 a callgraph update (creating a new cgraph node and updating
2032 its callees and callers).
2034 REDIRECT_CALLERS varray includes the edges to be redirected
2037 TREE_MAP is a mapping of tree nodes we want to replace with
2038 new ones (according to results of prior analysis).
2039 OLD_VERSION_NODE is the node that is versioned.
2040 It returns the new version's cgraph node.
2041 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2043 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2044 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2046 struct cgraph_node *
2047 cgraph_function_versioning (struct cgraph_node *old_version_node,
2048 VEC(cgraph_edge_p,heap) *redirect_callers,
2049 VEC (ipa_replace_map_p,gc)* tree_map,
2050 bitmap args_to_skip,
2052 basic_block new_entry_block,
2053 const char *clone_name)
2055 tree old_decl = old_version_node->decl;
2056 struct cgraph_node *new_version_node = NULL;
2059 if (!tree_versionable_function_p (old_decl))
2062 gcc_assert (old_version_node->local.can_change_signature || !args_to_skip);
2064 /* Make a new FUNCTION_DECL tree node for the
2067 new_decl = copy_node (old_decl);
2069 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2071 /* Generate a new name for the new version. */
2072 DECL_NAME (new_decl) = clone_function_name (old_decl, clone_name);
2073 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
2074 SET_DECL_RTL (new_decl, NULL);
2076 /* Create the new version's call-graph node.
2077 and update the edges of the new node. */
2079 cgraph_copy_node_for_versioning (old_version_node, new_decl,
2080 redirect_callers, bbs_to_copy);
2082 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2083 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip,
2084 bbs_to_copy, new_entry_block);
2086 /* Update the new version's properties.
2087 Make The new version visible only within this translation unit. Make sure
2088 that is not weak also.
2089 ??? We cannot use COMDAT linkage because there is no
2090 ABI support for this. */
2091 cgraph_make_decl_local (new_version_node->decl);
2092 DECL_VIRTUAL_P (new_version_node->decl) = 0;
2093 new_version_node->local.externally_visible = 0;
2094 new_version_node->local.local = 1;
2095 new_version_node->lowered = true;
2097 /* Update the call_expr on the edges to call the new version node. */
2098 update_call_expr (new_version_node);
2100 cgraph_call_function_insertion_hooks (new_version_node);
2101 return new_version_node;
2104 /* Produce separate function body for inline clones so the offline copy can be
2105 modified without affecting them. */
2106 struct cgraph_node *
2107 save_inline_function_body (struct cgraph_node *node)
2109 struct cgraph_node *first_clone, *n;
2111 gcc_assert (node == cgraph_get_node (node->decl));
2113 cgraph_lower_function (node);
2115 first_clone = node->clones;
2117 first_clone->decl = copy_node (node->decl);
2118 cgraph_insert_node_to_hashtable (first_clone);
2119 gcc_assert (first_clone == cgraph_get_node (first_clone->decl));
2120 if (first_clone->next_sibling_clone)
2122 for (n = first_clone->next_sibling_clone; n->next_sibling_clone; n = n->next_sibling_clone)
2123 n->clone_of = first_clone;
2124 n->clone_of = first_clone;
2125 n->next_sibling_clone = first_clone->clones;
2126 if (first_clone->clones)
2127 first_clone->clones->prev_sibling_clone = n;
2128 first_clone->clones = first_clone->next_sibling_clone;
2129 first_clone->next_sibling_clone->prev_sibling_clone = NULL;
2130 first_clone->next_sibling_clone = NULL;
2131 gcc_assert (!first_clone->prev_sibling_clone);
2133 first_clone->clone_of = NULL;
2134 node->clones = NULL;
2136 if (first_clone->clones)
2137 for (n = first_clone->clones; n != first_clone;)
2139 gcc_assert (n->decl == node->decl);
2140 n->decl = first_clone->decl;
2143 else if (n->next_sibling_clone)
2144 n = n->next_sibling_clone;
2147 while (n != first_clone && !n->next_sibling_clone)
2149 if (n != first_clone)
2150 n = n->next_sibling_clone;
2154 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2155 tree_function_versioning (node->decl, first_clone->decl, NULL, true, NULL,
2158 DECL_EXTERNAL (first_clone->decl) = 0;
2159 DECL_COMDAT_GROUP (first_clone->decl) = NULL_TREE;
2160 TREE_PUBLIC (first_clone->decl) = 0;
2161 DECL_COMDAT (first_clone->decl) = 0;
2162 VEC_free (ipa_opt_pass, heap,
2163 first_clone->ipa_transforms_to_apply);
2164 first_clone->ipa_transforms_to_apply = NULL;
2166 #ifdef ENABLE_CHECKING
2167 verify_cgraph_node (first_clone);
2172 /* Given virtual clone, turn it into actual clone. */
2174 cgraph_materialize_clone (struct cgraph_node *node)
2176 bitmap_obstack_initialize (NULL);
2177 node->former_clone_of = node->clone_of->decl;
2178 if (node->clone_of->former_clone_of)
2179 node->former_clone_of = node->clone_of->former_clone_of;
2180 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2181 tree_function_versioning (node->clone_of->decl, node->decl,
2182 node->clone.tree_map, true,
2183 node->clone.args_to_skip, NULL, NULL);
2184 if (cgraph_dump_file)
2186 dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
2187 dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
2190 /* Function is no longer clone. */
2191 if (node->next_sibling_clone)
2192 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
2193 if (node->prev_sibling_clone)
2194 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
2196 node->clone_of->clones = node->next_sibling_clone;
2197 node->next_sibling_clone = NULL;
2198 node->prev_sibling_clone = NULL;
2199 if (!node->clone_of->analyzed && !node->clone_of->clones)
2201 cgraph_release_function_body (node->clone_of);
2202 cgraph_node_remove_callees (node->clone_of);
2203 ipa_remove_all_references (&node->clone_of->ref_list);
2205 node->clone_of = NULL;
2206 bitmap_obstack_release (NULL);
2209 /* If necessary, change the function declaration in the call statement
2210 associated with E so that it corresponds to the edge callee. */
2213 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
2215 tree decl = gimple_call_fndecl (e->call_stmt);
2217 gimple_stmt_iterator gsi;
2218 bool gsi_computed = false;
2219 #ifdef ENABLE_CHECKING
2220 struct cgraph_node *node;
2223 if (e->indirect_unknown_callee
2224 || decl == e->callee->decl
2225 /* Don't update call from same body alias to the real function. */
2226 || (decl && cgraph_get_node (decl) == cgraph_get_node (e->callee->decl)))
2227 return e->call_stmt;
2229 #ifdef ENABLE_CHECKING
2232 node = cgraph_get_node (decl);
2233 gcc_assert (!node || !node->clone.combined_args_to_skip);
2237 if (cgraph_dump_file)
2239 fprintf (cgraph_dump_file, "updating call of %s/%i -> %s/%i: ",
2240 cgraph_node_name (e->caller), e->caller->uid,
2241 cgraph_node_name (e->callee), e->callee->uid);
2242 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2243 if (e->callee->clone.combined_args_to_skip)
2245 fprintf (cgraph_dump_file, " combined args to skip: ");
2246 dump_bitmap (cgraph_dump_file,
2247 e->callee->clone.combined_args_to_skip);
2251 if (e->indirect_info &&
2252 e->indirect_info->thunk_delta != 0
2253 && (!e->callee->clone.combined_args_to_skip
2254 || !bitmap_bit_p (e->callee->clone.combined_args_to_skip, 0)))
2256 if (cgraph_dump_file)
2257 fprintf (cgraph_dump_file, " Thunk delta is "
2258 HOST_WIDE_INT_PRINT_DEC "\n", e->indirect_info->thunk_delta);
2259 gsi = gsi_for_stmt (e->call_stmt);
2260 gsi_computed = true;
2261 gimple_adjust_this_by_delta (&gsi,
2262 build_int_cst (sizetype,
2263 e->indirect_info->thunk_delta));
2264 e->indirect_info->thunk_delta = 0;
2267 if (e->callee->clone.combined_args_to_skip)
2272 = gimple_call_copy_skip_args (e->call_stmt,
2273 e->callee->clone.combined_args_to_skip);
2274 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2276 if (gimple_vdef (new_stmt)
2277 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2278 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2281 gsi = gsi_for_stmt (e->call_stmt);
2282 gsi_replace (&gsi, new_stmt, false);
2283 /* We need to defer cleaning EH info on the new statement to
2284 fixup-cfg. We may not have dominator information at this point
2285 and thus would end up with unreachable blocks and have no way
2286 to communicate that we need to run CFG cleanup then. */
2287 lp_nr = lookup_stmt_eh_lp (e->call_stmt);
2290 remove_stmt_from_eh_lp (e->call_stmt);
2291 add_stmt_to_eh_lp (new_stmt, lp_nr);
2296 new_stmt = e->call_stmt;
2297 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2298 update_stmt (new_stmt);
2301 cgraph_set_call_stmt_including_clones (e->caller, e->call_stmt, new_stmt);
2303 if (cgraph_dump_file)
2305 fprintf (cgraph_dump_file, " updated to:");
2306 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2311 /* Once all functions from compilation unit are in memory, produce all clones
2312 and update all calls. We might also do this on demand if we don't want to
2313 bring all functions to memory prior compilation, but current WHOPR
2314 implementation does that and it is is bit easier to keep everything right in
2317 cgraph_materialize_all_clones (void)
2319 struct cgraph_node *node;
2320 bool stabilized = false;
2322 if (cgraph_dump_file)
2323 fprintf (cgraph_dump_file, "Materializing clones\n");
2324 #ifdef ENABLE_CHECKING
2328 /* We can also do topological order, but number of iterations should be
2329 bounded by number of IPA passes since single IPA pass is probably not
2330 going to create clones of clones it created itself. */
2334 for (node = cgraph_nodes; node; node = node->next)
2336 if (node->clone_of && node->decl != node->clone_of->decl
2337 && !gimple_has_body_p (node->decl))
2339 if (gimple_has_body_p (node->clone_of->decl))
2341 if (cgraph_dump_file)
2343 fprintf (cgraph_dump_file, "cloning %s to %s\n",
2344 cgraph_node_name (node->clone_of),
2345 cgraph_node_name (node));
2346 if (node->clone.tree_map)
2349 fprintf (cgraph_dump_file, " replace map: ");
2350 for (i = 0; i < VEC_length (ipa_replace_map_p,
2351 node->clone.tree_map);
2354 struct ipa_replace_map *replace_info;
2355 replace_info = VEC_index (ipa_replace_map_p,
2356 node->clone.tree_map,
2358 print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2359 fprintf (cgraph_dump_file, " -> ");
2360 print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2361 fprintf (cgraph_dump_file, "%s%s;",
2362 replace_info->replace_p ? "(replace)":"",
2363 replace_info->ref_p ? "(ref)":"");
2365 fprintf (cgraph_dump_file, "\n");
2367 if (node->clone.args_to_skip)
2369 fprintf (cgraph_dump_file, " args_to_skip: ");
2370 dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2372 if (node->clone.args_to_skip)
2374 fprintf (cgraph_dump_file, " combined_args_to_skip:");
2375 dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2378 cgraph_materialize_clone (node);
2384 for (node = cgraph_nodes; node; node = node->next)
2385 if (!node->analyzed && node->callees)
2386 cgraph_node_remove_callees (node);
2387 if (cgraph_dump_file)
2388 fprintf (cgraph_dump_file, "Materialization Call site updates done.\n");
2389 #ifdef ENABLE_CHECKING
2392 cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2395 #include "gt-cgraphunit.h"