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 && !DECL_DISREGARD_INLINE_LIMITS (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 && !DECL_DISREGARD_INLINE_LIMITS (decl)
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 notice_global_symbol (decl);
352 node->local.finalized = true;
353 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
355 if (cgraph_decide_is_function_needed (node, decl))
356 cgraph_mark_needed_node (node);
358 /* Since we reclaim unreachable nodes at the end of every language
359 level unit, we need to be conservative about possible entry points
361 if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
362 || DECL_STATIC_CONSTRUCTOR (decl)
363 || DECL_STATIC_DESTRUCTOR (decl)
364 /* COMDAT virtual functions may be referenced by vtable from
365 other compilation unit. Still we want to devirtualize calls
366 to those so we need to analyze them.
367 FIXME: We should introduce may edges for this purpose and update
368 their handling in unreachable function removal and inliner too. */
369 || (DECL_VIRTUAL_P (decl) && (DECL_COMDAT (decl) || DECL_EXTERNAL (decl))))
370 cgraph_mark_reachable_node (node);
372 /* If we've not yet emitted decl, tell the debug info about it. */
373 if (!TREE_ASM_WRITTEN (decl))
374 (*debug_hooks->deferred_inline_function) (decl);
376 /* Possibly warn about unused parameters. */
377 if (warn_unused_parameter)
378 do_warn_unused_parameter (decl);
384 /* C99 extern inline keywords allow changing of declaration after function
385 has been finalized. We need to re-decide if we want to mark the function as
389 cgraph_mark_if_needed (tree decl)
391 struct cgraph_node *node = cgraph_get_node (decl);
392 if (node->local.finalized && cgraph_decide_is_function_needed (node, decl))
393 cgraph_mark_needed_node (node);
396 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
398 clone_of_p (struct cgraph_node *node, struct cgraph_node *node2)
400 while (node != node2 && node2)
401 node2 = node2->clone_of;
402 return node2 != NULL;
405 /* Verify edge E count and frequency. */
408 verify_edge_count_and_frequency (struct cgraph_edge *e)
410 bool error_found = false;
413 error ("caller edge count is negative");
416 if (e->frequency < 0)
418 error ("caller edge frequency is negative");
421 if (e->frequency > CGRAPH_FREQ_MAX)
423 error ("caller edge frequency is too large");
426 if (gimple_has_body_p (e->caller->decl)
427 && !e->caller->global.inlined_to
429 != compute_call_stmt_bb_frequency (e->caller->decl,
430 gimple_bb (e->call_stmt))))
432 error ("caller edge frequency %i does not match BB frequency %i",
434 compute_call_stmt_bb_frequency (e->caller->decl,
435 gimple_bb (e->call_stmt)));
441 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
443 cgraph_debug_gimple_stmt (struct function *this_cfun, gimple stmt)
445 /* debug_gimple_stmt needs correct cfun */
446 if (cfun != this_cfun)
447 set_cfun (this_cfun);
448 debug_gimple_stmt (stmt);
451 /* Verify cgraph nodes of given cgraph node. */
453 verify_cgraph_node (struct cgraph_node *node)
455 struct cgraph_edge *e;
456 struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
457 basic_block this_block;
458 gimple_stmt_iterator gsi;
459 bool error_found = false;
464 timevar_push (TV_CGRAPH_VERIFY);
465 for (e = node->callees; e; e = e->next_callee)
468 error ("aux field set for edge %s->%s",
469 identifier_to_locale (cgraph_node_name (e->caller)),
470 identifier_to_locale (cgraph_node_name (e->callee)));
475 error ("execution count is negative");
478 if (node->global.inlined_to && node->local.externally_visible)
480 error ("externally visible inline clone");
483 if (node->global.inlined_to && node->address_taken)
485 error ("inline clone with address taken");
488 if (node->global.inlined_to && node->needed)
490 error ("inline clone is needed");
493 for (e = node->indirect_calls; e; e = e->next_callee)
497 error ("aux field set for indirect edge from %s",
498 identifier_to_locale (cgraph_node_name (e->caller)));
501 if (!e->indirect_unknown_callee
502 || !e->indirect_info)
504 error ("An indirect edge from %s is not marked as indirect or has "
505 "associated indirect_info, the corresponding statement is: ",
506 identifier_to_locale (cgraph_node_name (e->caller)));
507 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
511 for (e = node->callers; e; e = e->next_caller)
513 if (verify_edge_count_and_frequency (e))
515 if (!e->inline_failed)
517 if (node->global.inlined_to
518 != (e->caller->global.inlined_to
519 ? e->caller->global.inlined_to : e->caller))
521 error ("inlined_to pointer is wrong");
524 if (node->callers->next_caller)
526 error ("multiple inline callers");
531 if (node->global.inlined_to)
533 error ("inlined_to pointer set for noninline callers");
537 for (e = node->indirect_calls; e; e = e->next_callee)
538 if (verify_edge_count_and_frequency (e))
540 if (!node->callers && node->global.inlined_to)
542 error ("inlined_to pointer is set but no predecessors found");
545 if (node->global.inlined_to == node)
547 error ("inlined_to pointer refers to itself");
551 if (!cgraph_get_node (node->decl))
553 error ("node not found in cgraph_hash");
559 struct cgraph_node *n;
560 for (n = node->clone_of->clones; n; n = n->next_sibling_clone)
565 error ("node has wrong clone_of");
571 struct cgraph_node *n;
572 for (n = node->clones; n; n = n->next_sibling_clone)
573 if (n->clone_of != node)
577 error ("node has wrong clone list");
581 if ((node->prev_sibling_clone || node->next_sibling_clone) && !node->clone_of)
583 error ("node is in clone list but it is not clone");
586 if (!node->prev_sibling_clone && node->clone_of && node->clone_of->clones != node)
588 error ("node has wrong prev_clone pointer");
591 if (node->prev_sibling_clone && node->prev_sibling_clone->next_sibling_clone != node)
593 error ("double linked list of clones corrupted");
596 if (node->same_comdat_group)
598 struct cgraph_node *n = node->same_comdat_group;
600 if (!DECL_ONE_ONLY (node->decl))
602 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
607 error ("node is alone in a comdat group");
612 if (!n->same_comdat_group)
614 error ("same_comdat_group is not a circular list");
618 n = n->same_comdat_group;
623 if (node->analyzed && gimple_has_body_p (node->decl)
624 && !TREE_ASM_WRITTEN (node->decl)
625 && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to)
630 /* The nodes we're interested in are never shared, so walk
631 the tree ignoring duplicates. */
632 struct pointer_set_t *visited_nodes = pointer_set_create ();
633 /* Reach the trees by walking over the CFG, and note the
634 enclosing basic-blocks in the call edges. */
635 FOR_EACH_BB_FN (this_block, this_cfun)
636 for (gsi = gsi_start_bb (this_block);
640 gimple stmt = gsi_stmt (gsi);
641 if (is_gimple_call (stmt))
643 struct cgraph_edge *e = cgraph_edge (node, stmt);
644 tree decl = gimple_call_fndecl (stmt);
649 error ("shared call_stmt:");
650 cgraph_debug_gimple_stmt (this_cfun, stmt);
653 if (!e->indirect_unknown_callee)
655 struct cgraph_node *n;
657 if (e->callee->same_body_alias)
659 error ("edge points to same body alias:");
660 debug_tree (e->callee->decl);
663 else if (!e->callee->global.inlined_to
665 && cgraph_get_node (decl)
666 && (e->callee->former_clone_of
667 != cgraph_get_node (decl)->decl)
668 && !clone_of_p (cgraph_get_node (decl),
671 error ("edge points to wrong declaration:");
672 debug_tree (e->callee->decl);
673 fprintf (stderr," Instead of:");
678 && (n = cgraph_get_node_or_alias (decl))
679 && (n->same_body_alias
680 && n->thunk.thunk_p))
682 error ("a call to thunk improperly represented "
683 "in the call graph:");
684 cgraph_debug_gimple_stmt (this_cfun, stmt);
690 error ("an indirect edge with unknown callee "
691 "corresponding to a call_stmt with "
692 "a known declaration:");
694 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
700 error ("missing callgraph edge for call stmt:");
701 cgraph_debug_gimple_stmt (this_cfun, stmt);
706 pointer_set_destroy (visited_nodes);
709 /* No CFG available?! */
712 for (e = node->callees; e; e = e->next_callee)
716 error ("edge %s->%s has no corresponding call_stmt",
717 identifier_to_locale (cgraph_node_name (e->caller)),
718 identifier_to_locale (cgraph_node_name (e->callee)));
719 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
724 for (e = node->indirect_calls; e; e = e->next_callee)
728 error ("an indirect edge from %s has no corresponding call_stmt",
729 identifier_to_locale (cgraph_node_name (e->caller)));
730 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
738 dump_cgraph_node (stderr, node);
739 internal_error ("verify_cgraph_node failed");
741 timevar_pop (TV_CGRAPH_VERIFY);
744 /* Verify whole cgraph structure. */
748 struct cgraph_node *node;
753 for (node = cgraph_nodes; node; node = node->next)
754 verify_cgraph_node (node);
757 /* Output all asm statements we have stored up to be output. */
760 cgraph_output_pending_asms (void)
762 struct cgraph_asm_node *can;
767 for (can = cgraph_asm_nodes; can; can = can->next)
768 assemble_asm (can->asm_str);
769 cgraph_asm_nodes = NULL;
772 /* Analyze the function scheduled to be output. */
774 cgraph_analyze_function (struct cgraph_node *node)
776 tree save = current_function_decl;
777 tree decl = node->decl;
779 current_function_decl = decl;
780 push_cfun (DECL_STRUCT_FUNCTION (decl));
782 assign_assembler_name_if_neeeded (node->decl);
784 /* Make sure to gimplify bodies only once. During analyzing a
785 function we lower it, which will require gimplified nested
786 functions, so we can end up here with an already gimplified
788 if (!gimple_body (decl))
789 gimplify_function_tree (decl);
790 dump_function (TDI_generic, decl);
792 cgraph_lower_function (node);
793 node->analyzed = true;
796 current_function_decl = save;
799 /* Process attributes common for vars and functions. */
802 process_common_attributes (tree decl)
804 tree weakref = lookup_attribute ("weakref", DECL_ATTRIBUTES (decl));
806 if (weakref && !lookup_attribute ("alias", DECL_ATTRIBUTES (decl)))
808 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wattributes,
809 "%<weakref%> attribute should be accompanied with"
810 " an %<alias%> attribute");
811 DECL_WEAK (decl) = 0;
812 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
813 DECL_ATTRIBUTES (decl));
817 /* Look for externally_visible and used attributes and mark cgraph nodes
820 We cannot mark the nodes at the point the attributes are processed (in
821 handle_*_attribute) because the copy of the declarations available at that
822 point may not be canonical. For example, in:
825 void f() __attribute__((used));
827 the declaration we see in handle_used_attribute will be the second
828 declaration -- but the front end will subsequently merge that declaration
829 with the original declaration and discard the second declaration.
831 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
834 void f() __attribute__((externally_visible));
838 So, we walk the nodes at the end of the translation unit, applying the
839 attributes at that point. */
842 process_function_and_variable_attributes (struct cgraph_node *first,
843 struct varpool_node *first_var)
845 struct cgraph_node *node;
846 struct varpool_node *vnode;
848 for (node = cgraph_nodes; node != first; node = node->next)
850 tree decl = node->decl;
851 if (DECL_PRESERVE_P (decl))
852 cgraph_mark_needed_node (node);
853 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
854 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))
855 && TREE_PUBLIC (node->decl))
857 if (node->local.finalized)
858 cgraph_mark_needed_node (node);
860 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
862 if (! TREE_PUBLIC (node->decl))
863 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
864 "%<externally_visible%>"
865 " attribute have effect only on public objects");
866 else if (node->local.finalized)
867 cgraph_mark_needed_node (node);
869 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
870 && node->local.finalized)
872 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
873 "%<weakref%> attribute ignored"
874 " because function is defined");
875 DECL_WEAK (decl) = 0;
876 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
877 DECL_ATTRIBUTES (decl));
879 process_common_attributes (decl);
881 for (vnode = varpool_nodes; vnode != first_var; vnode = vnode->next)
883 tree decl = vnode->decl;
884 if (DECL_PRESERVE_P (decl))
886 vnode->force_output = true;
887 if (vnode->finalized)
888 varpool_mark_needed_node (vnode);
890 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
891 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))
892 && TREE_PUBLIC (vnode->decl))
894 if (vnode->finalized)
895 varpool_mark_needed_node (vnode);
897 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
899 if (! TREE_PUBLIC (vnode->decl))
900 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
901 "%<externally_visible%>"
902 " attribute have effect only on public objects");
903 else if (vnode->finalized)
904 varpool_mark_needed_node (vnode);
906 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
908 && DECL_INITIAL (decl))
910 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
911 "%<weakref%> attribute ignored"
912 " because variable is initialized");
913 DECL_WEAK (decl) = 0;
914 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
915 DECL_ATTRIBUTES (decl));
917 process_common_attributes (decl);
921 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
922 each reachable functions) and build cgraph.
923 The function can be called multiple times after inserting new nodes
924 into beginning of queue. Just the new part of queue is re-scanned then. */
927 cgraph_analyze_functions (void)
929 /* Keep track of already processed nodes when called multiple times for
930 intermodule optimization. */
931 static struct cgraph_node *first_analyzed;
932 struct cgraph_node *first_processed = first_analyzed;
933 static struct varpool_node *first_analyzed_var;
934 struct cgraph_node *node, *next;
936 bitmap_obstack_initialize (NULL);
937 process_function_and_variable_attributes (first_processed,
939 first_processed = cgraph_nodes;
940 first_analyzed_var = varpool_nodes;
941 varpool_analyze_pending_decls ();
942 if (cgraph_dump_file)
944 fprintf (cgraph_dump_file, "Initial entry points:");
945 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
947 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
948 fprintf (cgraph_dump_file, "\n");
950 cgraph_process_new_functions ();
952 /* Propagate reachability flag and lower representation of all reachable
953 functions. In the future, lowering will introduce new functions and
954 new entry points on the way (by template instantiation and virtual
955 method table generation for instance). */
956 while (cgraph_nodes_queue)
958 struct cgraph_edge *edge;
959 tree decl = cgraph_nodes_queue->decl;
961 node = cgraph_nodes_queue;
962 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
963 node->next_needed = NULL;
965 /* ??? It is possible to create extern inline function and later using
966 weak alias attribute to kill its body. See
967 gcc.c-torture/compile/20011119-1.c */
968 if (!DECL_STRUCT_FUNCTION (decl))
970 cgraph_reset_node (node);
975 cgraph_analyze_function (node);
977 for (edge = node->callees; edge; edge = edge->next_callee)
978 if (!edge->callee->reachable)
979 cgraph_mark_reachable_node (edge->callee);
981 if (node->same_comdat_group)
983 for (next = node->same_comdat_group;
985 next = next->same_comdat_group)
986 cgraph_mark_reachable_node (next);
989 /* If decl is a clone of an abstract function, mark that abstract
990 function so that we don't release its body. The DECL_INITIAL() of that
991 abstract function declaration will be later needed to output debug
993 if (DECL_ABSTRACT_ORIGIN (decl))
995 struct cgraph_node *origin_node;
996 origin_node = cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl));
997 origin_node->abstract_and_needed = true;
1000 /* We finalize local static variables during constructing callgraph
1001 edges. Process their attributes too. */
1002 process_function_and_variable_attributes (first_processed,
1003 first_analyzed_var);
1004 first_processed = cgraph_nodes;
1005 first_analyzed_var = varpool_nodes;
1006 varpool_analyze_pending_decls ();
1007 cgraph_process_new_functions ();
1010 /* Collect entry points to the unit. */
1011 if (cgraph_dump_file)
1013 fprintf (cgraph_dump_file, "Unit entry points:");
1014 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1016 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1017 fprintf (cgraph_dump_file, "\n\nInitial ");
1018 dump_cgraph (cgraph_dump_file);
1019 dump_varpool (cgraph_dump_file);
1022 if (cgraph_dump_file)
1023 fprintf (cgraph_dump_file, "\nReclaiming functions:");
1025 for (node = cgraph_nodes; node != first_analyzed; node = next)
1027 tree decl = node->decl;
1030 if (node->local.finalized && !gimple_has_body_p (decl))
1031 cgraph_reset_node (node);
1033 if (!node->reachable && gimple_has_body_p (decl))
1035 if (cgraph_dump_file)
1036 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1037 cgraph_remove_node (node);
1041 node->next_needed = NULL;
1042 gcc_assert (!node->local.finalized || gimple_has_body_p (decl));
1043 gcc_assert (node->analyzed == node->local.finalized);
1045 if (cgraph_dump_file)
1047 fprintf (cgraph_dump_file, "\n\nReclaimed ");
1048 dump_cgraph (cgraph_dump_file);
1049 dump_varpool (cgraph_dump_file);
1051 bitmap_obstack_release (NULL);
1052 first_analyzed = cgraph_nodes;
1057 /* Analyze the whole compilation unit once it is parsed completely. */
1060 cgraph_finalize_compilation_unit (void)
1062 timevar_push (TV_CGRAPH);
1064 /* If we're here there's no current function anymore. Some frontends
1065 are lazy in clearing these. */
1066 current_function_decl = NULL;
1069 /* Do not skip analyzing the functions if there were errors, we
1070 miss diagnostics for following functions otherwise. */
1072 /* Emit size functions we didn't inline. */
1073 finalize_size_functions ();
1075 /* Mark alias targets necessary and emit diagnostics. */
1076 finish_aliases_1 ();
1080 fprintf (stderr, "\nAnalyzing compilation unit\n");
1084 /* Gimplify and lower all functions, compute reachability and
1085 remove unreachable nodes. */
1086 cgraph_analyze_functions ();
1088 /* Mark alias targets necessary and emit diagnostics. */
1089 finish_aliases_1 ();
1091 /* Gimplify and lower thunks. */
1092 cgraph_analyze_functions ();
1094 /* Finally drive the pass manager. */
1097 timevar_pop (TV_CGRAPH);
1101 /* Figure out what functions we want to assemble. */
1104 cgraph_mark_functions_to_output (void)
1106 struct cgraph_node *node;
1107 #ifdef ENABLE_CHECKING
1108 bool check_same_comdat_groups = false;
1110 for (node = cgraph_nodes; node; node = node->next)
1111 gcc_assert (!node->process);
1114 for (node = cgraph_nodes; node; node = node->next)
1116 tree decl = node->decl;
1117 struct cgraph_edge *e;
1119 gcc_assert (!node->process || node->same_comdat_group);
1123 for (e = node->callers; e; e = e->next_caller)
1124 if (e->inline_failed)
1127 /* We need to output all local functions that are used and not
1128 always inlined, as well as those that are reachable from
1129 outside the current compilation unit. */
1131 && !node->global.inlined_to
1132 && (!cgraph_only_called_directly_p (node)
1133 || (e && node->reachable))
1134 && !TREE_ASM_WRITTEN (decl)
1135 && !DECL_EXTERNAL (decl))
1138 if (node->same_comdat_group)
1140 struct cgraph_node *next;
1141 for (next = node->same_comdat_group;
1143 next = next->same_comdat_group)
1147 else if (node->same_comdat_group)
1149 #ifdef ENABLE_CHECKING
1150 check_same_comdat_groups = true;
1155 /* We should've reclaimed all functions that are not needed. */
1156 #ifdef ENABLE_CHECKING
1157 if (!node->global.inlined_to
1158 && gimple_has_body_p (decl)
1159 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1160 are inside partition, we can end up not removing the body since we no longer
1161 have analyzed node pointing to it. */
1162 && !node->in_other_partition
1163 && !DECL_EXTERNAL (decl))
1165 dump_cgraph_node (stderr, node);
1166 internal_error ("failed to reclaim unneeded function");
1169 gcc_assert (node->global.inlined_to
1170 || !gimple_has_body_p (decl)
1171 || node->in_other_partition
1172 || DECL_EXTERNAL (decl));
1177 #ifdef ENABLE_CHECKING
1178 if (check_same_comdat_groups)
1179 for (node = cgraph_nodes; node; node = node->next)
1180 if (node->same_comdat_group && !node->process)
1182 tree decl = node->decl;
1183 if (!node->global.inlined_to
1184 && gimple_has_body_p (decl)
1185 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1186 are inside partition, we can end up not removing the body since we no longer
1187 have analyzed node pointing to it. */
1188 && !node->in_other_partition
1189 && !DECL_EXTERNAL (decl))
1191 dump_cgraph_node (stderr, node);
1192 internal_error ("failed to reclaim unneeded function");
1198 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1199 in lowered gimple form.
1201 Set current_function_decl and cfun to newly constructed empty function body.
1202 return basic block in the function body. */
1205 init_lowered_empty_function (tree decl)
1209 current_function_decl = decl;
1210 allocate_struct_function (decl, false);
1211 gimple_register_cfg_hooks ();
1212 init_empty_tree_cfg ();
1213 init_tree_ssa (cfun);
1214 init_ssa_operands ();
1215 cfun->gimple_df->in_ssa_p = true;
1216 DECL_INITIAL (decl) = make_node (BLOCK);
1218 DECL_SAVED_TREE (decl) = error_mark_node;
1219 cfun->curr_properties |=
1220 (PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_referenced_vars |
1223 /* Create BB for body of the function and connect it properly. */
1224 bb = create_basic_block (NULL, (void *) 0, ENTRY_BLOCK_PTR);
1225 make_edge (ENTRY_BLOCK_PTR, bb, 0);
1226 make_edge (bb, EXIT_BLOCK_PTR, 0);
1231 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1232 offset indicated by VIRTUAL_OFFSET, if that is
1233 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1234 zero for a result adjusting thunk. */
1237 thunk_adjust (gimple_stmt_iterator * bsi,
1238 tree ptr, bool this_adjusting,
1239 HOST_WIDE_INT fixed_offset, tree virtual_offset)
1245 && fixed_offset != 0)
1247 stmt = gimple_build_assign (ptr,
1248 fold_build2_loc (input_location,
1250 TREE_TYPE (ptr), ptr,
1251 size_int (fixed_offset)));
1252 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1255 /* If there's a virtual offset, look up that value in the vtable and
1256 adjust the pointer again. */
1264 if (!vtable_entry_type)
1266 tree vfunc_type = make_node (FUNCTION_TYPE);
1267 TREE_TYPE (vfunc_type) = integer_type_node;
1268 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
1269 layout_type (vfunc_type);
1271 vtable_entry_type = build_pointer_type (vfunc_type);
1275 create_tmp_var (build_pointer_type
1276 (build_pointer_type (vtable_entry_type)), "vptr");
1278 /* The vptr is always at offset zero in the object. */
1279 stmt = gimple_build_assign (vtabletmp,
1280 build1 (NOP_EXPR, TREE_TYPE (vtabletmp),
1282 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1283 mark_symbols_for_renaming (stmt);
1284 find_referenced_vars_in (stmt);
1286 /* Form the vtable address. */
1287 vtabletmp2 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp)),
1289 stmt = gimple_build_assign (vtabletmp2,
1290 build_simple_mem_ref (vtabletmp));
1291 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1292 mark_symbols_for_renaming (stmt);
1293 find_referenced_vars_in (stmt);
1295 /* Find the entry with the vcall offset. */
1296 stmt = gimple_build_assign (vtabletmp2,
1297 fold_build2_loc (input_location,
1299 TREE_TYPE (vtabletmp2),
1301 fold_convert (sizetype,
1303 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1305 /* Get the offset itself. */
1306 vtabletmp3 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2)),
1308 stmt = gimple_build_assign (vtabletmp3,
1309 build_simple_mem_ref (vtabletmp2));
1310 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1311 mark_symbols_for_renaming (stmt);
1312 find_referenced_vars_in (stmt);
1314 /* Cast to sizetype. */
1315 offsettmp = create_tmp_var (sizetype, "offset");
1316 stmt = gimple_build_assign (offsettmp, fold_convert (sizetype, vtabletmp3));
1317 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1318 mark_symbols_for_renaming (stmt);
1319 find_referenced_vars_in (stmt);
1321 /* Adjust the `this' pointer. */
1322 ptr = fold_build2_loc (input_location,
1323 POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
1328 && fixed_offset != 0)
1329 /* Adjust the pointer by the constant. */
1333 if (TREE_CODE (ptr) == VAR_DECL)
1337 ptrtmp = create_tmp_var (TREE_TYPE (ptr), "ptr");
1338 stmt = gimple_build_assign (ptrtmp, ptr);
1339 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1340 mark_symbols_for_renaming (stmt);
1341 find_referenced_vars_in (stmt);
1343 ptr = fold_build2_loc (input_location,
1344 POINTER_PLUS_EXPR, TREE_TYPE (ptrtmp), ptrtmp,
1345 size_int (fixed_offset));
1348 /* Emit the statement and gimplify the adjustment expression. */
1349 ret = create_tmp_var (TREE_TYPE (ptr), "adjusted_this");
1350 stmt = gimple_build_assign (ret, ptr);
1351 mark_symbols_for_renaming (stmt);
1352 find_referenced_vars_in (stmt);
1353 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1358 /* Produce assembler for thunk NODE. */
1361 assemble_thunk (struct cgraph_node *node)
1363 bool this_adjusting = node->thunk.this_adjusting;
1364 HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset;
1365 HOST_WIDE_INT virtual_value = node->thunk.virtual_value;
1366 tree virtual_offset = NULL;
1367 tree alias = node->thunk.alias;
1368 tree thunk_fndecl = node->decl;
1369 tree a = DECL_ARGUMENTS (thunk_fndecl);
1371 current_function_decl = thunk_fndecl;
1373 /* Ensure thunks are emitted in their correct sections. */
1374 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
1377 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
1378 virtual_value, alias))
1383 DECL_RESULT (thunk_fndecl)
1384 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl),
1385 RESULT_DECL, 0, integer_type_node);
1386 fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl));
1388 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1390 fn_block = make_node (BLOCK);
1391 BLOCK_VARS (fn_block) = a;
1392 DECL_INITIAL (thunk_fndecl) = fn_block;
1393 init_function_start (thunk_fndecl);
1395 assemble_start_function (thunk_fndecl, fnname);
1397 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
1398 fixed_offset, virtual_value, alias);
1400 assemble_end_function (thunk_fndecl, fnname);
1401 init_insn_lengths ();
1402 free_after_compilation (cfun);
1404 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1409 basic_block bb, then_bb, else_bb, return_bb;
1410 gimple_stmt_iterator bsi;
1416 VEC(tree, heap) *vargs;
1421 DECL_IGNORED_P (thunk_fndecl) = 1;
1422 bitmap_obstack_initialize (NULL);
1424 if (node->thunk.virtual_offset_p)
1425 virtual_offset = size_int (virtual_value);
1427 /* Build the return declaration for the function. */
1428 restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1429 if (DECL_RESULT (thunk_fndecl) == NULL_TREE)
1431 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
1432 DECL_ARTIFICIAL (resdecl) = 1;
1433 DECL_IGNORED_P (resdecl) = 1;
1434 DECL_RESULT (thunk_fndecl) = resdecl;
1437 resdecl = DECL_RESULT (thunk_fndecl);
1439 bb = then_bb = else_bb = return_bb = init_lowered_empty_function (thunk_fndecl);
1441 bsi = gsi_start_bb (bb);
1443 /* Build call to the function being thunked. */
1444 if (!VOID_TYPE_P (restype))
1446 if (!is_gimple_reg_type (restype))
1449 add_local_decl (cfun, restmp);
1450 BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp;
1453 restmp = create_tmp_var_raw (restype, "retval");
1456 for (arg = a; arg; arg = DECL_CHAIN (arg))
1458 vargs = VEC_alloc (tree, heap, nargs);
1460 VEC_quick_push (tree, vargs,
1465 VEC_quick_push (tree, vargs, a);
1466 for (i = 1, arg = DECL_CHAIN (a); i < nargs; i++, arg = DECL_CHAIN (arg))
1467 VEC_quick_push (tree, vargs, arg);
1468 call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
1469 VEC_free (tree, heap, vargs);
1470 gimple_call_set_cannot_inline (call, true);
1471 gimple_call_set_from_thunk (call, true);
1473 gimple_call_set_lhs (call, restmp);
1474 gsi_insert_after (&bsi, call, GSI_NEW_STMT);
1475 mark_symbols_for_renaming (call);
1476 find_referenced_vars_in (call);
1479 if (restmp && !this_adjusting)
1481 tree true_label = NULL_TREE;
1483 if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
1486 /* If the return type is a pointer, we need to
1487 protect against NULL. We know there will be an
1488 adjustment, because that's why we're emitting a
1490 then_bb = create_basic_block (NULL, (void *) 0, bb);
1491 return_bb = create_basic_block (NULL, (void *) 0, then_bb);
1492 else_bb = create_basic_block (NULL, (void *) 0, else_bb);
1493 remove_edge (single_succ_edge (bb));
1494 true_label = gimple_block_label (then_bb);
1495 stmt = gimple_build_cond (NE_EXPR, restmp,
1496 build_zero_cst (TREE_TYPE (restmp)),
1497 NULL_TREE, NULL_TREE);
1498 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1499 make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1500 make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1501 make_edge (return_bb, EXIT_BLOCK_PTR, 0);
1502 make_edge (then_bb, return_bb, EDGE_FALLTHRU);
1503 make_edge (else_bb, return_bb, EDGE_FALLTHRU);
1504 bsi = gsi_last_bb (then_bb);
1507 restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0,
1508 fixed_offset, virtual_offset);
1512 bsi = gsi_last_bb (else_bb);
1513 stmt = gimple_build_assign (restmp,
1514 build_zero_cst (TREE_TYPE (restmp)));
1515 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1516 bsi = gsi_last_bb (return_bb);
1520 gimple_call_set_tail (call, true);
1522 /* Build return value. */
1523 ret = gimple_build_return (restmp);
1524 gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
1526 delete_unreachable_blocks ();
1527 update_ssa (TODO_update_ssa);
1529 cgraph_remove_same_body_alias (node);
1530 /* Since we want to emit the thunk, we explicitly mark its name as
1532 cgraph_add_new_function (thunk_fndecl, true);
1533 bitmap_obstack_release (NULL);
1535 current_function_decl = NULL;
1538 /* Expand function specified by NODE. */
1541 cgraph_expand_function (struct cgraph_node *node)
1543 tree decl = node->decl;
1545 /* We ought to not compile any inline clones. */
1546 gcc_assert (!node->global.inlined_to);
1548 announce_function (decl);
1550 if (node->same_body)
1552 struct cgraph_node *alias, *next;
1553 bool saved_alias = node->alias;
1554 for (alias = node->same_body;
1555 alias && alias->next; alias = alias->next)
1557 /* Walk aliases in the order they were created; it is possible that
1558 thunks refers to the aliases made earlier. */
1559 for (; alias; alias = next)
1561 next = alias->previous;
1562 if (!alias->thunk.thunk_p)
1563 assemble_alias (alias->decl,
1564 DECL_ASSEMBLER_NAME (alias->thunk.alias));
1566 assemble_thunk (alias);
1568 node->alias = saved_alias;
1569 cgraph_process_new_functions ();
1572 gcc_assert (node->lowered);
1574 /* Generate RTL for the body of DECL. */
1575 tree_rest_of_compilation (decl);
1577 /* Make sure that BE didn't give up on compiling. */
1578 gcc_assert (TREE_ASM_WRITTEN (decl));
1579 current_function_decl = NULL;
1580 gcc_assert (!cgraph_preserve_function_body_p (decl));
1581 cgraph_release_function_body (node);
1582 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1583 points to the dead function body. */
1584 cgraph_node_remove_callees (node);
1586 cgraph_function_flags_ready = true;
1589 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1592 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason)
1594 *reason = e->inline_failed;
1595 return !e->inline_failed;
1600 /* Expand all functions that must be output.
1602 Attempt to topologically sort the nodes so function is output when
1603 all called functions are already assembled to allow data to be
1604 propagated across the callgraph. Use a stack to get smaller distance
1605 between a function and its callees (later we may choose to use a more
1606 sophisticated algorithm for function reordering; we will likely want
1607 to use subsections to make the output functions appear in top-down
1611 cgraph_expand_all_functions (void)
1613 struct cgraph_node *node;
1614 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1615 int order_pos, new_order_pos = 0;
1618 order_pos = cgraph_postorder (order);
1619 gcc_assert (order_pos == cgraph_n_nodes);
1621 /* Garbage collector may remove inline clones we eliminate during
1622 optimization. So we must be sure to not reference them. */
1623 for (i = 0; i < order_pos; i++)
1624 if (order[i]->process)
1625 order[new_order_pos++] = order[i];
1627 for (i = new_order_pos - 1; i >= 0; i--)
1632 gcc_assert (node->reachable);
1634 cgraph_expand_function (node);
1637 cgraph_process_new_functions ();
1643 /* This is used to sort the node types by the cgraph order number. */
1645 enum cgraph_order_sort_kind
1647 ORDER_UNDEFINED = 0,
1653 struct cgraph_order_sort
1655 enum cgraph_order_sort_kind kind;
1658 struct cgraph_node *f;
1659 struct varpool_node *v;
1660 struct cgraph_asm_node *a;
1664 /* Output all functions, variables, and asm statements in the order
1665 according to their order fields, which is the order in which they
1666 appeared in the file. This implements -fno-toplevel-reorder. In
1667 this mode we may output functions and variables which don't really
1668 need to be output. */
1671 cgraph_output_in_order (void)
1674 struct cgraph_order_sort *nodes;
1676 struct cgraph_node *pf;
1677 struct varpool_node *pv;
1678 struct cgraph_asm_node *pa;
1681 nodes = XCNEWVEC (struct cgraph_order_sort, max);
1683 varpool_analyze_pending_decls ();
1685 for (pf = cgraph_nodes; pf; pf = pf->next)
1690 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1691 nodes[i].kind = ORDER_FUNCTION;
1696 for (pv = varpool_nodes_queue; pv; pv = pv->next_needed)
1699 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1700 nodes[i].kind = ORDER_VAR;
1704 for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1707 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1708 nodes[i].kind = ORDER_ASM;
1712 /* In toplevel reorder mode we output all statics; mark them as needed. */
1713 for (i = 0; i < max; ++i)
1715 if (nodes[i].kind == ORDER_VAR)
1717 varpool_mark_needed_node (nodes[i].u.v);
1720 varpool_empty_needed_queue ();
1722 for (i = 0; i < max; ++i)
1723 if (nodes[i].kind == ORDER_VAR)
1724 varpool_finalize_named_section_flags (nodes[i].u.v);
1726 for (i = 0; i < max; ++i)
1728 switch (nodes[i].kind)
1730 case ORDER_FUNCTION:
1731 nodes[i].u.f->process = 0;
1732 cgraph_expand_function (nodes[i].u.f);
1736 varpool_assemble_decl (nodes[i].u.v);
1740 assemble_asm (nodes[i].u.a->asm_str);
1743 case ORDER_UNDEFINED:
1751 cgraph_asm_nodes = NULL;
1755 /* Return true when function body of DECL still needs to be kept around
1756 for later re-use. */
1758 cgraph_preserve_function_body_p (tree decl)
1760 struct cgraph_node *node;
1762 gcc_assert (cgraph_global_info_ready);
1763 /* Look if there is any clone around. */
1764 node = cgraph_get_node (decl);
1774 current_function_decl = NULL;
1775 gimple_register_cfg_hooks ();
1776 bitmap_obstack_initialize (NULL);
1778 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
1782 execute_ipa_pass_list (all_small_ipa_passes);
1787 /* If pass_all_early_optimizations was not scheduled, the state of
1788 the cgraph will not be properly updated. Update it now. */
1789 if (cgraph_state < CGRAPH_STATE_IPA_SSA)
1790 cgraph_state = CGRAPH_STATE_IPA_SSA;
1794 /* Generate coverage variables and constructors. */
1797 /* Process new functions added. */
1799 current_function_decl = NULL;
1800 cgraph_process_new_functions ();
1802 execute_ipa_summary_passes
1803 ((struct ipa_opt_pass_d *) all_regular_ipa_passes);
1806 /* Some targets need to handle LTO assembler output specially. */
1807 if (flag_generate_lto)
1808 targetm.asm_out.lto_start ();
1810 execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes);
1813 ipa_write_summaries ();
1815 if (flag_generate_lto)
1816 targetm.asm_out.lto_end ();
1819 execute_ipa_pass_list (all_regular_ipa_passes);
1820 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
1822 bitmap_obstack_release (NULL);
1826 /* Perform simple optimizations based on callgraph. */
1829 cgraph_optimize (void)
1834 #ifdef ENABLE_CHECKING
1838 /* Frontend may output common variables after the unit has been finalized.
1839 It is safe to deal with them here as they are always zero initialized. */
1840 varpool_analyze_pending_decls ();
1842 timevar_push (TV_CGRAPHOPT);
1843 if (pre_ipa_mem_report)
1845 fprintf (stderr, "Memory consumption before IPA\n");
1846 dump_memory_report (false);
1849 fprintf (stderr, "Performing interprocedural optimizations\n");
1850 cgraph_state = CGRAPH_STATE_IPA;
1852 /* Don't run the IPA passes if there was any error or sorry messages. */
1856 /* Do nothing else if any IPA pass found errors. */
1859 timevar_pop (TV_CGRAPHOPT);
1863 /* This pass remove bodies of extern inline functions we never inlined.
1864 Do this later so other IPA passes see what is really going on. */
1865 cgraph_remove_unreachable_nodes (false, dump_file);
1866 cgraph_global_info_ready = true;
1867 if (cgraph_dump_file)
1869 fprintf (cgraph_dump_file, "Optimized ");
1870 dump_cgraph (cgraph_dump_file);
1871 dump_varpool (cgraph_dump_file);
1873 if (post_ipa_mem_report)
1875 fprintf (stderr, "Memory consumption after IPA\n");
1876 dump_memory_report (false);
1878 timevar_pop (TV_CGRAPHOPT);
1880 /* Output everything. */
1881 (*debug_hooks->assembly_start) ();
1883 fprintf (stderr, "Assembling functions:\n");
1884 #ifdef ENABLE_CHECKING
1888 cgraph_materialize_all_clones ();
1889 cgraph_mark_functions_to_output ();
1891 cgraph_state = CGRAPH_STATE_EXPANSION;
1892 if (!flag_toplevel_reorder)
1893 cgraph_output_in_order ();
1896 cgraph_output_pending_asms ();
1898 cgraph_expand_all_functions ();
1899 varpool_remove_unreferenced_decls ();
1901 varpool_assemble_pending_decls ();
1903 cgraph_process_new_functions ();
1904 cgraph_state = CGRAPH_STATE_FINISHED;
1906 if (cgraph_dump_file)
1908 fprintf (cgraph_dump_file, "\nFinal ");
1909 dump_cgraph (cgraph_dump_file);
1910 dump_varpool (cgraph_dump_file);
1912 #ifdef ENABLE_CHECKING
1914 /* Double check that all inline clones are gone and that all
1915 function bodies have been released from memory. */
1918 struct cgraph_node *node;
1919 bool error_found = false;
1921 for (node = cgraph_nodes; node; node = node->next)
1923 && (node->global.inlined_to
1924 || gimple_has_body_p (node->decl)))
1927 dump_cgraph_node (stderr, node);
1930 internal_error ("nodes with unreleased memory found");
1938 if (!cgraph_dump_file)
1939 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1942 /* The edges representing the callers of the NEW_VERSION node were
1943 fixed by cgraph_function_versioning (), now the call_expr in their
1944 respective tree code should be updated to call the NEW_VERSION. */
1947 update_call_expr (struct cgraph_node *new_version)
1949 struct cgraph_edge *e;
1951 gcc_assert (new_version);
1953 /* Update the call expr on the edges to call the new version. */
1954 for (e = new_version->callers; e; e = e->next_caller)
1956 struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
1957 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
1958 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
1963 /* Create a new cgraph node which is the new version of
1964 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1965 edges which should be redirected to point to
1966 NEW_VERSION. ALL the callees edges of OLD_VERSION
1967 are cloned to the new version node. Return the new
1970 If non-NULL BLOCK_TO_COPY determine what basic blocks
1971 was copied to prevent duplications of calls that are dead
1974 static struct cgraph_node *
1975 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
1977 VEC(cgraph_edge_p,heap) *redirect_callers,
1980 struct cgraph_node *new_version;
1981 struct cgraph_edge *e;
1984 gcc_assert (old_version);
1986 new_version = cgraph_create_node (new_decl);
1988 new_version->analyzed = true;
1989 new_version->local = old_version->local;
1990 new_version->local.externally_visible = false;
1991 new_version->local.local = true;
1992 new_version->global = old_version->global;
1993 new_version->rtl = old_version->rtl;
1994 new_version->reachable = true;
1995 new_version->count = old_version->count;
1997 for (e = old_version->callees; e; e=e->next_callee)
1999 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
2000 cgraph_clone_edge (e, new_version, e->call_stmt,
2001 e->lto_stmt_uid, REG_BR_PROB_BASE,
2003 e->loop_nest, true);
2004 for (e = old_version->indirect_calls; e; e=e->next_callee)
2006 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
2007 cgraph_clone_edge (e, new_version, e->call_stmt,
2008 e->lto_stmt_uid, REG_BR_PROB_BASE,
2010 e->loop_nest, true);
2011 FOR_EACH_VEC_ELT (cgraph_edge_p, redirect_callers, i, e)
2013 /* Redirect calls to the old version node to point to its new
2015 cgraph_redirect_edge_callee (e, new_version);
2021 /* Perform function versioning.
2022 Function versioning includes copying of the tree and
2023 a callgraph update (creating a new cgraph node and updating
2024 its callees and callers).
2026 REDIRECT_CALLERS varray includes the edges to be redirected
2029 TREE_MAP is a mapping of tree nodes we want to replace with
2030 new ones (according to results of prior analysis).
2031 OLD_VERSION_NODE is the node that is versioned.
2032 It returns the new version's cgraph node.
2033 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2035 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2036 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2038 struct cgraph_node *
2039 cgraph_function_versioning (struct cgraph_node *old_version_node,
2040 VEC(cgraph_edge_p,heap) *redirect_callers,
2041 VEC (ipa_replace_map_p,gc)* tree_map,
2042 bitmap args_to_skip,
2044 basic_block new_entry_block,
2045 const char *clone_name)
2047 tree old_decl = old_version_node->decl;
2048 struct cgraph_node *new_version_node = NULL;
2051 if (!tree_versionable_function_p (old_decl))
2054 gcc_assert (old_version_node->local.can_change_signature || !args_to_skip);
2056 /* Make a new FUNCTION_DECL tree node for the
2059 new_decl = copy_node (old_decl);
2061 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2063 /* Generate a new name for the new version. */
2064 DECL_NAME (new_decl) = clone_function_name (old_decl, clone_name);
2065 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
2066 SET_DECL_RTL (new_decl, NULL);
2068 /* Create the new version's call-graph node.
2069 and update the edges of the new node. */
2071 cgraph_copy_node_for_versioning (old_version_node, new_decl,
2072 redirect_callers, bbs_to_copy);
2074 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2075 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip,
2076 bbs_to_copy, new_entry_block);
2078 /* Update the new version's properties.
2079 Make The new version visible only within this translation unit. Make sure
2080 that is not weak also.
2081 ??? We cannot use COMDAT linkage because there is no
2082 ABI support for this. */
2083 cgraph_make_decl_local (new_version_node->decl);
2084 DECL_VIRTUAL_P (new_version_node->decl) = 0;
2085 new_version_node->local.externally_visible = 0;
2086 new_version_node->local.local = 1;
2087 new_version_node->lowered = true;
2089 /* Update the call_expr on the edges to call the new version node. */
2090 update_call_expr (new_version_node);
2092 cgraph_call_function_insertion_hooks (new_version_node);
2093 return new_version_node;
2096 /* Given virtual clone, turn it into actual clone. */
2098 cgraph_materialize_clone (struct cgraph_node *node)
2100 bitmap_obstack_initialize (NULL);
2101 node->former_clone_of = node->clone_of->decl;
2102 if (node->clone_of->former_clone_of)
2103 node->former_clone_of = node->clone_of->former_clone_of;
2104 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2105 tree_function_versioning (node->clone_of->decl, node->decl,
2106 node->clone.tree_map, true,
2107 node->clone.args_to_skip, NULL, NULL);
2108 if (cgraph_dump_file)
2110 dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
2111 dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
2114 /* Function is no longer clone. */
2115 if (node->next_sibling_clone)
2116 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
2117 if (node->prev_sibling_clone)
2118 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
2120 node->clone_of->clones = node->next_sibling_clone;
2121 node->next_sibling_clone = NULL;
2122 node->prev_sibling_clone = NULL;
2123 if (!node->clone_of->analyzed && !node->clone_of->clones)
2125 cgraph_release_function_body (node->clone_of);
2126 cgraph_node_remove_callees (node->clone_of);
2127 ipa_remove_all_references (&node->clone_of->ref_list);
2129 node->clone_of = NULL;
2130 bitmap_obstack_release (NULL);
2133 /* If necessary, change the function declaration in the call statement
2134 associated with E so that it corresponds to the edge callee. */
2137 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
2139 tree decl = gimple_call_fndecl (e->call_stmt);
2141 gimple_stmt_iterator gsi;
2142 bool gsi_computed = false;
2143 #ifdef ENABLE_CHECKING
2144 struct cgraph_node *node;
2147 if (e->indirect_unknown_callee
2148 || decl == e->callee->decl
2149 /* Don't update call from same body alias to the real function. */
2150 || (decl && cgraph_get_node (decl) == cgraph_get_node (e->callee->decl)))
2151 return e->call_stmt;
2153 #ifdef ENABLE_CHECKING
2156 node = cgraph_get_node (decl);
2157 gcc_assert (!node || !node->clone.combined_args_to_skip);
2161 if (cgraph_dump_file)
2163 fprintf (cgraph_dump_file, "updating call of %s/%i -> %s/%i: ",
2164 cgraph_node_name (e->caller), e->caller->uid,
2165 cgraph_node_name (e->callee), e->callee->uid);
2166 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2167 if (e->callee->clone.combined_args_to_skip)
2169 fprintf (cgraph_dump_file, " combined args to skip: ");
2170 dump_bitmap (cgraph_dump_file,
2171 e->callee->clone.combined_args_to_skip);
2175 if (e->indirect_info &&
2176 e->indirect_info->thunk_delta != 0
2177 && (!e->callee->clone.combined_args_to_skip
2178 || !bitmap_bit_p (e->callee->clone.combined_args_to_skip, 0)))
2180 if (cgraph_dump_file)
2181 fprintf (cgraph_dump_file, " Thunk delta is "
2182 HOST_WIDE_INT_PRINT_DEC "\n", e->indirect_info->thunk_delta);
2183 gsi = gsi_for_stmt (e->call_stmt);
2184 gsi_computed = true;
2185 gimple_adjust_this_by_delta (&gsi,
2186 build_int_cst (sizetype,
2187 e->indirect_info->thunk_delta));
2188 e->indirect_info->thunk_delta = 0;
2191 if (e->callee->clone.combined_args_to_skip)
2196 = gimple_call_copy_skip_args (e->call_stmt,
2197 e->callee->clone.combined_args_to_skip);
2198 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2200 if (gimple_vdef (new_stmt)
2201 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2202 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2205 gsi = gsi_for_stmt (e->call_stmt);
2206 gsi_replace (&gsi, new_stmt, false);
2207 /* We need to defer cleaning EH info on the new statement to
2208 fixup-cfg. We may not have dominator information at this point
2209 and thus would end up with unreachable blocks and have no way
2210 to communicate that we need to run CFG cleanup then. */
2211 lp_nr = lookup_stmt_eh_lp (e->call_stmt);
2214 remove_stmt_from_eh_lp (e->call_stmt);
2215 add_stmt_to_eh_lp (new_stmt, lp_nr);
2220 new_stmt = e->call_stmt;
2221 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2222 update_stmt (new_stmt);
2225 cgraph_set_call_stmt_including_clones (e->caller, e->call_stmt, new_stmt);
2227 if (cgraph_dump_file)
2229 fprintf (cgraph_dump_file, " updated to:");
2230 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2235 /* Once all functions from compilation unit are in memory, produce all clones
2236 and update all calls. We might also do this on demand if we don't want to
2237 bring all functions to memory prior compilation, but current WHOPR
2238 implementation does that and it is is bit easier to keep everything right in
2241 cgraph_materialize_all_clones (void)
2243 struct cgraph_node *node;
2244 bool stabilized = false;
2246 if (cgraph_dump_file)
2247 fprintf (cgraph_dump_file, "Materializing clones\n");
2248 #ifdef ENABLE_CHECKING
2252 /* We can also do topological order, but number of iterations should be
2253 bounded by number of IPA passes since single IPA pass is probably not
2254 going to create clones of clones it created itself. */
2258 for (node = cgraph_nodes; node; node = node->next)
2260 if (node->clone_of && node->decl != node->clone_of->decl
2261 && !gimple_has_body_p (node->decl))
2263 if (gimple_has_body_p (node->clone_of->decl))
2265 if (cgraph_dump_file)
2267 fprintf (cgraph_dump_file, "cloning %s to %s\n",
2268 cgraph_node_name (node->clone_of),
2269 cgraph_node_name (node));
2270 if (node->clone.tree_map)
2273 fprintf (cgraph_dump_file, " replace map: ");
2274 for (i = 0; i < VEC_length (ipa_replace_map_p,
2275 node->clone.tree_map);
2278 struct ipa_replace_map *replace_info;
2279 replace_info = VEC_index (ipa_replace_map_p,
2280 node->clone.tree_map,
2282 print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2283 fprintf (cgraph_dump_file, " -> ");
2284 print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2285 fprintf (cgraph_dump_file, "%s%s;",
2286 replace_info->replace_p ? "(replace)":"",
2287 replace_info->ref_p ? "(ref)":"");
2289 fprintf (cgraph_dump_file, "\n");
2291 if (node->clone.args_to_skip)
2293 fprintf (cgraph_dump_file, " args_to_skip: ");
2294 dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2296 if (node->clone.args_to_skip)
2298 fprintf (cgraph_dump_file, " combined_args_to_skip:");
2299 dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2302 cgraph_materialize_clone (node);
2308 for (node = cgraph_nodes; node; node = node->next)
2309 if (!node->analyzed && node->callees)
2310 cgraph_node_remove_callees (node);
2311 if (cgraph_dump_file)
2312 fprintf (cgraph_dump_file, "Materialization Call site updates done.\n");
2313 #ifdef ENABLE_CHECKING
2316 cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2319 #include "gt-cgraphunit.h"