Remove generic cloning code for now - this code is not supposed to
[official-gcc.git] / gcc / cgraphunit.c
blobf823ddff50141d30c27608e7d3555152def1c5d4
1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This module implements main driver of compilation process as well as
23 few basic interprocedural optimizers.
25 The main scope of this file is to act as an interface in between
26 tree based frontends and the backend (and middle end)
28 The front-end is supposed to use following functionality:
30 - cgraph_finalize_function
32 This function is called once front-end has parsed whole body of function
33 and it is certain that the function body nor the declaration will change.
35 (There is one exception needed for implementing GCC extern inline
36 function.)
38 - varpool_finalize_variable
40 This function has same behavior as the above but is used for static
41 variables.
43 - cgraph_finalize_compilation_unit
45 This function is called once (source level) compilation unit is finalized
46 and it will no longer change.
48 In the the call-graph construction and local function
49 analysis takes place here. Bodies of unreachable functions are released
50 to conserve memory usage.
52 The function can be called multiple times when multiple source level
53 compilation units are combined (such as in C frontend)
55 - cgraph_optimize
57 In this unit-at-a-time compilation the intra procedural analysis takes
58 place here. In particular the static functions whose address is never
59 taken are marked as local. Backend can then use this information to
60 modify calling conventions, do better inlining or similar optimizations.
62 - cgraph_mark_needed_node
63 - varpool_mark_needed_node
65 When function or variable is referenced by some hidden way the call-graph
66 data structure must be updated accordingly by this function.
67 There should be little need to call this function and all the references
68 should be made explicit to cgraph code. At present these functions are
69 used by C++ frontend to explicitly mark the keyed methods.
71 - analyze_expr callback
73 This function is responsible for lowering tree nodes not understood by
74 generic code into understandable ones or alternatively marking
75 callgraph and varpool nodes referenced by the as needed.
77 ??? On the tree-ssa genericizing should take place here and we will avoid
78 need for these hooks (replacing them by genericizing hook)
80 Analyzing of all functions is deferred
81 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
83 In cgraph_finalize_compilation_unit the reachable functions are
84 analyzed. During analysis the call-graph edges from reachable
85 functions are constructed and their destinations are marked as
86 reachable. References to functions and variables are discovered too
87 and variables found to be needed output to the assembly file. Via
88 mark_referenced call in assemble_variable functions referenced by
89 static variables are noticed too.
91 The intra-procedural information is produced and its existence
92 indicated by global_info_ready. Once this flag is set it is impossible
93 to change function from !reachable to reachable and thus
94 assemble_variable no longer call mark_referenced.
96 Finally the call-graph is topologically sorted and all reachable functions
97 that has not been completely inlined or are not external are output.
99 ??? It is possible that reference to function or variable is optimized
100 out. We can not deal with this nicely because topological order is not
101 suitable for it. For tree-ssa we may consider another pass doing
102 optimization and re-discovering reachable functions.
104 ??? Reorganize code so variables are output very last and only if they
105 really has been referenced by produced code, so we catch more cases
106 where reference has been optimized out. */
109 #include "config.h"
110 #include "system.h"
111 #include "coretypes.h"
112 #include "tm.h"
113 #include "tree.h"
114 #include "rtl.h"
115 #include "tree-flow.h"
116 #include "tree-inline.h"
117 #include "langhooks.h"
118 #include "pointer-set.h"
119 #include "toplev.h"
120 #include "flags.h"
121 #include "ggc.h"
122 #include "debug.h"
123 #include "target.h"
124 #include "cgraph.h"
125 #include "diagnostic.h"
126 #include "timevar.h"
127 #include "params.h"
128 #include "fibheap.h"
129 #include "intl.h"
130 #include "function.h"
131 #include "ipa-prop.h"
132 #include "gimple.h"
133 #include "tree-iterator.h"
134 #include "tree-pass.h"
135 #include "tree-dump.h"
136 #include "output.h"
137 #include "coverage.h"
139 #include "opts.h"
140 #include "highlev-plugin-internal.h"
143 static void cgraph_expand_all_functions (void);
144 static void cgraph_mark_functions_to_output (void);
145 static void cgraph_expand_function (struct cgraph_node *);
146 static void cgraph_output_pending_asms (void);
147 static void cgraph_analyze_function (struct cgraph_node *);
149 static FILE *cgraph_dump_file;
151 /* A vector of FUNCTION_DECLs declared as static constructors. */
152 static GTY (()) VEC(tree, gc) *static_ctors;
153 /* A vector of FUNCTION_DECLs declared as static destructors. */
154 static GTY (()) VEC(tree, gc) *static_dtors;
156 /* When target does not have ctors and dtors, we call all constructor
157 and destructor by special initialization/destruction function
158 recognized by collect2.
160 When we are going to build this function, collect all constructors and
161 destructors and turn them into normal functions. */
163 static void
164 record_cdtor_fn (tree fndecl)
166 struct cgraph_node *node;
167 if (targetm.have_ctors_dtors
168 || (!DECL_STATIC_CONSTRUCTOR (fndecl)
169 && !DECL_STATIC_DESTRUCTOR (fndecl)))
170 return;
172 if (DECL_STATIC_CONSTRUCTOR (fndecl))
174 VEC_safe_push (tree, gc, static_ctors, fndecl);
175 DECL_STATIC_CONSTRUCTOR (fndecl) = 0;
177 if (DECL_STATIC_DESTRUCTOR (fndecl))
179 VEC_safe_push (tree, gc, static_dtors, fndecl);
180 DECL_STATIC_DESTRUCTOR (fndecl) = 0;
182 node = cgraph_node (fndecl);
183 node->local.disregard_inline_limits = 1;
184 cgraph_mark_reachable_node (node);
187 /* Define global constructors/destructor functions for the CDTORS, of
188 which they are LEN. The CDTORS are sorted by initialization
189 priority. If CTOR_P is true, these are constructors; otherwise,
190 they are destructors. */
192 static void
193 build_cdtor (bool ctor_p, tree *cdtors, size_t len)
195 size_t i;
197 i = 0;
198 while (i < len)
200 tree body;
201 tree fn;
202 priority_type priority;
204 priority = 0;
205 body = NULL_TREE;
206 /* Find the next batch of constructors/destructors with the same
207 initialization priority. */
210 priority_type p;
211 fn = cdtors[i];
212 p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn);
213 if (!body)
214 priority = p;
215 else if (p != priority)
216 break;
217 append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION,
218 fn, 0),
219 &body);
220 ++i;
222 while (i < len);
223 gcc_assert (body != NULL_TREE);
224 /* Generate a function to call all the function of like
225 priority. */
226 cgraph_build_static_cdtor (ctor_p ? 'I' : 'D', body, priority);
230 /* Comparison function for qsort. P1 and P2 are actually of type
231 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
232 used to determine the sort order. */
234 static int
235 compare_ctor (const void *p1, const void *p2)
237 tree f1;
238 tree f2;
239 int priority1;
240 int priority2;
242 f1 = *(const tree *)p1;
243 f2 = *(const tree *)p2;
244 priority1 = DECL_INIT_PRIORITY (f1);
245 priority2 = DECL_INIT_PRIORITY (f2);
247 if (priority1 < priority2)
248 return -1;
249 else if (priority1 > priority2)
250 return 1;
251 else
252 /* Ensure a stable sort. */
253 return (const tree *)p1 - (const tree *)p2;
256 /* Comparison function for qsort. P1 and P2 are actually of type
257 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
258 used to determine the sort order. */
260 static int
261 compare_dtor (const void *p1, const void *p2)
263 tree f1;
264 tree f2;
265 int priority1;
266 int priority2;
268 f1 = *(const tree *)p1;
269 f2 = *(const tree *)p2;
270 priority1 = DECL_FINI_PRIORITY (f1);
271 priority2 = DECL_FINI_PRIORITY (f2);
273 if (priority1 < priority2)
274 return -1;
275 else if (priority1 > priority2)
276 return 1;
277 else
278 /* Ensure a stable sort. */
279 return (const tree *)p1 - (const tree *)p2;
282 /* Generate functions to call static constructors and destructors
283 for targets that do not support .ctors/.dtors sections. These
284 functions have magic names which are detected by collect2. */
286 static void
287 cgraph_build_cdtor_fns (void)
289 if (!VEC_empty (tree, static_ctors))
291 gcc_assert (!targetm.have_ctors_dtors);
292 qsort (VEC_address (tree, static_ctors),
293 VEC_length (tree, static_ctors),
294 sizeof (tree),
295 compare_ctor);
296 build_cdtor (/*ctor_p=*/true,
297 VEC_address (tree, static_ctors),
298 VEC_length (tree, static_ctors));
299 VEC_truncate (tree, static_ctors, 0);
302 if (!VEC_empty (tree, static_dtors))
304 gcc_assert (!targetm.have_ctors_dtors);
305 qsort (VEC_address (tree, static_dtors),
306 VEC_length (tree, static_dtors),
307 sizeof (tree),
308 compare_dtor);
309 build_cdtor (/*ctor_p=*/false,
310 VEC_address (tree, static_dtors),
311 VEC_length (tree, static_dtors));
312 VEC_truncate (tree, static_dtors, 0);
316 /* Determine if function DECL is needed. That is, visible to something
317 either outside this translation unit, something magic in the system
318 configury. */
320 bool
321 cgraph_decide_is_function_needed (struct cgraph_node *node, tree decl)
323 /* If the user told us it is used, then it must be so. */
324 if (node->local.externally_visible)
325 return true;
327 /* ??? If the assembler name is set by hand, it is possible to assemble
328 the name later after finalizing the function and the fact is noticed
329 in assemble_name then. This is arguably a bug. */
330 if (DECL_ASSEMBLER_NAME_SET_P (decl)
331 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
332 return true;
334 /* With -fkeep-inline-functions we are keeping all inline functions except
335 for extern inline ones. */
336 if (flag_keep_inline_functions
337 && DECL_DECLARED_INLINE_P (decl)
338 && !DECL_EXTERNAL (decl)
339 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl)))
340 return true;
342 /* If we decided it was needed before, but at the time we didn't have
343 the body of the function available, then it's still needed. We have
344 to go back and re-check its dependencies now. */
345 if (node->needed)
346 return true;
348 /* Externally visible functions must be output. The exception is
349 COMDAT functions that must be output only when they are needed.
351 When not optimizing, also output the static functions. (see
352 PR24561), but don't do so for always_inline functions, functions
353 declared inline and nested functions. These was optimized out
354 in the original implementation and it is unclear whether we want
355 to change the behavior here. */
356 if (((TREE_PUBLIC (decl)
357 || (!optimize && !node->local.disregard_inline_limits
358 && !DECL_DECLARED_INLINE_P (decl)
359 && !node->origin))
360 && !flag_whole_program
361 && !flag_lto
362 && !flag_whopr)
363 && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
364 return true;
366 /* Constructors and destructors are reachable from the runtime by
367 some mechanism. */
368 if (DECL_STATIC_CONSTRUCTOR (decl) || DECL_STATIC_DESTRUCTOR (decl))
369 return true;
371 return false;
374 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
375 functions into callgraph in a way so they look like ordinary reachable
376 functions inserted into callgraph already at construction time. */
378 bool
379 cgraph_process_new_functions (void)
381 bool output = false;
382 tree fndecl;
383 struct cgraph_node *node;
385 /* Note that this queue may grow as its being processed, as the new
386 functions may generate new ones. */
387 while (cgraph_new_nodes)
389 node = cgraph_new_nodes;
390 fndecl = node->decl;
391 cgraph_new_nodes = cgraph_new_nodes->next_needed;
392 switch (cgraph_state)
394 case CGRAPH_STATE_CONSTRUCTION:
395 /* At construction time we just need to finalize function and move
396 it into reachable functions list. */
398 node->next_needed = NULL;
399 cgraph_finalize_function (fndecl, false);
400 cgraph_mark_reachable_node (node);
401 output = true;
402 break;
404 case CGRAPH_STATE_IPA:
405 case CGRAPH_STATE_IPA_SSA:
406 /* When IPA optimization already started, do all essential
407 transformations that has been already performed on the whole
408 cgraph but not on this function. */
410 gimple_register_cfg_hooks ();
411 if (!node->analyzed)
412 cgraph_analyze_function (node);
413 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
414 current_function_decl = fndecl;
415 compute_inline_parameters (node);
416 if ((cgraph_state == CGRAPH_STATE_IPA_SSA
417 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
418 /* When not optimizing, be sure we run early local passes anyway
419 to expand OMP. */
420 || !optimize)
421 execute_pass_list (pass_early_local_passes.pass.sub);
422 free_dominance_info (CDI_POST_DOMINATORS);
423 free_dominance_info (CDI_DOMINATORS);
424 pop_cfun ();
425 current_function_decl = NULL;
426 break;
428 case CGRAPH_STATE_EXPANSION:
429 /* Functions created during expansion shall be compiled
430 directly. */
431 node->process = 0;
432 cgraph_expand_function (node);
433 break;
435 default:
436 gcc_unreachable ();
437 break;
439 cgraph_call_function_insertion_hooks (node);
441 return output;
444 /* As an GCC extension we allow redefinition of the function. The
445 semantics when both copies of bodies differ is not well defined.
446 We replace the old body with new body so in unit at a time mode
447 we always use new body, while in normal mode we may end up with
448 old body inlined into some functions and new body expanded and
449 inlined in others.
451 ??? It may make more sense to use one body for inlining and other
452 body for expanding the function but this is difficult to do. */
454 static void
455 cgraph_reset_node (struct cgraph_node *node)
457 /* If node->process is set, then we have already begun whole-unit analysis.
458 This is *not* testing for whether we've already emitted the function.
459 That case can be sort-of legitimately seen with real function redefinition
460 errors. I would argue that the front end should never present us with
461 such a case, but don't enforce that for now. */
462 gcc_assert (!node->process);
464 /* Reset our data structures so we can analyze the function again. */
465 memset (&node->local, 0, sizeof (node->local));
466 memset (&node->global, 0, sizeof (node->global));
467 memset (&node->rtl, 0, sizeof (node->rtl));
468 node->analyzed = false;
469 node->local.redefined_extern_inline = true;
470 node->local.finalized = false;
472 cgraph_node_remove_callees (node);
474 /* We may need to re-queue the node for assembling in case
475 we already proceeded it and ignored as not needed or got
476 a re-declaration in IMA mode. */
477 if (node->reachable)
479 struct cgraph_node *n;
481 for (n = cgraph_nodes_queue; n; n = n->next_needed)
482 if (n == node)
483 break;
484 if (!n)
485 node->reachable = 0;
489 static void
490 cgraph_lower_function (struct cgraph_node *node)
492 if (node->lowered)
493 return;
495 if (node->nested)
496 lower_nested_functions (node->decl);
497 gcc_assert (!node->nested);
499 tree_lowering_passes (node->decl);
500 node->lowered = true;
503 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
504 logic in effect. If NESTED is true, then our caller cannot stand to have
505 the garbage collector run at the moment. We would need to either create
506 a new GC context, or just not compile right now. */
508 void
509 cgraph_finalize_function (tree decl, bool nested)
511 struct cgraph_node *node = cgraph_node (decl);
513 if (node->local.finalized)
514 cgraph_reset_node (node);
516 node->pid = cgraph_max_pid ++;
517 notice_global_symbol (decl);
518 node->local.finalized = true;
519 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
520 node->finalized_by_frontend = true;
521 record_cdtor_fn (node->decl);
523 if (cgraph_decide_is_function_needed (node, decl))
524 cgraph_mark_needed_node (node);
526 /* Since we reclaim unreachable nodes at the end of every language
527 level unit, we need to be conservative about possible entry points
528 there. */
529 if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl)))
530 cgraph_mark_reachable_node (node);
532 /* If we've not yet emitted decl, tell the debug info about it. */
533 if (!TREE_ASM_WRITTEN (decl))
534 (*debug_hooks->deferred_inline_function) (decl);
536 /* Possibly warn about unused parameters. */
537 if (warn_unused_parameter)
538 do_warn_unused_parameter (decl);
540 if (!nested)
541 ggc_collect ();
544 /* C99 extern inline keywords allow changing of declaration after function
545 has been finalized. We need to re-decide if we want to mark the function as
546 needed then. */
548 void
549 cgraph_mark_if_needed (tree decl)
551 struct cgraph_node *node = cgraph_node (decl);
552 if (node->local.finalized && cgraph_decide_is_function_needed (node, decl))
553 cgraph_mark_needed_node (node);
556 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
557 static bool
558 clone_of_p (struct cgraph_node *node, struct cgraph_node *node2)
560 while (node != node2 && node2)
561 node2 = node2->clone_of;
562 return node2 != NULL;
565 /* Verify cgraph nodes of given cgraph node. */
566 void
567 verify_cgraph_node (struct cgraph_node *node)
569 struct cgraph_edge *e;
570 struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
571 struct function *saved_cfun = cfun;
572 basic_block this_block;
573 gimple_stmt_iterator gsi;
574 bool error_found = false;
576 if (errorcount || sorrycount)
577 return;
579 timevar_push (TV_CGRAPH_VERIFY);
580 /* debug_generic_stmt needs correct cfun */
581 set_cfun (this_cfun);
582 for (e = node->callees; e; e = e->next_callee)
583 if (e->aux)
585 error ("aux field set for edge %s->%s",
586 identifier_to_locale (cgraph_node_name (e->caller)),
587 identifier_to_locale (cgraph_node_name (e->callee)));
588 error_found = true;
590 if (node->count < 0)
592 error ("Execution count is negative");
593 error_found = true;
595 if (node->global.inlined_to && node->local.externally_visible)
597 error ("Externally visible inline clone");
598 error_found = true;
600 if (node->global.inlined_to && node->address_taken)
602 error ("Inline clone with address taken");
603 error_found = true;
605 if (node->global.inlined_to && node->needed)
607 error ("Inline clone is needed");
608 error_found = true;
610 for (e = node->callers; e; e = e->next_caller)
612 if (e->count < 0)
614 error ("caller edge count is negative");
615 error_found = true;
617 if (e->frequency < 0)
619 error ("caller edge frequency is negative");
620 error_found = true;
622 if (e->frequency > CGRAPH_FREQ_MAX)
624 error ("caller edge frequency is too large");
625 error_found = true;
627 if (!e->inline_failed)
629 if (node->global.inlined_to
630 != (e->caller->global.inlined_to
631 ? e->caller->global.inlined_to : e->caller))
633 error ("inlined_to pointer is wrong");
634 error_found = true;
636 if (node->callers->next_caller)
638 error ("multiple inline callers");
639 error_found = true;
642 else
643 if (node->global.inlined_to)
645 error ("inlined_to pointer set for noninline callers");
646 error_found = true;
649 if (!node->callers && node->global.inlined_to)
651 error ("inlined_to pointer is set but no predecessors found");
652 error_found = true;
654 if (node->global.inlined_to == node)
656 error ("inlined_to pointer refers to itself");
657 error_found = true;
660 if (!cgraph_node (node->decl))
662 error ("node not found in cgraph_hash");
663 error_found = true;
666 if (node->clone_of)
668 struct cgraph_node *n;
669 for (n = node->clone_of->clones; n; n = n->next_sibling_clone)
670 if (n == node)
671 break;
672 if (!n)
674 error ("node has wrong clone_of");
675 error_found = true;
678 if (node->clones)
680 struct cgraph_node *n;
681 for (n = node->clones; n; n = n->next_sibling_clone)
682 if (n->clone_of != node)
683 break;
684 if (n)
686 error ("node has wrong clone list");
687 error_found = true;
690 if ((node->prev_sibling_clone || node->next_sibling_clone) && !node->clone_of)
692 error ("node is in clone list but it is not clone");
693 error_found = true;
695 if (!node->prev_sibling_clone && node->clone_of && node->clone_of->clones != node)
697 error ("node has wrong prev_clone pointer");
698 error_found = true;
700 if (node->prev_sibling_clone && node->prev_sibling_clone->next_sibling_clone != node)
702 error ("double linked list of clones corrupted");
703 error_found = true;
706 if (node->analyzed && gimple_has_body_p (node->decl)
707 && !TREE_ASM_WRITTEN (node->decl)
708 && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to)
709 && !flag_wpa)
711 if (this_cfun->cfg)
713 /* The nodes we're interested in are never shared, so walk
714 the tree ignoring duplicates. */
715 struct pointer_set_t *visited_nodes = pointer_set_create ();
716 /* Reach the trees by walking over the CFG, and note the
717 enclosing basic-blocks in the call edges. */
718 FOR_EACH_BB_FN (this_block, this_cfun)
719 for (gsi = gsi_start_bb (this_block);
720 !gsi_end_p (gsi);
721 gsi_next (&gsi))
723 gimple stmt = gsi_stmt (gsi);
724 tree decl;
725 if (is_gimple_call (stmt) && (decl = gimple_call_fndecl (stmt)))
727 struct cgraph_edge *e = cgraph_edge (node, stmt);
728 if (e)
730 if (e->aux)
732 error ("shared call_stmt:");
733 debug_gimple_stmt (stmt);
734 error_found = true;
736 if (!clone_of_p (cgraph_node (decl), e->callee)
737 && !e->callee->global.inlined_to)
739 error ("edge points to wrong declaration:");
740 debug_tree (e->callee->decl);
741 fprintf (stderr," Instead of:");
742 debug_tree (decl);
744 e->aux = (void *)1;
746 else
748 error ("missing callgraph edge for call stmt:");
749 debug_gimple_stmt (stmt);
750 error_found = true;
754 pointer_set_destroy (visited_nodes);
756 else
757 /* No CFG available?! */
758 gcc_unreachable ();
760 for (e = node->callees; e; e = e->next_callee)
762 if (!e->aux && !e->indirect_call)
764 error ("edge %s->%s has no corresponding call_stmt",
765 identifier_to_locale (cgraph_node_name (e->caller)),
766 identifier_to_locale (cgraph_node_name (e->callee)));
767 debug_gimple_stmt (e->call_stmt);
768 error_found = true;
770 e->aux = 0;
773 if (error_found)
775 dump_cgraph_node (stderr, node);
776 internal_error ("verify_cgraph_node failed");
778 set_cfun (saved_cfun);
779 timevar_pop (TV_CGRAPH_VERIFY);
782 /* Verify whole cgraph structure. */
783 void
784 verify_cgraph (void)
786 struct cgraph_node *node;
788 if (sorrycount || errorcount)
789 return;
791 for (node = cgraph_nodes; node; node = node->next)
792 verify_cgraph_node (node);
795 /* Output all asm statements we have stored up to be output. */
797 static void
798 cgraph_output_pending_asms (void)
800 struct cgraph_asm_node *can;
802 if (errorcount || sorrycount)
803 return;
805 for (can = cgraph_asm_nodes; can; can = can->next)
806 assemble_asm (can->asm_str);
807 cgraph_asm_nodes = NULL;
810 /* Analyze the function scheduled to be output. */
811 static void
812 cgraph_analyze_function (struct cgraph_node *node)
814 tree save = current_function_decl;
815 tree decl = node->decl;
817 current_function_decl = decl;
818 push_cfun (DECL_STRUCT_FUNCTION (decl));
820 /* Make sure to gimplify bodies only once. During analyzing a
821 function we lower it, which will require gimplified nested
822 functions, so we can end up here with an already gimplified
823 body. */
824 if (!gimple_body (decl))
825 gimplify_function_tree (decl);
826 dump_function (TDI_generic, decl);
828 cgraph_lower_function (node);
829 node->analyzed = true;
831 pop_cfun ();
832 current_function_decl = save;
835 /* Look for externally_visible and used attributes and mark cgraph nodes
836 accordingly.
838 We cannot mark the nodes at the point the attributes are processed (in
839 handle_*_attribute) because the copy of the declarations available at that
840 point may not be canonical. For example, in:
842 void f();
843 void f() __attribute__((used));
845 the declaration we see in handle_used_attribute will be the second
846 declaration -- but the front end will subsequently merge that declaration
847 with the original declaration and discard the second declaration.
849 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
851 void f() {}
852 void f() __attribute__((externally_visible));
854 is valid.
856 So, we walk the nodes at the end of the translation unit, applying the
857 attributes at that point. */
859 static void
860 process_function_and_variable_attributes (struct cgraph_node *first,
861 struct varpool_node *first_var)
863 struct cgraph_node *node;
864 struct varpool_node *vnode;
866 for (node = cgraph_nodes; node != first; node = node->next)
868 tree decl = node->decl;
869 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
871 mark_decl_referenced (decl);
872 if (node->local.finalized)
873 cgraph_mark_needed_node (node);
875 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
877 if (! TREE_PUBLIC (node->decl))
878 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
879 "%<externally_visible%>"
880 " attribute have effect only on public objects");
881 else if (node->local.finalized)
882 cgraph_mark_needed_node (node);
885 for (vnode = varpool_nodes; vnode != first_var; vnode = vnode->next)
887 tree decl = vnode->decl;
888 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
890 mark_decl_referenced (decl);
891 if (vnode->finalized)
892 varpool_mark_needed_node (vnode);
894 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
896 if (! TREE_PUBLIC (vnode->decl))
897 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
898 "%<externally_visible%>"
899 " attribute have effect only on public objects");
900 else if (vnode->finalized)
901 varpool_mark_needed_node (vnode);
906 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
907 each reachable functions) and build cgraph.
908 The function can be called multiple times after inserting new nodes
909 into beginning of queue. Just the new part of queue is re-scanned then. */
911 static void
912 cgraph_analyze_functions (void)
914 /* Keep track of already processed nodes when called multiple times for
915 intermodule optimization. */
916 static struct cgraph_node *first_analyzed;
917 struct cgraph_node *first_processed = first_analyzed;
918 static struct varpool_node *first_analyzed_var;
919 struct cgraph_node *node, *next;
921 process_function_and_variable_attributes (first_processed,
922 first_analyzed_var);
923 first_processed = cgraph_nodes;
924 first_analyzed_var = varpool_nodes;
925 varpool_analyze_pending_decls ();
926 if (cgraph_dump_file)
928 fprintf (cgraph_dump_file, "Initial entry points:");
929 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
930 if (node->needed)
931 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
932 fprintf (cgraph_dump_file, "\n");
934 cgraph_process_new_functions ();
936 /* Propagate reachability flag and lower representation of all reachable
937 functions. In the future, lowering will introduce new functions and
938 new entry points on the way (by template instantiation and virtual
939 method table generation for instance). */
940 while (cgraph_nodes_queue)
942 struct cgraph_edge *edge;
943 tree decl = cgraph_nodes_queue->decl;
945 node = cgraph_nodes_queue;
946 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
947 node->next_needed = NULL;
949 /* ??? It is possible to create extern inline function and later using
950 weak alias attribute to kill its body. See
951 gcc.c-torture/compile/20011119-1.c */
952 if (!DECL_STRUCT_FUNCTION (decl))
954 cgraph_reset_node (node);
955 continue;
958 if (!node->analyzed)
959 cgraph_analyze_function (node);
961 for (edge = node->callees; edge; edge = edge->next_callee)
962 if (!edge->callee->reachable)
963 cgraph_mark_reachable_node (edge->callee);
965 /* If decl is a clone of an abstract function, mark that abstract
966 function so that we don't release its body. The DECL_INITIAL() of that
967 abstract function declaration will be later needed to output debug info. */
968 if (DECL_ABSTRACT_ORIGIN (decl))
970 struct cgraph_node *origin_node = cgraph_node (DECL_ABSTRACT_ORIGIN (decl));
971 origin_node->abstract_and_needed = true;
974 /* We finalize local static variables during constructing callgraph
975 edges. Process their attributes too. */
976 process_function_and_variable_attributes (first_processed,
977 first_analyzed_var);
978 first_processed = cgraph_nodes;
979 first_analyzed_var = varpool_nodes;
980 varpool_analyze_pending_decls ();
981 cgraph_process_new_functions ();
984 /* Collect entry points to the unit. */
985 if (cgraph_dump_file)
987 fprintf (cgraph_dump_file, "Unit entry points:");
988 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
989 if (node->needed)
990 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
991 fprintf (cgraph_dump_file, "\n\nInitial ");
992 dump_cgraph (cgraph_dump_file);
995 if (cgraph_dump_file)
996 fprintf (cgraph_dump_file, "\nReclaiming functions:");
998 for (node = cgraph_nodes; node != first_analyzed; node = next)
1000 tree decl = node->decl;
1001 next = node->next;
1003 if (node->local.finalized && !gimple_has_body_p (decl))
1004 cgraph_reset_node (node);
1006 if (!node->reachable && gimple_has_body_p (decl))
1008 if (cgraph_dump_file)
1009 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1010 cgraph_remove_node (node);
1011 continue;
1013 else
1014 node->next_needed = NULL;
1015 gcc_assert (!node->local.finalized || gimple_has_body_p (decl));
1016 gcc_assert (node->analyzed == node->local.finalized);
1018 if (cgraph_dump_file)
1020 fprintf (cgraph_dump_file, "\n\nReclaimed ");
1021 dump_cgraph (cgraph_dump_file);
1023 first_analyzed = cgraph_nodes;
1024 ggc_collect ();
1028 /* Emit thunks for every node in the cgraph.
1029 FIXME: We really ought to emit thunks only for functions that are needed. */
1031 static void
1032 cgraph_emit_thunks (void)
1034 struct cgraph_node *n;
1036 for (n = cgraph_nodes; n; n = n->next)
1038 /* Only emit thunks on functions defined in this TU.
1039 Note that this may emit more thunks than strictly necessary.
1040 During optimization some nodes may disappear. It would be
1041 nice to only emit thunks only for the functions that will be
1042 emitted, but we cannot know that until the inliner and other
1043 IPA passes have run (see the sequencing of the call to
1044 cgraph_mark_functions_to_output in cgraph_optimize). */
1045 if (n->reachable
1046 && !DECL_EXTERNAL (n->decl))
1047 lang_hooks.callgraph.emit_associated_thunks (n->decl);
1052 /* Analyze the whole compilation unit once it is parsed completely. */
1054 void
1055 cgraph_finalize_compilation_unit (void)
1057 timevar_push (TV_CGRAPH);
1059 /* Do not skip analyzing the functions if there were errors, we
1060 miss diagnostics for following functions otherwise. */
1062 /* Emit size functions we didn't inline. */
1063 finalize_size_functions ();
1065 /* Call functions declared with the "constructor" or "destructor"
1066 attribute. */
1067 cgraph_build_cdtor_fns ();
1069 /* Mark alias targets necessary and emit diagnostics. */
1070 finish_aliases_1 ();
1072 if (!quiet_flag)
1074 fprintf (stderr, "\nAnalyzing compilation unit\n");
1075 fflush (stderr);
1078 /* Gimplify and lower all functions, compute reachability and
1079 remove unreachable nodes. */
1080 cgraph_analyze_functions ();
1082 /* Emit thunks for reachable nodes, if needed. */
1083 if (lang_hooks.callgraph.emit_associated_thunks)
1084 cgraph_emit_thunks ();
1086 /* Mark alias targets necessary and emit diagnostics. */
1087 finish_aliases_1 ();
1089 /* Gimplify and lower thunks. */
1090 cgraph_analyze_functions ();
1092 /* Finally drive the pass manager. */
1093 cgraph_optimize ();
1095 timevar_pop (TV_CGRAPH);
1099 /* Figure out what functions we want to assemble. */
1101 static void
1102 cgraph_mark_functions_to_output (void)
1104 struct cgraph_node *node;
1106 for (node = cgraph_nodes; node; node = node->next)
1108 tree decl = node->decl;
1109 struct cgraph_edge *e;
1111 gcc_assert (!node->process);
1113 for (e = node->callers; e; e = e->next_caller)
1114 if (e->inline_failed)
1115 break;
1117 /* We need to output all local functions that are used and not
1118 always inlined, as well as those that are reachable from
1119 outside the current compilation unit. */
1120 if (node->analyzed
1121 && !node->global.inlined_to
1122 && (node->needed
1123 || (e && node->reachable))
1124 && !TREE_ASM_WRITTEN (decl)
1125 && !DECL_EXTERNAL (decl))
1126 node->process = 1;
1127 else
1129 /* We should've reclaimed all functions that are not needed. */
1130 #ifdef ENABLE_CHECKING
1131 if (!node->global.inlined_to
1132 && gimple_has_body_p (decl)
1133 && !DECL_EXTERNAL (decl))
1135 dump_cgraph_node (stderr, node);
1136 internal_error ("failed to reclaim unneeded function");
1138 #endif
1139 gcc_assert (node->global.inlined_to
1140 || !gimple_has_body_p (decl)
1141 || DECL_EXTERNAL (decl));
1148 /* Expand function specified by NODE. */
1150 static void
1151 cgraph_expand_function (struct cgraph_node *node)
1153 tree decl = node->decl;
1155 /* We ought to not compile any inline clones. */
1156 gcc_assert (!node->global.inlined_to);
1158 announce_function (decl);
1159 node->process = 0;
1161 gcc_assert (node->lowered);
1163 /* Generate RTL for the body of DECL. */
1164 tree_rest_of_compilation (decl);
1166 /* Make sure that BE didn't give up on compiling. */
1167 gcc_assert (TREE_ASM_WRITTEN (decl));
1168 current_function_decl = NULL;
1169 gcc_assert (!cgraph_preserve_function_body_p (decl));
1170 cgraph_release_function_body (node);
1171 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1172 points to the dead function body. */
1173 cgraph_node_remove_callees (node);
1175 cgraph_function_flags_ready = true;
1178 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1180 bool
1181 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason)
1183 *reason = e->inline_failed;
1184 return !e->inline_failed;
1189 /* Expand all functions that must be output.
1191 Attempt to topologically sort the nodes so function is output when
1192 all called functions are already assembled to allow data to be
1193 propagated across the callgraph. Use a stack to get smaller distance
1194 between a function and its callees (later we may choose to use a more
1195 sophisticated algorithm for function reordering; we will likely want
1196 to use subsections to make the output functions appear in top-down
1197 order). */
1199 static void
1200 cgraph_expand_all_functions (void)
1202 struct cgraph_node *node;
1203 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1204 int order_pos, new_order_pos = 0;
1205 int i;
1207 order_pos = cgraph_postorder (order);
1208 gcc_assert (order_pos == cgraph_n_nodes);
1210 /* Garbage collector may remove inline clones we eliminate during
1211 optimization. So we must be sure to not reference them. */
1212 for (i = 0; i < order_pos; i++)
1213 if (order[i]->process)
1214 order[new_order_pos++] = order[i];
1216 for (i = new_order_pos - 1; i >= 0; i--)
1218 node = order[i];
1219 if (node->process)
1221 gcc_assert (node->reachable);
1222 node->process = 0;
1223 cgraph_expand_function (node);
1226 cgraph_process_new_functions ();
1228 free (order);
1232 /* This is used to sort the node types by the cgraph order number. */
1234 enum cgraph_order_sort_kind
1236 ORDER_UNDEFINED = 0,
1237 ORDER_FUNCTION,
1238 ORDER_VAR,
1239 ORDER_ASM
1242 struct cgraph_order_sort
1244 enum cgraph_order_sort_kind kind;
1245 union
1247 struct cgraph_node *f;
1248 struct varpool_node *v;
1249 struct cgraph_asm_node *a;
1250 } u;
1253 /* Output all functions, variables, and asm statements in the order
1254 according to their order fields, which is the order in which they
1255 appeared in the file. This implements -fno-toplevel-reorder. In
1256 this mode we may output functions and variables which don't really
1257 need to be output. */
1259 static void
1260 cgraph_output_in_order (void)
1262 int max;
1263 size_t size;
1264 struct cgraph_order_sort *nodes;
1265 int i;
1266 struct cgraph_node *pf;
1267 struct varpool_node *pv;
1268 struct cgraph_asm_node *pa;
1270 max = cgraph_order;
1271 size = max * sizeof (struct cgraph_order_sort);
1272 nodes = (struct cgraph_order_sort *) alloca (size);
1273 memset (nodes, 0, size);
1275 varpool_analyze_pending_decls ();
1277 for (pf = cgraph_nodes; pf; pf = pf->next)
1279 if (pf->process)
1281 i = pf->order;
1282 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1283 nodes[i].kind = ORDER_FUNCTION;
1284 nodes[i].u.f = pf;
1288 for (pv = varpool_nodes_queue; pv; pv = pv->next_needed)
1290 i = pv->order;
1291 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1292 nodes[i].kind = ORDER_VAR;
1293 nodes[i].u.v = pv;
1296 for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1298 i = pa->order;
1299 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1300 nodes[i].kind = ORDER_ASM;
1301 nodes[i].u.a = pa;
1304 /* In toplevel reorder mode we output all statics; mark them as needed. */
1305 for (i = 0; i < max; ++i)
1307 if (nodes[i].kind == ORDER_VAR)
1309 varpool_mark_needed_node (nodes[i].u.v);
1312 varpool_empty_needed_queue ();
1314 for (i = 0; i < max; ++i)
1316 switch (nodes[i].kind)
1318 case ORDER_FUNCTION:
1319 nodes[i].u.f->process = 0;
1320 cgraph_expand_function (nodes[i].u.f);
1321 break;
1323 case ORDER_VAR:
1324 varpool_assemble_decl (nodes[i].u.v);
1325 break;
1327 case ORDER_ASM:
1328 assemble_asm (nodes[i].u.a->asm_str);
1329 break;
1331 case ORDER_UNDEFINED:
1332 break;
1334 default:
1335 gcc_unreachable ();
1339 cgraph_asm_nodes = NULL;
1342 /* Return true when function body of DECL still needs to be kept around
1343 for later re-use. */
1344 bool
1345 cgraph_preserve_function_body_p (tree decl)
1347 struct cgraph_node *node;
1349 gcc_assert (cgraph_global_info_ready);
1350 /* Look if there is any clone around. */
1351 node = cgraph_node (decl);
1352 if (node->clones)
1353 return true;
1354 return false;
1358 /* Load function specific optimizations with parameters. */
1360 /* separate string into arguments. */
1361 static void
1362 ici_separate_arguments (const char *string, unsigned int *argc, char ***argv)
1364 const char *p;
1365 char c;
1366 char **args;
1367 unsigned int len;
1368 int i;
1370 /* Count number of args */
1371 p = string;
1372 c = *p;
1373 *argc = 1;
1374 while (c)
1376 if ((c == ' ' || c == '\t') && len)
1378 len = 0;
1379 ++*argc;
1381 else
1382 len = 1;
1383 c = *++p;
1385 if (len)
1386 ++*argc;
1388 args = (char **) xmalloc (sizeof(char *) * (*argc));
1389 *argv = args;
1390 args[0] = (char*)xmalloc(sizeof(char)); /* argv[0] unavailable */
1391 args[0][0]='\0';
1392 i = 1;
1393 p = string;
1394 c = *p;
1395 len = 0;
1396 while (c)
1398 if (c == ' ' || c == '\t')
1400 if (len)
1402 *(args + i) = (char *) xmalloc (sizeof(char) * (len + 1));
1403 strncpy (*(args + i), (p - len), len);
1404 args[i][len] = '\0';
1405 ++i;
1406 len = 0;
1409 else
1410 ++len;
1411 c = *++p;
1413 if (len)
1415 *(args + i) = (char *) xmalloc (sizeof(char) * (len + 1));
1416 strncpy (*(args + i), (p - len), len);
1417 args[i][len] = '\0';
1421 /* free arguments string. */
1422 static void
1423 ici_free_arguments (unsigned int argc, char **argv)
1425 unsigned int i;
1426 for (i = 0; i < argc; ++i)
1428 free (argv[i]);
1430 free (argv);
1435 /* load function specific option strings and save to function structures. */
1436 static void
1437 ici_load_function_specific_optimizations (void)
1439 static char *ici_function_spec_string;
1440 struct cgraph_node *node;
1441 struct function *old_cfun = cfun; /* Backup cfun. */
1442 for (node = cgraph_nodes; node; node = node->next)
1444 struct function *fun;
1445 tree fun_decl;
1447 fun = DECL_STRUCT_FUNCTION (node->decl);
1448 if (!fun)
1449 continue;
1450 set_cfun (fun);
1452 ici_function_spec_string = NULL;
1453 register_event_parameter ("function_spec_string",
1454 (void *) &ici_function_spec_string, EP_VOID);
1455 call_plugin_event ("function_spec_loader");
1456 unregister_event_parameter ("function_spec_string");
1457 if (!ici_function_spec_string)
1458 continue;
1460 fun_decl = fun->decl;
1461 if (TREE_CODE (fun_decl) == FUNCTION_DECL)
1463 unsigned int argc;
1464 char **argv;
1465 struct cl_optimization old_global_opts;
1466 tree old_function_opts;
1467 int saved_flag_strict_aliasing;
1468 int saved_flag_pcc_struct_return,
1469 saved_flag_omit_frame_pointer,
1470 saved_flag_asynchronous_unwind_tables;
1472 /* Save old global and function-specific optimizations. */
1473 cl_optimization_save (&old_global_opts);
1475 /* Store function-specific optimizations to global. */
1476 old_function_opts
1477 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fun_decl);
1478 if (old_function_opts)
1479 cl_optimization_restore (TREE_OPTIMIZATION (old_function_opts));
1481 /* Parse options string. */
1482 ici_separate_arguments (ici_function_spec_string, &argc, &argv);
1484 /* Save flags which should not be changed. */
1486 /* Change global optimizations with loaded
1487 function specific string */
1488 saved_flag_strict_aliasing = flag_strict_aliasing;
1489 saved_flag_omit_frame_pointer = flag_omit_frame_pointer;
1490 saved_flag_pcc_struct_return = flag_pcc_struct_return;
1491 saved_flag_asynchronous_unwind_tables = flag_asynchronous_unwind_tables;
1492 decode_options (argc, (const char **) argv);
1494 flag_strict_aliasing = saved_flag_strict_aliasing;
1495 flag_omit_frame_pointer = saved_flag_omit_frame_pointer;
1496 flag_asynchronous_unwind_tables = saved_flag_asynchronous_unwind_tables;
1497 flag_pcc_struct_return = saved_flag_pcc_struct_return;
1499 ici_free_arguments (argc, argv);
1500 argv = NULL;
1502 /* Restore saved flags. */
1504 /* Store global optimizations to function. */
1505 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fun_decl)
1506 = build_optimization_node ();
1508 /* Restore old global optmizations. */
1509 cl_optimization_restore (&old_global_opts);
1512 free (ici_function_spec_string);
1514 /* Restore cfun */
1515 set_cfun (old_cfun);
1519 static void
1520 ipa_passes (void)
1522 static int ici_ipa_passes_substitute_status;
1524 set_cfun (NULL);
1525 current_function_decl = NULL;
1526 gimple_register_cfg_hooks ();
1527 bitmap_obstack_initialize (NULL);
1529 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
1530 if ((invoke_plugin_va_callbacks
1531 (PLUGIN_ALL_IPA_PASSES_EXECUTION,
1532 "substitute_status", EP_SILENT, &ici_ipa_passes_substitute_status)
1533 != PLUGEVT_SUCCESS)
1534 || ici_ipa_passes_substitute_status == 0)
1536 if (!in_lto_p)
1537 execute_ipa_pass_list (all_small_ipa_passes);
1539 /* If pass_all_early_optimizations was not scheduled, the state of
1540 the cgraph will not be properly updated. Update it now. */
1541 if (cgraph_state < CGRAPH_STATE_IPA_SSA)
1542 cgraph_state = CGRAPH_STATE_IPA_SSA;
1544 if (!in_lto_p)
1546 /* Generate coverage variables and constructors. */
1547 coverage_finish ();
1549 /* Process new functions added. */
1550 set_cfun (NULL);
1551 current_function_decl = NULL;
1552 cgraph_process_new_functions ();
1554 execute_ipa_summary_passes
1555 ((struct ipa_opt_pass_d *) all_regular_ipa_passes);
1557 execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes);
1559 if (!in_lto_p)
1560 ipa_write_summaries ();
1562 if (!flag_ltrans)
1563 execute_ipa_pass_list (all_regular_ipa_passes);
1565 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
1567 bitmap_obstack_release (NULL);
1571 /* Perform simple optimizations based on callgraph. */
1573 void
1574 cgraph_optimize (void)
1576 if (errorcount || sorrycount)
1577 return;
1579 #ifdef ENABLE_CHECKING
1580 verify_cgraph ();
1581 #endif
1583 /* Frontend may output common variables after the unit has been finalized.
1584 It is safe to deal with them here as they are always zero initialized. */
1585 varpool_analyze_pending_decls ();
1587 timevar_push (TV_CGRAPHOPT);
1588 if (pre_ipa_mem_report)
1590 fprintf (stderr, "Memory consumption before IPA\n");
1591 dump_memory_report (false);
1593 if (!quiet_flag)
1594 fprintf (stderr, "Performing interprocedural optimizations\n");
1595 cgraph_state = CGRAPH_STATE_IPA;
1597 /* ICI: load and set function specific optimization with plugin. */
1598 ici_load_function_specific_optimizations ();
1600 /* Don't run the IPA passes if there was any error or sorry messages. */
1601 if (errorcount == 0 && sorrycount == 0)
1602 ipa_passes ();
1604 /* Do nothing else if any IPA pass found errors. */
1605 if (errorcount || sorrycount)
1607 timevar_pop (TV_CGRAPHOPT);
1608 return;
1611 /* This pass remove bodies of extern inline functions we never inlined.
1612 Do this later so other IPA passes see what is really going on. */
1613 cgraph_remove_unreachable_nodes (false, dump_file);
1614 cgraph_global_info_ready = true;
1615 if (cgraph_dump_file)
1617 fprintf (cgraph_dump_file, "Optimized ");
1618 dump_cgraph (cgraph_dump_file);
1619 dump_varpool (cgraph_dump_file);
1621 if (post_ipa_mem_report)
1623 fprintf (stderr, "Memory consumption after IPA\n");
1624 dump_memory_report (false);
1626 timevar_pop (TV_CGRAPHOPT);
1628 /* Output everything. */
1629 (*debug_hooks->assembly_start) ();
1630 if (!quiet_flag)
1631 fprintf (stderr, "Assembling functions:\n");
1632 #ifdef ENABLE_CHECKING
1633 verify_cgraph ();
1634 #endif
1636 cgraph_materialize_all_clones ();
1637 cgraph_mark_functions_to_output ();
1639 cgraph_state = CGRAPH_STATE_EXPANSION;
1640 if (!flag_toplevel_reorder)
1641 cgraph_output_in_order ();
1642 else
1644 cgraph_output_pending_asms ();
1646 cgraph_expand_all_functions ();
1647 varpool_remove_unreferenced_decls ();
1649 varpool_assemble_pending_decls ();
1651 cgraph_process_new_functions ();
1652 cgraph_state = CGRAPH_STATE_FINISHED;
1654 if (cgraph_dump_file)
1656 fprintf (cgraph_dump_file, "\nFinal ");
1657 dump_cgraph (cgraph_dump_file);
1659 #ifdef ENABLE_CHECKING
1660 verify_cgraph ();
1661 /* Double check that all inline clones are gone and that all
1662 function bodies have been released from memory. */
1663 if (!(sorrycount || errorcount))
1665 struct cgraph_node *node;
1666 bool error_found = false;
1668 for (node = cgraph_nodes; node; node = node->next)
1669 if (node->analyzed
1670 && (node->global.inlined_to
1671 || gimple_has_body_p (node->decl)))
1673 error_found = true;
1674 dump_cgraph_node (stderr, node);
1676 if (error_found)
1677 internal_error ("nodes with unreleased memory found");
1679 #endif
1683 /* Generate and emit a static constructor or destructor. WHICH must
1684 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1685 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1686 initialization priority for this constructor or destructor. */
1688 void
1689 cgraph_build_static_cdtor (char which, tree body, int priority)
1691 static int counter = 0;
1692 char which_buf[16];
1693 tree decl, name, resdecl;
1695 /* The priority is encoded in the constructor or destructor name.
1696 collect2 will sort the names and arrange that they are called at
1697 program startup. */
1698 sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
1699 name = get_file_function_name (which_buf);
1701 decl = build_decl (input_location, FUNCTION_DECL, name,
1702 build_function_type (void_type_node, void_list_node));
1703 current_function_decl = decl;
1705 resdecl = build_decl (input_location,
1706 RESULT_DECL, NULL_TREE, void_type_node);
1707 DECL_ARTIFICIAL (resdecl) = 1;
1708 DECL_RESULT (decl) = resdecl;
1709 DECL_CONTEXT (resdecl) = decl;
1711 allocate_struct_function (decl, false);
1713 TREE_STATIC (decl) = 1;
1714 TREE_USED (decl) = 1;
1715 DECL_ARTIFICIAL (decl) = 1;
1716 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1717 DECL_SAVED_TREE (decl) = body;
1718 TREE_PUBLIC (decl) = ! targetm.have_ctors_dtors;
1719 DECL_UNINLINABLE (decl) = 1;
1721 DECL_INITIAL (decl) = make_node (BLOCK);
1722 TREE_USED (DECL_INITIAL (decl)) = 1;
1724 DECL_SOURCE_LOCATION (decl) = input_location;
1725 cfun->function_end_locus = input_location;
1727 switch (which)
1729 case 'I':
1730 DECL_STATIC_CONSTRUCTOR (decl) = 1;
1731 decl_init_priority_insert (decl, priority);
1732 break;
1733 case 'D':
1734 DECL_STATIC_DESTRUCTOR (decl) = 1;
1735 decl_fini_priority_insert (decl, priority);
1736 break;
1737 default:
1738 gcc_unreachable ();
1741 gimplify_function_tree (decl);
1743 cgraph_add_new_function (decl, false);
1744 cgraph_mark_needed_node (cgraph_node (decl));
1745 set_cfun (NULL);
1748 void
1749 init_cgraph (void)
1751 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1754 /* The edges representing the callers of the NEW_VERSION node were
1755 fixed by cgraph_function_versioning (), now the call_expr in their
1756 respective tree code should be updated to call the NEW_VERSION. */
1758 static void
1759 update_call_expr (struct cgraph_node *new_version)
1761 struct cgraph_edge *e;
1763 gcc_assert (new_version);
1765 /* Update the call expr on the edges to call the new version. */
1766 for (e = new_version->callers; e; e = e->next_caller)
1768 struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
1769 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
1770 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
1775 /* Create a new cgraph node which is the new version of
1776 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1777 edges which should be redirected to point to
1778 NEW_VERSION. ALL the callees edges of OLD_VERSION
1779 are cloned to the new version node. Return the new
1780 version node. */
1782 static struct cgraph_node *
1783 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
1784 tree new_decl,
1785 VEC(cgraph_edge_p,heap) *redirect_callers)
1787 struct cgraph_node *new_version;
1788 struct cgraph_edge *e, *new_e;
1789 struct cgraph_edge *next_callee;
1790 unsigned i;
1792 gcc_assert (old_version);
1794 new_version = cgraph_node (new_decl);
1796 new_version->analyzed = true;
1797 new_version->local = old_version->local;
1798 new_version->global = old_version->global;
1799 new_version->rtl = new_version->rtl;
1800 new_version->reachable = true;
1801 new_version->count = old_version->count;
1803 /* Clone the old node callees. Recursive calls are
1804 also cloned. */
1805 for (e = old_version->callees;e; e=e->next_callee)
1807 new_e = cgraph_clone_edge (e, new_version, e->call_stmt,
1808 e->lto_stmt_uid, 0, e->frequency,
1809 e->loop_nest, true);
1810 new_e->count = e->count;
1812 /* Fix recursive calls.
1813 If OLD_VERSION has a recursive call after the
1814 previous edge cloning, the new version will have an edge
1815 pointing to the old version, which is wrong;
1816 Redirect it to point to the new version. */
1817 for (e = new_version->callees ; e; e = next_callee)
1819 next_callee = e->next_callee;
1820 if (e->callee == old_version)
1821 cgraph_redirect_edge_callee (e, new_version);
1823 if (!next_callee)
1824 break;
1826 for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
1828 /* Redirect calls to the old version node to point to its new
1829 version. */
1830 cgraph_redirect_edge_callee (e, new_version);
1833 return new_version;
1836 /* Perform function versioning.
1837 Function versioning includes copying of the tree and
1838 a callgraph update (creating a new cgraph node and updating
1839 its callees and callers).
1841 REDIRECT_CALLERS varray includes the edges to be redirected
1842 to the new version.
1844 TREE_MAP is a mapping of tree nodes we want to replace with
1845 new ones (according to results of prior analysis).
1846 OLD_VERSION_NODE is the node that is versioned.
1847 It returns the new version's cgraph node.
1848 ARGS_TO_SKIP lists arguments to be omitted from functions
1851 struct cgraph_node *
1852 cgraph_function_versioning (struct cgraph_node *old_version_node,
1853 VEC(cgraph_edge_p,heap) *redirect_callers,
1854 VEC (ipa_replace_map_p,gc)* tree_map,
1855 bitmap args_to_skip)
1857 tree old_decl = old_version_node->decl;
1858 struct cgraph_node *new_version_node = NULL;
1859 tree new_decl;
1861 if (!tree_versionable_function_p (old_decl))
1862 return NULL;
1864 /* Make a new FUNCTION_DECL tree node for the
1865 new version. */
1866 if (!args_to_skip)
1867 new_decl = copy_node (old_decl);
1868 else
1869 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
1871 /* Create the new version's call-graph node.
1872 and update the edges of the new node. */
1873 new_version_node =
1874 cgraph_copy_node_for_versioning (old_version_node, new_decl,
1875 redirect_callers);
1877 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1878 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip);
1880 /* Update the new version's properties.
1881 Make The new version visible only within this translation unit. Make sure
1882 that is not weak also.
1883 ??? We cannot use COMDAT linkage because there is no
1884 ABI support for this. */
1885 DECL_EXTERNAL (new_version_node->decl) = 0;
1886 DECL_COMDAT_GROUP (new_version_node->decl) = NULL_TREE;
1887 TREE_PUBLIC (new_version_node->decl) = 0;
1888 DECL_COMDAT (new_version_node->decl) = 0;
1889 DECL_WEAK (new_version_node->decl) = 0;
1890 DECL_VIRTUAL_P (new_version_node->decl) = 0;
1891 new_version_node->local.externally_visible = 0;
1892 new_version_node->local.local = 1;
1893 new_version_node->lowered = true;
1895 /* Update the call_expr on the edges to call the new version node. */
1896 update_call_expr (new_version_node);
1898 cgraph_call_function_insertion_hooks (new_version_node);
1899 return new_version_node;
1902 /* Produce separate function body for inline clones so the offline copy can be
1903 modified without affecting them. */
1904 struct cgraph_node *
1905 save_inline_function_body (struct cgraph_node *node)
1907 struct cgraph_node *first_clone, *n;
1909 gcc_assert (node == cgraph_node (node->decl));
1911 cgraph_lower_function (node);
1913 first_clone = node->clones;
1915 first_clone->decl = copy_node (node->decl);
1916 cgraph_insert_node_to_hashtable (first_clone);
1917 gcc_assert (first_clone == cgraph_node (first_clone->decl));
1918 if (first_clone->next_sibling_clone)
1920 for (n = first_clone->next_sibling_clone; n->next_sibling_clone; n = n->next_sibling_clone)
1921 n->clone_of = first_clone;
1922 n->clone_of = first_clone;
1923 n->next_sibling_clone = first_clone->clones;
1924 if (first_clone->clones)
1925 first_clone->clones->prev_sibling_clone = n;
1926 first_clone->clones = first_clone->next_sibling_clone;
1927 first_clone->next_sibling_clone->prev_sibling_clone = NULL;
1928 first_clone->next_sibling_clone = NULL;
1929 gcc_assert (!first_clone->prev_sibling_clone);
1931 first_clone->clone_of = NULL;
1932 node->clones = NULL;
1934 if (first_clone->clones)
1935 for (n = first_clone->clones; n != first_clone;)
1937 gcc_assert (n->decl == node->decl);
1938 n->decl = first_clone->decl;
1939 if (n->clones)
1940 n = n->clones;
1941 else if (n->next_sibling_clone)
1942 n = n->next_sibling_clone;
1943 else
1945 while (n != first_clone && !n->next_sibling_clone)
1946 n = n->clone_of;
1947 if (n != first_clone)
1948 n = n->next_sibling_clone;
1952 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1953 tree_function_versioning (node->decl, first_clone->decl, NULL, true, NULL);
1955 DECL_EXTERNAL (first_clone->decl) = 0;
1956 DECL_COMDAT_GROUP (first_clone->decl) = NULL_TREE;
1957 TREE_PUBLIC (first_clone->decl) = 0;
1958 DECL_COMDAT (first_clone->decl) = 0;
1959 VEC_free (ipa_opt_pass, heap,
1960 DECL_STRUCT_FUNCTION (first_clone->decl)->ipa_transforms_to_apply);
1961 DECL_STRUCT_FUNCTION (first_clone->decl)->ipa_transforms_to_apply = NULL;
1963 #ifdef ENABLE_CHECKING
1964 verify_cgraph_node (first_clone);
1965 #endif
1966 return first_clone;
1969 /* Given virtual clone, turn it into actual clone. */
1970 static void
1971 cgraph_materialize_clone (struct cgraph_node *node)
1973 bitmap_obstack_initialize (NULL);
1974 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1975 tree_function_versioning (node->clone_of->decl, node->decl,
1976 node->clone.tree_map, true,
1977 node->clone.args_to_skip);
1978 if (cgraph_dump_file)
1980 dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
1981 dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
1984 /* Function is no longer clone. */
1985 if (node->next_sibling_clone)
1986 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
1987 if (node->prev_sibling_clone)
1988 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
1989 else
1990 node->clone_of->clones = node->next_sibling_clone;
1991 node->next_sibling_clone = NULL;
1992 node->prev_sibling_clone = NULL;
1993 node->clone_of = NULL;
1994 bitmap_obstack_release (NULL);
1997 /* Once all functions from compilation unit are in memory, produce all clones
1998 and update all calls.
1999 We might also do this on demand if we don't want to bring all functions to
2000 memory prior compilation, but current WHOPR implementation does that and it is
2001 is bit easier to keep everything right in this order. */
2002 void
2003 cgraph_materialize_all_clones (void)
2005 struct cgraph_node *node;
2006 bool stabilized = false;
2008 if (cgraph_dump_file)
2009 fprintf (cgraph_dump_file, "Materializing clones\n");
2010 #ifdef ENABLE_CHECKING
2011 verify_cgraph ();
2012 #endif
2014 /* We can also do topological order, but number of iterations should be
2015 bounded by number of IPA passes since single IPA pass is probably not
2016 going to create clones of clones it created itself. */
2017 while (!stabilized)
2019 stabilized = true;
2020 for (node = cgraph_nodes; node; node = node->next)
2022 if (node->clone_of && node->decl != node->clone_of->decl
2023 && !gimple_has_body_p (node->decl))
2025 if (gimple_has_body_p (node->clone_of->decl))
2027 if (cgraph_dump_file)
2029 fprintf (cgraph_dump_file, "clonning %s to %s\n",
2030 cgraph_node_name (node->clone_of),
2031 cgraph_node_name (node));
2032 if (node->clone.tree_map)
2034 unsigned int i;
2035 fprintf (cgraph_dump_file, " replace map: ");
2036 for (i = 0; i < VEC_length (ipa_replace_map_p,
2037 node->clone.tree_map);
2038 i++)
2040 struct ipa_replace_map *replace_info;
2041 replace_info = VEC_index (ipa_replace_map_p,
2042 node->clone.tree_map,
2044 print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2045 fprintf (cgraph_dump_file, " -> ");
2046 print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2047 fprintf (cgraph_dump_file, "%s%s;",
2048 replace_info->replace_p ? "(replace)":"",
2049 replace_info->ref_p ? "(ref)":"");
2051 fprintf (cgraph_dump_file, "\n");
2053 if (node->clone.args_to_skip)
2055 fprintf (cgraph_dump_file, " args_to_skip: ");
2056 dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2058 if (node->clone.args_to_skip)
2060 fprintf (cgraph_dump_file, " combined_args_to_skip:");
2061 dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2064 cgraph_materialize_clone (node);
2066 else
2067 stabilized = false;
2071 if (cgraph_dump_file)
2072 fprintf (cgraph_dump_file, "Updating call sites\n");
2073 for (node = cgraph_nodes; node; node = node->next)
2074 if (node->analyzed && gimple_has_body_p (node->decl)
2075 && (!node->clone_of || node->clone_of->decl != node->decl))
2077 struct cgraph_edge *e;
2079 current_function_decl = node->decl;
2080 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2081 for (e = node->callees; e; e = e->next_callee)
2083 tree decl = gimple_call_fndecl (e->call_stmt);
2084 /* When function gets inlined, indirect inlining might've invented
2085 new edge for orginally indirect stmt. Since we are not
2086 preserving clones in the original form, we must not update here
2087 since other inline clones don't need to contain call to the same
2088 call. Inliner will do the substitution for us later. */
2089 if (decl && decl != e->callee->decl)
2091 gimple new_stmt;
2092 gimple_stmt_iterator gsi;
2094 if (cgraph_dump_file)
2096 fprintf (cgraph_dump_file, "updating call of %s in %s:",
2097 cgraph_node_name (node),
2098 cgraph_node_name (e->callee));
2099 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2102 if (e->callee->clone.combined_args_to_skip)
2103 new_stmt = gimple_call_copy_skip_args (e->call_stmt,
2104 e->callee->clone.combined_args_to_skip);
2105 else
2106 new_stmt = e->call_stmt;
2107 if (gimple_vdef (new_stmt)
2108 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2109 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2110 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2112 gsi = gsi_for_stmt (e->call_stmt);
2113 gsi_replace (&gsi, new_stmt, true);
2115 /* Update EH information too, just in case. */
2116 maybe_clean_or_replace_eh_stmt (e->call_stmt, new_stmt);
2118 cgraph_set_call_stmt_including_clones (node, e->call_stmt, new_stmt);
2120 if (cgraph_dump_file)
2122 fprintf (cgraph_dump_file, " updated to:");
2123 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2127 pop_cfun ();
2128 current_function_decl = NULL;
2129 #ifdef ENABLE_CHECKING
2130 verify_cgraph_node (node);
2131 #endif
2133 #ifdef ENABLE_CHECKING
2134 verify_cgraph ();
2135 #endif
2136 cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2139 #include "gt-cgraphunit.h"