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 *);
174 static void cgraph_output_pending_asms (void);
176 /* Records tree nodes seen in record_reference. Simply using
177 walk_tree_without_duplicates doesn't guarantee each node is visited
178 once because it gets a new htab upon each recursive call from
179 record_reference itself. */
180 static struct pointer_set_t
*visited_nodes
;
182 static FILE *cgraph_dump_file
;
184 /* Determine if function DECL is needed. That is, visible to something
185 either outside this translation unit, something magic in the system
186 configury, or (if not doing unit-at-a-time) to something we havn't
190 decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
193 if (MAIN_NAME_P (DECL_NAME (decl
))
194 && TREE_PUBLIC (decl
))
196 node
->local
.externally_visible
= true;
200 /* If the user told us it is used, then it must be so. */
201 if (node
->local
.externally_visible
202 || lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
205 /* ??? If the assembler name is set by hand, it is possible to assemble
206 the name later after finalizing the function and the fact is noticed
207 in assemble_name then. This is arguably a bug. */
208 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
209 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
212 /* If we decided it was needed before, but at the time we didn't have
213 the body of the function available, then it's still needed. We have
214 to go back and re-check its dependencies now. */
218 /* Externally visible functions must be output. The exception is
219 COMDAT functions that must be output only when they are needed. */
220 if ((TREE_PUBLIC (decl
) && !flag_whole_program
)
221 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
224 /* Constructors and destructors are reachable from the runtime by
226 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
229 if (flag_unit_at_a_time
)
232 /* If not doing unit at a time, then we'll only defer this function
233 if its marked for inlining. Otherwise we want to emit it now. */
235 /* "extern inline" functions are never output locally. */
236 if (DECL_EXTERNAL (decl
))
238 /* Nested functions of extern inline function shall not be emit unless
239 we inlined the origin. */
240 for (origin
= decl_function_context (decl
); origin
;
241 origin
= decl_function_context (origin
))
242 if (DECL_EXTERNAL (origin
))
244 /* We want to emit COMDAT functions only when absolutely necessary. */
245 if (DECL_COMDAT (decl
))
247 if (!DECL_INLINE (decl
)
248 || (!node
->local
.disregard_inline_limits
249 /* When declared inline, defer even the uninlinable functions.
250 This allows them to be eliminated when unused. */
251 && !DECL_DECLARED_INLINE_P (decl
)
252 && (!node
->local
.inlinable
|| !cgraph_default_inline_p (node
, NULL
))))
258 /* Walk the decls we marked as necessary and see if they reference new
259 variables or functions and add them into the worklists. */
261 cgraph_varpool_analyze_pending_decls (void)
263 bool changed
= false;
264 timevar_push (TV_CGRAPH
);
266 while (cgraph_varpool_first_unanalyzed_node
)
268 tree decl
= cgraph_varpool_first_unanalyzed_node
->decl
;
270 cgraph_varpool_first_unanalyzed_node
->analyzed
= true;
272 cgraph_varpool_first_unanalyzed_node
= cgraph_varpool_first_unanalyzed_node
->next_needed
;
274 if (DECL_INITIAL (decl
))
276 visited_nodes
= pointer_set_create ();
277 walk_tree (&DECL_INITIAL (decl
), record_reference
, NULL
, visited_nodes
);
278 pointer_set_destroy (visited_nodes
);
279 visited_nodes
= NULL
;
283 timevar_pop (TV_CGRAPH
);
287 /* Optimization of function bodies might've rendered some variables as
288 unnecessary so we want to avoid these from being compiled.
290 This is done by pruning the queue and keeping only the variables that
291 really appear needed (ie they are either externally visible or referenced
292 by compiled function). Re-doing the reachability analysis on variables
293 brings back the remaining variables referenced by these. */
295 cgraph_varpool_remove_unreferenced_decls (void)
297 struct cgraph_varpool_node
*next
, *node
= cgraph_varpool_nodes_queue
;
299 cgraph_varpool_reset_queue ();
301 if (errorcount
|| sorrycount
)
306 tree decl
= node
->decl
;
307 next
= node
->next_needed
;
311 && ((DECL_ASSEMBLER_NAME_SET_P (decl
)
312 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
313 || node
->force_output
314 || decide_is_variable_needed (node
, decl
)
315 /* ??? Cgraph does not yet rule the world with an iron hand,
316 and does not control the emission of debug information.
317 After a variable has its DECL_RTL set, we must assume that
318 it may be referenced by the debug information, and we can
319 no longer elide it. */
320 || DECL_RTL_SET_P (decl
)))
321 cgraph_varpool_mark_needed_node (node
);
325 /* Make sure we mark alias targets as used targets. */
327 cgraph_varpool_analyze_pending_decls ();
331 /* When not doing unit-at-a-time, output all functions enqueued.
332 Return true when such a functions were found. */
335 cgraph_assemble_pending_functions (void)
339 if (flag_unit_at_a_time
)
342 cgraph_output_pending_asms ();
344 while (cgraph_nodes_queue
)
346 struct cgraph_node
*n
= cgraph_nodes_queue
;
348 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
349 n
->next_needed
= NULL
;
350 if (!n
->global
.inlined_to
352 && !DECL_EXTERNAL (n
->decl
))
354 cgraph_expand_function (n
);
359 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
360 the expansion process. Note that this queue may grow as its
361 being processed, as the new functions may generate new ones. */
362 while (cgraph_expand_queue
)
364 struct cgraph_node
*n
= cgraph_expand_queue
;
365 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
366 n
->next_needed
= NULL
;
367 cgraph_finalize_function (n
->decl
, false);
375 /* As an GCC extension we allow redefinition of the function. The
376 semantics when both copies of bodies differ is not well defined.
377 We replace the old body with new body so in unit at a time mode
378 we always use new body, while in normal mode we may end up with
379 old body inlined into some functions and new body expanded and
382 ??? It may make more sense to use one body for inlining and other
383 body for expanding the function but this is difficult to do. */
386 cgraph_reset_node (struct cgraph_node
*node
)
388 /* If node->output is set, then this is a unit-at-a-time compilation
389 and we have already begun whole-unit analysis. This is *not*
390 testing for whether we've already emitted the function. That
391 case can be sort-of legitimately seen with real function
392 redefinition errors. I would argue that the front end should
393 never present us with such a case, but don't enforce that for now. */
394 gcc_assert (!node
->output
);
396 /* Reset our data structures so we can analyze the function again. */
397 memset (&node
->local
, 0, sizeof (node
->local
));
398 memset (&node
->global
, 0, sizeof (node
->global
));
399 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
400 node
->analyzed
= false;
401 node
->local
.redefined_extern_inline
= true;
402 node
->local
.finalized
= false;
404 if (!flag_unit_at_a_time
)
406 struct cgraph_node
*n
;
408 for (n
= cgraph_nodes
; n
; n
= n
->next
)
409 if (n
->global
.inlined_to
== node
)
410 cgraph_remove_node (n
);
413 cgraph_node_remove_callees (node
);
415 /* We may need to re-queue the node for assembling in case
416 we already proceeded it and ignored as not needed. */
417 if (node
->reachable
&& !flag_unit_at_a_time
)
419 struct cgraph_node
*n
;
421 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
430 cgraph_lower_function (struct cgraph_node
*node
)
434 tree_lowering_passes (node
->decl
);
435 node
->lowered
= true;
438 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
439 logic in effect. If NESTED is true, then our caller cannot stand to have
440 the garbage collector run at the moment. We would need to either create
441 a new GC context, or just not compile right now. */
444 cgraph_finalize_function (tree decl
, bool nested
)
446 struct cgraph_node
*node
= cgraph_node (decl
);
448 if (node
->local
.finalized
)
449 cgraph_reset_node (node
);
451 notice_global_symbol (decl
);
453 node
->local
.finalized
= true;
454 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
456 lower_nested_functions (decl
);
457 gcc_assert (!node
->nested
);
459 /* If not unit at a time, then we need to create the call graph
460 now, so that called functions can be queued and emitted now. */
461 if (!flag_unit_at_a_time
)
463 cgraph_analyze_function (node
);
464 cgraph_decide_inlining_incrementally (node
, false);
467 if (decide_is_function_needed (node
, decl
))
468 cgraph_mark_needed_node (node
);
470 /* Since we reclaim unreachable nodes at the end of every language
471 level unit, we need to be conservative about possible entry points
473 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
474 cgraph_mark_reachable_node (node
);
476 /* If not unit at a time, go ahead and emit everything we've found
477 to be reachable at this time. */
480 if (!cgraph_assemble_pending_functions ())
484 /* If we've not yet emitted decl, tell the debug info about it. */
485 if (!TREE_ASM_WRITTEN (decl
))
486 (*debug_hooks
->deferred_inline_function
) (decl
);
488 /* Possibly warn about unused parameters. */
489 if (warn_unused_parameter
)
490 do_warn_unused_parameter (decl
);
493 /* Walk tree and record all calls. Called via walk_tree. */
495 record_reference (tree
*tp
, int *walk_subtrees
, void *data
)
499 switch (TREE_CODE (t
))
502 /* ??? Really, we should mark this decl as *potentially* referenced
503 by this function and re-examine whether the decl is actually used
504 after rtl has been generated. */
505 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
507 cgraph_varpool_mark_needed_node (cgraph_varpool_node (t
));
508 if (lang_hooks
.callgraph
.analyze_expr
)
509 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
,
516 if (flag_unit_at_a_time
)
518 /* Record dereferences to the functions. This makes the
519 functions reachable unconditionally. */
520 tree decl
= TREE_OPERAND (*tp
, 0);
521 if (TREE_CODE (decl
) == FUNCTION_DECL
)
522 cgraph_mark_needed_node (cgraph_node (decl
));
527 /* Save some cycles by not walking types and declaration as we
528 won't find anything useful there anyway. */
529 if (IS_TYPE_OR_DECL_P (*tp
))
535 if ((unsigned int) TREE_CODE (t
) >= LAST_AND_UNUSED_TREE_CODE
)
536 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
, data
);
543 /* Create cgraph edges for function calls inside BODY from NODE. */
546 cgraph_create_edges (struct cgraph_node
*node
, tree body
)
550 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (body
);
551 block_stmt_iterator bsi
;
553 visited_nodes
= pointer_set_create ();
555 /* Reach the trees by walking over the CFG, and note the
556 enclosing basic-blocks in the call edges. */
557 FOR_EACH_BB_FN (bb
, this_cfun
)
558 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
560 tree stmt
= bsi_stmt (bsi
);
561 tree call
= get_call_expr_in (stmt
);
564 if (call
&& (decl
= get_callee_fndecl (call
)))
566 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
569 walk_tree (&TREE_OPERAND (call
, 1),
570 record_reference
, node
, visited_nodes
);
571 if (TREE_CODE (stmt
) == MODIFY_EXPR
)
572 walk_tree (&TREE_OPERAND (stmt
, 0),
573 record_reference
, node
, visited_nodes
);
576 walk_tree (bsi_stmt_ptr (bsi
), record_reference
, node
, visited_nodes
);
579 /* Look for initializers of constant variables and private statics. */
580 for (step
= DECL_STRUCT_FUNCTION (body
)->unexpanded_var_list
;
582 step
= TREE_CHAIN (step
))
584 tree decl
= TREE_VALUE (step
);
585 if (TREE_CODE (decl
) == VAR_DECL
586 && (TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
587 && flag_unit_at_a_time
)
588 cgraph_varpool_finalize_decl (decl
);
589 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
590 walk_tree (&DECL_INITIAL (decl
), record_reference
, node
, visited_nodes
);
593 pointer_set_destroy (visited_nodes
);
594 visited_nodes
= NULL
;
597 /* Give initial reasons why inlining would fail. Those gets
598 either NULLified or usually overwritten by more precise reason
601 initialize_inline_failed (struct cgraph_node
*node
)
603 struct cgraph_edge
*e
;
605 for (e
= node
->callers
; e
; e
= e
->next_caller
)
607 gcc_assert (!e
->callee
->global
.inlined_to
);
608 gcc_assert (e
->inline_failed
);
609 if (node
->local
.redefined_extern_inline
)
610 e
->inline_failed
= N_("redefined extern inline functions are not "
611 "considered for inlining");
612 else if (!node
->local
.inlinable
)
613 e
->inline_failed
= N_("function not inlinable");
615 e
->inline_failed
= N_("function not considered for inlining");
619 /* Rebuild call edges from current function after a passes not aware
620 of cgraph updating. */
622 rebuild_cgraph_edges (void)
625 struct cgraph_node
*node
= cgraph_node (current_function_decl
);
626 block_stmt_iterator bsi
;
628 cgraph_node_remove_callees (node
);
630 node
->count
= ENTRY_BLOCK_PTR
->count
;
633 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
635 tree stmt
= bsi_stmt (bsi
);
636 tree call
= get_call_expr_in (stmt
);
639 if (call
&& (decl
= get_callee_fndecl (call
)))
640 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
644 initialize_inline_failed (node
);
645 gcc_assert (!node
->global
.inlined_to
);
648 struct tree_opt_pass pass_rebuild_cgraph_edges
=
652 rebuild_cgraph_edges
, /* execute */
655 0, /* static_pass_number */
657 PROP_cfg
, /* properties_required */
658 0, /* properties_provided */
659 0, /* properties_destroyed */
660 0, /* todo_flags_start */
661 0, /* todo_flags_finish */
665 /* Verify cgraph nodes of given cgraph node. */
667 verify_cgraph_node (struct cgraph_node
*node
)
669 struct cgraph_edge
*e
;
670 struct cgraph_node
*main_clone
;
671 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
672 basic_block this_block
;
673 block_stmt_iterator bsi
;
674 bool error_found
= false;
676 if (node
!= cgraph_node_by_uid (node
->uid
))
678 error ("cgraph_node_by_uid corrupted");
682 timevar_push (TV_CGRAPH_VERIFY
);
683 for (e
= node
->callees
; e
; e
= e
->next_callee
)
686 error ("aux field set for edge %s->%s",
687 cgraph_node_name (e
->caller
), cgraph_node_name (e
->callee
));
692 error ("Execution count is negative");
695 for (e
= node
->callers
; e
; e
= e
->next_caller
)
699 error ("caller edge count is negative");
702 if (!e
->inline_failed
)
704 if (node
->global
.inlined_to
705 != (e
->caller
->global
.inlined_to
706 ? e
->caller
->global
.inlined_to
: e
->caller
))
708 error ("inlined_to pointer is wrong");
711 if (node
->callers
->next_caller
)
713 error ("multiple inline callers");
718 if (node
->global
.inlined_to
)
720 error ("inlined_to pointer set for noninline callers");
724 if (!node
->callers
&& node
->global
.inlined_to
)
726 error ("inlined_to pointer is set but no predecesors found");
729 if (node
->global
.inlined_to
== node
)
731 error ("inlined_to pointer refers to itself");
735 for (main_clone
= cgraph_node (node
->decl
); main_clone
;
736 main_clone
= main_clone
->next_clone
)
737 if (main_clone
== node
)
741 error ("node not found in DECL_ASSEMBLER_NAME hash");
746 && DECL_SAVED_TREE (node
->decl
) && !TREE_ASM_WRITTEN (node
->decl
)
747 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
))
751 /* The nodes we're interested in are never shared, so walk
752 the tree ignoring duplicates. */
753 visited_nodes
= pointer_set_create ();
754 /* Reach the trees by walking over the CFG, and note the
755 enclosing basic-blocks in the call edges. */
756 FOR_EACH_BB_FN (this_block
, this_cfun
)
757 for (bsi
= bsi_start (this_block
); !bsi_end_p (bsi
); bsi_next (&bsi
))
759 tree stmt
= bsi_stmt (bsi
);
760 tree call
= get_call_expr_in (stmt
);
762 if (call
&& (decl
= get_callee_fndecl (call
)))
764 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
769 error ("shared call_stmt:");
770 debug_generic_stmt (stmt
);
773 if (e
->callee
->decl
!= cgraph_node (decl
)->decl
776 error ("edge points to wrong declaration:");
777 debug_tree (e
->callee
->decl
);
778 fprintf (stderr
," Instead of:");
785 error ("missing callgraph edge for call stmt:");
786 debug_generic_stmt (stmt
);
791 pointer_set_destroy (visited_nodes
);
792 visited_nodes
= NULL
;
795 /* No CFG available?! */
798 for (e
= node
->callees
; e
; e
= e
->next_callee
)
802 error ("edge %s->%s has no corresponding call_stmt",
803 cgraph_node_name (e
->caller
),
804 cgraph_node_name (e
->callee
));
805 debug_generic_stmt (e
->call_stmt
);
813 dump_cgraph_node (stderr
, node
);
814 internal_error ("verify_cgraph_node failed");
816 timevar_pop (TV_CGRAPH_VERIFY
);
819 /* Verify whole cgraph structure. */
823 struct cgraph_node
*node
;
825 if (sorrycount
|| errorcount
)
828 for (node
= cgraph_nodes
; node
; node
= node
->next
)
829 verify_cgraph_node (node
);
832 /* Output one variable, if necessary. Return whether we output it. */
834 cgraph_varpool_assemble_decl (struct cgraph_varpool_node
*node
)
836 tree decl
= node
->decl
;
838 if (!TREE_ASM_WRITTEN (decl
)
840 && !DECL_EXTERNAL (decl
)
841 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_HAS_VALUE_EXPR_P (decl
)))
843 assemble_variable (decl
, 0, 1, 0);
844 /* Local static variables are never seen by check_global_declarations
845 so we need to output debug info by hand. */
846 if (DECL_CONTEXT (decl
)
847 && (TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
848 || TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
849 && errorcount
== 0 && sorrycount
== 0)
851 timevar_push (TV_SYMOUT
);
852 (*debug_hooks
->global_decl
) (decl
);
853 timevar_pop (TV_SYMOUT
);
861 /* Output all variables enqueued to be assembled. */
863 cgraph_varpool_assemble_pending_decls (void)
865 bool changed
= false;
867 if (errorcount
|| sorrycount
)
870 /* EH might mark decls as needed during expansion. This should be safe since
871 we don't create references to new function, but it should not be used
873 cgraph_varpool_analyze_pending_decls ();
875 while (cgraph_varpool_nodes_queue
)
877 struct cgraph_varpool_node
*node
= cgraph_varpool_nodes_queue
;
879 cgraph_varpool_nodes_queue
= cgraph_varpool_nodes_queue
->next_needed
;
880 if (cgraph_varpool_assemble_decl (node
))
882 node
->next_needed
= NULL
;
887 /* Output all asm statements we have stored up to be output. */
890 cgraph_output_pending_asms (void)
892 struct cgraph_asm_node
*can
;
894 if (errorcount
|| sorrycount
)
897 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
898 assemble_asm (can
->asm_str
);
899 cgraph_asm_nodes
= NULL
;
902 /* Analyze the function scheduled to be output. */
904 cgraph_analyze_function (struct cgraph_node
*node
)
906 tree decl
= node
->decl
;
908 current_function_decl
= decl
;
909 push_cfun (DECL_STRUCT_FUNCTION (decl
));
910 cgraph_lower_function (node
);
912 /* First kill forward declaration so reverse inlining works properly. */
913 cgraph_create_edges (node
, decl
);
915 node
->local
.inlinable
= tree_inlinable_function_p (decl
);
916 node
->local
.self_insns
= estimate_num_insns (decl
);
917 if (node
->local
.inlinable
)
918 node
->local
.disregard_inline_limits
919 = lang_hooks
.tree_inlining
.disregard_inline_limits (decl
);
920 initialize_inline_failed (node
);
921 if (flag_really_no_inline
&& !node
->local
.disregard_inline_limits
)
922 node
->local
.inlinable
= 0;
923 /* Inlining characteristics are maintained by the cgraph_mark_inline. */
924 node
->global
.insns
= node
->local
.self_insns
;
926 node
->analyzed
= true;
928 current_function_decl
= NULL
;
931 /* Analyze the whole compilation unit once it is parsed completely. */
934 cgraph_finalize_compilation_unit (void)
936 struct cgraph_node
*node
;
937 /* Keep track of already processed nodes when called multiple times for
938 intermodule optimization. */
939 static struct cgraph_node
*first_analyzed
;
943 if (!flag_unit_at_a_time
)
945 cgraph_output_pending_asms ();
946 cgraph_assemble_pending_functions ();
952 fprintf (stderr
, "\nAnalyzing compilation unit");
956 timevar_push (TV_CGRAPH
);
957 cgraph_varpool_analyze_pending_decls ();
958 if (cgraph_dump_file
)
960 fprintf (cgraph_dump_file
, "Initial entry points:");
961 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
962 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
963 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
964 fprintf (cgraph_dump_file
, "\n");
967 /* Propagate reachability flag and lower representation of all reachable
968 functions. In the future, lowering will introduce new functions and
969 new entry points on the way (by template instantiation and virtual
970 method table generation for instance). */
971 while (cgraph_nodes_queue
)
973 struct cgraph_edge
*edge
;
974 tree decl
= cgraph_nodes_queue
->decl
;
976 node
= cgraph_nodes_queue
;
977 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
978 node
->next_needed
= NULL
;
980 /* ??? It is possible to create extern inline function and later using
981 weak alias attribute to kill its body. See
982 gcc.c-torture/compile/20011119-1.c */
983 if (!DECL_SAVED_TREE (decl
))
985 cgraph_reset_node (node
);
989 gcc_assert (!node
->analyzed
&& node
->reachable
);
990 gcc_assert (DECL_SAVED_TREE (decl
));
992 cgraph_analyze_function (node
);
994 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
995 if (!edge
->callee
->reachable
)
996 cgraph_mark_reachable_node (edge
->callee
);
998 cgraph_varpool_analyze_pending_decls ();
1001 /* Collect entry points to the unit. */
1003 if (cgraph_dump_file
)
1005 fprintf (cgraph_dump_file
, "Unit entry points:");
1006 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1007 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
1008 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1009 fprintf (cgraph_dump_file
, "\n\nInitial ");
1010 dump_cgraph (cgraph_dump_file
);
1013 if (cgraph_dump_file
)
1014 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1016 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1018 tree decl
= node
->decl
;
1020 if (node
->local
.finalized
&& !DECL_SAVED_TREE (decl
))
1021 cgraph_reset_node (node
);
1023 if (!node
->reachable
&& DECL_SAVED_TREE (decl
))
1025 if (cgraph_dump_file
)
1026 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1027 cgraph_remove_node (node
);
1031 node
->next_needed
= NULL
;
1032 gcc_assert (!node
->local
.finalized
|| DECL_SAVED_TREE (decl
));
1033 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1035 if (cgraph_dump_file
)
1037 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1038 dump_cgraph (cgraph_dump_file
);
1040 first_analyzed
= cgraph_nodes
;
1042 timevar_pop (TV_CGRAPH
);
1044 /* Figure out what functions we want to assemble. */
1047 cgraph_mark_functions_to_output (void)
1049 struct cgraph_node
*node
;
1051 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1053 tree decl
= node
->decl
;
1054 struct cgraph_edge
*e
;
1056 gcc_assert (!node
->output
);
1058 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1059 if (e
->inline_failed
)
1062 /* We need to output all local functions that are used and not
1063 always inlined, as well as those that are reachable from
1064 outside the current compilation unit. */
1065 if (DECL_SAVED_TREE (decl
)
1066 && !node
->global
.inlined_to
1068 || (e
&& node
->reachable
))
1069 && !TREE_ASM_WRITTEN (decl
)
1070 && !DECL_EXTERNAL (decl
))
1074 /* We should've reclaimed all functions that are not needed. */
1075 #ifdef ENABLE_CHECKING
1076 if (!node
->global
.inlined_to
&& DECL_SAVED_TREE (decl
)
1077 && !DECL_EXTERNAL (decl
))
1079 dump_cgraph_node (stderr
, node
);
1080 internal_error ("failed to reclaim unneeded function");
1083 gcc_assert (node
->global
.inlined_to
|| !DECL_SAVED_TREE (decl
)
1084 || DECL_EXTERNAL (decl
));
1091 /* Expand function specified by NODE. */
1094 cgraph_expand_function (struct cgraph_node
*node
)
1096 tree decl
= node
->decl
;
1098 /* We ought to not compile any inline clones. */
1099 gcc_assert (!node
->global
.inlined_to
);
1101 if (flag_unit_at_a_time
)
1102 announce_function (decl
);
1104 cgraph_lower_function (node
);
1106 /* Generate RTL for the body of DECL. */
1107 lang_hooks
.callgraph
.expand_function (decl
);
1109 /* Make sure that BE didn't give up on compiling. */
1110 /* ??? Can happen with nested function of extern inline. */
1111 gcc_assert (TREE_ASM_WRITTEN (node
->decl
));
1113 current_function_decl
= NULL
;
1114 if (!cgraph_preserve_function_body_p (node
->decl
))
1116 DECL_SAVED_TREE (node
->decl
) = NULL
;
1117 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
1118 DECL_INITIAL (node
->decl
) = error_mark_node
;
1119 /* Eliminate all call edges. This is important so the call_expr no longer
1120 points to the dead function body. */
1121 cgraph_node_remove_callees (node
);
1124 cgraph_function_flags_ready
= true;
1127 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1130 cgraph_inline_p (struct cgraph_edge
*e
, const char **reason
)
1132 *reason
= e
->inline_failed
;
1133 return !e
->inline_failed
;
1138 /* Expand all functions that must be output.
1140 Attempt to topologically sort the nodes so function is output when
1141 all called functions are already assembled to allow data to be
1142 propagated across the callgraph. Use a stack to get smaller distance
1143 between a function and its callees (later we may choose to use a more
1144 sophisticated algorithm for function reordering; we will likely want
1145 to use subsections to make the output functions appear in top-down
1149 cgraph_expand_all_functions (void)
1151 struct cgraph_node
*node
;
1152 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1153 int order_pos
= 0, new_order_pos
= 0;
1156 order_pos
= cgraph_postorder (order
);
1157 gcc_assert (order_pos
== cgraph_n_nodes
);
1159 /* Garbage collector may remove inline clones we eliminate during
1160 optimization. So we must be sure to not reference them. */
1161 for (i
= 0; i
< order_pos
; i
++)
1162 if (order
[i
]->output
)
1163 order
[new_order_pos
++] = order
[i
];
1165 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1170 gcc_assert (node
->reachable
);
1172 cgraph_expand_function (node
);
1178 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
1179 the expansion process. Note that this queue may grow as its
1180 being processed, as the new functions may generate new ones. */
1181 while (cgraph_expand_queue
)
1183 node
= cgraph_expand_queue
;
1184 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
1185 node
->next_needed
= NULL
;
1187 node
->lowered
= DECL_STRUCT_FUNCTION (node
->decl
)->cfg
!= NULL
;
1188 cgraph_expand_function (node
);
1192 /* This is used to sort the node types by the cgraph order number. */
1194 struct cgraph_order_sort
1196 enum { ORDER_UNDEFINED
= 0, ORDER_FUNCTION
, ORDER_VAR
, ORDER_ASM
} kind
;
1199 struct cgraph_node
*f
;
1200 struct cgraph_varpool_node
*v
;
1201 struct cgraph_asm_node
*a
;
1205 /* Output all functions, variables, and asm statements in the order
1206 according to their order fields, which is the order in which they
1207 appeared in the file. This implements -fno-toplevel-reorder. In
1208 this mode we may output functions and variables which don't really
1209 need to be output. */
1212 cgraph_output_in_order (void)
1216 struct cgraph_order_sort
*nodes
;
1218 struct cgraph_node
*pf
;
1219 struct cgraph_varpool_node
*pv
;
1220 struct cgraph_asm_node
*pa
;
1223 size
= max
* sizeof (struct cgraph_order_sort
);
1224 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1225 memset (nodes
, 0, size
);
1227 cgraph_varpool_analyze_pending_decls ();
1229 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1234 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1235 nodes
[i
].kind
= ORDER_FUNCTION
;
1240 for (pv
= cgraph_varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1243 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1244 nodes
[i
].kind
= ORDER_VAR
;
1248 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1251 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1252 nodes
[i
].kind
= ORDER_ASM
;
1256 for (i
= 0; i
< max
; ++i
)
1258 switch (nodes
[i
].kind
)
1260 case ORDER_FUNCTION
:
1261 nodes
[i
].u
.f
->output
= 0;
1262 cgraph_expand_function (nodes
[i
].u
.f
);
1266 cgraph_varpool_assemble_decl (nodes
[i
].u
.v
);
1270 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1273 case ORDER_UNDEFINED
:
1281 cgraph_asm_nodes
= NULL
;
1284 /* Mark visibility of all functions.
1286 A local function is one whose calls can occur only in the current
1287 compilation unit and all its calls are explicit, so we can change
1288 its calling convention. We simply mark all static functions whose
1289 address is not taken as local.
1291 We also change the TREE_PUBLIC flag of all declarations that are public
1292 in language point of view but we want to overwrite this default
1293 via visibilities for the backend point of view. */
1296 cgraph_function_and_variable_visibility (void)
1298 struct cgraph_node
*node
;
1299 struct cgraph_varpool_node
*vnode
;
1301 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1304 && (DECL_COMDAT (node
->decl
)
1305 || (!flag_whole_program
1306 && TREE_PUBLIC (node
->decl
) && !DECL_EXTERNAL (node
->decl
))))
1307 node
->local
.externally_visible
= true;
1308 if (!node
->local
.externally_visible
&& node
->analyzed
1309 && !DECL_EXTERNAL (node
->decl
))
1311 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (node
->decl
));
1312 TREE_PUBLIC (node
->decl
) = 0;
1314 node
->local
.local
= (!node
->needed
1316 && !DECL_EXTERNAL (node
->decl
)
1317 && !node
->local
.externally_visible
);
1319 for (vnode
= cgraph_varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1322 && !flag_whole_program
1323 && (DECL_COMDAT (vnode
->decl
) || TREE_PUBLIC (vnode
->decl
)))
1324 vnode
->externally_visible
= 1;
1325 if (!vnode
->externally_visible
)
1327 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (vnode
->decl
));
1328 TREE_PUBLIC (vnode
->decl
) = 0;
1330 gcc_assert (TREE_STATIC (vnode
->decl
));
1333 /* Because we have to be conservative on the boundaries of source
1334 level units, it is possible that we marked some functions in
1335 reachable just because they might be used later via external
1336 linkage, but after making them local they are really unreachable
1338 cgraph_remove_unreachable_nodes (true, cgraph_dump_file
);
1340 if (cgraph_dump_file
)
1342 fprintf (cgraph_dump_file
, "\nMarking local functions:");
1343 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1344 if (node
->local
.local
)
1345 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1346 fprintf (cgraph_dump_file
, "\n\n");
1347 fprintf (cgraph_dump_file
, "\nMarking externally visible functions:");
1348 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1349 if (node
->local
.externally_visible
)
1350 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1351 fprintf (cgraph_dump_file
, "\n\n");
1353 cgraph_function_flags_ready
= true;
1356 /* Return true when function body of DECL still needs to be kept around
1357 for later re-use. */
1359 cgraph_preserve_function_body_p (tree decl
)
1361 struct cgraph_node
*node
;
1362 if (!cgraph_global_info_ready
)
1363 return (DECL_INLINE (decl
) && !flag_really_no_inline
);
1364 /* Look if there is any clone around. */
1365 for (node
= cgraph_node (decl
); node
; node
= node
->next_clone
)
1366 if (node
->global
.inlined_to
)
1375 tree_register_cfg_hooks ();
1376 bitmap_obstack_initialize (NULL
);
1377 execute_ipa_pass_list (all_ipa_passes
);
1378 bitmap_obstack_release (NULL
);
1381 /* Perform simple optimizations based on callgraph. */
1384 cgraph_optimize (void)
1386 #ifdef ENABLE_CHECKING
1389 if (!flag_unit_at_a_time
)
1391 cgraph_output_pending_asms ();
1392 cgraph_varpool_assemble_pending_decls ();
1396 process_pending_assemble_externals ();
1398 /* Frontend may output common variables after the unit has been finalized.
1399 It is safe to deal with them here as they are always zero initialized. */
1400 cgraph_varpool_analyze_pending_decls ();
1402 timevar_push (TV_CGRAPHOPT
);
1404 fprintf (stderr
, "Performing intraprocedural optimizations\n");
1406 cgraph_function_and_variable_visibility ();
1407 if (cgraph_dump_file
)
1409 fprintf (cgraph_dump_file
, "Marked ");
1410 dump_cgraph (cgraph_dump_file
);
1413 /* This pass remove bodies of extern inline functions we never inlined.
1414 Do this later so other IPA passes see what is really going on. */
1415 cgraph_remove_unreachable_nodes (false, dump_file
);
1416 cgraph_global_info_ready
= true;
1417 if (cgraph_dump_file
)
1419 fprintf (cgraph_dump_file
, "Optimized ");
1420 dump_cgraph (cgraph_dump_file
);
1421 dump_varpool (cgraph_dump_file
);
1423 timevar_pop (TV_CGRAPHOPT
);
1425 /* Output everything. */
1427 fprintf (stderr
, "Assembling functions:\n");
1428 #ifdef ENABLE_CHECKING
1432 cgraph_mark_functions_to_output ();
1434 if (!flag_toplevel_reorder
)
1435 cgraph_output_in_order ();
1438 cgraph_output_pending_asms ();
1440 cgraph_expand_all_functions ();
1441 cgraph_varpool_remove_unreferenced_decls ();
1443 cgraph_varpool_assemble_pending_decls ();
1446 if (cgraph_dump_file
)
1448 fprintf (cgraph_dump_file
, "\nFinal ");
1449 dump_cgraph (cgraph_dump_file
);
1451 #ifdef ENABLE_CHECKING
1453 /* Double check that all inline clones are gone and that all
1454 function bodies have been released from memory. */
1455 if (flag_unit_at_a_time
1456 && !dump_enabled_p (TDI_tree_all
)
1457 && !(sorrycount
|| errorcount
))
1459 struct cgraph_node
*node
;
1460 bool error_found
= false;
1462 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1464 && (node
->global
.inlined_to
1465 || DECL_SAVED_TREE (node
->decl
)))
1468 dump_cgraph_node (stderr
, node
);
1471 internal_error ("nodes with no released memory found");
1476 /* Generate and emit a static constructor or destructor. WHICH must be
1477 one of 'I' or 'D'. BODY should be a STATEMENT_LIST containing
1478 GENERIC statements. */
1481 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1483 static int counter
= 0;
1485 tree decl
, name
, resdecl
;
1487 sprintf (which_buf
, "%c_%d", which
, counter
++);
1488 name
= get_file_function_name_long (which_buf
);
1490 decl
= build_decl (FUNCTION_DECL
, name
,
1491 build_function_type (void_type_node
, void_list_node
));
1492 current_function_decl
= decl
;
1494 resdecl
= build_decl (RESULT_DECL
, NULL_TREE
, void_type_node
);
1495 DECL_ARTIFICIAL (resdecl
) = 1;
1496 DECL_IGNORED_P (resdecl
) = 1;
1497 DECL_RESULT (decl
) = resdecl
;
1499 allocate_struct_function (decl
);
1501 TREE_STATIC (decl
) = 1;
1502 TREE_USED (decl
) = 1;
1503 DECL_ARTIFICIAL (decl
) = 1;
1504 DECL_IGNORED_P (decl
) = 1;
1505 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1506 DECL_SAVED_TREE (decl
) = body
;
1507 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1508 DECL_UNINLINABLE (decl
) = 1;
1510 DECL_INITIAL (decl
) = make_node (BLOCK
);
1511 TREE_USED (DECL_INITIAL (decl
)) = 1;
1513 DECL_SOURCE_LOCATION (decl
) = input_location
;
1514 cfun
->function_end_locus
= input_location
;
1519 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1522 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1528 gimplify_function_tree (decl
);
1530 /* ??? We will get called LATE in the compilation process. */
1531 if (cgraph_global_info_ready
)
1533 tree_lowering_passes (decl
);
1534 tree_rest_of_compilation (decl
);
1537 cgraph_finalize_function (decl
, 0);
1539 if (targetm
.have_ctors_dtors
)
1541 void (*fn
) (rtx
, int);
1544 fn
= targetm
.asm_out
.constructor
;
1546 fn
= targetm
.asm_out
.destructor
;
1547 fn (XEXP (DECL_RTL (decl
), 0), priority
);
1554 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1557 /* The edges representing the callers of the NEW_VERSION node were
1558 fixed by cgraph_function_versioning (), now the call_expr in their
1559 respective tree code should be updated to call the NEW_VERSION. */
1562 update_call_expr (struct cgraph_node
*new_version
)
1564 struct cgraph_edge
*e
;
1566 gcc_assert (new_version
);
1567 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1568 /* Update the call expr on the edges
1569 to call the new version. */
1570 TREE_OPERAND (TREE_OPERAND (get_call_expr_in (e
->call_stmt
), 0), 0) = new_version
->decl
;
1574 /* Create a new cgraph node which is the new version of
1575 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1576 edges which should be redirected to point to
1577 NEW_VERSION. ALL the callees edges of OLD_VERSION
1578 are cloned to the new version node. Return the new
1581 static struct cgraph_node
*
1582 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1583 tree new_decl
, varray_type redirect_callers
)
1585 struct cgraph_node
*new_version
;
1586 struct cgraph_edge
*e
, *new_e
;
1587 struct cgraph_edge
*next_callee
;
1590 gcc_assert (old_version
);
1592 new_version
= cgraph_node (new_decl
);
1594 new_version
->analyzed
= true;
1595 new_version
->local
= old_version
->local
;
1596 new_version
->global
= old_version
->global
;
1597 new_version
->rtl
= new_version
->rtl
;
1598 new_version
->reachable
= true;
1599 new_version
->count
= old_version
->count
;
1601 /* Clone the old node callees. Recursive calls are
1603 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
1605 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
, 0, e
->loop_nest
, true);
1606 new_e
->count
= e
->count
;
1608 /* Fix recursive calls.
1609 If OLD_VERSION has a recursive call after the
1610 previous edge cloning, the new version will have an edge
1611 pointing to the old version, which is wrong;
1612 Redirect it to point to the new version. */
1613 for (e
= new_version
->callees
; e
; e
= next_callee
)
1615 next_callee
= e
->next_callee
;
1616 if (e
->callee
== old_version
)
1617 cgraph_redirect_edge_callee (e
, new_version
);
1622 if (redirect_callers
)
1623 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (redirect_callers
); i
++)
1625 e
= VARRAY_GENERIC_PTR (redirect_callers
, i
);
1626 /* Redirect calls to the old version node
1627 to point to it's new version. */
1628 cgraph_redirect_edge_callee (e
, new_version
);
1634 /* Perform function versioning.
1635 Function versioning includes copying of the tree and
1636 a callgraph update (creating a new cgraph node and updating
1637 its callees and callers).
1639 REDIRECT_CALLERS varray includes the edges to be redirected
1642 TREE_MAP is a mapping of tree nodes we want to replace with
1643 new ones (according to results of prior analysis).
1644 OLD_VERSION_NODE is the node that is versioned.
1645 It returns the new version's cgraph node. */
1647 struct cgraph_node
*
1648 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
1649 varray_type redirect_callers
,
1650 varray_type tree_map
)
1652 tree old_decl
= old_version_node
->decl
;
1653 struct cgraph_node
*new_version_node
= NULL
;
1656 if (!tree_versionable_function_p (old_decl
))
1659 /* Make a new FUNCTION_DECL tree node for the
1661 new_decl
= copy_node (old_decl
);
1663 /* Create the new version's call-graph node.
1664 and update the edges of the new node. */
1666 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
1669 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1670 tree_function_versioning (old_decl
, new_decl
, tree_map
, false);
1671 /* Update the call_expr on the edges to call the new version node. */
1672 update_call_expr (new_version_node
);
1674 /* Update the new version's properties.
1675 Make The new version visible only within this translation unit.
1676 ??? We cannot use COMDAT linkage because there is no
1677 ABI support for this. */
1678 DECL_EXTERNAL (new_version_node
->decl
) = 0;
1679 DECL_ONE_ONLY (new_version_node
->decl
) = 0;
1680 TREE_PUBLIC (new_version_node
->decl
) = 0;
1681 DECL_COMDAT (new_version_node
->decl
) = 0;
1682 new_version_node
->local
.externally_visible
= 0;
1683 new_version_node
->local
.local
= 1;
1684 new_version_node
->lowered
= true;
1685 return new_version_node
;
1688 /* Produce separate function body for inline clones so the offline copy can be
1689 modified without affecting them. */
1690 struct cgraph_node
*
1691 save_inline_function_body (struct cgraph_node
*node
)
1693 struct cgraph_node
*first_clone
;
1695 gcc_assert (node
== cgraph_node (node
->decl
));
1697 cgraph_lower_function (node
);
1699 /* In non-unit-at-a-time we construct full fledged clone we never output to
1700 assembly file. This clone is pointed out by inline_decl of orginal function
1701 and inlining infrastructure knows how to deal with this. */
1702 if (!flag_unit_at_a_time
)
1704 struct cgraph_edge
*e
;
1706 first_clone
= cgraph_clone_node (node
, node
->count
, 0, false);
1707 first_clone
->needed
= 0;
1708 first_clone
->reachable
= 1;
1709 /* Recursively clone all bodies. */
1710 for (e
= first_clone
->callees
; e
; e
= e
->next_callee
)
1711 if (!e
->inline_failed
)
1712 cgraph_clone_inlined_nodes (e
, true, false);
1715 first_clone
= node
->next_clone
;
1717 first_clone
->decl
= copy_node (node
->decl
);
1718 node
->next_clone
= NULL
;
1719 if (!flag_unit_at_a_time
)
1720 node
->inline_decl
= first_clone
->decl
;
1721 first_clone
->prev_clone
= NULL
;
1722 cgraph_insert_node_to_hashtable (first_clone
);
1723 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
1725 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1726 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true);
1728 DECL_EXTERNAL (first_clone
->decl
) = 0;
1729 DECL_ONE_ONLY (first_clone
->decl
) = 0;
1730 TREE_PUBLIC (first_clone
->decl
) = 0;
1731 DECL_COMDAT (first_clone
->decl
) = 0;
1733 for (node
= first_clone
->next_clone
; node
; node
= node
->next_clone
)
1734 node
->decl
= first_clone
->decl
;
1735 #ifdef ENABLE_CHECKING
1736 verify_cgraph_node (first_clone
);