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.
221 When not optimizing, also output the static functions. (see
224 if (((TREE_PUBLIC (decl
) || !optimize
) && !flag_whole_program
)
225 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
228 /* Constructors and destructors are reachable from the runtime by
230 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
233 if (flag_unit_at_a_time
)
236 /* If not doing unit at a time, then we'll only defer this function
237 if its marked for inlining. Otherwise we want to emit it now. */
239 /* "extern inline" functions are never output locally. */
240 if (DECL_EXTERNAL (decl
))
242 /* Nested functions of extern inline function shall not be emit unless
243 we inlined the origin. */
244 for (origin
= decl_function_context (decl
); origin
;
245 origin
= decl_function_context (origin
))
246 if (DECL_EXTERNAL (origin
))
248 /* We want to emit COMDAT functions only when absolutely necessary. */
249 if (DECL_COMDAT (decl
))
251 if (!DECL_INLINE (decl
)
252 || (!node
->local
.disregard_inline_limits
253 /* When declared inline, defer even the uninlinable functions.
254 This allows them to be eliminated when unused. */
255 && !DECL_DECLARED_INLINE_P (decl
)
256 && (!node
->local
.inlinable
|| !cgraph_default_inline_p (node
, NULL
))))
262 /* Walk the decls we marked as necessary and see if they reference new
263 variables or functions and add them into the worklists. */
265 cgraph_varpool_analyze_pending_decls (void)
267 bool changed
= false;
268 timevar_push (TV_CGRAPH
);
270 while (cgraph_varpool_first_unanalyzed_node
)
272 tree decl
= cgraph_varpool_first_unanalyzed_node
->decl
;
274 cgraph_varpool_first_unanalyzed_node
->analyzed
= true;
276 cgraph_varpool_first_unanalyzed_node
= cgraph_varpool_first_unanalyzed_node
->next_needed
;
278 if (DECL_INITIAL (decl
))
280 visited_nodes
= pointer_set_create ();
281 walk_tree (&DECL_INITIAL (decl
), record_reference
, NULL
, visited_nodes
);
282 pointer_set_destroy (visited_nodes
);
283 visited_nodes
= NULL
;
287 timevar_pop (TV_CGRAPH
);
291 /* Optimization of function bodies might've rendered some variables as
292 unnecessary so we want to avoid these from being compiled.
294 This is done by pruning the queue and keeping only the variables that
295 really appear needed (ie they are either externally visible or referenced
296 by compiled function). Re-doing the reachability analysis on variables
297 brings back the remaining variables referenced by these. */
299 cgraph_varpool_remove_unreferenced_decls (void)
301 struct cgraph_varpool_node
*next
, *node
= cgraph_varpool_nodes_queue
;
303 cgraph_varpool_reset_queue ();
305 if (errorcount
|| sorrycount
)
310 tree decl
= node
->decl
;
311 next
= node
->next_needed
;
315 && ((DECL_ASSEMBLER_NAME_SET_P (decl
)
316 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
317 || node
->force_output
318 || decide_is_variable_needed (node
, decl
)
319 /* ??? Cgraph does not yet rule the world with an iron hand,
320 and does not control the emission of debug information.
321 After a variable has its DECL_RTL set, we must assume that
322 it may be referenced by the debug information, and we can
323 no longer elide it. */
324 || DECL_RTL_SET_P (decl
)))
325 cgraph_varpool_mark_needed_node (node
);
329 /* Make sure we mark alias targets as used targets. */
331 cgraph_varpool_analyze_pending_decls ();
335 /* When not doing unit-at-a-time, output all functions enqueued.
336 Return true when such a functions were found. */
339 cgraph_assemble_pending_functions (void)
343 if (flag_unit_at_a_time
)
346 cgraph_output_pending_asms ();
348 while (cgraph_nodes_queue
)
350 struct cgraph_node
*n
= cgraph_nodes_queue
;
352 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
353 n
->next_needed
= NULL
;
354 if (!n
->global
.inlined_to
356 && !DECL_EXTERNAL (n
->decl
))
358 cgraph_expand_function (n
);
363 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
364 the expansion process. Note that this queue may grow as its
365 being processed, as the new functions may generate new ones. */
366 while (cgraph_expand_queue
)
368 struct cgraph_node
*n
= cgraph_expand_queue
;
369 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
370 n
->next_needed
= NULL
;
371 cgraph_finalize_function (n
->decl
, false);
379 /* As an GCC extension we allow redefinition of the function. The
380 semantics when both copies of bodies differ is not well defined.
381 We replace the old body with new body so in unit at a time mode
382 we always use new body, while in normal mode we may end up with
383 old body inlined into some functions and new body expanded and
386 ??? It may make more sense to use one body for inlining and other
387 body for expanding the function but this is difficult to do. */
390 cgraph_reset_node (struct cgraph_node
*node
)
392 /* If node->output is set, then this is a unit-at-a-time compilation
393 and we have already begun whole-unit analysis. This is *not*
394 testing for whether we've already emitted the function. That
395 case can be sort-of legitimately seen with real function
396 redefinition errors. I would argue that the front end should
397 never present us with such a case, but don't enforce that for now. */
398 gcc_assert (!node
->output
);
400 /* Reset our data structures so we can analyze the function again. */
401 memset (&node
->local
, 0, sizeof (node
->local
));
402 memset (&node
->global
, 0, sizeof (node
->global
));
403 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
404 node
->analyzed
= false;
405 node
->local
.redefined_extern_inline
= true;
406 node
->local
.finalized
= false;
408 if (!flag_unit_at_a_time
)
410 struct cgraph_node
*n
;
412 for (n
= cgraph_nodes
; n
; n
= n
->next
)
413 if (n
->global
.inlined_to
== node
)
414 cgraph_remove_node (n
);
417 cgraph_node_remove_callees (node
);
419 /* We may need to re-queue the node for assembling in case
420 we already proceeded it and ignored as not needed. */
421 if (node
->reachable
&& !flag_unit_at_a_time
)
423 struct cgraph_node
*n
;
425 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
434 cgraph_lower_function (struct cgraph_node
*node
)
438 tree_lowering_passes (node
->decl
);
439 node
->lowered
= true;
442 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
443 logic in effect. If NESTED is true, then our caller cannot stand to have
444 the garbage collector run at the moment. We would need to either create
445 a new GC context, or just not compile right now. */
448 cgraph_finalize_function (tree decl
, bool nested
)
450 struct cgraph_node
*node
= cgraph_node (decl
);
452 if (node
->local
.finalized
)
453 cgraph_reset_node (node
);
455 notice_global_symbol (decl
);
457 node
->local
.finalized
= true;
458 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
460 lower_nested_functions (decl
);
461 gcc_assert (!node
->nested
);
463 /* If not unit at a time, then we need to create the call graph
464 now, so that called functions can be queued and emitted now. */
465 if (!flag_unit_at_a_time
)
467 cgraph_analyze_function (node
);
468 cgraph_decide_inlining_incrementally (node
, false);
471 if (decide_is_function_needed (node
, decl
))
472 cgraph_mark_needed_node (node
);
474 /* Since we reclaim unreachable nodes at the end of every language
475 level unit, we need to be conservative about possible entry points
477 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
478 cgraph_mark_reachable_node (node
);
480 /* If not unit at a time, go ahead and emit everything we've found
481 to be reachable at this time. */
484 if (!cgraph_assemble_pending_functions ())
488 /* If we've not yet emitted decl, tell the debug info about it. */
489 if (!TREE_ASM_WRITTEN (decl
))
490 (*debug_hooks
->deferred_inline_function
) (decl
);
492 /* Possibly warn about unused parameters. */
493 if (warn_unused_parameter
)
494 do_warn_unused_parameter (decl
);
497 /* Walk tree and record all calls. Called via walk_tree. */
499 record_reference (tree
*tp
, int *walk_subtrees
, void *data
)
503 switch (TREE_CODE (t
))
506 /* ??? Really, we should mark this decl as *potentially* referenced
507 by this function and re-examine whether the decl is actually used
508 after rtl has been generated. */
509 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
511 cgraph_varpool_mark_needed_node (cgraph_varpool_node (t
));
512 if (lang_hooks
.callgraph
.analyze_expr
)
513 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
,
520 if (flag_unit_at_a_time
)
522 /* Record dereferences to the functions. This makes the
523 functions reachable unconditionally. */
524 tree decl
= TREE_OPERAND (*tp
, 0);
525 if (TREE_CODE (decl
) == FUNCTION_DECL
)
526 cgraph_mark_needed_node (cgraph_node (decl
));
531 /* Save some cycles by not walking types and declaration as we
532 won't find anything useful there anyway. */
533 if (IS_TYPE_OR_DECL_P (*tp
))
539 if ((unsigned int) TREE_CODE (t
) >= LAST_AND_UNUSED_TREE_CODE
)
540 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
, data
);
547 /* Create cgraph edges for function calls inside BODY from NODE. */
550 cgraph_create_edges (struct cgraph_node
*node
, tree body
)
554 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (body
);
555 block_stmt_iterator bsi
;
557 visited_nodes
= pointer_set_create ();
559 /* Reach the trees by walking over the CFG, and note the
560 enclosing basic-blocks in the call edges. */
561 FOR_EACH_BB_FN (bb
, this_cfun
)
562 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
564 tree stmt
= bsi_stmt (bsi
);
565 tree call
= get_call_expr_in (stmt
);
568 if (call
&& (decl
= get_callee_fndecl (call
)))
570 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
573 walk_tree (&TREE_OPERAND (call
, 1),
574 record_reference
, node
, visited_nodes
);
575 if (TREE_CODE (stmt
) == MODIFY_EXPR
)
576 walk_tree (&TREE_OPERAND (stmt
, 0),
577 record_reference
, node
, visited_nodes
);
580 walk_tree (bsi_stmt_ptr (bsi
), record_reference
, node
, visited_nodes
);
583 /* Look for initializers of constant variables and private statics. */
584 for (step
= DECL_STRUCT_FUNCTION (body
)->unexpanded_var_list
;
586 step
= TREE_CHAIN (step
))
588 tree decl
= TREE_VALUE (step
);
589 if (TREE_CODE (decl
) == VAR_DECL
590 && (TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
591 && flag_unit_at_a_time
)
592 cgraph_varpool_finalize_decl (decl
);
593 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
594 walk_tree (&DECL_INITIAL (decl
), record_reference
, node
, visited_nodes
);
597 pointer_set_destroy (visited_nodes
);
598 visited_nodes
= NULL
;
601 /* Give initial reasons why inlining would fail. Those gets
602 either NULLified or usually overwritten by more precise reason
605 initialize_inline_failed (struct cgraph_node
*node
)
607 struct cgraph_edge
*e
;
609 for (e
= node
->callers
; e
; e
= e
->next_caller
)
611 gcc_assert (!e
->callee
->global
.inlined_to
);
612 gcc_assert (e
->inline_failed
);
613 if (node
->local
.redefined_extern_inline
)
614 e
->inline_failed
= N_("redefined extern inline functions are not "
615 "considered for inlining");
616 else if (!node
->local
.inlinable
)
617 e
->inline_failed
= N_("function not inlinable");
619 e
->inline_failed
= N_("function not considered for inlining");
623 /* Rebuild call edges from current function after a passes not aware
624 of cgraph updating. */
626 rebuild_cgraph_edges (void)
629 struct cgraph_node
*node
= cgraph_node (current_function_decl
);
630 block_stmt_iterator bsi
;
632 cgraph_node_remove_callees (node
);
634 node
->count
= ENTRY_BLOCK_PTR
->count
;
637 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
639 tree stmt
= bsi_stmt (bsi
);
640 tree call
= get_call_expr_in (stmt
);
643 if (call
&& (decl
= get_callee_fndecl (call
)))
644 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
648 initialize_inline_failed (node
);
649 gcc_assert (!node
->global
.inlined_to
);
653 struct tree_opt_pass pass_rebuild_cgraph_edges
=
657 rebuild_cgraph_edges
, /* execute */
660 0, /* static_pass_number */
662 PROP_cfg
, /* properties_required */
663 0, /* properties_provided */
664 0, /* properties_destroyed */
665 0, /* todo_flags_start */
666 0, /* todo_flags_finish */
670 /* Verify cgraph nodes of given cgraph node. */
672 verify_cgraph_node (struct cgraph_node
*node
)
674 struct cgraph_edge
*e
;
675 struct cgraph_node
*main_clone
;
676 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
677 basic_block this_block
;
678 block_stmt_iterator bsi
;
679 bool error_found
= false;
681 timevar_push (TV_CGRAPH_VERIFY
);
682 for (e
= node
->callees
; e
; e
= e
->next_callee
)
685 error ("aux field set for edge %s->%s",
686 cgraph_node_name (e
->caller
), cgraph_node_name (e
->callee
));
691 error ("Execution count is negative");
694 for (e
= node
->callers
; e
; e
= e
->next_caller
)
698 error ("caller edge count is negative");
701 if (!e
->inline_failed
)
703 if (node
->global
.inlined_to
704 != (e
->caller
->global
.inlined_to
705 ? e
->caller
->global
.inlined_to
: e
->caller
))
707 error ("inlined_to pointer is wrong");
710 if (node
->callers
->next_caller
)
712 error ("multiple inline callers");
717 if (node
->global
.inlined_to
)
719 error ("inlined_to pointer set for noninline callers");
723 if (!node
->callers
&& node
->global
.inlined_to
)
725 error ("inlined_to pointer is set but no predecesors found");
728 if (node
->global
.inlined_to
== node
)
730 error ("inlined_to pointer refers to itself");
734 for (main_clone
= cgraph_node (node
->decl
); main_clone
;
735 main_clone
= main_clone
->next_clone
)
736 if (main_clone
== node
)
738 if (!cgraph_node (node
->decl
))
740 error ("node not found in cgraph_hash");
745 && DECL_SAVED_TREE (node
->decl
) && !TREE_ASM_WRITTEN (node
->decl
)
746 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
))
750 /* The nodes we're interested in are never shared, so walk
751 the tree ignoring duplicates. */
752 visited_nodes
= pointer_set_create ();
753 /* Reach the trees by walking over the CFG, and note the
754 enclosing basic-blocks in the call edges. */
755 FOR_EACH_BB_FN (this_block
, this_cfun
)
756 for (bsi
= bsi_start (this_block
); !bsi_end_p (bsi
); bsi_next (&bsi
))
758 tree stmt
= bsi_stmt (bsi
);
759 tree call
= get_call_expr_in (stmt
);
761 if (call
&& (decl
= get_callee_fndecl (call
)))
763 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
768 error ("shared call_stmt:");
769 debug_generic_stmt (stmt
);
772 if (e
->callee
->decl
!= cgraph_node (decl
)->decl
775 error ("edge points to wrong declaration:");
776 debug_tree (e
->callee
->decl
);
777 fprintf (stderr
," Instead of:");
784 error ("missing callgraph edge for call stmt:");
785 debug_generic_stmt (stmt
);
790 pointer_set_destroy (visited_nodes
);
791 visited_nodes
= NULL
;
794 /* No CFG available?! */
797 for (e
= node
->callees
; e
; e
= e
->next_callee
)
801 error ("edge %s->%s has no corresponding call_stmt",
802 cgraph_node_name (e
->caller
),
803 cgraph_node_name (e
->callee
));
804 debug_generic_stmt (e
->call_stmt
);
812 dump_cgraph_node (stderr
, node
);
813 internal_error ("verify_cgraph_node failed");
815 timevar_pop (TV_CGRAPH_VERIFY
);
818 /* Verify whole cgraph structure. */
822 struct cgraph_node
*node
;
824 if (sorrycount
|| errorcount
)
827 for (node
= cgraph_nodes
; node
; node
= node
->next
)
828 verify_cgraph_node (node
);
831 /* Output one variable, if necessary. Return whether we output it. */
833 cgraph_varpool_assemble_decl (struct cgraph_varpool_node
*node
)
835 tree decl
= node
->decl
;
837 if (!TREE_ASM_WRITTEN (decl
)
839 && !DECL_EXTERNAL (decl
)
840 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_HAS_VALUE_EXPR_P (decl
)))
842 assemble_variable (decl
, 0, 1, 0);
843 /* Local static variables are never seen by check_global_declarations
844 so we need to output debug info by hand. */
845 if (DECL_CONTEXT (decl
)
846 && (TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
847 || TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
848 && errorcount
== 0 && sorrycount
== 0)
850 timevar_push (TV_SYMOUT
);
851 (*debug_hooks
->global_decl
) (decl
);
852 timevar_pop (TV_SYMOUT
);
860 /* Output all variables enqueued to be assembled. */
862 cgraph_varpool_assemble_pending_decls (void)
864 bool changed
= false;
866 if (errorcount
|| sorrycount
)
869 /* EH might mark decls as needed during expansion. This should be safe since
870 we don't create references to new function, but it should not be used
872 cgraph_varpool_analyze_pending_decls ();
874 while (cgraph_varpool_nodes_queue
)
876 struct cgraph_varpool_node
*node
= cgraph_varpool_nodes_queue
;
878 cgraph_varpool_nodes_queue
= cgraph_varpool_nodes_queue
->next_needed
;
879 if (cgraph_varpool_assemble_decl (node
))
881 node
->next_needed
= NULL
;
886 /* Output all asm statements we have stored up to be output. */
889 cgraph_output_pending_asms (void)
891 struct cgraph_asm_node
*can
;
893 if (errorcount
|| sorrycount
)
896 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
897 assemble_asm (can
->asm_str
);
898 cgraph_asm_nodes
= NULL
;
901 /* Analyze the function scheduled to be output. */
903 cgraph_analyze_function (struct cgraph_node
*node
)
905 tree decl
= node
->decl
;
907 current_function_decl
= decl
;
908 push_cfun (DECL_STRUCT_FUNCTION (decl
));
909 cgraph_lower_function (node
);
911 /* First kill forward declaration so reverse inlining works properly. */
912 cgraph_create_edges (node
, decl
);
914 node
->local
.inlinable
= tree_inlinable_function_p (decl
);
915 node
->local
.self_insns
= estimate_num_insns (decl
);
916 if (node
->local
.inlinable
)
917 node
->local
.disregard_inline_limits
918 = lang_hooks
.tree_inlining
.disregard_inline_limits (decl
);
919 initialize_inline_failed (node
);
920 if (flag_really_no_inline
&& !node
->local
.disregard_inline_limits
)
921 node
->local
.inlinable
= 0;
922 /* Inlining characteristics are maintained by the cgraph_mark_inline. */
923 node
->global
.insns
= node
->local
.self_insns
;
925 node
->analyzed
= true;
927 current_function_decl
= NULL
;
930 /* Analyze the whole compilation unit once it is parsed completely. */
933 cgraph_finalize_compilation_unit (void)
935 struct cgraph_node
*node
;
936 /* Keep track of already processed nodes when called multiple times for
937 intermodule optimization. */
938 static struct cgraph_node
*first_analyzed
;
942 if (!flag_unit_at_a_time
)
944 cgraph_output_pending_asms ();
945 cgraph_assemble_pending_functions ();
951 fprintf (stderr
, "\nAnalyzing compilation unit");
955 timevar_push (TV_CGRAPH
);
956 cgraph_varpool_analyze_pending_decls ();
957 if (cgraph_dump_file
)
959 fprintf (cgraph_dump_file
, "Initial entry points:");
960 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
961 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
962 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
963 fprintf (cgraph_dump_file
, "\n");
966 /* Propagate reachability flag and lower representation of all reachable
967 functions. In the future, lowering will introduce new functions and
968 new entry points on the way (by template instantiation and virtual
969 method table generation for instance). */
970 while (cgraph_nodes_queue
)
972 struct cgraph_edge
*edge
;
973 tree decl
= cgraph_nodes_queue
->decl
;
975 node
= cgraph_nodes_queue
;
976 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
977 node
->next_needed
= NULL
;
979 /* ??? It is possible to create extern inline function and later using
980 weak alias attribute to kill its body. See
981 gcc.c-torture/compile/20011119-1.c */
982 if (!DECL_SAVED_TREE (decl
))
984 cgraph_reset_node (node
);
988 gcc_assert (!node
->analyzed
&& node
->reachable
);
989 gcc_assert (DECL_SAVED_TREE (decl
));
991 cgraph_analyze_function (node
);
993 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
994 if (!edge
->callee
->reachable
)
995 cgraph_mark_reachable_node (edge
->callee
);
997 cgraph_varpool_analyze_pending_decls ();
1000 /* Collect entry points to the unit. */
1002 if (cgraph_dump_file
)
1004 fprintf (cgraph_dump_file
, "Unit entry points:");
1005 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1006 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
1007 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1008 fprintf (cgraph_dump_file
, "\n\nInitial ");
1009 dump_cgraph (cgraph_dump_file
);
1012 if (cgraph_dump_file
)
1013 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1015 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1017 tree decl
= node
->decl
;
1019 if (node
->local
.finalized
&& !DECL_SAVED_TREE (decl
))
1020 cgraph_reset_node (node
);
1022 if (!node
->reachable
&& DECL_SAVED_TREE (decl
))
1024 if (cgraph_dump_file
)
1025 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1026 cgraph_remove_node (node
);
1030 node
->next_needed
= NULL
;
1031 gcc_assert (!node
->local
.finalized
|| DECL_SAVED_TREE (decl
));
1032 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1034 if (cgraph_dump_file
)
1036 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1037 dump_cgraph (cgraph_dump_file
);
1039 first_analyzed
= cgraph_nodes
;
1041 timevar_pop (TV_CGRAPH
);
1043 /* Figure out what functions we want to assemble. */
1046 cgraph_mark_functions_to_output (void)
1048 struct cgraph_node
*node
;
1050 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1052 tree decl
= node
->decl
;
1053 struct cgraph_edge
*e
;
1055 gcc_assert (!node
->output
);
1057 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1058 if (e
->inline_failed
)
1061 /* We need to output all local functions that are used and not
1062 always inlined, as well as those that are reachable from
1063 outside the current compilation unit. */
1064 if (DECL_SAVED_TREE (decl
)
1065 && !node
->global
.inlined_to
1067 || (e
&& node
->reachable
))
1068 && !TREE_ASM_WRITTEN (decl
)
1069 && !DECL_EXTERNAL (decl
))
1073 /* We should've reclaimed all functions that are not needed. */
1074 #ifdef ENABLE_CHECKING
1075 if (!node
->global
.inlined_to
&& DECL_SAVED_TREE (decl
)
1076 && !DECL_EXTERNAL (decl
))
1078 dump_cgraph_node (stderr
, node
);
1079 internal_error ("failed to reclaim unneeded function");
1082 gcc_assert (node
->global
.inlined_to
|| !DECL_SAVED_TREE (decl
)
1083 || DECL_EXTERNAL (decl
));
1090 /* Expand function specified by NODE. */
1093 cgraph_expand_function (struct cgraph_node
*node
)
1095 tree decl
= node
->decl
;
1097 /* We ought to not compile any inline clones. */
1098 gcc_assert (!node
->global
.inlined_to
);
1100 if (flag_unit_at_a_time
)
1101 announce_function (decl
);
1103 cgraph_lower_function (node
);
1105 /* Generate RTL for the body of DECL. */
1106 lang_hooks
.callgraph
.expand_function (decl
);
1108 /* Make sure that BE didn't give up on compiling. */
1109 /* ??? Can happen with nested function of extern inline. */
1110 gcc_assert (TREE_ASM_WRITTEN (node
->decl
));
1112 current_function_decl
= NULL
;
1113 if (!cgraph_preserve_function_body_p (node
->decl
))
1115 DECL_SAVED_TREE (node
->decl
) = NULL
;
1116 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
1117 DECL_INITIAL (node
->decl
) = error_mark_node
;
1118 /* Eliminate all call edges. This is important so the call_expr no longer
1119 points to the dead function body. */
1120 cgraph_node_remove_callees (node
);
1123 cgraph_function_flags_ready
= true;
1126 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1129 cgraph_inline_p (struct cgraph_edge
*e
, const char **reason
)
1131 *reason
= e
->inline_failed
;
1132 return !e
->inline_failed
;
1137 /* Expand all functions that must be output.
1139 Attempt to topologically sort the nodes so function is output when
1140 all called functions are already assembled to allow data to be
1141 propagated across the callgraph. Use a stack to get smaller distance
1142 between a function and its callees (later we may choose to use a more
1143 sophisticated algorithm for function reordering; we will likely want
1144 to use subsections to make the output functions appear in top-down
1148 cgraph_expand_all_functions (void)
1150 struct cgraph_node
*node
;
1151 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1152 int order_pos
= 0, new_order_pos
= 0;
1155 order_pos
= cgraph_postorder (order
);
1156 gcc_assert (order_pos
== cgraph_n_nodes
);
1158 /* Garbage collector may remove inline clones we eliminate during
1159 optimization. So we must be sure to not reference them. */
1160 for (i
= 0; i
< order_pos
; i
++)
1161 if (order
[i
]->output
)
1162 order
[new_order_pos
++] = order
[i
];
1164 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1169 gcc_assert (node
->reachable
);
1171 cgraph_expand_function (node
);
1177 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
1178 the expansion process. Note that this queue may grow as its
1179 being processed, as the new functions may generate new ones. */
1180 while (cgraph_expand_queue
)
1182 node
= cgraph_expand_queue
;
1183 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
1184 node
->next_needed
= NULL
;
1186 node
->lowered
= DECL_STRUCT_FUNCTION (node
->decl
)->cfg
!= NULL
;
1187 cgraph_expand_function (node
);
1191 /* This is used to sort the node types by the cgraph order number. */
1193 struct cgraph_order_sort
1195 enum { ORDER_UNDEFINED
= 0, ORDER_FUNCTION
, ORDER_VAR
, ORDER_ASM
} kind
;
1198 struct cgraph_node
*f
;
1199 struct cgraph_varpool_node
*v
;
1200 struct cgraph_asm_node
*a
;
1204 /* Output all functions, variables, and asm statements in the order
1205 according to their order fields, which is the order in which they
1206 appeared in the file. This implements -fno-toplevel-reorder. In
1207 this mode we may output functions and variables which don't really
1208 need to be output. */
1211 cgraph_output_in_order (void)
1215 struct cgraph_order_sort
*nodes
;
1217 struct cgraph_node
*pf
;
1218 struct cgraph_varpool_node
*pv
;
1219 struct cgraph_asm_node
*pa
;
1222 size
= max
* sizeof (struct cgraph_order_sort
);
1223 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1224 memset (nodes
, 0, size
);
1226 cgraph_varpool_analyze_pending_decls ();
1228 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1233 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1234 nodes
[i
].kind
= ORDER_FUNCTION
;
1239 for (pv
= cgraph_varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1242 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1243 nodes
[i
].kind
= ORDER_VAR
;
1247 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1250 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1251 nodes
[i
].kind
= ORDER_ASM
;
1255 for (i
= 0; i
< max
; ++i
)
1257 switch (nodes
[i
].kind
)
1259 case ORDER_FUNCTION
:
1260 nodes
[i
].u
.f
->output
= 0;
1261 cgraph_expand_function (nodes
[i
].u
.f
);
1265 cgraph_varpool_assemble_decl (nodes
[i
].u
.v
);
1269 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1272 case ORDER_UNDEFINED
:
1280 cgraph_asm_nodes
= NULL
;
1283 /* Mark visibility of all functions.
1285 A local function is one whose calls can occur only in the current
1286 compilation unit and all its calls are explicit, so we can change
1287 its calling convention. We simply mark all static functions whose
1288 address is not taken as local.
1290 We also change the TREE_PUBLIC flag of all declarations that are public
1291 in language point of view but we want to overwrite this default
1292 via visibilities for the backend point of view. */
1295 cgraph_function_and_variable_visibility (void)
1297 struct cgraph_node
*node
;
1298 struct cgraph_varpool_node
*vnode
;
1300 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1303 && (DECL_COMDAT (node
->decl
)
1304 || (!flag_whole_program
1305 && TREE_PUBLIC (node
->decl
) && !DECL_EXTERNAL (node
->decl
))))
1306 node
->local
.externally_visible
= true;
1307 if (!node
->local
.externally_visible
&& node
->analyzed
1308 && !DECL_EXTERNAL (node
->decl
))
1310 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (node
->decl
));
1311 TREE_PUBLIC (node
->decl
) = 0;
1313 node
->local
.local
= (!node
->needed
1315 && !DECL_EXTERNAL (node
->decl
)
1316 && !node
->local
.externally_visible
);
1318 for (vnode
= cgraph_varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1321 && !flag_whole_program
1322 && (DECL_COMDAT (vnode
->decl
) || TREE_PUBLIC (vnode
->decl
)))
1323 vnode
->externally_visible
= 1;
1324 if (!vnode
->externally_visible
)
1326 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (vnode
->decl
));
1327 TREE_PUBLIC (vnode
->decl
) = 0;
1329 gcc_assert (TREE_STATIC (vnode
->decl
));
1332 /* Because we have to be conservative on the boundaries of source
1333 level units, it is possible that we marked some functions in
1334 reachable just because they might be used later via external
1335 linkage, but after making them local they are really unreachable
1337 cgraph_remove_unreachable_nodes (true, cgraph_dump_file
);
1339 if (cgraph_dump_file
)
1341 fprintf (cgraph_dump_file
, "\nMarking local functions:");
1342 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1343 if (node
->local
.local
)
1344 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1345 fprintf (cgraph_dump_file
, "\n\n");
1346 fprintf (cgraph_dump_file
, "\nMarking externally visible functions:");
1347 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1348 if (node
->local
.externally_visible
)
1349 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1350 fprintf (cgraph_dump_file
, "\n\n");
1352 cgraph_function_flags_ready
= true;
1355 /* Return true when function body of DECL still needs to be kept around
1356 for later re-use. */
1358 cgraph_preserve_function_body_p (tree decl
)
1360 struct cgraph_node
*node
;
1361 if (!cgraph_global_info_ready
)
1362 return (DECL_INLINE (decl
) && !flag_really_no_inline
);
1363 /* Look if there is any clone around. */
1364 for (node
= cgraph_node (decl
); node
; node
= node
->next_clone
)
1365 if (node
->global
.inlined_to
)
1374 tree_register_cfg_hooks ();
1375 bitmap_obstack_initialize (NULL
);
1376 execute_ipa_pass_list (all_ipa_passes
);
1377 bitmap_obstack_release (NULL
);
1380 /* Perform simple optimizations based on callgraph. */
1383 cgraph_optimize (void)
1385 #ifdef ENABLE_CHECKING
1388 if (!flag_unit_at_a_time
)
1390 cgraph_output_pending_asms ();
1391 cgraph_varpool_assemble_pending_decls ();
1395 process_pending_assemble_externals ();
1397 /* Frontend may output common variables after the unit has been finalized.
1398 It is safe to deal with them here as they are always zero initialized. */
1399 cgraph_varpool_analyze_pending_decls ();
1401 timevar_push (TV_CGRAPHOPT
);
1403 fprintf (stderr
, "Performing intraprocedural optimizations\n");
1405 cgraph_function_and_variable_visibility ();
1406 if (cgraph_dump_file
)
1408 fprintf (cgraph_dump_file
, "Marked ");
1409 dump_cgraph (cgraph_dump_file
);
1412 /* This pass remove bodies of extern inline functions we never inlined.
1413 Do this later so other IPA passes see what is really going on. */
1414 cgraph_remove_unreachable_nodes (false, dump_file
);
1415 cgraph_global_info_ready
= true;
1416 if (cgraph_dump_file
)
1418 fprintf (cgraph_dump_file
, "Optimized ");
1419 dump_cgraph (cgraph_dump_file
);
1420 dump_varpool (cgraph_dump_file
);
1422 timevar_pop (TV_CGRAPHOPT
);
1424 /* Output everything. */
1426 fprintf (stderr
, "Assembling functions:\n");
1427 #ifdef ENABLE_CHECKING
1431 cgraph_mark_functions_to_output ();
1433 if (!flag_toplevel_reorder
)
1434 cgraph_output_in_order ();
1437 cgraph_output_pending_asms ();
1439 cgraph_expand_all_functions ();
1440 cgraph_varpool_remove_unreferenced_decls ();
1442 cgraph_varpool_assemble_pending_decls ();
1445 if (cgraph_dump_file
)
1447 fprintf (cgraph_dump_file
, "\nFinal ");
1448 dump_cgraph (cgraph_dump_file
);
1450 #ifdef ENABLE_CHECKING
1452 /* Double check that all inline clones are gone and that all
1453 function bodies have been released from memory. */
1454 if (flag_unit_at_a_time
1455 && !dump_enabled_p (TDI_tree_all
)
1456 && !(sorrycount
|| errorcount
))
1458 struct cgraph_node
*node
;
1459 bool error_found
= false;
1461 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1463 && (node
->global
.inlined_to
1464 || DECL_SAVED_TREE (node
->decl
)))
1467 dump_cgraph_node (stderr
, node
);
1470 internal_error ("nodes with no released memory found");
1475 /* Generate and emit a static constructor or destructor. WHICH must be
1476 one of 'I' or 'D'. BODY should be a STATEMENT_LIST containing
1477 GENERIC statements. */
1480 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1482 static int counter
= 0;
1484 tree decl
, name
, resdecl
;
1486 sprintf (which_buf
, "%c_%d", which
, counter
++);
1487 name
= get_file_function_name_long (which_buf
);
1489 decl
= build_decl (FUNCTION_DECL
, name
,
1490 build_function_type (void_type_node
, void_list_node
));
1491 current_function_decl
= decl
;
1493 resdecl
= build_decl (RESULT_DECL
, NULL_TREE
, void_type_node
);
1494 DECL_ARTIFICIAL (resdecl
) = 1;
1495 DECL_IGNORED_P (resdecl
) = 1;
1496 DECL_RESULT (decl
) = resdecl
;
1498 allocate_struct_function (decl
);
1500 TREE_STATIC (decl
) = 1;
1501 TREE_USED (decl
) = 1;
1502 DECL_ARTIFICIAL (decl
) = 1;
1503 DECL_IGNORED_P (decl
) = 1;
1504 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1505 DECL_SAVED_TREE (decl
) = body
;
1506 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1507 DECL_UNINLINABLE (decl
) = 1;
1509 DECL_INITIAL (decl
) = make_node (BLOCK
);
1510 TREE_USED (DECL_INITIAL (decl
)) = 1;
1512 DECL_SOURCE_LOCATION (decl
) = input_location
;
1513 cfun
->function_end_locus
= input_location
;
1518 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1521 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1527 gimplify_function_tree (decl
);
1529 /* ??? We will get called LATE in the compilation process. */
1530 if (cgraph_global_info_ready
)
1532 tree_lowering_passes (decl
);
1533 tree_rest_of_compilation (decl
);
1536 cgraph_finalize_function (decl
, 0);
1538 if (targetm
.have_ctors_dtors
)
1540 void (*fn
) (rtx
, int);
1543 fn
= targetm
.asm_out
.constructor
;
1545 fn
= targetm
.asm_out
.destructor
;
1546 fn (XEXP (DECL_RTL (decl
), 0), priority
);
1553 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1556 /* The edges representing the callers of the NEW_VERSION node were
1557 fixed by cgraph_function_versioning (), now the call_expr in their
1558 respective tree code should be updated to call the NEW_VERSION. */
1561 update_call_expr (struct cgraph_node
*new_version
)
1563 struct cgraph_edge
*e
;
1565 gcc_assert (new_version
);
1566 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1567 /* Update the call expr on the edges
1568 to call the new version. */
1569 TREE_OPERAND (TREE_OPERAND (get_call_expr_in (e
->call_stmt
), 0), 0) = new_version
->decl
;
1573 /* Create a new cgraph node which is the new version of
1574 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1575 edges which should be redirected to point to
1576 NEW_VERSION. ALL the callees edges of OLD_VERSION
1577 are cloned to the new version node. Return the new
1580 static struct cgraph_node
*
1581 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1583 VEC(cgraph_edge_p
,heap
) *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 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
1624 /* Redirect calls to the old version node to point to its new
1626 cgraph_redirect_edge_callee (e
, new_version
);
1632 /* Perform function versioning.
1633 Function versioning includes copying of the tree and
1634 a callgraph update (creating a new cgraph node and updating
1635 its callees and callers).
1637 REDIRECT_CALLERS varray includes the edges to be redirected
1640 TREE_MAP is a mapping of tree nodes we want to replace with
1641 new ones (according to results of prior analysis).
1642 OLD_VERSION_NODE is the node that is versioned.
1643 It returns the new version's cgraph node. */
1645 struct cgraph_node
*
1646 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
1647 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1648 varray_type tree_map
)
1650 tree old_decl
= old_version_node
->decl
;
1651 struct cgraph_node
*new_version_node
= NULL
;
1654 if (!tree_versionable_function_p (old_decl
))
1657 /* Make a new FUNCTION_DECL tree node for the
1659 new_decl
= copy_node (old_decl
);
1661 /* Create the new version's call-graph node.
1662 and update the edges of the new node. */
1664 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
1667 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1668 tree_function_versioning (old_decl
, new_decl
, tree_map
, false);
1669 /* Update the call_expr on the edges to call the new version node. */
1670 update_call_expr (new_version_node
);
1672 /* Update the new version's properties.
1673 Make The new version visible only within this translation unit.
1674 ??? We cannot use COMDAT linkage because there is no
1675 ABI support for this. */
1676 DECL_EXTERNAL (new_version_node
->decl
) = 0;
1677 DECL_ONE_ONLY (new_version_node
->decl
) = 0;
1678 TREE_PUBLIC (new_version_node
->decl
) = 0;
1679 DECL_COMDAT (new_version_node
->decl
) = 0;
1680 new_version_node
->local
.externally_visible
= 0;
1681 new_version_node
->local
.local
= 1;
1682 new_version_node
->lowered
= true;
1683 return new_version_node
;
1686 /* Produce separate function body for inline clones so the offline copy can be
1687 modified without affecting them. */
1688 struct cgraph_node
*
1689 save_inline_function_body (struct cgraph_node
*node
)
1691 struct cgraph_node
*first_clone
;
1693 gcc_assert (node
== cgraph_node (node
->decl
));
1695 cgraph_lower_function (node
);
1697 /* In non-unit-at-a-time we construct full fledged clone we never output to
1698 assembly file. This clone is pointed out by inline_decl of original function
1699 and inlining infrastructure knows how to deal with this. */
1700 if (!flag_unit_at_a_time
)
1702 struct cgraph_edge
*e
;
1704 first_clone
= cgraph_clone_node (node
, node
->count
, 0, false);
1705 first_clone
->needed
= 0;
1706 first_clone
->reachable
= 1;
1707 /* Recursively clone all bodies. */
1708 for (e
= first_clone
->callees
; e
; e
= e
->next_callee
)
1709 if (!e
->inline_failed
)
1710 cgraph_clone_inlined_nodes (e
, true, false);
1713 first_clone
= node
->next_clone
;
1715 first_clone
->decl
= copy_node (node
->decl
);
1716 node
->next_clone
= NULL
;
1717 if (!flag_unit_at_a_time
)
1718 node
->inline_decl
= first_clone
->decl
;
1719 first_clone
->prev_clone
= NULL
;
1720 cgraph_insert_node_to_hashtable (first_clone
);
1721 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
1723 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1724 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true);
1726 DECL_EXTERNAL (first_clone
->decl
) = 0;
1727 DECL_ONE_ONLY (first_clone
->decl
) = 0;
1728 TREE_PUBLIC (first_clone
->decl
) = 0;
1729 DECL_COMDAT (first_clone
->decl
) = 0;
1731 for (node
= first_clone
->next_clone
; node
; node
= node
->next_clone
)
1732 node
->decl
= first_clone
->decl
;
1733 #ifdef ENABLE_CHECKING
1734 verify_cgraph_node (first_clone
);