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
)
204 if (!flag_unit_at_a_time
&& lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
207 /* ??? If the assembler name is set by hand, it is possible to assemble
208 the name later after finalizing the function and the fact is noticed
209 in assemble_name then. This is arguably a bug. */
210 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
211 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
214 /* If we decided it was needed before, but at the time we didn't have
215 the body of the function available, then it's still needed. We have
216 to go back and re-check its dependencies now. */
220 /* Externally visible functions must be output. The exception is
221 COMDAT functions that must be output only when they are needed.
223 When not optimizing, also output the static functions. (see
224 PR24561), but don't do so for always_inline functions, functions
225 declared inline and nested functions. These was optimized out
226 in the original implementation and it is unclear whether we want
227 to change the behavior here. */
228 if (((TREE_PUBLIC (decl
)
229 || (!optimize
&& !node
->local
.disregard_inline_limits
230 && !DECL_DECLARED_INLINE_P (decl
)
232 && !flag_whole_program
)
233 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
236 /* Constructors and destructors are reachable from the runtime by
238 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
241 if (flag_unit_at_a_time
)
244 /* If not doing unit at a time, then we'll only defer this function
245 if its marked for inlining. Otherwise we want to emit it now. */
247 /* "extern inline" functions are never output locally. */
248 if (DECL_EXTERNAL (decl
))
250 /* Nested functions of extern inline function shall not be emit unless
251 we inlined the origin. */
252 for (origin
= decl_function_context (decl
); origin
;
253 origin
= decl_function_context (origin
))
254 if (DECL_EXTERNAL (origin
))
256 /* We want to emit COMDAT functions only when absolutely necessary. */
257 if (DECL_COMDAT (decl
))
259 if (!DECL_INLINE (decl
)
260 || (!node
->local
.disregard_inline_limits
261 /* When declared inline, defer even the uninlinable functions.
262 This allows them to be eliminated when unused. */
263 && !DECL_DECLARED_INLINE_P (decl
)
264 && (!node
->local
.inlinable
|| !cgraph_default_inline_p (node
, NULL
))))
270 /* Walk the decls we marked as necessary and see if they reference new
271 variables or functions and add them into the worklists. */
273 cgraph_varpool_analyze_pending_decls (void)
275 bool changed
= false;
276 timevar_push (TV_CGRAPH
);
278 while (cgraph_varpool_first_unanalyzed_node
)
280 tree decl
= cgraph_varpool_first_unanalyzed_node
->decl
;
282 cgraph_varpool_first_unanalyzed_node
->analyzed
= true;
284 cgraph_varpool_first_unanalyzed_node
= cgraph_varpool_first_unanalyzed_node
->next_needed
;
286 /* Compute the alignment early so function body expanders are
287 already informed about increased alignment. */
288 align_variable (decl
, 0);
290 if (DECL_INITIAL (decl
))
292 visited_nodes
= pointer_set_create ();
293 walk_tree (&DECL_INITIAL (decl
), record_reference
, NULL
, visited_nodes
);
294 pointer_set_destroy (visited_nodes
);
295 visited_nodes
= NULL
;
299 timevar_pop (TV_CGRAPH
);
303 /* Optimization of function bodies might've rendered some variables as
304 unnecessary so we want to avoid these from being compiled.
306 This is done by pruning the queue and keeping only the variables that
307 really appear needed (ie they are either externally visible or referenced
308 by compiled function). Re-doing the reachability analysis on variables
309 brings back the remaining variables referenced by these. */
311 cgraph_varpool_remove_unreferenced_decls (void)
313 struct cgraph_varpool_node
*next
, *node
= cgraph_varpool_nodes_queue
;
315 cgraph_varpool_reset_queue ();
317 if (errorcount
|| sorrycount
)
322 tree decl
= node
->decl
;
323 next
= node
->next_needed
;
327 && ((DECL_ASSEMBLER_NAME_SET_P (decl
)
328 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
329 || node
->force_output
330 || decide_is_variable_needed (node
, decl
)
331 /* ??? Cgraph does not yet rule the world with an iron hand,
332 and does not control the emission of debug information.
333 After a variable has its DECL_RTL set, we must assume that
334 it may be referenced by the debug information, and we can
335 no longer elide it. */
336 || DECL_RTL_SET_P (decl
)))
337 cgraph_varpool_mark_needed_node (node
);
341 /* Make sure we mark alias targets as used targets. */
343 cgraph_varpool_analyze_pending_decls ();
347 /* When not doing unit-at-a-time, output all functions enqueued.
348 Return true when such a functions were found. */
351 cgraph_assemble_pending_functions (void)
355 if (flag_unit_at_a_time
)
358 cgraph_output_pending_asms ();
360 while (cgraph_nodes_queue
)
362 struct cgraph_node
*n
= cgraph_nodes_queue
;
364 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
365 n
->next_needed
= NULL
;
366 if (!n
->global
.inlined_to
368 && !DECL_EXTERNAL (n
->decl
))
370 cgraph_expand_function (n
);
375 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
376 the expansion process. Note that this queue may grow as its
377 being processed, as the new functions may generate new ones. */
378 while (cgraph_expand_queue
)
380 struct cgraph_node
*n
= cgraph_expand_queue
;
381 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
382 n
->next_needed
= NULL
;
383 cgraph_finalize_function (n
->decl
, false);
391 /* As an GCC extension we allow redefinition of the function. The
392 semantics when both copies of bodies differ is not well defined.
393 We replace the old body with new body so in unit at a time mode
394 we always use new body, while in normal mode we may end up with
395 old body inlined into some functions and new body expanded and
398 ??? It may make more sense to use one body for inlining and other
399 body for expanding the function but this is difficult to do. */
402 cgraph_reset_node (struct cgraph_node
*node
)
404 /* If node->output is set, then this is a unit-at-a-time compilation
405 and we have already begun whole-unit analysis. This is *not*
406 testing for whether we've already emitted the function. That
407 case can be sort-of legitimately seen with real function
408 redefinition errors. I would argue that the front end should
409 never present us with such a case, but don't enforce that for now. */
410 gcc_assert (!node
->output
);
412 /* Reset our data structures so we can analyze the function again. */
413 memset (&node
->local
, 0, sizeof (node
->local
));
414 memset (&node
->global
, 0, sizeof (node
->global
));
415 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
416 node
->analyzed
= false;
417 node
->local
.redefined_extern_inline
= true;
418 node
->local
.finalized
= false;
420 if (!flag_unit_at_a_time
)
422 struct cgraph_node
*n
, *next
;
424 for (n
= cgraph_nodes
; n
; n
= next
)
427 if (n
->global
.inlined_to
== node
)
428 cgraph_remove_node (n
);
432 cgraph_node_remove_callees (node
);
434 /* We may need to re-queue the node for assembling in case
435 we already proceeded it and ignored as not needed. */
436 if (node
->reachable
&& !flag_unit_at_a_time
)
438 struct cgraph_node
*n
;
440 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
449 cgraph_lower_function (struct cgraph_node
*node
)
453 tree_lowering_passes (node
->decl
);
454 node
->lowered
= true;
457 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
458 logic in effect. If NESTED is true, then our caller cannot stand to have
459 the garbage collector run at the moment. We would need to either create
460 a new GC context, or just not compile right now. */
463 cgraph_finalize_function (tree decl
, bool nested
)
465 struct cgraph_node
*node
= cgraph_node (decl
);
467 if (node
->local
.finalized
)
468 cgraph_reset_node (node
);
470 notice_global_symbol (decl
);
472 node
->local
.finalized
= true;
473 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
475 lower_nested_functions (decl
);
476 gcc_assert (!node
->nested
);
478 /* If not unit at a time, then we need to create the call graph
479 now, so that called functions can be queued and emitted now. */
480 if (!flag_unit_at_a_time
)
482 cgraph_analyze_function (node
);
483 cgraph_decide_inlining_incrementally (node
, false);
486 if (decide_is_function_needed (node
, decl
))
487 cgraph_mark_needed_node (node
);
489 /* Since we reclaim unreachable nodes at the end of every language
490 level unit, we need to be conservative about possible entry points
492 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
493 cgraph_mark_reachable_node (node
);
495 /* If not unit at a time, go ahead and emit everything we've found
496 to be reachable at this time. */
499 if (!cgraph_assemble_pending_functions ())
503 /* If we've not yet emitted decl, tell the debug info about it. */
504 if (!TREE_ASM_WRITTEN (decl
))
505 (*debug_hooks
->deferred_inline_function
) (decl
);
507 /* Possibly warn about unused parameters. */
508 if (warn_unused_parameter
)
509 do_warn_unused_parameter (decl
);
512 /* Walk tree and record all calls. Called via walk_tree. */
514 record_reference (tree
*tp
, int *walk_subtrees
, void *data
)
518 switch (TREE_CODE (t
))
521 /* ??? Really, we should mark this decl as *potentially* referenced
522 by this function and re-examine whether the decl is actually used
523 after rtl has been generated. */
524 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
526 cgraph_varpool_mark_needed_node (cgraph_varpool_node (t
));
527 if (lang_hooks
.callgraph
.analyze_expr
)
528 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
,
535 if (flag_unit_at_a_time
)
537 /* Record dereferences to the functions. This makes the
538 functions reachable unconditionally. */
539 tree decl
= TREE_OPERAND (*tp
, 0);
540 if (TREE_CODE (decl
) == FUNCTION_DECL
)
541 cgraph_mark_needed_node (cgraph_node (decl
));
546 /* Save some cycles by not walking types and declaration as we
547 won't find anything useful there anyway. */
548 if (IS_TYPE_OR_DECL_P (*tp
))
554 if ((unsigned int) TREE_CODE (t
) >= LAST_AND_UNUSED_TREE_CODE
)
555 return lang_hooks
.callgraph
.analyze_expr (tp
, walk_subtrees
, data
);
562 /* Create cgraph edges for function calls inside BODY from NODE. */
565 cgraph_create_edges (struct cgraph_node
*node
, tree body
)
569 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (body
);
570 block_stmt_iterator bsi
;
572 visited_nodes
= pointer_set_create ();
574 /* Reach the trees by walking over the CFG, and note the
575 enclosing basic-blocks in the call edges. */
576 FOR_EACH_BB_FN (bb
, this_cfun
)
577 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
579 tree stmt
= bsi_stmt (bsi
);
580 tree call
= get_call_expr_in (stmt
);
583 if (call
&& (decl
= get_callee_fndecl (call
)))
585 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
588 walk_tree (&TREE_OPERAND (call
, 1),
589 record_reference
, node
, visited_nodes
);
590 if (TREE_CODE (stmt
) == MODIFY_EXPR
)
591 walk_tree (&TREE_OPERAND (stmt
, 0),
592 record_reference
, node
, visited_nodes
);
595 walk_tree (bsi_stmt_ptr (bsi
), record_reference
, node
, visited_nodes
);
598 /* Look for initializers of constant variables and private statics. */
599 for (step
= DECL_STRUCT_FUNCTION (body
)->unexpanded_var_list
;
601 step
= TREE_CHAIN (step
))
603 tree decl
= TREE_VALUE (step
);
604 if (TREE_CODE (decl
) == VAR_DECL
605 && (TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
606 && flag_unit_at_a_time
)
607 cgraph_varpool_finalize_decl (decl
);
608 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
609 walk_tree (&DECL_INITIAL (decl
), record_reference
, node
, visited_nodes
);
612 pointer_set_destroy (visited_nodes
);
613 visited_nodes
= NULL
;
616 /* Give initial reasons why inlining would fail. Those gets
617 either NULLified or usually overwritten by more precise reason
620 initialize_inline_failed (struct cgraph_node
*node
)
622 struct cgraph_edge
*e
;
624 for (e
= node
->callers
; e
; e
= e
->next_caller
)
626 gcc_assert (!e
->callee
->global
.inlined_to
);
627 gcc_assert (e
->inline_failed
);
628 if (node
->local
.redefined_extern_inline
)
629 e
->inline_failed
= N_("redefined extern inline functions are not "
630 "considered for inlining");
631 else if (!node
->local
.inlinable
)
632 e
->inline_failed
= N_("function not inlinable");
634 e
->inline_failed
= N_("function not considered for inlining");
638 /* Rebuild call edges from current function after a passes not aware
639 of cgraph updating. */
641 rebuild_cgraph_edges (void)
644 struct cgraph_node
*node
= cgraph_node (current_function_decl
);
645 block_stmt_iterator bsi
;
647 cgraph_node_remove_callees (node
);
649 node
->count
= ENTRY_BLOCK_PTR
->count
;
652 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
654 tree stmt
= bsi_stmt (bsi
);
655 tree call
= get_call_expr_in (stmt
);
658 if (call
&& (decl
= get_callee_fndecl (call
)))
659 cgraph_create_edge (node
, cgraph_node (decl
), stmt
,
663 initialize_inline_failed (node
);
664 gcc_assert (!node
->global
.inlined_to
);
668 struct tree_opt_pass pass_rebuild_cgraph_edges
=
672 rebuild_cgraph_edges
, /* execute */
675 0, /* static_pass_number */
677 PROP_cfg
, /* properties_required */
678 0, /* properties_provided */
679 0, /* properties_destroyed */
680 0, /* todo_flags_start */
681 0, /* todo_flags_finish */
685 /* Verify cgraph nodes of given cgraph node. */
687 verify_cgraph_node (struct cgraph_node
*node
)
689 struct cgraph_edge
*e
;
690 struct cgraph_node
*main_clone
;
691 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
692 basic_block this_block
;
693 block_stmt_iterator bsi
;
694 bool error_found
= false;
696 timevar_push (TV_CGRAPH_VERIFY
);
697 for (e
= node
->callees
; e
; e
= e
->next_callee
)
700 error ("aux field set for edge %s->%s",
701 cgraph_node_name (e
->caller
), cgraph_node_name (e
->callee
));
706 error ("Execution count is negative");
709 for (e
= node
->callers
; e
; e
= e
->next_caller
)
713 error ("caller edge count is negative");
716 if (!e
->inline_failed
)
718 if (node
->global
.inlined_to
719 != (e
->caller
->global
.inlined_to
720 ? e
->caller
->global
.inlined_to
: e
->caller
))
722 error ("inlined_to pointer is wrong");
725 if (node
->callers
->next_caller
)
727 error ("multiple inline callers");
732 if (node
->global
.inlined_to
)
734 error ("inlined_to pointer set for noninline callers");
738 if (!node
->callers
&& node
->global
.inlined_to
)
740 error ("inlined_to pointer is set but no predecessors found");
743 if (node
->global
.inlined_to
== node
)
745 error ("inlined_to pointer refers to itself");
749 for (main_clone
= cgraph_node (node
->decl
); main_clone
;
750 main_clone
= main_clone
->next_clone
)
751 if (main_clone
== node
)
753 if (!cgraph_node (node
->decl
))
755 error ("node not found in cgraph_hash");
760 && DECL_SAVED_TREE (node
->decl
) && !TREE_ASM_WRITTEN (node
->decl
)
761 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
))
765 /* The nodes we're interested in are never shared, so walk
766 the tree ignoring duplicates. */
767 visited_nodes
= pointer_set_create ();
768 /* Reach the trees by walking over the CFG, and note the
769 enclosing basic-blocks in the call edges. */
770 FOR_EACH_BB_FN (this_block
, this_cfun
)
771 for (bsi
= bsi_start (this_block
); !bsi_end_p (bsi
); bsi_next (&bsi
))
773 tree stmt
= bsi_stmt (bsi
);
774 tree call
= get_call_expr_in (stmt
);
776 if (call
&& (decl
= get_callee_fndecl (call
)))
778 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
783 error ("shared call_stmt:");
784 debug_generic_stmt (stmt
);
787 if (e
->callee
->decl
!= cgraph_node (decl
)->decl
790 error ("edge points to wrong declaration:");
791 debug_tree (e
->callee
->decl
);
792 fprintf (stderr
," Instead of:");
799 error ("missing callgraph edge for call stmt:");
800 debug_generic_stmt (stmt
);
805 pointer_set_destroy (visited_nodes
);
806 visited_nodes
= NULL
;
809 /* No CFG available?! */
812 for (e
= node
->callees
; e
; e
= e
->next_callee
)
816 error ("edge %s->%s has no corresponding call_stmt",
817 cgraph_node_name (e
->caller
),
818 cgraph_node_name (e
->callee
));
819 debug_generic_stmt (e
->call_stmt
);
827 dump_cgraph_node (stderr
, node
);
828 internal_error ("verify_cgraph_node failed");
830 timevar_pop (TV_CGRAPH_VERIFY
);
833 /* Verify whole cgraph structure. */
837 struct cgraph_node
*node
;
839 if (sorrycount
|| errorcount
)
842 for (node
= cgraph_nodes
; node
; node
= node
->next
)
843 verify_cgraph_node (node
);
846 /* Output one variable, if necessary. Return whether we output it. */
848 cgraph_varpool_assemble_decl (struct cgraph_varpool_node
*node
)
850 tree decl
= node
->decl
;
852 if (!TREE_ASM_WRITTEN (decl
)
854 && !DECL_EXTERNAL (decl
)
855 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_HAS_VALUE_EXPR_P (decl
)))
857 assemble_variable (decl
, 0, 1, 0);
858 /* Local static variables are never seen by check_global_declarations
859 so we need to output debug info by hand. */
860 if (DECL_CONTEXT (decl
)
861 && (TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
862 || TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
863 && errorcount
== 0 && sorrycount
== 0)
865 timevar_push (TV_SYMOUT
);
866 (*debug_hooks
->global_decl
) (decl
);
867 timevar_pop (TV_SYMOUT
);
875 /* Output all variables enqueued to be assembled. */
877 cgraph_varpool_assemble_pending_decls (void)
879 bool changed
= false;
881 if (errorcount
|| sorrycount
)
884 /* EH might mark decls as needed during expansion. This should be safe since
885 we don't create references to new function, but it should not be used
887 cgraph_varpool_analyze_pending_decls ();
889 while (cgraph_varpool_nodes_queue
)
891 struct cgraph_varpool_node
*node
= cgraph_varpool_nodes_queue
;
893 cgraph_varpool_nodes_queue
= cgraph_varpool_nodes_queue
->next_needed
;
894 if (cgraph_varpool_assemble_decl (node
))
896 node
->next_needed
= NULL
;
901 /* Output all asm statements we have stored up to be output. */
904 cgraph_output_pending_asms (void)
906 struct cgraph_asm_node
*can
;
908 if (errorcount
|| sorrycount
)
911 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
912 assemble_asm (can
->asm_str
);
913 cgraph_asm_nodes
= NULL
;
916 /* Analyze the function scheduled to be output. */
918 cgraph_analyze_function (struct cgraph_node
*node
)
920 tree decl
= node
->decl
;
922 current_function_decl
= decl
;
923 push_cfun (DECL_STRUCT_FUNCTION (decl
));
924 cgraph_lower_function (node
);
926 /* First kill forward declaration so reverse inlining works properly. */
927 cgraph_create_edges (node
, decl
);
929 node
->local
.inlinable
= tree_inlinable_function_p (decl
);
930 node
->local
.self_insns
= estimate_num_insns (decl
);
931 if (node
->local
.inlinable
)
932 node
->local
.disregard_inline_limits
933 = lang_hooks
.tree_inlining
.disregard_inline_limits (decl
);
934 initialize_inline_failed (node
);
935 if (flag_really_no_inline
&& !node
->local
.disregard_inline_limits
)
936 node
->local
.inlinable
= 0;
937 /* Inlining characteristics are maintained by the cgraph_mark_inline. */
938 node
->global
.insns
= node
->local
.self_insns
;
940 node
->analyzed
= true;
942 current_function_decl
= NULL
;
945 /* Look for externally_visible and used attributes and mark cgraph nodes
948 We cannot mark the nodes at the point the attributes are processed (in
949 handle_*_attribute) because the copy of the declarations available at that
950 point may not be canonical. For example, in:
953 void f() __attribute__((used));
955 the declaration we see in handle_used_attribute will be the second
956 declaration -- but the front end will subsequently merge that declaration
957 with the original declaration and discard the second declaration.
959 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
962 void f() __attribute__((externally_visible));
966 So, we walk the nodes at the end of the translation unit, applying the
967 attributes at that point. */
970 process_function_and_variable_attributes (struct cgraph_node
*first
,
971 struct cgraph_varpool_node
*first_var
)
973 struct cgraph_node
*node
;
974 struct cgraph_varpool_node
*vnode
;
976 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
978 tree decl
= node
->decl
;
979 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
981 mark_decl_referenced (decl
);
982 if (node
->local
.finalized
)
983 cgraph_mark_needed_node (node
);
985 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
987 if (node
->local
.finalized
)
988 cgraph_mark_needed_node (node
);
989 node
->externally_visible
= true;
992 for (vnode
= cgraph_varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
994 tree decl
= vnode
->decl
;
995 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
997 mark_decl_referenced (decl
);
998 if (vnode
->finalized
)
999 cgraph_varpool_mark_needed_node (vnode
);
1001 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
1003 if (vnode
->finalized
)
1004 cgraph_varpool_mark_needed_node (vnode
);
1005 vnode
->externally_visible
= true;
1010 /* Analyze the whole compilation unit once it is parsed completely. */
1013 cgraph_finalize_compilation_unit (void)
1015 struct cgraph_node
*node
, *next
;
1016 /* Keep track of already processed nodes when called multiple times for
1017 intermodule optimization. */
1018 static struct cgraph_node
*first_analyzed
;
1019 static struct cgraph_varpool_node
*first_analyzed_var
;
1021 finish_aliases_1 ();
1023 if (!flag_unit_at_a_time
)
1025 cgraph_output_pending_asms ();
1026 cgraph_assemble_pending_functions ();
1032 fprintf (stderr
, "\nAnalyzing compilation unit");
1036 timevar_push (TV_CGRAPH
);
1037 process_function_and_variable_attributes (first_analyzed
, first_analyzed_var
);
1038 cgraph_varpool_analyze_pending_decls ();
1039 if (cgraph_dump_file
)
1041 fprintf (cgraph_dump_file
, "Initial entry points:");
1042 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1043 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
1044 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1045 fprintf (cgraph_dump_file
, "\n");
1048 /* Propagate reachability flag and lower representation of all reachable
1049 functions. In the future, lowering will introduce new functions and
1050 new entry points on the way (by template instantiation and virtual
1051 method table generation for instance). */
1052 while (cgraph_nodes_queue
)
1054 struct cgraph_edge
*edge
;
1055 tree decl
= cgraph_nodes_queue
->decl
;
1057 node
= cgraph_nodes_queue
;
1058 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
1059 node
->next_needed
= NULL
;
1061 /* ??? It is possible to create extern inline function and later using
1062 weak alias attribute to kill its body. See
1063 gcc.c-torture/compile/20011119-1.c */
1064 if (!DECL_SAVED_TREE (decl
))
1066 cgraph_reset_node (node
);
1070 gcc_assert (!node
->analyzed
&& node
->reachable
);
1071 gcc_assert (DECL_SAVED_TREE (decl
));
1073 cgraph_analyze_function (node
);
1075 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1076 if (!edge
->callee
->reachable
)
1077 cgraph_mark_reachable_node (edge
->callee
);
1079 cgraph_varpool_analyze_pending_decls ();
1082 /* Collect entry points to the unit. */
1084 if (cgraph_dump_file
)
1086 fprintf (cgraph_dump_file
, "Unit entry points:");
1087 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1088 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
1089 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1090 fprintf (cgraph_dump_file
, "\n\nInitial ");
1091 dump_cgraph (cgraph_dump_file
);
1094 if (cgraph_dump_file
)
1095 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1097 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1099 tree decl
= node
->decl
;
1102 if (node
->local
.finalized
&& !DECL_SAVED_TREE (decl
))
1103 cgraph_reset_node (node
);
1105 if (!node
->reachable
&& DECL_SAVED_TREE (decl
))
1107 if (cgraph_dump_file
)
1108 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1109 cgraph_remove_node (node
);
1113 node
->next_needed
= NULL
;
1114 gcc_assert (!node
->local
.finalized
|| DECL_SAVED_TREE (decl
));
1115 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1117 if (cgraph_dump_file
)
1119 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1120 dump_cgraph (cgraph_dump_file
);
1122 first_analyzed
= cgraph_nodes
;
1123 first_analyzed_var
= cgraph_varpool_nodes
;
1125 timevar_pop (TV_CGRAPH
);
1127 /* Figure out what functions we want to assemble. */
1130 cgraph_mark_functions_to_output (void)
1132 struct cgraph_node
*node
;
1134 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1136 tree decl
= node
->decl
;
1137 struct cgraph_edge
*e
;
1139 gcc_assert (!node
->output
);
1141 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1142 if (e
->inline_failed
)
1145 /* We need to output all local functions that are used and not
1146 always inlined, as well as those that are reachable from
1147 outside the current compilation unit. */
1148 if (DECL_SAVED_TREE (decl
)
1149 && !node
->global
.inlined_to
1151 || (e
&& node
->reachable
))
1152 && !TREE_ASM_WRITTEN (decl
)
1153 && !DECL_EXTERNAL (decl
))
1157 /* We should've reclaimed all functions that are not needed. */
1158 #ifdef ENABLE_CHECKING
1159 if (!node
->global
.inlined_to
&& DECL_SAVED_TREE (decl
)
1160 && !DECL_EXTERNAL (decl
))
1162 dump_cgraph_node (stderr
, node
);
1163 internal_error ("failed to reclaim unneeded function");
1166 gcc_assert (node
->global
.inlined_to
|| !DECL_SAVED_TREE (decl
)
1167 || DECL_EXTERNAL (decl
));
1174 /* Expand function specified by NODE. */
1177 cgraph_expand_function (struct cgraph_node
*node
)
1179 tree decl
= node
->decl
;
1181 /* We ought to not compile any inline clones. */
1182 gcc_assert (!node
->global
.inlined_to
);
1184 if (flag_unit_at_a_time
)
1185 announce_function (decl
);
1187 cgraph_lower_function (node
);
1189 /* Generate RTL for the body of DECL. */
1190 lang_hooks
.callgraph
.expand_function (decl
);
1192 /* Make sure that BE didn't give up on compiling. */
1193 /* ??? Can happen with nested function of extern inline. */
1194 gcc_assert (TREE_ASM_WRITTEN (node
->decl
));
1196 current_function_decl
= NULL
;
1197 if (!cgraph_preserve_function_body_p (node
->decl
))
1199 DECL_SAVED_TREE (node
->decl
) = NULL
;
1200 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
1201 DECL_INITIAL (node
->decl
) = error_mark_node
;
1202 /* Eliminate all call edges. This is important so the call_expr no longer
1203 points to the dead function body. */
1204 cgraph_node_remove_callees (node
);
1207 cgraph_function_flags_ready
= true;
1210 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1213 cgraph_inline_p (struct cgraph_edge
*e
, const char **reason
)
1215 *reason
= e
->inline_failed
;
1216 return !e
->inline_failed
;
1221 /* Expand all functions that must be output.
1223 Attempt to topologically sort the nodes so function is output when
1224 all called functions are already assembled to allow data to be
1225 propagated across the callgraph. Use a stack to get smaller distance
1226 between a function and its callees (later we may choose to use a more
1227 sophisticated algorithm for function reordering; we will likely want
1228 to use subsections to make the output functions appear in top-down
1232 cgraph_expand_all_functions (void)
1234 struct cgraph_node
*node
;
1235 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1236 int order_pos
= 0, new_order_pos
= 0;
1239 order_pos
= cgraph_postorder (order
);
1240 gcc_assert (order_pos
== cgraph_n_nodes
);
1242 /* Garbage collector may remove inline clones we eliminate during
1243 optimization. So we must be sure to not reference them. */
1244 for (i
= 0; i
< order_pos
; i
++)
1245 if (order
[i
]->output
)
1246 order
[new_order_pos
++] = order
[i
];
1248 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1253 gcc_assert (node
->reachable
);
1255 cgraph_expand_function (node
);
1261 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
1262 the expansion process. Note that this queue may grow as its
1263 being processed, as the new functions may generate new ones. */
1264 while (cgraph_expand_queue
)
1266 node
= cgraph_expand_queue
;
1267 cgraph_expand_queue
= cgraph_expand_queue
->next_needed
;
1268 node
->next_needed
= NULL
;
1270 node
->lowered
= DECL_STRUCT_FUNCTION (node
->decl
)->cfg
!= NULL
;
1271 cgraph_expand_function (node
);
1275 /* This is used to sort the node types by the cgraph order number. */
1277 struct cgraph_order_sort
1279 enum { ORDER_UNDEFINED
= 0, ORDER_FUNCTION
, ORDER_VAR
, ORDER_ASM
} kind
;
1282 struct cgraph_node
*f
;
1283 struct cgraph_varpool_node
*v
;
1284 struct cgraph_asm_node
*a
;
1288 /* Output all functions, variables, and asm statements in the order
1289 according to their order fields, which is the order in which they
1290 appeared in the file. This implements -fno-toplevel-reorder. In
1291 this mode we may output functions and variables which don't really
1292 need to be output. */
1295 cgraph_output_in_order (void)
1299 struct cgraph_order_sort
*nodes
;
1301 struct cgraph_node
*pf
;
1302 struct cgraph_varpool_node
*pv
;
1303 struct cgraph_asm_node
*pa
;
1306 size
= max
* sizeof (struct cgraph_order_sort
);
1307 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1308 memset (nodes
, 0, size
);
1310 cgraph_varpool_analyze_pending_decls ();
1312 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1317 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1318 nodes
[i
].kind
= ORDER_FUNCTION
;
1323 for (pv
= cgraph_varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1326 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1327 nodes
[i
].kind
= ORDER_VAR
;
1331 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1334 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1335 nodes
[i
].kind
= ORDER_ASM
;
1339 for (i
= 0; i
< max
; ++i
)
1341 switch (nodes
[i
].kind
)
1343 case ORDER_FUNCTION
:
1344 nodes
[i
].u
.f
->output
= 0;
1345 cgraph_expand_function (nodes
[i
].u
.f
);
1349 cgraph_varpool_assemble_decl (nodes
[i
].u
.v
);
1353 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1356 case ORDER_UNDEFINED
:
1364 cgraph_asm_nodes
= NULL
;
1367 /* Mark visibility of all functions.
1369 A local function is one whose calls can occur only in the current
1370 compilation unit and all its calls are explicit, so we can change
1371 its calling convention. We simply mark all static functions whose
1372 address is not taken as local.
1374 We also change the TREE_PUBLIC flag of all declarations that are public
1375 in language point of view but we want to overwrite this default
1376 via visibilities for the backend point of view. */
1379 cgraph_function_and_variable_visibility (void)
1381 struct cgraph_node
*node
;
1382 struct cgraph_varpool_node
*vnode
;
1384 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1387 && (DECL_COMDAT (node
->decl
)
1388 || (!flag_whole_program
1389 && TREE_PUBLIC (node
->decl
) && !DECL_EXTERNAL (node
->decl
))))
1390 node
->local
.externally_visible
= true;
1391 if (!node
->local
.externally_visible
&& node
->analyzed
1392 && !DECL_EXTERNAL (node
->decl
))
1394 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (node
->decl
));
1395 TREE_PUBLIC (node
->decl
) = 0;
1397 node
->local
.local
= (!node
->needed
1399 && !DECL_EXTERNAL (node
->decl
)
1400 && !node
->local
.externally_visible
);
1402 for (vnode
= cgraph_varpool_nodes_queue
; vnode
; vnode
= vnode
->next_needed
)
1405 && !flag_whole_program
1406 && (DECL_COMDAT (vnode
->decl
) || TREE_PUBLIC (vnode
->decl
)))
1407 vnode
->externally_visible
= 1;
1408 if (!vnode
->externally_visible
)
1410 gcc_assert (flag_whole_program
|| !TREE_PUBLIC (vnode
->decl
));
1411 TREE_PUBLIC (vnode
->decl
) = 0;
1413 gcc_assert (TREE_STATIC (vnode
->decl
));
1416 /* Because we have to be conservative on the boundaries of source
1417 level units, it is possible that we marked some functions in
1418 reachable just because they might be used later via external
1419 linkage, but after making them local they are really unreachable
1421 cgraph_remove_unreachable_nodes (true, cgraph_dump_file
);
1423 if (cgraph_dump_file
)
1425 fprintf (cgraph_dump_file
, "\nMarking local functions:");
1426 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1427 if (node
->local
.local
)
1428 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1429 fprintf (cgraph_dump_file
, "\n\n");
1430 fprintf (cgraph_dump_file
, "\nMarking externally visible functions:");
1431 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1432 if (node
->local
.externally_visible
)
1433 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1434 fprintf (cgraph_dump_file
, "\n\n");
1436 cgraph_function_flags_ready
= true;
1439 /* Return true when function body of DECL still needs to be kept around
1440 for later re-use. */
1442 cgraph_preserve_function_body_p (tree decl
)
1444 struct cgraph_node
*node
;
1445 if (!cgraph_global_info_ready
)
1446 return (DECL_INLINE (decl
) && !flag_really_no_inline
);
1447 /* Look if there is any clone around. */
1448 for (node
= cgraph_node (decl
); node
; node
= node
->next_clone
)
1449 if (node
->global
.inlined_to
)
1458 tree_register_cfg_hooks ();
1459 bitmap_obstack_initialize (NULL
);
1460 execute_ipa_pass_list (all_ipa_passes
);
1461 bitmap_obstack_release (NULL
);
1464 /* Perform simple optimizations based on callgraph. */
1467 cgraph_optimize (void)
1469 #ifdef ENABLE_CHECKING
1472 if (!flag_unit_at_a_time
)
1474 cgraph_output_pending_asms ();
1475 cgraph_varpool_assemble_pending_decls ();
1479 process_pending_assemble_externals ();
1481 /* Frontend may output common variables after the unit has been finalized.
1482 It is safe to deal with them here as they are always zero initialized. */
1483 cgraph_varpool_analyze_pending_decls ();
1485 timevar_push (TV_CGRAPHOPT
);
1487 fprintf (stderr
, "Performing intraprocedural optimizations\n");
1489 cgraph_function_and_variable_visibility ();
1490 if (cgraph_dump_file
)
1492 fprintf (cgraph_dump_file
, "Marked ");
1493 dump_cgraph (cgraph_dump_file
);
1496 /* Don't run the IPA passes if there was any error or sorry messages. */
1497 if (errorcount
== 0 && sorrycount
== 0)
1500 /* This pass remove bodies of extern inline functions we never inlined.
1501 Do this later so other IPA passes see what is really going on. */
1502 cgraph_remove_unreachable_nodes (false, dump_file
);
1503 cgraph_global_info_ready
= true;
1504 if (cgraph_dump_file
)
1506 fprintf (cgraph_dump_file
, "Optimized ");
1507 dump_cgraph (cgraph_dump_file
);
1508 dump_varpool (cgraph_dump_file
);
1510 timevar_pop (TV_CGRAPHOPT
);
1512 /* Output everything. */
1514 fprintf (stderr
, "Assembling functions:\n");
1515 #ifdef ENABLE_CHECKING
1519 cgraph_mark_functions_to_output ();
1521 if (!flag_toplevel_reorder
)
1522 cgraph_output_in_order ();
1525 cgraph_output_pending_asms ();
1527 cgraph_expand_all_functions ();
1528 cgraph_varpool_remove_unreferenced_decls ();
1530 cgraph_varpool_assemble_pending_decls ();
1533 if (cgraph_dump_file
)
1535 fprintf (cgraph_dump_file
, "\nFinal ");
1536 dump_cgraph (cgraph_dump_file
);
1538 #ifdef ENABLE_CHECKING
1540 /* Double check that all inline clones are gone and that all
1541 function bodies have been released from memory. */
1542 if (flag_unit_at_a_time
1543 && !(sorrycount
|| errorcount
))
1545 struct cgraph_node
*node
;
1546 bool error_found
= false;
1548 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1550 && (node
->global
.inlined_to
1551 || DECL_SAVED_TREE (node
->decl
)))
1554 dump_cgraph_node (stderr
, node
);
1557 internal_error ("nodes with no released memory found");
1562 /* Generate and emit a static constructor or destructor. WHICH must be
1563 one of 'I' or 'D'. BODY should be a STATEMENT_LIST containing
1564 GENERIC statements. */
1567 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1569 static int counter
= 0;
1571 tree decl
, name
, resdecl
;
1573 sprintf (which_buf
, "%c_%d", which
, counter
++);
1574 name
= get_file_function_name_long (which_buf
);
1576 decl
= build_decl (FUNCTION_DECL
, name
,
1577 build_function_type (void_type_node
, void_list_node
));
1578 current_function_decl
= decl
;
1580 resdecl
= build_decl (RESULT_DECL
, NULL_TREE
, void_type_node
);
1581 DECL_ARTIFICIAL (resdecl
) = 1;
1582 DECL_IGNORED_P (resdecl
) = 1;
1583 DECL_RESULT (decl
) = resdecl
;
1585 allocate_struct_function (decl
);
1587 TREE_STATIC (decl
) = 1;
1588 TREE_USED (decl
) = 1;
1589 DECL_ARTIFICIAL (decl
) = 1;
1590 DECL_IGNORED_P (decl
) = 1;
1591 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1592 DECL_SAVED_TREE (decl
) = body
;
1593 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1594 DECL_UNINLINABLE (decl
) = 1;
1596 DECL_INITIAL (decl
) = make_node (BLOCK
);
1597 TREE_USED (DECL_INITIAL (decl
)) = 1;
1599 DECL_SOURCE_LOCATION (decl
) = input_location
;
1600 cfun
->function_end_locus
= input_location
;
1605 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1608 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1614 gimplify_function_tree (decl
);
1616 /* ??? We will get called LATE in the compilation process. */
1617 if (cgraph_global_info_ready
)
1619 tree_lowering_passes (decl
);
1620 tree_rest_of_compilation (decl
);
1623 cgraph_finalize_function (decl
, 0);
1625 if (targetm
.have_ctors_dtors
)
1627 void (*fn
) (rtx
, int);
1630 fn
= targetm
.asm_out
.constructor
;
1632 fn
= targetm
.asm_out
.destructor
;
1633 fn (XEXP (DECL_RTL (decl
), 0), priority
);
1640 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1643 /* The edges representing the callers of the NEW_VERSION node were
1644 fixed by cgraph_function_versioning (), now the call_expr in their
1645 respective tree code should be updated to call the NEW_VERSION. */
1648 update_call_expr (struct cgraph_node
*new_version
)
1650 struct cgraph_edge
*e
;
1652 gcc_assert (new_version
);
1653 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1654 /* Update the call expr on the edges
1655 to call the new version. */
1656 TREE_OPERAND (TREE_OPERAND (get_call_expr_in (e
->call_stmt
), 0), 0) = new_version
->decl
;
1660 /* Create a new cgraph node which is the new version of
1661 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1662 edges which should be redirected to point to
1663 NEW_VERSION. ALL the callees edges of OLD_VERSION
1664 are cloned to the new version node. Return the new
1667 static struct cgraph_node
*
1668 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1670 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
1672 struct cgraph_node
*new_version
;
1673 struct cgraph_edge
*e
, *new_e
;
1674 struct cgraph_edge
*next_callee
;
1677 gcc_assert (old_version
);
1679 new_version
= cgraph_node (new_decl
);
1681 new_version
->analyzed
= true;
1682 new_version
->local
= old_version
->local
;
1683 new_version
->global
= old_version
->global
;
1684 new_version
->rtl
= new_version
->rtl
;
1685 new_version
->reachable
= true;
1686 new_version
->count
= old_version
->count
;
1688 /* Clone the old node callees. Recursive calls are
1690 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
1692 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
, 0, e
->loop_nest
, true);
1693 new_e
->count
= e
->count
;
1695 /* Fix recursive calls.
1696 If OLD_VERSION has a recursive call after the
1697 previous edge cloning, the new version will have an edge
1698 pointing to the old version, which is wrong;
1699 Redirect it to point to the new version. */
1700 for (e
= new_version
->callees
; e
; e
= next_callee
)
1702 next_callee
= e
->next_callee
;
1703 if (e
->callee
== old_version
)
1704 cgraph_redirect_edge_callee (e
, new_version
);
1709 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
1711 /* Redirect calls to the old version node to point to its new
1713 cgraph_redirect_edge_callee (e
, new_version
);
1719 /* Perform function versioning.
1720 Function versioning includes copying of the tree and
1721 a callgraph update (creating a new cgraph node and updating
1722 its callees and callers).
1724 REDIRECT_CALLERS varray includes the edges to be redirected
1727 TREE_MAP is a mapping of tree nodes we want to replace with
1728 new ones (according to results of prior analysis).
1729 OLD_VERSION_NODE is the node that is versioned.
1730 It returns the new version's cgraph node. */
1732 struct cgraph_node
*
1733 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
1734 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1735 varray_type tree_map
)
1737 tree old_decl
= old_version_node
->decl
;
1738 struct cgraph_node
*new_version_node
= NULL
;
1741 if (!tree_versionable_function_p (old_decl
))
1744 /* Make a new FUNCTION_DECL tree node for the
1746 new_decl
= copy_node (old_decl
);
1748 /* Create the new version's call-graph node.
1749 and update the edges of the new node. */
1751 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
1754 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1755 tree_function_versioning (old_decl
, new_decl
, tree_map
, false);
1756 /* Update the call_expr on the edges to call the new version node. */
1757 update_call_expr (new_version_node
);
1759 /* Update the new version's properties.
1760 Make The new version visible only within this translation unit.
1761 ??? We cannot use COMDAT linkage because there is no
1762 ABI support for this. */
1763 DECL_EXTERNAL (new_version_node
->decl
) = 0;
1764 DECL_ONE_ONLY (new_version_node
->decl
) = 0;
1765 TREE_PUBLIC (new_version_node
->decl
) = 0;
1766 DECL_COMDAT (new_version_node
->decl
) = 0;
1767 new_version_node
->local
.externally_visible
= 0;
1768 new_version_node
->local
.local
= 1;
1769 new_version_node
->lowered
= true;
1770 return new_version_node
;
1773 /* Produce separate function body for inline clones so the offline copy can be
1774 modified without affecting them. */
1775 struct cgraph_node
*
1776 save_inline_function_body (struct cgraph_node
*node
)
1778 struct cgraph_node
*first_clone
;
1780 gcc_assert (node
== cgraph_node (node
->decl
));
1782 cgraph_lower_function (node
);
1784 /* In non-unit-at-a-time we construct full fledged clone we never output to
1785 assembly file. This clone is pointed out by inline_decl of original function
1786 and inlining infrastructure knows how to deal with this. */
1787 if (!flag_unit_at_a_time
)
1789 struct cgraph_edge
*e
;
1791 first_clone
= cgraph_clone_node (node
, node
->count
, 0, false);
1792 first_clone
->needed
= 0;
1793 first_clone
->reachable
= 1;
1794 /* Recursively clone all bodies. */
1795 for (e
= first_clone
->callees
; e
; e
= e
->next_callee
)
1796 if (!e
->inline_failed
)
1797 cgraph_clone_inlined_nodes (e
, true, false);
1800 first_clone
= node
->next_clone
;
1802 first_clone
->decl
= copy_node (node
->decl
);
1803 node
->next_clone
= NULL
;
1804 if (!flag_unit_at_a_time
)
1805 node
->inline_decl
= first_clone
->decl
;
1806 first_clone
->prev_clone
= NULL
;
1807 cgraph_insert_node_to_hashtable (first_clone
);
1808 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
1810 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1811 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true);
1813 DECL_EXTERNAL (first_clone
->decl
) = 0;
1814 DECL_ONE_ONLY (first_clone
->decl
) = 0;
1815 TREE_PUBLIC (first_clone
->decl
) = 0;
1816 DECL_COMDAT (first_clone
->decl
) = 0;
1818 for (node
= first_clone
->next_clone
; node
; node
= node
->next_clone
)
1819 node
->decl
= first_clone
->decl
;
1820 #ifdef ENABLE_CHECKING
1821 verify_cgraph_node (first_clone
);