1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 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 the call-graph construction and local function
49 analysis takes place here. Bodies of unreachable functions are released
50 to 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);
146 static void cgraph_analyze_function (struct cgraph_node *);
148 FILE *cgraph_dump_file;
150 /* Used for vtable lookup in thunk adjusting. */
151 static GTY (()) tree vtable_entry_type;
153 /* Determine if function DECL is needed. That is, visible to something
154 either outside this translation unit, something magic in the system
158 cgraph_decide_is_function_needed (struct cgraph_node *node, tree decl)
160 /* If the user told us it is used, then it must be so. */
161 if (node->local.externally_visible)
164 /* ??? If the assembler name is set by hand, it is possible to assemble
165 the name later after finalizing the function and the fact is noticed
166 in assemble_name then. This is arguably a bug. */
167 if (DECL_ASSEMBLER_NAME_SET_P (decl)
168 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
171 /* With -fkeep-inline-functions we are keeping all inline functions except
172 for extern inline ones. */
173 if (flag_keep_inline_functions
174 && DECL_DECLARED_INLINE_P (decl)
175 && !DECL_EXTERNAL (decl)
176 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl)))
179 /* If we decided it was needed before, but at the time we didn't have
180 the body of the function available, then it's still needed. We have
181 to go back and re-check its dependencies now. */
185 /* Externally visible functions must be output. The exception is
186 COMDAT functions that must be output only when they are needed.
188 When not optimizing, also output the static functions. (see
189 PR24561), but don't do so for always_inline functions, functions
190 declared inline and nested functions. These were optimized out
191 in the original implementation and it is unclear whether we want
192 to change the behavior here. */
193 if (((TREE_PUBLIC (decl)
195 && !node->local.disregard_inline_limits
196 && !DECL_DECLARED_INLINE_P (decl)
197 && !(DECL_CONTEXT (decl)
198 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)))
199 && !flag_whole_program
202 && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
208 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
209 functions into callgraph in a way so they look like ordinary reachable
210 functions inserted into callgraph already at construction time. */
213 cgraph_process_new_functions (void)
217 struct cgraph_node *node;
219 varpool_analyze_pending_decls ();
220 /* Note that this queue may grow as its being processed, as the new
221 functions may generate new ones. */
222 while (cgraph_new_nodes)
224 node = cgraph_new_nodes;
226 cgraph_new_nodes = cgraph_new_nodes->next_needed;
227 switch (cgraph_state)
229 case CGRAPH_STATE_CONSTRUCTION:
230 /* At construction time we just need to finalize function and move
231 it into reachable functions list. */
233 node->next_needed = NULL;
234 cgraph_finalize_function (fndecl, false);
235 cgraph_mark_reachable_node (node);
239 case CGRAPH_STATE_IPA:
240 case CGRAPH_STATE_IPA_SSA:
241 /* When IPA optimization already started, do all essential
242 transformations that has been already performed on the whole
243 cgraph but not on this function. */
245 gimple_register_cfg_hooks ();
247 cgraph_analyze_function (node);
248 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
249 current_function_decl = fndecl;
250 compute_inline_parameters (node);
251 if ((cgraph_state == CGRAPH_STATE_IPA_SSA
252 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
253 /* When not optimizing, be sure we run early local passes anyway
256 execute_pass_list (pass_early_local_passes.pass.sub);
257 free_dominance_info (CDI_POST_DOMINATORS);
258 free_dominance_info (CDI_DOMINATORS);
260 current_function_decl = NULL;
263 case CGRAPH_STATE_EXPANSION:
264 /* Functions created during expansion shall be compiled
267 cgraph_expand_function (node);
274 cgraph_call_function_insertion_hooks (node);
275 varpool_analyze_pending_decls ();
280 /* As an GCC extension we allow redefinition of the function. The
281 semantics when both copies of bodies differ is not well defined.
282 We replace the old body with new body so in unit at a time mode
283 we always use new body, while in normal mode we may end up with
284 old body inlined into some functions and new body expanded and
287 ??? It may make more sense to use one body for inlining and other
288 body for expanding the function but this is difficult to do. */
291 cgraph_reset_node (struct cgraph_node *node)
293 /* If node->process is set, then we have already begun whole-unit analysis.
294 This is *not* testing for whether we've already emitted the function.
295 That case can be sort-of legitimately seen with real function redefinition
296 errors. I would argue that the front end should never present us with
297 such a case, but don't enforce that for now. */
298 gcc_assert (!node->process);
300 /* Reset our data structures so we can analyze the function again. */
301 memset (&node->local, 0, sizeof (node->local));
302 memset (&node->global, 0, sizeof (node->global));
303 memset (&node->rtl, 0, sizeof (node->rtl));
304 node->analyzed = false;
305 node->local.redefined_extern_inline = true;
306 node->local.finalized = false;
308 cgraph_node_remove_callees (node);
310 /* We may need to re-queue the node for assembling in case
311 we already proceeded it and ignored as not needed or got
312 a re-declaration in IMA mode. */
315 struct cgraph_node *n;
317 for (n = cgraph_nodes_queue; n; n = n->next_needed)
326 cgraph_lower_function (struct cgraph_node *node)
332 lower_nested_functions (node->decl);
333 gcc_assert (!node->nested);
335 tree_lowering_passes (node->decl);
336 node->lowered = true;
339 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
340 logic in effect. If NESTED is true, then our caller cannot stand to have
341 the garbage collector run at the moment. We would need to either create
342 a new GC context, or just not compile right now. */
345 cgraph_finalize_function (tree decl, bool nested)
347 struct cgraph_node *node = cgraph_node (decl);
349 if (node->local.finalized)
350 cgraph_reset_node (node);
352 node->pid = cgraph_max_pid ++;
353 notice_global_symbol (decl);
354 node->local.finalized = true;
355 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
356 node->finalized_by_frontend = true;
358 if (cgraph_decide_is_function_needed (node, decl))
359 cgraph_mark_needed_node (node);
361 /* Since we reclaim unreachable nodes at the end of every language
362 level unit, we need to be conservative about possible entry points
364 if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
365 || DECL_STATIC_CONSTRUCTOR (decl)
366 || DECL_STATIC_DESTRUCTOR (decl))
367 cgraph_mark_reachable_node (node);
369 /* If we've not yet emitted decl, tell the debug info about it. */
370 if (!TREE_ASM_WRITTEN (decl))
371 (*debug_hooks->deferred_inline_function) (decl);
373 /* Possibly warn about unused parameters. */
374 if (warn_unused_parameter)
375 do_warn_unused_parameter (decl);
381 /* C99 extern inline keywords allow changing of declaration after function
382 has been finalized. We need to re-decide if we want to mark the function as
386 cgraph_mark_if_needed (tree decl)
388 struct cgraph_node *node = cgraph_node (decl);
389 if (node->local.finalized && cgraph_decide_is_function_needed (node, decl))
390 cgraph_mark_needed_node (node);
393 #ifdef ENABLE_CHECKING
394 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
396 clone_of_p (struct cgraph_node *node, struct cgraph_node *node2)
398 while (node != node2 && node2)
399 node2 = node2->clone_of;
400 return node2 != NULL;
404 /* Verify edge E count and frequency. */
407 verify_edge_count_and_frequency (struct cgraph_edge *e)
409 bool error_found = false;
412 error ("caller edge count is negative");
415 if (e->frequency < 0)
417 error ("caller edge frequency is negative");
420 if (e->frequency > CGRAPH_FREQ_MAX)
422 error ("caller edge frequency is too large");
425 if (gimple_has_body_p (e->caller->decl)
426 && !e->caller->global.inlined_to
428 != compute_call_stmt_bb_frequency (e->caller->decl,
429 gimple_bb (e->call_stmt))))
431 error ("caller edge frequency %i does not match BB freqency %i",
433 compute_call_stmt_bb_frequency (e->caller->decl,
434 gimple_bb (e->call_stmt)));
440 /* Verify cgraph nodes of given cgraph node. */
442 verify_cgraph_node (struct cgraph_node *node)
444 struct cgraph_edge *e;
445 struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
446 struct function *saved_cfun = cfun;
447 basic_block this_block;
448 gimple_stmt_iterator gsi;
449 bool error_found = false;
454 timevar_push (TV_CGRAPH_VERIFY);
455 /* debug_generic_stmt needs correct cfun */
456 set_cfun (this_cfun);
457 for (e = node->callees; e; e = e->next_callee)
460 error ("aux field set for edge %s->%s",
461 identifier_to_locale (cgraph_node_name (e->caller)),
462 identifier_to_locale (cgraph_node_name (e->callee)));
467 error ("Execution count is negative");
470 if (node->global.inlined_to && node->local.externally_visible)
472 error ("Externally visible inline clone");
475 if (node->global.inlined_to && node->address_taken)
477 error ("Inline clone with address taken");
480 if (node->global.inlined_to && node->needed)
482 error ("Inline clone is needed");
485 for (e = node->indirect_calls; e; e = e->next_callee)
489 error ("aux field set for indirect edge from %s",
490 identifier_to_locale (cgraph_node_name (e->caller)));
493 if (!e->indirect_unknown_callee
494 || !e->indirect_info)
496 error ("An indirect edge from %s is not marked as indirect or has "
497 "associated indirect_info, the corresponding statement is: ",
498 identifier_to_locale (cgraph_node_name (e->caller)));
499 debug_gimple_stmt (e->call_stmt);
503 for (e = node->callers; e; e = e->next_caller)
505 if (verify_edge_count_and_frequency (e))
507 if (!e->inline_failed)
509 if (node->global.inlined_to
510 != (e->caller->global.inlined_to
511 ? e->caller->global.inlined_to : e->caller))
513 error ("inlined_to pointer is wrong");
516 if (node->callers->next_caller)
518 error ("multiple inline callers");
523 if (node->global.inlined_to)
525 error ("inlined_to pointer set for noninline callers");
529 for (e = node->indirect_calls; e; e = e->next_callee)
530 if (verify_edge_count_and_frequency (e))
532 if (!node->callers && node->global.inlined_to)
534 error ("inlined_to pointer is set but no predecessors found");
537 if (node->global.inlined_to == node)
539 error ("inlined_to pointer refers to itself");
543 if (!cgraph_node (node->decl))
545 error ("node not found in cgraph_hash");
551 struct cgraph_node *n;
552 for (n = node->clone_of->clones; n; n = n->next_sibling_clone)
557 error ("node has wrong clone_of");
563 struct cgraph_node *n;
564 for (n = node->clones; n; n = n->next_sibling_clone)
565 if (n->clone_of != node)
569 error ("node has wrong clone list");
573 if ((node->prev_sibling_clone || node->next_sibling_clone) && !node->clone_of)
575 error ("node is in clone list but it is not clone");
578 if (!node->prev_sibling_clone && node->clone_of && node->clone_of->clones != node)
580 error ("node has wrong prev_clone pointer");
583 if (node->prev_sibling_clone && node->prev_sibling_clone->next_sibling_clone != node)
585 error ("double linked list of clones corrupted");
588 if (node->same_comdat_group)
590 struct cgraph_node *n = node->same_comdat_group;
592 if (!DECL_ONE_ONLY (node->decl))
594 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
599 error ("node is alone in a comdat group");
604 if (!n->same_comdat_group)
606 error ("same_comdat_group is not a circular list");
610 n = n->same_comdat_group;
615 if (node->analyzed && gimple_has_body_p (node->decl)
616 && !TREE_ASM_WRITTEN (node->decl)
617 && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to)
622 /* The nodes we're interested in are never shared, so walk
623 the tree ignoring duplicates. */
624 struct pointer_set_t *visited_nodes = pointer_set_create ();
625 /* Reach the trees by walking over the CFG, and note the
626 enclosing basic-blocks in the call edges. */
627 FOR_EACH_BB_FN (this_block, this_cfun)
628 for (gsi = gsi_start_bb (this_block);
632 gimple stmt = gsi_stmt (gsi);
633 if (is_gimple_call (stmt))
635 struct cgraph_edge *e = cgraph_edge (node, stmt);
636 tree decl = gimple_call_fndecl (stmt);
641 error ("shared call_stmt:");
642 debug_gimple_stmt (stmt);
645 if (!e->indirect_unknown_callee)
647 if (e->callee->same_body_alias)
649 error ("edge points to same body alias:");
650 debug_tree (e->callee->decl);
653 #ifdef ENABLE_CHECKING
654 else if (!e->callee->global.inlined_to
656 && cgraph_get_node (decl)
657 && (e->callee->former_clone_of
658 != cgraph_get_node (decl)->decl)
659 && !clone_of_p (cgraph_node (decl),
662 error ("edge points to wrong declaration:");
663 debug_tree (e->callee->decl);
664 fprintf (stderr," Instead of:");
672 error ("an indirect edge with unknown callee "
673 "corresponding to a call_stmt with "
674 "a known declaration:");
676 debug_gimple_stmt (e->call_stmt);
682 error ("missing callgraph edge for call stmt:");
683 debug_gimple_stmt (stmt);
688 pointer_set_destroy (visited_nodes);
691 /* No CFG available?! */
694 for (e = node->callees; e; e = e->next_callee)
698 error ("edge %s->%s has no corresponding call_stmt",
699 identifier_to_locale (cgraph_node_name (e->caller)),
700 identifier_to_locale (cgraph_node_name (e->callee)));
701 debug_gimple_stmt (e->call_stmt);
706 for (e = node->indirect_calls; e; e = e->next_callee)
710 error ("an indirect edge from %s has no corresponding call_stmt",
711 identifier_to_locale (cgraph_node_name (e->caller)));
712 debug_gimple_stmt (e->call_stmt);
720 dump_cgraph_node (stderr, node);
721 internal_error ("verify_cgraph_node failed");
723 set_cfun (saved_cfun);
724 timevar_pop (TV_CGRAPH_VERIFY);
727 /* Verify whole cgraph structure. */
731 struct cgraph_node *node;
736 for (node = cgraph_nodes; node; node = node->next)
737 verify_cgraph_node (node);
740 /* Output all asm statements we have stored up to be output. */
743 cgraph_output_pending_asms (void)
745 struct cgraph_asm_node *can;
750 for (can = cgraph_asm_nodes; can; can = can->next)
751 assemble_asm (can->asm_str);
752 cgraph_asm_nodes = NULL;
755 /* Analyze the function scheduled to be output. */
757 cgraph_analyze_function (struct cgraph_node *node)
759 tree save = current_function_decl;
760 tree decl = node->decl;
762 current_function_decl = decl;
763 push_cfun (DECL_STRUCT_FUNCTION (decl));
765 assign_assembler_name_if_neeeded (node->decl);
767 /* Make sure to gimplify bodies only once. During analyzing a
768 function we lower it, which will require gimplified nested
769 functions, so we can end up here with an already gimplified
771 if (!gimple_body (decl))
772 gimplify_function_tree (decl);
773 dump_function (TDI_generic, decl);
775 cgraph_lower_function (node);
776 node->analyzed = true;
779 current_function_decl = save;
782 /* Look for externally_visible and used attributes and mark cgraph nodes
785 We cannot mark the nodes at the point the attributes are processed (in
786 handle_*_attribute) because the copy of the declarations available at that
787 point may not be canonical. For example, in:
790 void f() __attribute__((used));
792 the declaration we see in handle_used_attribute will be the second
793 declaration -- but the front end will subsequently merge that declaration
794 with the original declaration and discard the second declaration.
796 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
799 void f() __attribute__((externally_visible));
803 So, we walk the nodes at the end of the translation unit, applying the
804 attributes at that point. */
807 process_function_and_variable_attributes (struct cgraph_node *first,
808 struct varpool_node *first_var)
810 struct cgraph_node *node;
811 struct varpool_node *vnode;
813 for (node = cgraph_nodes; node != first; node = node->next)
815 tree decl = node->decl;
816 if (DECL_PRESERVE_P (decl))
817 cgraph_mark_needed_node (node);
818 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
820 if (! TREE_PUBLIC (node->decl))
821 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
822 "%<externally_visible%>"
823 " attribute have effect only on public objects");
824 else if (node->local.finalized)
825 cgraph_mark_needed_node (node);
828 for (vnode = varpool_nodes; vnode != first_var; vnode = vnode->next)
830 tree decl = vnode->decl;
831 if (DECL_PRESERVE_P (decl))
833 vnode->force_output = true;
834 if (vnode->finalized)
835 varpool_mark_needed_node (vnode);
837 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
839 if (! TREE_PUBLIC (vnode->decl))
840 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
841 "%<externally_visible%>"
842 " attribute have effect only on public objects");
843 else if (vnode->finalized)
844 varpool_mark_needed_node (vnode);
849 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
850 each reachable functions) and build cgraph.
851 The function can be called multiple times after inserting new nodes
852 into beginning of queue. Just the new part of queue is re-scanned then. */
855 cgraph_analyze_functions (void)
857 /* Keep track of already processed nodes when called multiple times for
858 intermodule optimization. */
859 static struct cgraph_node *first_analyzed;
860 struct cgraph_node *first_processed = first_analyzed;
861 static struct varpool_node *first_analyzed_var;
862 struct cgraph_node *node, *next;
864 bitmap_obstack_initialize (NULL);
865 process_function_and_variable_attributes (first_processed,
867 first_processed = cgraph_nodes;
868 first_analyzed_var = varpool_nodes;
869 varpool_analyze_pending_decls ();
870 if (cgraph_dump_file)
872 fprintf (cgraph_dump_file, "Initial entry points:");
873 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
875 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
876 fprintf (cgraph_dump_file, "\n");
878 cgraph_process_new_functions ();
880 /* Propagate reachability flag and lower representation of all reachable
881 functions. In the future, lowering will introduce new functions and
882 new entry points on the way (by template instantiation and virtual
883 method table generation for instance). */
884 while (cgraph_nodes_queue)
886 struct cgraph_edge *edge;
887 tree decl = cgraph_nodes_queue->decl;
889 node = cgraph_nodes_queue;
890 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
891 node->next_needed = NULL;
893 /* ??? It is possible to create extern inline function and later using
894 weak alias attribute to kill its body. See
895 gcc.c-torture/compile/20011119-1.c */
896 if (!DECL_STRUCT_FUNCTION (decl))
898 cgraph_reset_node (node);
903 cgraph_analyze_function (node);
905 for (edge = node->callees; edge; edge = edge->next_callee)
906 if (!edge->callee->reachable)
907 cgraph_mark_reachable_node (edge->callee);
909 if (node->same_comdat_group)
911 for (next = node->same_comdat_group;
913 next = next->same_comdat_group)
914 cgraph_mark_reachable_node (next);
917 /* If decl is a clone of an abstract function, mark that abstract
918 function so that we don't release its body. The DECL_INITIAL() of that
919 abstract function declaration will be later needed to output debug info. */
920 if (DECL_ABSTRACT_ORIGIN (decl))
922 struct cgraph_node *origin_node = cgraph_node (DECL_ABSTRACT_ORIGIN (decl));
923 origin_node->abstract_and_needed = true;
926 /* We finalize local static variables during constructing callgraph
927 edges. Process their attributes too. */
928 process_function_and_variable_attributes (first_processed,
930 first_processed = cgraph_nodes;
931 first_analyzed_var = varpool_nodes;
932 varpool_analyze_pending_decls ();
933 cgraph_process_new_functions ();
936 /* Collect entry points to the unit. */
937 if (cgraph_dump_file)
939 fprintf (cgraph_dump_file, "Unit entry points:");
940 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
942 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
943 fprintf (cgraph_dump_file, "\n\nInitial ");
944 dump_cgraph (cgraph_dump_file);
947 if (cgraph_dump_file)
948 fprintf (cgraph_dump_file, "\nReclaiming functions:");
950 for (node = cgraph_nodes; node != first_analyzed; node = next)
952 tree decl = node->decl;
955 if (node->local.finalized && !gimple_has_body_p (decl))
956 cgraph_reset_node (node);
958 if (!node->reachable && gimple_has_body_p (decl))
960 if (cgraph_dump_file)
961 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
962 cgraph_remove_node (node);
966 node->next_needed = NULL;
967 gcc_assert (!node->local.finalized || gimple_has_body_p (decl));
968 gcc_assert (node->analyzed == node->local.finalized);
970 if (cgraph_dump_file)
972 fprintf (cgraph_dump_file, "\n\nReclaimed ");
973 dump_cgraph (cgraph_dump_file);
975 bitmap_obstack_release (NULL);
976 first_analyzed = cgraph_nodes;
981 /* Analyze the whole compilation unit once it is parsed completely. */
984 cgraph_finalize_compilation_unit (void)
986 timevar_push (TV_CGRAPH);
988 /* Do not skip analyzing the functions if there were errors, we
989 miss diagnostics for following functions otherwise. */
991 /* Emit size functions we didn't inline. */
992 finalize_size_functions ();
994 /* Mark alias targets necessary and emit diagnostics. */
999 fprintf (stderr, "\nAnalyzing compilation unit\n");
1003 /* Gimplify and lower all functions, compute reachability and
1004 remove unreachable nodes. */
1005 cgraph_analyze_functions ();
1007 /* Mark alias targets necessary and emit diagnostics. */
1008 finish_aliases_1 ();
1010 /* Gimplify and lower thunks. */
1011 cgraph_analyze_functions ();
1013 /* Finally drive the pass manager. */
1016 timevar_pop (TV_CGRAPH);
1020 /* Figure out what functions we want to assemble. */
1023 cgraph_mark_functions_to_output (void)
1025 struct cgraph_node *node;
1026 #ifdef ENABLE_CHECKING
1027 bool check_same_comdat_groups = false;
1029 for (node = cgraph_nodes; node; node = node->next)
1030 gcc_assert (!node->process);
1033 for (node = cgraph_nodes; node; node = node->next)
1035 tree decl = node->decl;
1036 struct cgraph_edge *e;
1038 gcc_assert (!node->process || node->same_comdat_group);
1042 for (e = node->callers; e; e = e->next_caller)
1043 if (e->inline_failed)
1046 /* We need to output all local functions that are used and not
1047 always inlined, as well as those that are reachable from
1048 outside the current compilation unit. */
1050 && !node->global.inlined_to
1051 && (!cgraph_only_called_directly_p (node)
1052 || (e && node->reachable))
1053 && !TREE_ASM_WRITTEN (decl)
1054 && !DECL_EXTERNAL (decl))
1057 if (node->same_comdat_group)
1059 struct cgraph_node *next;
1060 for (next = node->same_comdat_group;
1062 next = next->same_comdat_group)
1066 else if (node->same_comdat_group)
1068 #ifdef ENABLE_CHECKING
1069 check_same_comdat_groups = true;
1074 /* We should've reclaimed all functions that are not needed. */
1075 #ifdef ENABLE_CHECKING
1076 if (!node->global.inlined_to
1077 && gimple_has_body_p (decl)
1078 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1079 are inside partition, we can end up not removing the body since we no longer
1080 have analyzed node pointing to it. */
1081 && !node->in_other_partition
1082 && !DECL_EXTERNAL (decl))
1084 dump_cgraph_node (stderr, node);
1085 internal_error ("failed to reclaim unneeded function");
1088 gcc_assert (node->global.inlined_to
1089 || !gimple_has_body_p (decl)
1090 || node->in_other_partition
1091 || DECL_EXTERNAL (decl));
1096 #ifdef ENABLE_CHECKING
1097 if (check_same_comdat_groups)
1098 for (node = cgraph_nodes; node; node = node->next)
1099 if (node->same_comdat_group && !node->process)
1101 tree decl = node->decl;
1102 if (!node->global.inlined_to
1103 && gimple_has_body_p (decl)
1104 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1105 are inside partition, we can end up not removing the body since we no longer
1106 have analyzed node pointing to it. */
1107 && !node->in_other_partition
1108 && !DECL_EXTERNAL (decl))
1110 dump_cgraph_node (stderr, node);
1111 internal_error ("failed to reclaim unneeded function");
1117 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1118 in lowered gimple form.
1120 Set current_function_decl and cfun to newly constructed empty function body.
1121 return basic block in the function body. */
1124 init_lowered_empty_function (tree decl)
1128 current_function_decl = decl;
1129 allocate_struct_function (decl, false);
1130 gimple_register_cfg_hooks ();
1131 init_empty_tree_cfg ();
1132 init_tree_ssa (cfun);
1133 init_ssa_operands ();
1134 cfun->gimple_df->in_ssa_p = true;
1135 DECL_INITIAL (decl) = make_node (BLOCK);
1137 DECL_SAVED_TREE (decl) = error_mark_node;
1138 cfun->curr_properties |=
1139 (PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_referenced_vars |
1142 /* Create BB for body of the function and connect it properly. */
1143 bb = create_basic_block (NULL, (void *) 0, ENTRY_BLOCK_PTR);
1144 make_edge (ENTRY_BLOCK_PTR, bb, 0);
1145 make_edge (bb, EXIT_BLOCK_PTR, 0);
1150 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1151 offset indicated by VIRTUAL_OFFSET, if that is
1152 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1153 zero for a result adjusting thunk. */
1156 thunk_adjust (gimple_stmt_iterator * bsi,
1157 tree ptr, bool this_adjusting,
1158 HOST_WIDE_INT fixed_offset, tree virtual_offset)
1164 && fixed_offset != 0)
1166 stmt = gimple_build_assign (ptr,
1167 fold_build2_loc (input_location,
1169 TREE_TYPE (ptr), ptr,
1170 size_int (fixed_offset)));
1171 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1174 /* If there's a virtual offset, look up that value in the vtable and
1175 adjust the pointer again. */
1183 if (!vtable_entry_type)
1185 tree vfunc_type = make_node (FUNCTION_TYPE);
1186 TREE_TYPE (vfunc_type) = integer_type_node;
1187 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
1188 layout_type (vfunc_type);
1190 vtable_entry_type = build_pointer_type (vfunc_type);
1194 create_tmp_var (build_pointer_type
1195 (build_pointer_type (vtable_entry_type)), "vptr");
1197 /* The vptr is always at offset zero in the object. */
1198 stmt = gimple_build_assign (vtabletmp,
1199 build1 (NOP_EXPR, TREE_TYPE (vtabletmp),
1201 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1202 mark_symbols_for_renaming (stmt);
1203 find_referenced_vars_in (stmt);
1205 /* Form the vtable address. */
1206 vtabletmp2 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp)),
1208 stmt = gimple_build_assign (vtabletmp2,
1209 build_simple_mem_ref (vtabletmp));
1210 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1211 mark_symbols_for_renaming (stmt);
1212 find_referenced_vars_in (stmt);
1214 /* Find the entry with the vcall offset. */
1215 stmt = gimple_build_assign (vtabletmp2,
1216 fold_build2_loc (input_location,
1218 TREE_TYPE (vtabletmp2),
1220 fold_convert (sizetype,
1222 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1224 /* Get the offset itself. */
1225 vtabletmp3 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2)),
1227 stmt = gimple_build_assign (vtabletmp3,
1228 build_simple_mem_ref (vtabletmp2));
1229 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1230 mark_symbols_for_renaming (stmt);
1231 find_referenced_vars_in (stmt);
1233 /* Cast to sizetype. */
1234 offsettmp = create_tmp_var (sizetype, "offset");
1235 stmt = gimple_build_assign (offsettmp, fold_convert (sizetype, vtabletmp3));
1236 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1237 mark_symbols_for_renaming (stmt);
1238 find_referenced_vars_in (stmt);
1240 /* Adjust the `this' pointer. */
1241 ptr = fold_build2_loc (input_location,
1242 POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
1247 && fixed_offset != 0)
1248 /* Adjust the pointer by the constant. */
1252 if (TREE_CODE (ptr) == VAR_DECL)
1256 ptrtmp = create_tmp_var (TREE_TYPE (ptr), "ptr");
1257 stmt = gimple_build_assign (ptrtmp, ptr);
1258 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1259 mark_symbols_for_renaming (stmt);
1260 find_referenced_vars_in (stmt);
1262 ptr = fold_build2_loc (input_location,
1263 POINTER_PLUS_EXPR, TREE_TYPE (ptrtmp), ptrtmp,
1264 size_int (fixed_offset));
1267 /* Emit the statement and gimplify the adjustment expression. */
1268 ret = create_tmp_var (TREE_TYPE (ptr), "adjusted_this");
1269 stmt = gimple_build_assign (ret, ptr);
1270 mark_symbols_for_renaming (stmt);
1271 find_referenced_vars_in (stmt);
1272 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1277 /* Produce assembler for thunk NODE. */
1280 assemble_thunk (struct cgraph_node *node)
1282 bool this_adjusting = node->thunk.this_adjusting;
1283 HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset;
1284 HOST_WIDE_INT virtual_value = node->thunk.virtual_value;
1285 tree virtual_offset = NULL;
1286 tree alias = node->thunk.alias;
1287 tree thunk_fndecl = node->decl;
1288 tree a = DECL_ARGUMENTS (thunk_fndecl);
1290 current_function_decl = thunk_fndecl;
1293 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
1294 virtual_value, alias))
1299 DECL_RESULT (thunk_fndecl)
1300 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl),
1301 RESULT_DECL, 0, integer_type_node);
1302 fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl));
1304 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1306 fn_block = make_node (BLOCK);
1307 BLOCK_VARS (fn_block) = a;
1308 DECL_INITIAL (thunk_fndecl) = fn_block;
1309 init_function_start (thunk_fndecl);
1311 assemble_start_function (thunk_fndecl, fnname);
1313 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
1314 fixed_offset, virtual_value, alias);
1316 assemble_end_function (thunk_fndecl, fnname);
1317 init_insn_lengths ();
1318 free_after_compilation (cfun);
1320 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1325 basic_block bb, then_bb, else_bb, return_bb;
1326 gimple_stmt_iterator bsi;
1332 VEC(tree, heap) *vargs;
1337 DECL_IGNORED_P (thunk_fndecl) = 1;
1338 bitmap_obstack_initialize (NULL);
1340 if (node->thunk.virtual_offset_p)
1341 virtual_offset = size_int (virtual_value);
1343 /* Build the return declaration for the function. */
1344 restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1345 if (DECL_RESULT (thunk_fndecl) == NULL_TREE)
1347 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
1348 DECL_ARTIFICIAL (resdecl) = 1;
1349 DECL_IGNORED_P (resdecl) = 1;
1350 DECL_RESULT (thunk_fndecl) = resdecl;
1353 resdecl = DECL_RESULT (thunk_fndecl);
1355 bb = then_bb = else_bb = return_bb = init_lowered_empty_function (thunk_fndecl);
1357 bsi = gsi_start_bb (bb);
1359 /* Build call to the function being thunked. */
1360 if (!VOID_TYPE_P (restype))
1362 if (!is_gimple_reg_type (restype))
1365 add_local_decl (cfun, restmp);
1366 BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp;
1369 restmp = create_tmp_var_raw (restype, "retval");
1372 for (arg = a; arg; arg = DECL_CHAIN (arg))
1374 vargs = VEC_alloc (tree, heap, nargs);
1376 VEC_quick_push (tree, vargs,
1381 VEC_quick_push (tree, vargs, a);
1382 for (i = 1, arg = DECL_CHAIN (a); i < nargs; i++, arg = DECL_CHAIN (arg))
1383 VEC_quick_push (tree, vargs, arg);
1384 call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
1385 VEC_free (tree, heap, vargs);
1386 gimple_call_set_cannot_inline (call, true);
1387 gimple_call_set_from_thunk (call, true);
1389 gimple_call_set_lhs (call, restmp);
1390 gsi_insert_after (&bsi, call, GSI_NEW_STMT);
1391 mark_symbols_for_renaming (call);
1392 find_referenced_vars_in (call);
1395 if (restmp && !this_adjusting)
1397 tree true_label = NULL_TREE;
1399 if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
1402 /* If the return type is a pointer, we need to
1403 protect against NULL. We know there will be an
1404 adjustment, because that's why we're emitting a
1406 then_bb = create_basic_block (NULL, (void *) 0, bb);
1407 return_bb = create_basic_block (NULL, (void *) 0, then_bb);
1408 else_bb = create_basic_block (NULL, (void *) 0, else_bb);
1409 remove_edge (single_succ_edge (bb));
1410 true_label = gimple_block_label (then_bb);
1411 stmt = gimple_build_cond (NE_EXPR, restmp,
1412 fold_convert (TREE_TYPE (restmp),
1414 NULL_TREE, NULL_TREE);
1415 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1416 make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1417 make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1418 make_edge (return_bb, EXIT_BLOCK_PTR, 0);
1419 make_edge (then_bb, return_bb, EDGE_FALLTHRU);
1420 make_edge (else_bb, return_bb, EDGE_FALLTHRU);
1421 bsi = gsi_last_bb (then_bb);
1424 restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0,
1425 fixed_offset, virtual_offset);
1429 bsi = gsi_last_bb (else_bb);
1430 stmt = gimple_build_assign (restmp, fold_convert (TREE_TYPE (restmp),
1431 integer_zero_node));
1432 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1433 bsi = gsi_last_bb (return_bb);
1437 gimple_call_set_tail (call, true);
1439 /* Build return value. */
1440 ret = gimple_build_return (restmp);
1441 gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
1443 delete_unreachable_blocks ();
1444 update_ssa (TODO_update_ssa);
1446 cgraph_remove_same_body_alias (node);
1447 /* Since we want to emit the thunk, we explicitly mark its name as
1449 cgraph_add_new_function (thunk_fndecl, true);
1450 bitmap_obstack_release (NULL);
1452 current_function_decl = NULL;
1455 /* Expand function specified by NODE. */
1458 cgraph_expand_function (struct cgraph_node *node)
1460 tree decl = node->decl;
1462 /* We ought to not compile any inline clones. */
1463 gcc_assert (!node->global.inlined_to);
1465 announce_function (decl);
1468 gcc_assert (node->lowered);
1470 /* Generate RTL for the body of DECL. */
1471 tree_rest_of_compilation (decl);
1473 /* Make sure that BE didn't give up on compiling. */
1474 gcc_assert (TREE_ASM_WRITTEN (decl));
1475 current_function_decl = NULL;
1476 if (node->same_body)
1478 struct cgraph_node *alias, *next;
1479 bool saved_alias = node->alias;
1480 for (alias = node->same_body;
1481 alias && alias->next; alias = alias->next)
1483 /* Walk aliases in the order they were created; it is possible that
1484 thunks reffers to the aliases made earlier. */
1485 for (; alias; alias = next)
1487 next = alias->previous;
1488 if (!alias->thunk.thunk_p)
1489 assemble_alias (alias->decl,
1490 DECL_ASSEMBLER_NAME (alias->thunk.alias));
1492 assemble_thunk (alias);
1494 node->alias = saved_alias;
1496 gcc_assert (!cgraph_preserve_function_body_p (decl));
1497 cgraph_release_function_body (node);
1498 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1499 points to the dead function body. */
1500 cgraph_node_remove_callees (node);
1502 cgraph_function_flags_ready = true;
1505 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1508 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason)
1510 *reason = e->inline_failed;
1511 return !e->inline_failed;
1516 /* Expand all functions that must be output.
1518 Attempt to topologically sort the nodes so function is output when
1519 all called functions are already assembled to allow data to be
1520 propagated across the callgraph. Use a stack to get smaller distance
1521 between a function and its callees (later we may choose to use a more
1522 sophisticated algorithm for function reordering; we will likely want
1523 to use subsections to make the output functions appear in top-down
1527 cgraph_expand_all_functions (void)
1529 struct cgraph_node *node;
1530 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1531 int order_pos, new_order_pos = 0;
1534 order_pos = cgraph_postorder (order);
1535 gcc_assert (order_pos == cgraph_n_nodes);
1537 /* Garbage collector may remove inline clones we eliminate during
1538 optimization. So we must be sure to not reference them. */
1539 for (i = 0; i < order_pos; i++)
1540 if (order[i]->process)
1541 order[new_order_pos++] = order[i];
1543 for (i = new_order_pos - 1; i >= 0; i--)
1548 gcc_assert (node->reachable);
1550 cgraph_expand_function (node);
1553 cgraph_process_new_functions ();
1559 /* This is used to sort the node types by the cgraph order number. */
1561 enum cgraph_order_sort_kind
1563 ORDER_UNDEFINED = 0,
1569 struct cgraph_order_sort
1571 enum cgraph_order_sort_kind kind;
1574 struct cgraph_node *f;
1575 struct varpool_node *v;
1576 struct cgraph_asm_node *a;
1580 /* Output all functions, variables, and asm statements in the order
1581 according to their order fields, which is the order in which they
1582 appeared in the file. This implements -fno-toplevel-reorder. In
1583 this mode we may output functions and variables which don't really
1584 need to be output. */
1587 cgraph_output_in_order (void)
1590 struct cgraph_order_sort *nodes;
1592 struct cgraph_node *pf;
1593 struct varpool_node *pv;
1594 struct cgraph_asm_node *pa;
1597 nodes = XCNEWVEC (struct cgraph_order_sort, max);
1599 varpool_analyze_pending_decls ();
1601 for (pf = cgraph_nodes; pf; pf = pf->next)
1606 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1607 nodes[i].kind = ORDER_FUNCTION;
1612 for (pv = varpool_nodes_queue; pv; pv = pv->next_needed)
1615 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1616 nodes[i].kind = ORDER_VAR;
1620 for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1623 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1624 nodes[i].kind = ORDER_ASM;
1628 /* In toplevel reorder mode we output all statics; mark them as needed. */
1629 for (i = 0; i < max; ++i)
1631 if (nodes[i].kind == ORDER_VAR)
1633 varpool_mark_needed_node (nodes[i].u.v);
1636 varpool_empty_needed_queue ();
1638 for (i = 0; i < max; ++i)
1640 switch (nodes[i].kind)
1642 case ORDER_FUNCTION:
1643 nodes[i].u.f->process = 0;
1644 cgraph_expand_function (nodes[i].u.f);
1648 varpool_assemble_decl (nodes[i].u.v);
1652 assemble_asm (nodes[i].u.a->asm_str);
1655 case ORDER_UNDEFINED:
1663 cgraph_asm_nodes = NULL;
1667 /* Return true when function body of DECL still needs to be kept around
1668 for later re-use. */
1670 cgraph_preserve_function_body_p (tree decl)
1672 struct cgraph_node *node;
1674 gcc_assert (cgraph_global_info_ready);
1675 /* Look if there is any clone around. */
1676 node = cgraph_node (decl);
1686 current_function_decl = NULL;
1687 gimple_register_cfg_hooks ();
1688 bitmap_obstack_initialize (NULL);
1690 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
1693 execute_ipa_pass_list (all_small_ipa_passes);
1695 /* If pass_all_early_optimizations was not scheduled, the state of
1696 the cgraph will not be properly updated. Update it now. */
1697 if (cgraph_state < CGRAPH_STATE_IPA_SSA)
1698 cgraph_state = CGRAPH_STATE_IPA_SSA;
1702 /* Generate coverage variables and constructors. */
1705 /* Process new functions added. */
1707 current_function_decl = NULL;
1708 cgraph_process_new_functions ();
1710 execute_ipa_summary_passes
1711 ((struct ipa_opt_pass_d *) all_regular_ipa_passes);
1714 /* Some targets need to handle LTO assembler output specially. */
1715 if (flag_generate_lto)
1716 targetm.asm_out.lto_start ();
1718 execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes);
1721 ipa_write_summaries ();
1723 if (flag_generate_lto)
1724 targetm.asm_out.lto_end ();
1727 execute_ipa_pass_list (all_regular_ipa_passes);
1728 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
1730 bitmap_obstack_release (NULL);
1734 /* Perform simple optimizations based on callgraph. */
1737 cgraph_optimize (void)
1742 #ifdef ENABLE_CHECKING
1746 /* Frontend may output common variables after the unit has been finalized.
1747 It is safe to deal with them here as they are always zero initialized. */
1748 varpool_analyze_pending_decls ();
1750 timevar_push (TV_CGRAPHOPT);
1751 if (pre_ipa_mem_report)
1753 fprintf (stderr, "Memory consumption before IPA\n");
1754 dump_memory_report (false);
1757 fprintf (stderr, "Performing interprocedural optimizations\n");
1758 cgraph_state = CGRAPH_STATE_IPA;
1760 /* Don't run the IPA passes if there was any error or sorry messages. */
1764 /* Do nothing else if any IPA pass found errors. */
1767 timevar_pop (TV_CGRAPHOPT);
1771 /* This pass remove bodies of extern inline functions we never inlined.
1772 Do this later so other IPA passes see what is really going on. */
1773 cgraph_remove_unreachable_nodes (false, dump_file);
1774 cgraph_global_info_ready = true;
1775 if (cgraph_dump_file)
1777 fprintf (cgraph_dump_file, "Optimized ");
1778 dump_cgraph (cgraph_dump_file);
1779 dump_varpool (cgraph_dump_file);
1781 if (post_ipa_mem_report)
1783 fprintf (stderr, "Memory consumption after IPA\n");
1784 dump_memory_report (false);
1786 timevar_pop (TV_CGRAPHOPT);
1788 /* Output everything. */
1789 (*debug_hooks->assembly_start) ();
1791 fprintf (stderr, "Assembling functions:\n");
1792 #ifdef ENABLE_CHECKING
1796 cgraph_materialize_all_clones ();
1797 cgraph_mark_functions_to_output ();
1799 cgraph_state = CGRAPH_STATE_EXPANSION;
1800 if (!flag_toplevel_reorder)
1801 cgraph_output_in_order ();
1804 cgraph_output_pending_asms ();
1806 cgraph_expand_all_functions ();
1807 varpool_remove_unreferenced_decls ();
1809 varpool_assemble_pending_decls ();
1811 cgraph_process_new_functions ();
1812 cgraph_state = CGRAPH_STATE_FINISHED;
1814 if (cgraph_dump_file)
1816 fprintf (cgraph_dump_file, "\nFinal ");
1817 dump_cgraph (cgraph_dump_file);
1819 #ifdef ENABLE_CHECKING
1821 /* Double check that all inline clones are gone and that all
1822 function bodies have been released from memory. */
1825 struct cgraph_node *node;
1826 bool error_found = false;
1828 for (node = cgraph_nodes; node; node = node->next)
1830 && (node->global.inlined_to
1831 || gimple_has_body_p (node->decl)))
1834 dump_cgraph_node (stderr, node);
1837 internal_error ("nodes with unreleased memory found");
1845 if (!cgraph_dump_file)
1846 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1849 /* The edges representing the callers of the NEW_VERSION node were
1850 fixed by cgraph_function_versioning (), now the call_expr in their
1851 respective tree code should be updated to call the NEW_VERSION. */
1854 update_call_expr (struct cgraph_node *new_version)
1856 struct cgraph_edge *e;
1858 gcc_assert (new_version);
1860 /* Update the call expr on the edges to call the new version. */
1861 for (e = new_version->callers; e; e = e->next_caller)
1863 struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
1864 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
1865 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
1870 /* Create a new cgraph node which is the new version of
1871 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1872 edges which should be redirected to point to
1873 NEW_VERSION. ALL the callees edges of OLD_VERSION
1874 are cloned to the new version node. Return the new
1877 If non-NULL BLOCK_TO_COPY determine what basic blocks
1878 was copied to prevent duplications of calls that are dead
1881 static struct cgraph_node *
1882 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
1884 VEC(cgraph_edge_p,heap) *redirect_callers,
1887 struct cgraph_node *new_version;
1888 struct cgraph_edge *e;
1891 gcc_assert (old_version);
1893 new_version = cgraph_node (new_decl);
1895 new_version->analyzed = true;
1896 new_version->local = old_version->local;
1897 new_version->local.externally_visible = false;
1898 new_version->local.local = true;
1899 new_version->local.vtable_method = false;
1900 new_version->global = old_version->global;
1901 new_version->rtl = old_version->rtl;
1902 new_version->reachable = true;
1903 new_version->count = old_version->count;
1905 for (e = old_version->callees; e; e=e->next_callee)
1907 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
1908 cgraph_clone_edge (e, new_version, e->call_stmt,
1909 e->lto_stmt_uid, REG_BR_PROB_BASE,
1911 e->loop_nest, true);
1912 for (e = old_version->indirect_calls; e; e=e->next_callee)
1914 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
1915 cgraph_clone_edge (e, new_version, e->call_stmt,
1916 e->lto_stmt_uid, REG_BR_PROB_BASE,
1918 e->loop_nest, true);
1919 FOR_EACH_VEC_ELT (cgraph_edge_p, redirect_callers, i, e)
1921 /* Redirect calls to the old version node to point to its new
1923 cgraph_redirect_edge_callee (e, new_version);
1929 /* Perform function versioning.
1930 Function versioning includes copying of the tree and
1931 a callgraph update (creating a new cgraph node and updating
1932 its callees and callers).
1934 REDIRECT_CALLERS varray includes the edges to be redirected
1937 TREE_MAP is a mapping of tree nodes we want to replace with
1938 new ones (according to results of prior analysis).
1939 OLD_VERSION_NODE is the node that is versioned.
1940 It returns the new version's cgraph node.
1941 If non-NULL ARGS_TO_SKIP determine function parameters to remove
1943 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
1944 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
1946 struct cgraph_node *
1947 cgraph_function_versioning (struct cgraph_node *old_version_node,
1948 VEC(cgraph_edge_p,heap) *redirect_callers,
1949 VEC (ipa_replace_map_p,gc)* tree_map,
1950 bitmap args_to_skip,
1952 basic_block new_entry_block,
1953 const char *clone_name)
1955 tree old_decl = old_version_node->decl;
1956 struct cgraph_node *new_version_node = NULL;
1959 if (!tree_versionable_function_p (old_decl))
1962 /* Make a new FUNCTION_DECL tree node for the
1965 new_decl = copy_node (old_decl);
1967 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
1969 /* Generate a new name for the new version. */
1970 DECL_NAME (new_decl) = clone_function_name (old_decl, clone_name);
1971 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1972 SET_DECL_RTL (new_decl, NULL);
1974 /* Create the new version's call-graph node.
1975 and update the edges of the new node. */
1977 cgraph_copy_node_for_versioning (old_version_node, new_decl,
1978 redirect_callers, bbs_to_copy);
1980 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1981 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip,
1982 bbs_to_copy, new_entry_block);
1984 /* Update the new version's properties.
1985 Make The new version visible only within this translation unit. Make sure
1986 that is not weak also.
1987 ??? We cannot use COMDAT linkage because there is no
1988 ABI support for this. */
1989 cgraph_make_decl_local (new_version_node->decl);
1990 DECL_VIRTUAL_P (new_version_node->decl) = 0;
1991 new_version_node->local.externally_visible = 0;
1992 new_version_node->local.local = 1;
1993 new_version_node->lowered = true;
1995 /* Update the call_expr on the edges to call the new version node. */
1996 update_call_expr (new_version_node);
1998 cgraph_call_function_insertion_hooks (new_version_node);
1999 return new_version_node;
2002 /* Produce separate function body for inline clones so the offline copy can be
2003 modified without affecting them. */
2004 struct cgraph_node *
2005 save_inline_function_body (struct cgraph_node *node)
2007 struct cgraph_node *first_clone, *n;
2009 gcc_assert (node == cgraph_node (node->decl));
2011 cgraph_lower_function (node);
2013 first_clone = node->clones;
2015 first_clone->decl = copy_node (node->decl);
2016 cgraph_insert_node_to_hashtable (first_clone);
2017 gcc_assert (first_clone == cgraph_node (first_clone->decl));
2018 if (first_clone->next_sibling_clone)
2020 for (n = first_clone->next_sibling_clone; n->next_sibling_clone; n = n->next_sibling_clone)
2021 n->clone_of = first_clone;
2022 n->clone_of = first_clone;
2023 n->next_sibling_clone = first_clone->clones;
2024 if (first_clone->clones)
2025 first_clone->clones->prev_sibling_clone = n;
2026 first_clone->clones = first_clone->next_sibling_clone;
2027 first_clone->next_sibling_clone->prev_sibling_clone = NULL;
2028 first_clone->next_sibling_clone = NULL;
2029 gcc_assert (!first_clone->prev_sibling_clone);
2031 first_clone->clone_of = NULL;
2032 node->clones = NULL;
2034 if (first_clone->clones)
2035 for (n = first_clone->clones; n != first_clone;)
2037 gcc_assert (n->decl == node->decl);
2038 n->decl = first_clone->decl;
2041 else if (n->next_sibling_clone)
2042 n = n->next_sibling_clone;
2045 while (n != first_clone && !n->next_sibling_clone)
2047 if (n != first_clone)
2048 n = n->next_sibling_clone;
2052 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2053 tree_function_versioning (node->decl, first_clone->decl, NULL, true, NULL,
2056 DECL_EXTERNAL (first_clone->decl) = 0;
2057 DECL_COMDAT_GROUP (first_clone->decl) = NULL_TREE;
2058 TREE_PUBLIC (first_clone->decl) = 0;
2059 DECL_COMDAT (first_clone->decl) = 0;
2060 VEC_free (ipa_opt_pass, heap,
2061 first_clone->ipa_transforms_to_apply);
2062 first_clone->ipa_transforms_to_apply = NULL;
2064 #ifdef ENABLE_CHECKING
2065 verify_cgraph_node (first_clone);
2070 /* Given virtual clone, turn it into actual clone. */
2072 cgraph_materialize_clone (struct cgraph_node *node)
2074 bitmap_obstack_initialize (NULL);
2075 #ifdef ENABLE_CHECKING
2076 node->former_clone_of = node->clone_of->decl;
2077 if (node->clone_of->former_clone_of)
2078 node->former_clone_of = node->clone_of->former_clone_of;
2080 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2081 tree_function_versioning (node->clone_of->decl, node->decl,
2082 node->clone.tree_map, true,
2083 node->clone.args_to_skip, NULL, NULL);
2084 if (cgraph_dump_file)
2086 dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
2087 dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
2090 /* Function is no longer clone. */
2091 if (node->next_sibling_clone)
2092 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
2093 if (node->prev_sibling_clone)
2094 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
2096 node->clone_of->clones = node->next_sibling_clone;
2097 node->next_sibling_clone = NULL;
2098 node->prev_sibling_clone = NULL;
2099 if (!node->clone_of->analyzed && !node->clone_of->clones)
2101 cgraph_release_function_body (node->clone_of);
2102 cgraph_node_remove_callees (node->clone_of);
2103 ipa_remove_all_references (&node->clone_of->ref_list);
2105 node->clone_of = NULL;
2106 bitmap_obstack_release (NULL);
2109 /* If necessary, change the function declaration in the call statement
2110 associated with E so that it corresponds to the edge callee. */
2113 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
2115 tree decl = gimple_call_fndecl (e->call_stmt);
2117 #ifdef ENABLE_CHECKING
2118 struct cgraph_node *node;
2121 if (e->indirect_unknown_callee
2122 || decl == e->callee->decl
2123 /* Don't update call from same body alias to the real function. */
2124 || (decl && cgraph_get_node (decl) == cgraph_get_node (e->callee->decl)))
2125 return e->call_stmt;
2127 #ifdef ENABLE_CHECKING
2130 node = cgraph_get_node (decl);
2131 gcc_assert (!node || !node->clone.combined_args_to_skip);
2135 if (cgraph_dump_file)
2137 fprintf (cgraph_dump_file, "updating call of %s/%i -> %s/%i: ",
2138 cgraph_node_name (e->caller), e->caller->uid,
2139 cgraph_node_name (e->callee), e->callee->uid);
2140 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2141 if (e->callee->clone.combined_args_to_skip)
2143 fprintf (cgraph_dump_file, " combined args to skip: ");
2144 dump_bitmap (cgraph_dump_file,
2145 e->callee->clone.combined_args_to_skip);
2149 if (e->callee->clone.combined_args_to_skip)
2151 gimple_stmt_iterator gsi;
2154 = gimple_call_copy_skip_args (e->call_stmt,
2155 e->callee->clone.combined_args_to_skip);
2157 if (gimple_vdef (new_stmt)
2158 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2159 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2161 gsi = gsi_for_stmt (e->call_stmt);
2162 gsi_replace (&gsi, new_stmt, true);
2165 new_stmt = e->call_stmt;
2167 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2168 update_stmt (new_stmt);
2170 cgraph_set_call_stmt_including_clones (e->caller, e->call_stmt, new_stmt);
2172 if (cgraph_dump_file)
2174 fprintf (cgraph_dump_file, " updated to:");
2175 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2180 /* Once all functions from compilation unit are in memory, produce all clones
2181 and update all calls. We might also do this on demand if we don't want to
2182 bring all functions to memory prior compilation, but current WHOPR
2183 implementation does that and it is is bit easier to keep everything right in
2186 cgraph_materialize_all_clones (void)
2188 struct cgraph_node *node;
2189 bool stabilized = false;
2191 if (cgraph_dump_file)
2192 fprintf (cgraph_dump_file, "Materializing clones\n");
2193 #ifdef ENABLE_CHECKING
2197 /* We can also do topological order, but number of iterations should be
2198 bounded by number of IPA passes since single IPA pass is probably not
2199 going to create clones of clones it created itself. */
2203 for (node = cgraph_nodes; node; node = node->next)
2205 if (node->clone_of && node->decl != node->clone_of->decl
2206 && !gimple_has_body_p (node->decl))
2208 if (gimple_has_body_p (node->clone_of->decl))
2210 if (cgraph_dump_file)
2212 fprintf (cgraph_dump_file, "clonning %s to %s\n",
2213 cgraph_node_name (node->clone_of),
2214 cgraph_node_name (node));
2215 if (node->clone.tree_map)
2218 fprintf (cgraph_dump_file, " replace map: ");
2219 for (i = 0; i < VEC_length (ipa_replace_map_p,
2220 node->clone.tree_map);
2223 struct ipa_replace_map *replace_info;
2224 replace_info = VEC_index (ipa_replace_map_p,
2225 node->clone.tree_map,
2227 print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2228 fprintf (cgraph_dump_file, " -> ");
2229 print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2230 fprintf (cgraph_dump_file, "%s%s;",
2231 replace_info->replace_p ? "(replace)":"",
2232 replace_info->ref_p ? "(ref)":"");
2234 fprintf (cgraph_dump_file, "\n");
2236 if (node->clone.args_to_skip)
2238 fprintf (cgraph_dump_file, " args_to_skip: ");
2239 dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2241 if (node->clone.args_to_skip)
2243 fprintf (cgraph_dump_file, " combined_args_to_skip:");
2244 dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2247 cgraph_materialize_clone (node);
2253 for (node = cgraph_nodes; node; node = node->next)
2254 if (!node->analyzed && node->callees)
2255 cgraph_node_remove_callees (node);
2256 if (cgraph_dump_file)
2257 fprintf (cgraph_dump_file, "Materialization Call site updates done.\n");
2258 #ifdef ENABLE_CHECKING
2261 cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2264 #include "gt-cgraphunit.h"