1 /* Callgraph based intraprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
22 /* This module implements main driver of compilation process as well as
23 few basic intraprocedural 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 function.)
37 - cgraph_varpool_finalize_variable
39 This function has same behavior as the above but is used for static
42 - cgraph_finalize_compilation_unit
44 This function is called once compilation unit is finalized and it will
47 In the unit-at-a-time the call-graph construction and local function
48 analysis takes place here. Bodies of unreachable functions are released
49 to conserve memory usage.
51 ??? The compilation unit in this point of view should be compilation
52 unit as defined by the language - for instance C frontend allows multiple
53 compilation units to be parsed at once and it should call function each
54 time parsing is done so we save memory.
58 In this unit-at-a-time compilation the intra procedural analysis takes
59 place here. In particular the static functions whose address is never
60 taken are marked as local. Backend can then use this information to
61 modify calling conventions, do better inlining or similar optimizations.
63 - cgraph_assemble_pending_functions
64 - cgraph_varpool_assemble_pending_variables
66 In non-unit-at-a-time mode these functions can be used to force compilation
67 of functions or variables that are known to be needed at given stage
70 - cgraph_mark_needed_node
71 - cgraph_varpool_mark_needed_node
73 When function or variable is referenced by some hidden way (for instance
74 via assembly code and marked by attribute "used"), the call-graph data structure
75 must be updated accordingly by this function.
77 - analyze_expr callback
79 This function is responsible for lowering tree nodes not understood by
80 generic code into understandable ones or alternatively marking
81 callgraph and varpool nodes referenced by the as needed.
83 ??? On the tree-ssa genericizing should take place here and we will avoid
84 need for these hooks (replacing them by genericizing hook)
86 - expand_function callback
88 This function is used to expand function and pass it into RTL back-end.
89 Front-end should not make any assumptions about when this function can be
90 called. In particular cgraph_assemble_pending_functions,
91 cgraph_varpool_assemble_pending_variables, cgraph_finalize_function,
92 cgraph_varpool_finalize_function, cgraph_optimize can cause arbitrarily
93 previously finalized functions to be expanded.
95 We implement two compilation modes.
97 - unit-at-a-time: In this mode analyzing of all functions is deferred
98 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
100 In cgraph_finalize_compilation_unit the reachable functions are
101 analyzed. During analysis the call-graph edges from reachable
102 functions are constructed and their destinations are marked as
103 reachable. References to functions and variables are discovered too
104 and variables found to be needed output to the assembly file. Via
105 mark_referenced call in assemble_variable functions referenced by
106 static variables are noticed too.
108 The intra-procedural information is produced and its existence
109 indicated by global_info_ready. Once this flag is set it is impossible
110 to change function from !reachable to reachable and thus
111 assemble_variable no longer call mark_referenced.
113 Finally the call-graph is topologically sorted and all reachable functions
114 that has not been completely inlined or are not external are output.
116 ??? It is possible that reference to function or variable is optimized
117 out. We can not deal with this nicely because topological order is not
118 suitable for it. For tree-ssa we may consider another pass doing
119 optimization and re-discovering reachable functions.
121 ??? Reorganize code so variables are output very last and only if they
122 really has been referenced by produced code, so we catch more cases
123 where reference has been optimized out.
127 All functions are variables are output as early as possible to conserve
128 memory consumption. This may or may not result in less memory used but
129 it is still needed for some legacy code that rely on particular ordering
130 of things output from the compiler.
132 Varpool data structures are not used and variables are output directly.
134 Functions are output early using call of
135 cgraph_assemble_pending_function from cgraph_finalize_function. The
136 decision on whether function is needed is made more conservative so
137 uninlininable static functions are needed too. During the call-graph
138 construction the edge destinations are not marked as reachable and it
139 is completely relied upn assemble_variable to mark them. */
144 #include "coretypes.h"
148 #include "tree-flow.h"
149 #include "tree-inline.h"
150 #include "langhooks.h"
151 #include "pointer-set.h"
158 #include "diagnostic.h"
162 #include "c-common.h"
164 #include "function.h"
165 #include "ipa-prop.h"
166 #include "tree-gimple.h"
167 #include "tree-pass.h"
170 static void cgraph_expand_all_functions (void);
171 static void cgraph_mark_functions_to_output (void);
172 static void cgraph_expand_function (struct cgraph_node
*);
173 static tree
record_reference (tree
*, int *, void *);
175 /* Records tree nodes seen in record_reference. Simply using
176 walk_tree_without_duplicates doesn't guarantee each node is visited
177 once because it gets a new htab upon each recursive call from
178 record_reference itself. */
179 static struct pointer_set_t
*visited_nodes
;
181 static FILE *cgraph_dump_file
;
183 /* Determine if function DECL is needed. That is, visible to something
184 either outside this translation unit, something magic in the system
185 configury, or (if not doing unit-at-a-time) to something we havn't
189 decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
192 if (MAIN_NAME_P (DECL_NAME (decl
))
193 && TREE_PUBLIC (decl
))
195 node
->local
.externally_visible
= true;
199 /* If the user told us it is used, then it must be so. */
200 if (node
->local
.externally_visible
201 || lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
204 /* ??? If the assembler name is set by hand, it is possible to assemble
205 the name later after finalizing the function and the fact is noticed
206 in assemble_name then. This is arguably a bug. */
207 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
208 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
211 /* If we decided it was needed before, but at the time we didn't have
212 the body of the function available, then it's still needed. We have
213 to go back and re-check its dependencies now. */
217 /* Externally visible functions must be output. The exception is
218 COMDAT functions that must be output only when they are needed. */
219 if ((TREE_PUBLIC (decl
) && !flag_whole_program
)
220 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
223 /* Constructors and destructors are reachable from the runtime by
225 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
228 if (flag_unit_at_a_time
)
231 /* If not doing unit at a time, then we'll only defer this function
232 if its marked for inlining. Otherwise we want to emit it now. */
234 /* "extern inline" functions are never output locally. */
235 if (DECL_EXTERNAL (decl
))
237 /* Nested functions of extern inline function shall not be emit unless
238 we inlined the origin. */
239 for (origin
= decl_function_context (decl
); origin
;
240 origin
= decl_function_context (origin
))
241 if (DECL_EXTERNAL (origin
))
243 /* We want to emit COMDAT functions only when absolutely necessary. */
244 if (DECL_COMDAT (decl
))
246 if (!DECL_INLINE (decl
)
247 || (!node
->local
.disregard_inline_limits
248 /* When declared inline, defer even the uninlinable functions.
249 This allows them to be eliminated when unused. */
250 && !DECL_DECLARED_INLINE_P (decl
)
251 && (!node
->local
.inlinable
|| !cgraph_default_inline_p (node
, NULL
))))
257 /* Walk the decls we marked as necessary and see if they reference new
258 variables or functions and add them into the worklists. */
260 cgraph_varpool_analyze_pending_decls (void)
262 bool changed
= false;
263 timevar_push (TV_CGRAPH
);
265 while (cgraph_varpool_first_unanalyzed_node
)
267 tree decl
= cgraph_varpool_first_unanalyzed_node
->decl
;
269 cgraph_varpool_first_unanalyzed_node
->analyzed
= true;
271 cgraph_varpool_first_unanalyzed_node
= cgraph_varpool_first_unanalyzed_node
->next_needed
;
273 if (DECL_INITIAL (decl
))
275 visited_nodes
= pointer_set_create ();
276 walk_tree (&DECL_INITIAL (decl
), record_reference
, NULL
, visited_nodes
);
277 pointer_set_destroy (visited_nodes
);
278 visited_nodes
= NULL
;
282 timevar_pop (TV_CGRAPH
);
286 /* Optimization of function bodies might've rendered some variables as
287 unnecessary so we want to avoid these from being compiled.
289 This is done by pruning the queue and keeping only the variables that
290 really appear needed (ie they are either externally visible or referenced
291 by compiled function). Re-doing the reachability analysis on variables
292 brings back the remaining variables referenced by these. */
294 cgraph_varpool_remove_unreferenced_decls (void)
296 struct cgraph_varpool_node
*next
, *node
= cgraph_varpool_nodes_queue
;
298 cgraph_varpool_reset_queue ();
300 if (errorcount
|| sorrycount
)
305 tree decl
= node
->decl
;
306 next
= node
->next_needed
;
310 && ((DECL_ASSEMBLER_NAME_SET_P (decl
)
311 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
312 || node
->force_output
313 || decide_is_variable_needed (node
, decl
)
314 /* ??? Cgraph does not yet rule the world with an iron hand,
315 and does not control the emission of debug information.
316 After a variable has its DECL_RTL set, we must assume that
317 it may be referenced by the debug information, and we can
318 no longer elide it. */
319 || DECL_RTL_SET_P (decl
)))
320 cgraph_varpool_mark_needed_node (node
);
324 /* Make sure we mark alias targets as used targets. */
326 cgraph_varpool_analyze_pending_decls ();
330 /* When not doing unit-at-a-time, output all functions enqueued.
331 Return true when such a functions were found. */
334 cgraph_assemble_pending_functions (void)
338 if (flag_unit_at_a_time
)
341 while (cgraph_nodes_queue
)
343 struct cgraph_node
*n
= cgraph_nodes_queue
;
345 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
346 n
->next_needed
= NULL
;
347 if (!n
->global
.inlined_to
349 && !DECL_EXTERNAL (n
->decl
))
351 cgraph_expand_function (n
);
356 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
357 the expansion process. Note that this queue may grow as its
358 being processed, as the new functions may generate new ones. */
359 while (cgraph_expand_queue
)
361 struct cgraph_node
*n
= cgraph_expand_queue
;
362 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
363 n
->next_needed
= NULL
;
364 cgraph_finalize_function (n
->decl
, false);
372 /* As an GCC extension we allow redefinition of the function. The
373 semantics when both copies of bodies differ is not well defined.
374 We replace the old body with new body so in unit at a time mode
375 we always use new body, while in normal mode we may end up with
376 old body inlined into some functions and new body expanded and
379 ??? It may make more sense to use one body for inlining and other
380 body for expanding the function but this is difficult to do. */
383 cgraph_reset_node (struct cgraph_node
*node
)
385 /* If node->output is set, then this is a unit-at-a-time compilation
386 and we have already begun whole-unit analysis. This is *not*
387 testing for whether we've already emitted the function. That
388 case can be sort-of legitimately seen with real function
389 redefinition errors. I would argue that the front end should
390 never present us with such a case, but don't enforce that for now. */
391 gcc_assert (!node
->output
);
393 /* Reset our data structures so we can analyze the function again. */
394 memset (&node
->local
, 0, sizeof (node
->local
));
395 memset (&node
->global
, 0, sizeof (node
->global
));
396 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
397 node
->analyzed
= false;
398 node
->local
.redefined_extern_inline
= true;
399 node
->local
.finalized
= false;
401 if (!flag_unit_at_a_time
)
403 struct cgraph_node
*n
;
405 for (n
= cgraph_nodes
; n
; n
= n
->next
)
406 if (n
->global
.inlined_to
== node
)
407 cgraph_remove_node (n
);
410 cgraph_node_remove_callees (node
);
412 /* We may need to re-queue the node for assembling in case
413 we already proceeded it and ignored as not needed. */
414 if (node
->reachable
&& !flag_unit_at_a_time
)
416 struct cgraph_node
*n
;
418 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
427 cgraph_lower_function (struct cgraph_node
*node
)
431 tree_lowering_passes (node
->decl
);
432 node
->lowered
= true;
435 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
436 logic in effect. If NESTED is true, then our caller cannot stand to have
437 the garbage collector run at the moment. We would need to either create
438 a new GC context, or just not compile right now. */
441 cgraph_finalize_function (tree decl
, bool nested
)
443 struct cgraph_node
*node
= cgraph_node (decl
);
445 if (node
->local
.finalized
)
446 cgraph_reset_node (node
);
448 notice_global_symbol (decl
);
450 node
->local
.finalized
= true;
451 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
453 lower_nested_functions (decl
);
454 gcc_assert (!node
->nested
);
456 /* If not unit at a time, then we need to create the call graph
457 now, so that called functions can be queued and emitted now. */
458 if (!flag_unit_at_a_time
)
460 cgraph_analyze_function (node
);
461 cgraph_decide_inlining_incrementally (node
, false);
464 if (decide_is_function_needed (node
, decl
))
465 cgraph_mark_needed_node (node
);
467 /* Since we reclaim unreachable nodes at the end of every language
468 level unit, we need to be conservative about possible entry points
470 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
471 cgraph_mark_reachable_node (node
);
473 /* If not unit at a time, go ahead and emit everything we've found
474 to be reachable at this time. */
477 if (!cgraph_assemble_pending_functions ())
481 /* If we've not yet emitted decl, tell the debug info about it. */
482 if (!TREE_ASM_WRITTEN (decl
))
483 (*debug_hooks
->deferred_inline_function
) (decl
);
485 /* Possibly warn about unused parameters. */
486 if (warn_unused_parameter
)
487 do_warn_unused_parameter (decl
);
490 /* Walk tree and record all calls. Called via walk_tree. */
492 record_reference (tree
*tp
, int *walk_subtrees
, void *data
)
496 switch (TREE_CODE (t
))
499 /* ??? Really, we should mark this decl as *potentially* referenced
500 by this function and re-examine whether the decl is actually used
501 after rtl has been generated. */
502 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
504 cgraph_varpool_mark_needed_node (cgraph_varpool_node (t
));
505 if (lang_hooks
.callgraph
.analyze_expr
)
506 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
,
513 if (flag_unit_at_a_time
)
515 /* Record dereferences to the functions. This makes the
516 functions reachable unconditionally. */
517 tree decl
= TREE_OPERAND (*tp
, 0);
518 if (TREE_CODE (decl
) == FUNCTION_DECL
)
519 cgraph_mark_needed_node (cgraph_node (decl
));
524 /* Save some cycles by not walking types and declaration as we
525 won't find anything useful there anyway. */
526 if (IS_TYPE_OR_DECL_P (*tp
))
532 if ((unsigned int) TREE_CODE (t
) >= LAST_AND_UNUSED_TREE_CODE
)
533 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
, data
);
540 /* Create cgraph edges for function calls inside BODY from NODE. */
543 cgraph_create_edges (struct cgraph_node
*node
, tree body
)
547 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (body
);
548 block_stmt_iterator bsi
;
550 visited_nodes
= pointer_set_create ();
552 /* Reach the trees by walking over the CFG, and note the
553 enclosing basic-blocks in the call edges. */
554 FOR_EACH_BB_FN (bb
, this_cfun
)
555 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
557 tree stmt
= bsi_stmt (bsi
);
558 tree call
= get_call_expr_in (stmt
);
561 if (call
&& (decl
= get_callee_fndecl (call
)))
563 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
566 walk_tree (&TREE_OPERAND (call
, 1),
567 record_reference
, node
, visited_nodes
);
568 if (TREE_CODE (stmt
) == MODIFY_EXPR
)
569 walk_tree (&TREE_OPERAND (stmt
, 0),
570 record_reference
, node
, visited_nodes
);
573 walk_tree (bsi_stmt_ptr (bsi
), record_reference
, node
, visited_nodes
);
576 /* Look for initializers of constant variables and private statics. */
577 for (step
= DECL_STRUCT_FUNCTION (body
)->unexpanded_var_list
;
579 step
= TREE_CHAIN (step
))
581 tree decl
= TREE_VALUE (step
);
582 if (TREE_CODE (decl
) == VAR_DECL
583 && (TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
584 && flag_unit_at_a_time
)
585 cgraph_varpool_finalize_decl (decl
);
586 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
587 walk_tree (&DECL_INITIAL (decl
), record_reference
, node
, visited_nodes
);
590 pointer_set_destroy (visited_nodes
);
591 visited_nodes
= NULL
;
594 /* Give initial reasons why inlining would fail. Those gets
595 either NULLified or usually overwritten by more precise reason
598 initialize_inline_failed (struct cgraph_node
*node
)
600 struct cgraph_edge
*e
;
602 for (e
= node
->callers
; e
; e
= e
->next_caller
)
604 gcc_assert (!e
->callee
->global
.inlined_to
);
605 gcc_assert (e
->inline_failed
);
606 if (node
->local
.redefined_extern_inline
)
607 e
->inline_failed
= N_("redefined extern inline functions are not "
608 "considered for inlining");
609 else if (!node
->local
.inlinable
)
610 e
->inline_failed
= N_("function not inlinable");
612 e
->inline_failed
= N_("function not considered for inlining");
616 /* Rebuild call edges from current function after a passes not aware
617 of cgraph updating. */
619 rebuild_cgraph_edges (void)
622 struct cgraph_node
*node
= cgraph_node (current_function_decl
);
623 block_stmt_iterator bsi
;
625 cgraph_node_remove_callees (node
);
627 node
->count
= ENTRY_BLOCK_PTR
->count
;
630 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
632 tree stmt
= bsi_stmt (bsi
);
633 tree call
= get_call_expr_in (stmt
);
636 if (call
&& (decl
= get_callee_fndecl (call
)))
637 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
641 initialize_inline_failed (node
);
642 gcc_assert (!node
->global
.inlined_to
);
645 struct tree_opt_pass pass_rebuild_cgraph_edges
=
649 rebuild_cgraph_edges
, /* execute */
652 0, /* static_pass_number */
654 PROP_cfg
, /* properties_required */
655 0, /* properties_provided */
656 0, /* properties_destroyed */
657 0, /* todo_flags_start */
658 0, /* todo_flags_finish */
662 /* Verify cgraph nodes of given cgraph node. */
664 verify_cgraph_node (struct cgraph_node
*node
)
666 struct cgraph_edge
*e
;
667 struct cgraph_node
*main_clone
;
668 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
669 basic_block this_block
;
670 block_stmt_iterator bsi
;
671 bool error_found
= false;
673 timevar_push (TV_CGRAPH_VERIFY
);
674 for (e
= node
->callees
; e
; e
= e
->next_callee
)
677 error ("aux field set for edge %s->%s",
678 cgraph_node_name (e
->caller
), cgraph_node_name (e
->callee
));
683 error ("Execution count is negative");
686 for (e
= node
->callers
; e
; e
= e
->next_caller
)
690 error ("caller edge count is negative");
693 if (!e
->inline_failed
)
695 if (node
->global
.inlined_to
696 != (e
->caller
->global
.inlined_to
697 ? e
->caller
->global
.inlined_to
: e
->caller
))
699 error ("inlined_to pointer is wrong");
702 if (node
->callers
->next_caller
)
704 error ("multiple inline callers");
709 if (node
->global
.inlined_to
)
711 error ("inlined_to pointer set for noninline callers");
715 if (!node
->callers
&& node
->global
.inlined_to
)
717 error ("inlined_to pointer is set but no predecesors found");
720 if (node
->global
.inlined_to
== node
)
722 error ("inlined_to pointer refers to itself");
726 for (main_clone
= cgraph_node (node
->decl
); main_clone
;
727 main_clone
= main_clone
->next_clone
)
728 if (main_clone
== node
)
732 error ("node not found in DECL_ASSEMBLER_NAME hash");
737 && DECL_SAVED_TREE (node
->decl
) && !TREE_ASM_WRITTEN (node
->decl
)
738 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
))
742 /* The nodes we're interested in are never shared, so walk
743 the tree ignoring duplicates. */
744 visited_nodes
= pointer_set_create ();
745 /* Reach the trees by walking over the CFG, and note the
746 enclosing basic-blocks in the call edges. */
747 FOR_EACH_BB_FN (this_block
, this_cfun
)
748 for (bsi
= bsi_start (this_block
); !bsi_end_p (bsi
); bsi_next (&bsi
))
750 tree stmt
= bsi_stmt (bsi
);
751 tree call
= get_call_expr_in (stmt
);
753 if (call
&& (decl
= get_callee_fndecl (call
)))
755 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
760 error ("shared call_stmt:");
761 debug_generic_stmt (stmt
);
764 if (e
->callee
->decl
!= cgraph_node (decl
)->decl
767 error ("edge points to wrong declaration:");
768 debug_tree (e
->callee
->decl
);
769 fprintf (stderr
," Instead of:");
776 error ("missing callgraph edge for call stmt:");
777 debug_generic_stmt (stmt
);
782 pointer_set_destroy (visited_nodes
);
783 visited_nodes
= NULL
;
786 /* No CFG available?! */
789 for (e
= node
->callees
; e
; e
= e
->next_callee
)
793 error ("edge %s->%s has no corresponding call_stmt",
794 cgraph_node_name (e
->caller
),
795 cgraph_node_name (e
->callee
));
796 debug_generic_stmt (e
->call_stmt
);
804 dump_cgraph_node (stderr
, node
);
805 internal_error ("verify_cgraph_node failed");
807 timevar_pop (TV_CGRAPH_VERIFY
);
810 /* Verify whole cgraph structure. */
814 struct cgraph_node
*node
;
816 if (sorrycount
|| errorcount
)
819 for (node
= cgraph_nodes
; node
; node
= node
->next
)
820 verify_cgraph_node (node
);
823 /* Output one variable, if necessary. Return whether we output it. */
825 cgraph_varpool_assemble_decl (struct cgraph_varpool_node
*node
)
827 tree decl
= node
->decl
;
829 if (!TREE_ASM_WRITTEN (decl
)
831 && !DECL_EXTERNAL (decl
)
832 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_HAS_VALUE_EXPR_P (decl
)))
834 assemble_variable (decl
, 0, 1, 0);
835 /* Local static variables are never seen by check_global_declarations
836 so we need to output debug info by hand. */
837 if (DECL_CONTEXT (decl
)
838 && (TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
839 || TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
840 && errorcount
== 0 && sorrycount
== 0)
842 timevar_push (TV_SYMOUT
);
843 (*debug_hooks
->global_decl
) (decl
);
844 timevar_pop (TV_SYMOUT
);
852 /* Output all variables enqueued to be assembled. */
854 cgraph_varpool_assemble_pending_decls (void)
856 bool changed
= false;
858 if (errorcount
|| sorrycount
)
861 /* EH might mark decls as needed during expansion. This should be safe since
862 we don't create references to new function, but it should not be used
864 cgraph_varpool_analyze_pending_decls ();
866 while (cgraph_varpool_nodes_queue
)
868 struct cgraph_varpool_node
*node
= cgraph_varpool_nodes_queue
;
870 cgraph_varpool_nodes_queue
= cgraph_varpool_nodes_queue
->next_needed
;
871 if (cgraph_varpool_assemble_decl (node
))
873 node
->next_needed
= NULL
;
878 /* Output all asm statements we have stored up to be output. */
881 cgraph_output_pending_asms (void)
883 struct cgraph_asm_node
*can
;
885 if (errorcount
|| sorrycount
)
888 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
889 assemble_asm (can
->asm_str
);
890 cgraph_asm_nodes
= NULL
;
893 /* Analyze the function scheduled to be output. */
895 cgraph_analyze_function (struct cgraph_node
*node
)
897 tree decl
= node
->decl
;
899 current_function_decl
= decl
;
900 push_cfun (DECL_STRUCT_FUNCTION (decl
));
901 cgraph_lower_function (node
);
903 /* First kill forward declaration so reverse inlining works properly. */
904 cgraph_create_edges (node
, decl
);
906 node
->local
.inlinable
= tree_inlinable_function_p (decl
);
907 node
->local
.self_insns
= estimate_num_insns (decl
);
908 if (node
->local
.inlinable
)
909 node
->local
.disregard_inline_limits
910 = lang_hooks
.tree_inlining
.disregard_inline_limits (decl
);
911 initialize_inline_failed (node
);
912 if (flag_really_no_inline
&& !node
->local
.disregard_inline_limits
)
913 node
->local
.inlinable
= 0;
914 /* Inlining characteristics are maintained by the cgraph_mark_inline. */
915 node
->global
.insns
= node
->local
.self_insns
;
917 node
->analyzed
= true;
919 current_function_decl
= NULL
;
922 /* Analyze the whole compilation unit once it is parsed completely. */
925 cgraph_finalize_compilation_unit (void)
927 struct cgraph_node
*node
;
928 /* Keep track of already processed nodes when called multiple times for
929 intermodule optimization. */
930 static struct cgraph_node
*first_analyzed
;
934 if (!flag_unit_at_a_time
)
936 cgraph_output_pending_asms ();
937 cgraph_assemble_pending_functions ();
943 fprintf (stderr
, "\nAnalyzing compilation unit");
947 timevar_push (TV_CGRAPH
);
948 cgraph_varpool_analyze_pending_decls ();
949 if (cgraph_dump_file
)
951 fprintf (cgraph_dump_file
, "Initial entry points:");
952 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
953 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
954 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
955 fprintf (cgraph_dump_file
, "\n");
958 /* Propagate reachability flag and lower representation of all reachable
959 functions. In the future, lowering will introduce new functions and
960 new entry points on the way (by template instantiation and virtual
961 method table generation for instance). */
962 while (cgraph_nodes_queue
)
964 struct cgraph_edge
*edge
;
965 tree decl
= cgraph_nodes_queue
->decl
;
967 node
= cgraph_nodes_queue
;
968 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
969 node
->next_needed
= NULL
;
971 /* ??? It is possible to create extern inline function and later using
972 weak alias attribute to kill its body. See
973 gcc.c-torture/compile/20011119-1.c */
974 if (!DECL_SAVED_TREE (decl
))
976 cgraph_reset_node (node
);
980 gcc_assert (!node
->analyzed
&& node
->reachable
);
981 gcc_assert (DECL_SAVED_TREE (decl
));
983 cgraph_analyze_function (node
);
985 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
986 if (!edge
->callee
->reachable
)
987 cgraph_mark_reachable_node (edge
->callee
);
989 cgraph_varpool_analyze_pending_decls ();
992 /* Collect entry points to the unit. */
994 if (cgraph_dump_file
)
996 fprintf (cgraph_dump_file
, "Unit entry points:");
997 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
998 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
999 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1000 fprintf (cgraph_dump_file
, "\n\nInitial ");
1001 dump_cgraph (cgraph_dump_file
);
1004 if (cgraph_dump_file
)
1005 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1007 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1009 tree decl
= node
->decl
;
1011 if (node
->local
.finalized
&& !DECL_SAVED_TREE (decl
))
1012 cgraph_reset_node (node
);
1014 if (!node
->reachable
&& DECL_SAVED_TREE (decl
))
1016 if (cgraph_dump_file
)
1017 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1018 cgraph_remove_node (node
);
1022 node
->next_needed
= NULL
;
1023 gcc_assert (!node
->local
.finalized
|| DECL_SAVED_TREE (decl
));
1024 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1026 if (cgraph_dump_file
)
1028 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1029 dump_cgraph (cgraph_dump_file
);
1031 first_analyzed
= cgraph_nodes
;
1033 timevar_pop (TV_CGRAPH
);
1035 /* Figure out what functions we want to assemble. */
1038 cgraph_mark_functions_to_output (void)
1040 struct cgraph_node
*node
;
1042 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1044 tree decl
= node
->decl
;
1045 struct cgraph_edge
*e
;
1047 gcc_assert (!node
->output
);
1049 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1050 if (e
->inline_failed
)
1053 /* We need to output all local functions that are used and not
1054 always inlined, as well as those that are reachable from
1055 outside the current compilation unit. */
1056 if (DECL_SAVED_TREE (decl
)
1057 && !node
->global
.inlined_to
1059 || (e
&& node
->reachable
))
1060 && !TREE_ASM_WRITTEN (decl
)
1061 && !DECL_EXTERNAL (decl
))
1065 /* We should've reclaimed all functions that are not needed. */
1066 #ifdef ENABLE_CHECKING
1067 if (!node
->global
.inlined_to
&& DECL_SAVED_TREE (decl
)
1068 && !DECL_EXTERNAL (decl
))
1070 dump_cgraph_node (stderr
, node
);
1071 internal_error ("failed to reclaim unneeded function");
1074 gcc_assert (node
->global
.inlined_to
|| !DECL_SAVED_TREE (decl
)
1075 || DECL_EXTERNAL (decl
));
1082 /* Expand function specified by NODE. */
1085 cgraph_expand_function (struct cgraph_node
*node
)
1087 tree decl
= node
->decl
;
1089 /* We ought to not compile any inline clones. */
1090 gcc_assert (!node
->global
.inlined_to
);
1092 if (flag_unit_at_a_time
)
1093 announce_function (decl
);
1095 cgraph_lower_function (node
);
1097 /* Generate RTL for the body of DECL. */
1098 lang_hooks
.callgraph
.expand_function (decl
);
1100 /* Make sure that BE didn't give up on compiling. */
1101 /* ??? Can happen with nested function of extern inline. */
1102 gcc_assert (TREE_ASM_WRITTEN (node
->decl
));
1104 current_function_decl
= NULL
;
1105 if (!cgraph_preserve_function_body_p (node
->decl
))
1107 DECL_SAVED_TREE (node
->decl
) = NULL
;
1108 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
1109 DECL_INITIAL (node
->decl
) = error_mark_node
;
1110 /* Eliminate all call edges. This is important so the call_expr no longer
1111 points to the dead function body. */
1112 cgraph_node_remove_callees (node
);
1115 cgraph_function_flags_ready
= true;
1118 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1121 cgraph_inline_p (struct cgraph_edge
*e
, const char **reason
)
1123 *reason
= e
->inline_failed
;
1124 return !e
->inline_failed
;
1129 /* Expand all functions that must be output.
1131 Attempt to topologically sort the nodes so function is output when
1132 all called functions are already assembled to allow data to be
1133 propagated across the callgraph. Use a stack to get smaller distance
1134 between a function and its callees (later we may choose to use a more
1135 sophisticated algorithm for function reordering; we will likely want
1136 to use subsections to make the output functions appear in top-down
1140 cgraph_expand_all_functions (void)
1142 struct cgraph_node
*node
;
1143 struct cgraph_node
**order
=
1144 xcalloc (cgraph_n_nodes
, sizeof (struct cgraph_node
*));
1145 int order_pos
= 0, new_order_pos
= 0;
1148 order_pos
= cgraph_postorder (order
);
1149 gcc_assert (order_pos
== cgraph_n_nodes
);
1151 /* Garbage collector may remove inline clones we eliminate during
1152 optimization. So we must be sure to not reference them. */
1153 for (i
= 0; i
< order_pos
; i
++)
1154 if (order
[i
]->output
)
1155 order
[new_order_pos
++] = order
[i
];
1157 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1162 gcc_assert (node
->reachable
);
1164 cgraph_expand_function (node
);
1170 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
1171 the expansion process. Note that this queue may grow as its
1172 being processed, as the new functions may generate new ones. */
1173 while (cgraph_expand_queue
)
1175 node
= cgraph_expand_queue
;
1176 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
1177 node
->next_needed
= NULL
;
1179 node
->lowered
= DECL_STRUCT_FUNCTION (node
->decl
)->cfg
!= NULL
;
1180 cgraph_expand_function (node
);
1184 /* This is used to sort the node types by the cgraph order number. */
1186 struct cgraph_order_sort
1188 enum { ORDER_UNDEFINED
= 0, ORDER_FUNCTION
, ORDER_VAR
, ORDER_ASM
} kind
;
1191 struct cgraph_node
*f
;
1192 struct cgraph_varpool_node
*v
;
1193 struct cgraph_asm_node
*a
;
1197 /* Output all functions, variables, and asm statements in the order
1198 according to their order fields, which is the order in which they
1199 appeared in the file. This implements -fno-toplevel-reorder. In
1200 this mode we may output functions and variables which don't really
1201 need to be output. */
1204 cgraph_output_in_order (void)
1208 struct cgraph_order_sort
*nodes
;
1210 struct cgraph_node
*pf
;
1211 struct cgraph_varpool_node
*pv
;
1212 struct cgraph_asm_node
*pa
;
1215 size
= max
* sizeof (struct cgraph_order_sort
);
1216 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1217 memset (nodes
, 0, size
);
1219 cgraph_varpool_analyze_pending_decls ();
1221 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1226 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1227 nodes
[i
].kind
= ORDER_FUNCTION
;
1232 for (pv
= cgraph_varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1235 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1236 nodes
[i
].kind
= ORDER_VAR
;
1240 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1243 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1244 nodes
[i
].kind
= ORDER_ASM
;
1247 cgraph_asm_nodes
= NULL
;
1249 for (i
= 0; i
< max
; ++i
)
1251 switch (nodes
[i
].kind
)
1253 case ORDER_FUNCTION
:
1254 nodes
[i
].u
.f
->output
= 0;
1255 cgraph_expand_function (nodes
[i
].u
.f
);
1259 cgraph_varpool_assemble_decl (nodes
[i
].u
.v
);
1263 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1266 case ORDER_UNDEFINED
:
1275 /* Mark visibility of all functions.
1277 A local function is one whose calls can occur only in the current
1278 compilation unit and all its calls are explicit, so we can change
1279 its calling convention. We simply mark all static functions whose
1280 address is not taken as local.
1282 We also change the TREE_PUBLIC flag of all declarations that are public
1283 in language point of view but we want to overwrite this default
1284 via visibilities for the backend point of view. */
1287 cgraph_function_and_variable_visibility (void)
1289 struct cgraph_node
*node
;
1290 struct cgraph_varpool_node
*vnode
;
1292 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1295 && (DECL_COMDAT (node
->decl
)
1296 || (!flag_whole_program
1297 && TREE_PUBLIC (node
->decl
) && !DECL_EXTERNAL (node
->decl
))))
1298 node
->local
.externally_visible
= true;
1299 if (!node
->local
.externally_visible
&& node
->analyzed
1300 && !DECL_EXTERNAL (node
->decl
))
1302 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (node
->decl
));
1303 TREE_PUBLIC (node
->decl
) = 0;
1305 node
->local
.local
= (!node
->needed
1307 && !DECL_EXTERNAL (node
->decl
)
1308 && !node
->local
.externally_visible
);
1310 for (vnode
= cgraph_varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1313 && !flag_whole_program
1314 && (DECL_COMDAT (vnode
->decl
) || TREE_PUBLIC (vnode
->decl
)))
1315 vnode
->externally_visible
= 1;
1316 if (!vnode
->externally_visible
)
1318 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (vnode
->decl
));
1319 TREE_PUBLIC (vnode
->decl
) = 0;
1321 gcc_assert (TREE_STATIC (vnode
->decl
));
1324 /* Because we have to be conservative on the boundaries of source
1325 level units, it is possible that we marked some functions in
1326 reachable just because they might be used later via external
1327 linkage, but after making them local they are really unreachable
1329 cgraph_remove_unreachable_nodes (true, cgraph_dump_file
);
1331 if (cgraph_dump_file
)
1333 fprintf (cgraph_dump_file
, "\nMarking local functions:");
1334 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1335 if (node
->local
.local
)
1336 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1337 fprintf (cgraph_dump_file
, "\n\n");
1338 fprintf (cgraph_dump_file
, "\nMarking externally visible functions:");
1339 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1340 if (node
->local
.externally_visible
)
1341 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1342 fprintf (cgraph_dump_file
, "\n\n");
1344 cgraph_function_flags_ready
= true;
1347 /* Return true when function body of DECL still needs to be kept around
1348 for later re-use. */
1350 cgraph_preserve_function_body_p (tree decl
)
1352 struct cgraph_node
*node
;
1353 if (!cgraph_global_info_ready
)
1354 return (DECL_INLINE (decl
) && !flag_really_no_inline
);
1355 /* Look if there is any clone around. */
1356 for (node
= cgraph_node (decl
); node
; node
= node
->next_clone
)
1357 if (node
->global
.inlined_to
)
1366 tree_register_cfg_hooks ();
1367 bitmap_obstack_initialize (NULL
);
1368 execute_ipa_pass_list (all_ipa_passes
);
1369 bitmap_obstack_release (NULL
);
1372 /* Perform simple optimizations based on callgraph. */
1375 cgraph_optimize (void)
1377 #ifdef ENABLE_CHECKING
1380 if (!flag_unit_at_a_time
)
1382 cgraph_output_pending_asms ();
1383 cgraph_varpool_assemble_pending_decls ();
1387 process_pending_assemble_externals ();
1389 /* Frontend may output common variables after the unit has been finalized.
1390 It is safe to deal with them here as they are always zero initialized. */
1391 cgraph_varpool_analyze_pending_decls ();
1393 timevar_push (TV_CGRAPHOPT
);
1395 fprintf (stderr
, "Performing intraprocedural optimizations\n");
1397 cgraph_function_and_variable_visibility ();
1398 if (cgraph_dump_file
)
1400 fprintf (cgraph_dump_file
, "Marked ");
1401 dump_cgraph (cgraph_dump_file
);
1404 /* This pass remove bodies of extern inline functions we never inlined.
1405 Do this later so other IPA passes see what is really going on. */
1406 cgraph_remove_unreachable_nodes (false, dump_file
);
1407 cgraph_global_info_ready
= true;
1408 if (cgraph_dump_file
)
1410 fprintf (cgraph_dump_file
, "Optimized ");
1411 dump_cgraph (cgraph_dump_file
);
1412 dump_varpool (cgraph_dump_file
);
1414 timevar_pop (TV_CGRAPHOPT
);
1416 /* Output everything. */
1418 fprintf (stderr
, "Assembling functions:\n");
1419 #ifdef ENABLE_CHECKING
1423 cgraph_mark_functions_to_output ();
1425 if (!flag_toplevel_reorder
)
1426 cgraph_output_in_order ();
1429 cgraph_output_pending_asms ();
1431 cgraph_expand_all_functions ();
1432 cgraph_varpool_remove_unreferenced_decls ();
1434 cgraph_varpool_assemble_pending_decls ();
1437 if (cgraph_dump_file
)
1439 fprintf (cgraph_dump_file
, "\nFinal ");
1440 dump_cgraph (cgraph_dump_file
);
1442 #ifdef ENABLE_CHECKING
1444 /* Double check that all inline clones are gone and that all
1445 function bodies have been released from memory. */
1446 if (flag_unit_at_a_time
1447 && !dump_enabled_p (TDI_tree_all
)
1448 && !(sorrycount
|| errorcount
))
1450 struct cgraph_node
*node
;
1451 bool error_found
= false;
1453 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1455 && (node
->global
.inlined_to
1456 || DECL_SAVED_TREE (node
->decl
)))
1459 dump_cgraph_node (stderr
, node
);
1462 internal_error ("nodes with no released memory found");
1467 /* Generate and emit a static constructor or destructor. WHICH must be
1468 one of 'I' or 'D'. BODY should be a STATEMENT_LIST containing
1469 GENERIC statements. */
1472 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1474 static int counter
= 0;
1476 tree decl
, name
, resdecl
;
1478 sprintf (which_buf
, "%c_%d", which
, counter
++);
1479 name
= get_file_function_name_long (which_buf
);
1481 decl
= build_decl (FUNCTION_DECL
, name
,
1482 build_function_type (void_type_node
, void_list_node
));
1483 current_function_decl
= decl
;
1485 resdecl
= build_decl (RESULT_DECL
, NULL_TREE
, void_type_node
);
1486 DECL_ARTIFICIAL (resdecl
) = 1;
1487 DECL_IGNORED_P (resdecl
) = 1;
1488 DECL_RESULT (decl
) = resdecl
;
1490 allocate_struct_function (decl
);
1492 TREE_STATIC (decl
) = 1;
1493 TREE_USED (decl
) = 1;
1494 DECL_ARTIFICIAL (decl
) = 1;
1495 DECL_IGNORED_P (decl
) = 1;
1496 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1497 DECL_SAVED_TREE (decl
) = body
;
1498 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1499 DECL_UNINLINABLE (decl
) = 1;
1501 DECL_INITIAL (decl
) = make_node (BLOCK
);
1502 TREE_USED (DECL_INITIAL (decl
)) = 1;
1504 DECL_SOURCE_LOCATION (decl
) = input_location
;
1505 cfun
->function_end_locus
= input_location
;
1510 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1513 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1519 gimplify_function_tree (decl
);
1521 /* ??? We will get called LATE in the compilation process. */
1522 if (cgraph_global_info_ready
)
1524 tree_lowering_passes (decl
);
1525 tree_rest_of_compilation (decl
);
1528 cgraph_finalize_function (decl
, 0);
1530 if (targetm
.have_ctors_dtors
)
1532 void (*fn
) (rtx
, int);
1535 fn
= targetm
.asm_out
.constructor
;
1537 fn
= targetm
.asm_out
.destructor
;
1538 fn (XEXP (DECL_RTL (decl
), 0), priority
);
1545 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1548 /* The edges representing the callers of the NEW_VERSION node were
1549 fixed by cgraph_function_versioning (), now the call_expr in their
1550 respective tree code should be updated to call the NEW_VERSION. */
1553 update_call_expr (struct cgraph_node
*new_version
)
1555 struct cgraph_edge
*e
;
1557 gcc_assert (new_version
);
1558 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1559 /* Update the call expr on the edges
1560 to call the new version. */
1561 TREE_OPERAND (TREE_OPERAND (get_call_expr_in (e
->call_stmt
), 0), 0) = new_version
->decl
;
1565 /* Create a new cgraph node which is the new version of
1566 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1567 edges which should be redirected to point to
1568 NEW_VERSION. ALL the callees edges of OLD_VERSION
1569 are cloned to the new version node. Return the new
1572 static struct cgraph_node
*
1573 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1574 tree new_decl
, varray_type redirect_callers
)
1576 struct cgraph_node
*new_version
;
1577 struct cgraph_edge
*e
, *new_e
;
1578 struct cgraph_edge
*next_callee
;
1581 gcc_assert (old_version
);
1583 new_version
= cgraph_node (new_decl
);
1585 new_version
->analyzed
= true;
1586 new_version
->local
= old_version
->local
;
1587 new_version
->global
= old_version
->global
;
1588 new_version
->rtl
= new_version
->rtl
;
1589 new_version
->reachable
= true;
1590 new_version
->count
= old_version
->count
;
1592 /* Clone the old node callees. Recursive calls are
1594 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
1596 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
, 0, e
->loop_nest
, true);
1597 new_e
->count
= e
->count
;
1599 /* Fix recursive calls.
1600 If OLD_VERSION has a recursive call after the
1601 previous edge cloning, the new version will have an edge
1602 pointing to the old version, which is wrong;
1603 Redirect it to point to the new version. */
1604 for (e
= new_version
->callees
; e
; e
= next_callee
)
1606 next_callee
= e
->next_callee
;
1607 if (e
->callee
== old_version
)
1608 cgraph_redirect_edge_callee (e
, new_version
);
1613 if (redirect_callers
)
1614 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (redirect_callers
); i
++)
1616 e
= VARRAY_GENERIC_PTR (redirect_callers
, i
);
1617 /* Redirect calls to the old version node
1618 to point to it's new version. */
1619 cgraph_redirect_edge_callee (e
, new_version
);
1625 /* Perform function versioning.
1626 Function versioning includes copying of the tree and
1627 a callgraph update (creating a new cgraph node and updating
1628 its callees and callers).
1630 REDIRECT_CALLERS varray includes the edges to be redirected
1633 TREE_MAP is a mapping of tree nodes we want to replace with
1634 new ones (according to results of prior analysis).
1635 OLD_VERSION_NODE is the node that is versioned.
1636 It returns the new version's cgraph node. */
1638 struct cgraph_node
*
1639 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
1640 varray_type redirect_callers
,
1641 varray_type tree_map
)
1643 tree old_decl
= old_version_node
->decl
;
1644 struct cgraph_node
*new_version_node
= NULL
;
1647 if (!tree_versionable_function_p (old_decl
))
1650 /* Make a new FUNCTION_DECL tree node for the
1652 new_decl
= copy_node (old_decl
);
1654 /* Create the new version's call-graph node.
1655 and update the edges of the new node. */
1657 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
1660 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1661 tree_function_versioning (old_decl
, new_decl
, tree_map
, false);
1662 /* Update the call_expr on the edges to call the new version node. */
1663 update_call_expr (new_version_node
);
1665 /* Update the new version's properties.
1666 Make The new version visible only within this translation unit.
1667 ??? We cannot use COMDAT linkage because there is no
1668 ABI support for this. */
1669 DECL_EXTERNAL (new_version_node
->decl
) = 0;
1670 DECL_ONE_ONLY (new_version_node
->decl
) = 0;
1671 TREE_PUBLIC (new_version_node
->decl
) = 0;
1672 DECL_COMDAT (new_version_node
->decl
) = 0;
1673 new_version_node
->local
.externally_visible
= 0;
1674 new_version_node
->local
.local
= 1;
1675 new_version_node
->lowered
= true;
1676 return new_version_node
;
1679 /* Produce separate function body for inline clones so the offline copy can be
1680 modified without affecting them. */
1681 struct cgraph_node
*
1682 save_inline_function_body (struct cgraph_node
*node
)
1684 struct cgraph_node
*first_clone
;
1686 gcc_assert (node
== cgraph_node (node
->decl
));
1688 cgraph_lower_function (node
);
1690 /* In non-unit-at-a-time we construct full fledged clone we never output to
1691 assembly file. This clone is pointed out by inline_decl of orginal function
1692 and inlining infrastructure knows how to deal with this. */
1693 if (!flag_unit_at_a_time
)
1695 struct cgraph_edge
*e
;
1697 first_clone
= cgraph_clone_node (node
, node
->count
, 0, false);
1698 first_clone
->needed
= 0;
1699 first_clone
->reachable
= 1;
1700 /* Recursively clone all bodies. */
1701 for (e
= first_clone
->callees
; e
; e
= e
->next_callee
)
1702 if (!e
->inline_failed
)
1703 cgraph_clone_inlined_nodes (e
, true, false);
1706 first_clone
= node
->next_clone
;
1708 first_clone
->decl
= copy_node (node
->decl
);
1709 node
->next_clone
= NULL
;
1710 if (!flag_unit_at_a_time
)
1711 node
->inline_decl
= first_clone
->decl
;
1712 first_clone
->prev_clone
= NULL
;
1713 cgraph_insert_node_to_hashtable (first_clone
);
1714 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
1716 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1717 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true);
1719 DECL_EXTERNAL (first_clone
->decl
) = 0;
1720 DECL_ONE_ONLY (first_clone
->decl
) = 0;
1721 TREE_PUBLIC (first_clone
->decl
) = 0;
1722 DECL_COMDAT (first_clone
->decl
) = 0;
1724 for (node
= first_clone
->next_clone
; node
; node
= node
->next_clone
)
1725 node
->decl
= first_clone
->decl
;
1726 #ifdef ENABLE_CHECKING
1727 verify_cgraph_node (first_clone
);