1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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
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
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
38 - varpool_finalize_variable
40 This function has same behavior as the above but is used for static
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)
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. */
111 #include "coretypes.h"
115 #include "tree-flow.h"
116 #include "tree-inline.h"
117 #include "langhooks.h"
118 #include "pointer-set.h"
125 #include "diagnostic.h"
126 #include "tree-pretty-print.h"
127 #include "gimple-pretty-print.h"
132 #include "function.h"
133 #include "ipa-prop.h"
135 #include "tree-iterator.h"
136 #include "tree-pass.h"
137 #include "tree-dump.h"
139 #include "coverage.h"
142 static void cgraph_expand_all_functions (void);
143 static void cgraph_mark_functions_to_output (void);
144 static void cgraph_expand_function (struct cgraph_node
*);
145 static void cgraph_output_pending_asms (void);
146 static void cgraph_analyze_function (struct cgraph_node
*);
148 FILE *cgraph_dump_file
;
150 /* A vector of FUNCTION_DECLs declared as static constructors. */
151 static GTY (()) VEC(tree
, gc
) *static_ctors
;
152 /* A vector of FUNCTION_DECLs declared as static destructors. */
153 static GTY (()) VEC(tree
, gc
) *static_dtors
;
155 /* Used for vtable lookup in thunk adjusting. */
156 static GTY (()) tree vtable_entry_type
;
158 /* When target does not have ctors and dtors, we call all constructor
159 and destructor by special initialization/destruction function
160 recognized by collect2.
162 When we are going to build this function, collect all constructors and
163 destructors and turn them into normal functions. */
166 record_cdtor_fn (tree fndecl
)
168 struct cgraph_node
*node
;
169 if (targetm
.have_ctors_dtors
170 || (!DECL_STATIC_CONSTRUCTOR (fndecl
)
171 && !DECL_STATIC_DESTRUCTOR (fndecl
)))
174 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
176 VEC_safe_push (tree
, gc
, static_ctors
, fndecl
);
177 DECL_STATIC_CONSTRUCTOR (fndecl
) = 0;
179 if (DECL_STATIC_DESTRUCTOR (fndecl
))
181 VEC_safe_push (tree
, gc
, static_dtors
, fndecl
);
182 DECL_STATIC_DESTRUCTOR (fndecl
) = 0;
184 node
= cgraph_node (fndecl
);
185 node
->local
.disregard_inline_limits
= 1;
186 cgraph_mark_reachable_node (node
);
189 /* Define global constructors/destructor functions for the CDTORS, of
190 which they are LEN. The CDTORS are sorted by initialization
191 priority. If CTOR_P is true, these are constructors; otherwise,
192 they are destructors. */
195 build_cdtor (bool ctor_p
, tree
*cdtors
, size_t len
)
204 priority_type priority
;
208 /* Find the next batch of constructors/destructors with the same
209 initialization priority. */
214 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
217 else if (p
!= priority
)
219 append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION
,
225 gcc_assert (body
!= NULL_TREE
);
226 /* Generate a function to call all the function of like
228 cgraph_build_static_cdtor (ctor_p
? 'I' : 'D', body
, priority
);
232 /* Comparison function for qsort. P1 and P2 are actually of type
233 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
234 used to determine the sort order. */
237 compare_ctor (const void *p1
, const void *p2
)
244 f1
= *(const tree
*)p1
;
245 f2
= *(const tree
*)p2
;
246 priority1
= DECL_INIT_PRIORITY (f1
);
247 priority2
= DECL_INIT_PRIORITY (f2
);
249 if (priority1
< priority2
)
251 else if (priority1
> priority2
)
254 /* Ensure a stable sort. */
255 return (const tree
*)p1
- (const tree
*)p2
;
258 /* Comparison function for qsort. P1 and P2 are actually of type
259 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
260 used to determine the sort order. */
263 compare_dtor (const void *p1
, const void *p2
)
270 f1
= *(const tree
*)p1
;
271 f2
= *(const tree
*)p2
;
272 priority1
= DECL_FINI_PRIORITY (f1
);
273 priority2
= DECL_FINI_PRIORITY (f2
);
275 if (priority1
< priority2
)
277 else if (priority1
> priority2
)
280 /* Ensure a stable sort. */
281 return (const tree
*)p1
- (const tree
*)p2
;
284 /* Generate functions to call static constructors and destructors
285 for targets that do not support .ctors/.dtors sections. These
286 functions have magic names which are detected by collect2. */
289 cgraph_build_cdtor_fns (void)
291 if (!VEC_empty (tree
, static_ctors
))
293 gcc_assert (!targetm
.have_ctors_dtors
);
294 qsort (VEC_address (tree
, static_ctors
),
295 VEC_length (tree
, static_ctors
),
298 build_cdtor (/*ctor_p=*/true,
299 VEC_address (tree
, static_ctors
),
300 VEC_length (tree
, static_ctors
));
301 VEC_truncate (tree
, static_ctors
, 0);
304 if (!VEC_empty (tree
, static_dtors
))
306 gcc_assert (!targetm
.have_ctors_dtors
);
307 qsort (VEC_address (tree
, static_dtors
),
308 VEC_length (tree
, static_dtors
),
311 build_cdtor (/*ctor_p=*/false,
312 VEC_address (tree
, static_dtors
),
313 VEC_length (tree
, static_dtors
));
314 VEC_truncate (tree
, static_dtors
, 0);
318 /* Determine if function DECL is needed. That is, visible to something
319 either outside this translation unit, something magic in the system
323 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
325 /* If the user told us it is used, then it must be so. */
326 if (node
->local
.externally_visible
)
329 /* ??? If the assembler name is set by hand, it is possible to assemble
330 the name later after finalizing the function and the fact is noticed
331 in assemble_name then. This is arguably a bug. */
332 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
333 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
336 /* With -fkeep-inline-functions we are keeping all inline functions except
337 for extern inline ones. */
338 if (flag_keep_inline_functions
339 && DECL_DECLARED_INLINE_P (decl
)
340 && !DECL_EXTERNAL (decl
)
341 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
)))
344 /* If we decided it was needed before, but at the time we didn't have
345 the body of the function available, then it's still needed. We have
346 to go back and re-check its dependencies now. */
350 /* Externally visible functions must be output. The exception is
351 COMDAT functions that must be output only when they are needed.
353 When not optimizing, also output the static functions. (see
354 PR24561), but don't do so for always_inline functions, functions
355 declared inline and nested functions. These was optimized out
356 in the original implementation and it is unclear whether we want
357 to change the behavior here. */
358 if (((TREE_PUBLIC (decl
)
359 || (!optimize
&& !node
->local
.disregard_inline_limits
360 && !DECL_DECLARED_INLINE_P (decl
)
362 && !flag_whole_program
365 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
368 /* Constructors and destructors are reachable from the runtime by
370 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
376 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
377 functions into callgraph in a way so they look like ordinary reachable
378 functions inserted into callgraph already at construction time. */
381 cgraph_process_new_functions (void)
385 struct cgraph_node
*node
;
387 varpool_analyze_pending_decls ();
388 /* Note that this queue may grow as its being processed, as the new
389 functions may generate new ones. */
390 while (cgraph_new_nodes
)
392 node
= cgraph_new_nodes
;
394 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
395 switch (cgraph_state
)
397 case CGRAPH_STATE_CONSTRUCTION
:
398 /* At construction time we just need to finalize function and move
399 it into reachable functions list. */
401 node
->next_needed
= NULL
;
402 cgraph_finalize_function (fndecl
, false);
403 cgraph_mark_reachable_node (node
);
407 case CGRAPH_STATE_IPA
:
408 case CGRAPH_STATE_IPA_SSA
:
409 /* When IPA optimization already started, do all essential
410 transformations that has been already performed on the whole
411 cgraph but not on this function. */
413 gimple_register_cfg_hooks ();
415 cgraph_analyze_function (node
);
416 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
417 current_function_decl
= fndecl
;
418 compute_inline_parameters (node
);
419 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
420 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
421 /* When not optimizing, be sure we run early local passes anyway
424 execute_pass_list (pass_early_local_passes
.pass
.sub
);
425 free_dominance_info (CDI_POST_DOMINATORS
);
426 free_dominance_info (CDI_DOMINATORS
);
428 current_function_decl
= NULL
;
431 case CGRAPH_STATE_EXPANSION
:
432 /* Functions created during expansion shall be compiled
435 cgraph_expand_function (node
);
442 cgraph_call_function_insertion_hooks (node
);
443 varpool_analyze_pending_decls ();
448 /* As an GCC extension we allow redefinition of the function. The
449 semantics when both copies of bodies differ is not well defined.
450 We replace the old body with new body so in unit at a time mode
451 we always use new body, while in normal mode we may end up with
452 old body inlined into some functions and new body expanded and
455 ??? It may make more sense to use one body for inlining and other
456 body for expanding the function but this is difficult to do. */
459 cgraph_reset_node (struct cgraph_node
*node
)
461 /* If node->process is set, then we have already begun whole-unit analysis.
462 This is *not* testing for whether we've already emitted the function.
463 That case can be sort-of legitimately seen with real function redefinition
464 errors. I would argue that the front end should never present us with
465 such a case, but don't enforce that for now. */
466 gcc_assert (!node
->process
);
468 /* Reset our data structures so we can analyze the function again. */
469 memset (&node
->local
, 0, sizeof (node
->local
));
470 memset (&node
->global
, 0, sizeof (node
->global
));
471 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
472 node
->analyzed
= false;
473 node
->local
.redefined_extern_inline
= true;
474 node
->local
.finalized
= false;
476 cgraph_node_remove_callees (node
);
478 /* We may need to re-queue the node for assembling in case
479 we already proceeded it and ignored as not needed or got
480 a re-declaration in IMA mode. */
483 struct cgraph_node
*n
;
485 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
494 cgraph_lower_function (struct cgraph_node
*node
)
500 lower_nested_functions (node
->decl
);
501 gcc_assert (!node
->nested
);
503 tree_lowering_passes (node
->decl
);
504 node
->lowered
= true;
507 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
508 logic in effect. If NESTED is true, then our caller cannot stand to have
509 the garbage collector run at the moment. We would need to either create
510 a new GC context, or just not compile right now. */
513 cgraph_finalize_function (tree decl
, bool nested
)
515 struct cgraph_node
*node
= cgraph_node (decl
);
517 if (node
->local
.finalized
)
518 cgraph_reset_node (node
);
520 node
->pid
= cgraph_max_pid
++;
521 notice_global_symbol (decl
);
522 node
->local
.finalized
= true;
523 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
524 node
->finalized_by_frontend
= true;
525 record_cdtor_fn (node
->decl
);
527 if (cgraph_decide_is_function_needed (node
, decl
))
528 cgraph_mark_needed_node (node
);
530 /* Since we reclaim unreachable nodes at the end of every language
531 level unit, we need to be conservative about possible entry points
533 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
534 cgraph_mark_reachable_node (node
);
536 /* If we've not yet emitted decl, tell the debug info about it. */
537 if (!TREE_ASM_WRITTEN (decl
))
538 (*debug_hooks
->deferred_inline_function
) (decl
);
540 /* Possibly warn about unused parameters. */
541 if (warn_unused_parameter
)
542 do_warn_unused_parameter (decl
);
548 /* C99 extern inline keywords allow changing of declaration after function
549 has been finalized. We need to re-decide if we want to mark the function as
553 cgraph_mark_if_needed (tree decl
)
555 struct cgraph_node
*node
= cgraph_node (decl
);
556 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
557 cgraph_mark_needed_node (node
);
560 #ifdef ENABLE_CHECKING
561 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
563 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
565 while (node
!= node2
&& node2
)
566 node2
= node2
->clone_of
;
567 return node2
!= NULL
;
571 /* Verify cgraph nodes of given cgraph node. */
573 verify_cgraph_node (struct cgraph_node
*node
)
575 struct cgraph_edge
*e
;
576 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
577 struct function
*saved_cfun
= cfun
;
578 basic_block this_block
;
579 gimple_stmt_iterator gsi
;
580 bool error_found
= false;
585 timevar_push (TV_CGRAPH_VERIFY
);
586 /* debug_generic_stmt needs correct cfun */
587 set_cfun (this_cfun
);
588 for (e
= node
->callees
; e
; e
= e
->next_callee
)
591 error ("aux field set for edge %s->%s",
592 identifier_to_locale (cgraph_node_name (e
->caller
)),
593 identifier_to_locale (cgraph_node_name (e
->callee
)));
598 error ("Execution count is negative");
601 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
603 error ("Externally visible inline clone");
606 if (node
->global
.inlined_to
&& node
->address_taken
)
608 error ("Inline clone with address taken");
611 if (node
->global
.inlined_to
&& node
->needed
)
613 error ("Inline clone is needed");
616 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
620 error ("aux field set for indirect edge from %s",
621 identifier_to_locale (cgraph_node_name (e
->caller
)));
624 if (!e
->indirect_unknown_callee
625 || !e
->indirect_info
)
627 error ("An indirect edge from %s is not marked as indirect or has "
628 "associated indirect_info, the corresponding statement is: ",
629 identifier_to_locale (cgraph_node_name (e
->caller
)));
630 debug_gimple_stmt (e
->call_stmt
);
634 for (e
= node
->callers
; e
; e
= e
->next_caller
)
638 error ("caller edge count is negative");
641 if (e
->frequency
< 0)
643 error ("caller edge frequency is negative");
646 if (e
->frequency
> CGRAPH_FREQ_MAX
)
648 error ("caller edge frequency is too large");
651 if (gimple_has_body_p (e
->caller
->decl
)
652 && !e
->caller
->global
.inlined_to
654 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
655 gimple_bb (e
->call_stmt
))))
657 error ("caller edge frequency %i does not match BB freqency %i",
659 compute_call_stmt_bb_frequency (e
->caller
->decl
,
660 gimple_bb (e
->call_stmt
)));
663 if (!e
->inline_failed
)
665 if (node
->global
.inlined_to
666 != (e
->caller
->global
.inlined_to
667 ? e
->caller
->global
.inlined_to
: e
->caller
))
669 error ("inlined_to pointer is wrong");
672 if (node
->callers
->next_caller
)
674 error ("multiple inline callers");
679 if (node
->global
.inlined_to
)
681 error ("inlined_to pointer set for noninline callers");
685 if (!node
->callers
&& node
->global
.inlined_to
)
687 error ("inlined_to pointer is set but no predecessors found");
690 if (node
->global
.inlined_to
== node
)
692 error ("inlined_to pointer refers to itself");
696 if (!cgraph_node (node
->decl
))
698 error ("node not found in cgraph_hash");
704 struct cgraph_node
*n
;
705 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
710 error ("node has wrong clone_of");
716 struct cgraph_node
*n
;
717 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
718 if (n
->clone_of
!= node
)
722 error ("node has wrong clone list");
726 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
728 error ("node is in clone list but it is not clone");
731 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
733 error ("node has wrong prev_clone pointer");
736 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
738 error ("double linked list of clones corrupted");
741 if (node
->same_comdat_group
)
743 struct cgraph_node
*n
= node
->same_comdat_group
;
745 if (!DECL_ONE_ONLY (node
->decl
))
747 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
752 error ("node is alone in a comdat group");
757 if (!n
->same_comdat_group
)
759 error ("same_comdat_group is not a circular list");
763 n
= n
->same_comdat_group
;
768 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
769 && !TREE_ASM_WRITTEN (node
->decl
)
770 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
775 /* The nodes we're interested in are never shared, so walk
776 the tree ignoring duplicates. */
777 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
778 /* Reach the trees by walking over the CFG, and note the
779 enclosing basic-blocks in the call edges. */
780 FOR_EACH_BB_FN (this_block
, this_cfun
)
781 for (gsi
= gsi_start_bb (this_block
);
785 gimple stmt
= gsi_stmt (gsi
);
786 if (is_gimple_call (stmt
))
788 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
789 tree decl
= gimple_call_fndecl (stmt
);
794 error ("shared call_stmt:");
795 debug_gimple_stmt (stmt
);
798 if (!e
->indirect_unknown_callee
)
800 if (e
->callee
->same_body_alias
)
802 error ("edge points to same body alias:");
803 debug_tree (e
->callee
->decl
);
806 #ifdef ENABLE_CHECKING
807 else if (!e
->callee
->global
.inlined_to
809 && cgraph_get_node (decl
)
810 && (e
->callee
->former_clone_of
811 != cgraph_get_node (decl
)->decl
)
812 && !clone_of_p (cgraph_node (decl
),
815 error ("edge points to wrong declaration:");
816 debug_tree (e
->callee
->decl
);
817 fprintf (stderr
," Instead of:");
825 error ("an indirect edge with unknown callee "
826 "corresponding to a call_stmt with "
827 "a known declaration:");
829 debug_gimple_stmt (e
->call_stmt
);
835 error ("missing callgraph edge for call stmt:");
836 debug_gimple_stmt (stmt
);
841 pointer_set_destroy (visited_nodes
);
844 /* No CFG available?! */
847 for (e
= node
->callees
; e
; e
= e
->next_callee
)
851 error ("edge %s->%s has no corresponding call_stmt",
852 identifier_to_locale (cgraph_node_name (e
->caller
)),
853 identifier_to_locale (cgraph_node_name (e
->callee
)));
854 debug_gimple_stmt (e
->call_stmt
);
859 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
863 error ("an indirect edge from %s has no corresponding call_stmt",
864 identifier_to_locale (cgraph_node_name (e
->caller
)));
865 debug_gimple_stmt (e
->call_stmt
);
873 dump_cgraph_node (stderr
, node
);
874 internal_error ("verify_cgraph_node failed");
876 set_cfun (saved_cfun
);
877 timevar_pop (TV_CGRAPH_VERIFY
);
880 /* Verify whole cgraph structure. */
884 struct cgraph_node
*node
;
889 for (node
= cgraph_nodes
; node
; node
= node
->next
)
890 verify_cgraph_node (node
);
893 /* Output all asm statements we have stored up to be output. */
896 cgraph_output_pending_asms (void)
898 struct cgraph_asm_node
*can
;
903 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
904 assemble_asm (can
->asm_str
);
905 cgraph_asm_nodes
= NULL
;
908 /* Analyze the function scheduled to be output. */
910 cgraph_analyze_function (struct cgraph_node
*node
)
912 tree save
= current_function_decl
;
913 tree decl
= node
->decl
;
915 current_function_decl
= decl
;
916 push_cfun (DECL_STRUCT_FUNCTION (decl
));
918 assign_assembler_name_if_neeeded (node
->decl
);
920 /* Make sure to gimplify bodies only once. During analyzing a
921 function we lower it, which will require gimplified nested
922 functions, so we can end up here with an already gimplified
924 if (!gimple_body (decl
))
925 gimplify_function_tree (decl
);
926 dump_function (TDI_generic
, decl
);
928 cgraph_lower_function (node
);
929 node
->analyzed
= true;
932 current_function_decl
= save
;
935 /* Look for externally_visible and used attributes and mark cgraph nodes
938 We cannot mark the nodes at the point the attributes are processed (in
939 handle_*_attribute) because the copy of the declarations available at that
940 point may not be canonical. For example, in:
943 void f() __attribute__((used));
945 the declaration we see in handle_used_attribute will be the second
946 declaration -- but the front end will subsequently merge that declaration
947 with the original declaration and discard the second declaration.
949 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
952 void f() __attribute__((externally_visible));
956 So, we walk the nodes at the end of the translation unit, applying the
957 attributes at that point. */
960 process_function_and_variable_attributes (struct cgraph_node
*first
,
961 struct varpool_node
*first_var
)
963 struct cgraph_node
*node
;
964 struct varpool_node
*vnode
;
966 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
968 tree decl
= node
->decl
;
969 if (DECL_PRESERVE_P (decl
))
970 cgraph_mark_needed_node (node
);
971 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
973 if (! TREE_PUBLIC (node
->decl
))
974 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
975 "%<externally_visible%>"
976 " attribute have effect only on public objects");
977 else if (node
->local
.finalized
)
978 cgraph_mark_needed_node (node
);
981 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
983 tree decl
= vnode
->decl
;
984 if (DECL_PRESERVE_P (decl
))
986 vnode
->force_output
= true;
987 if (vnode
->finalized
)
988 varpool_mark_needed_node (vnode
);
990 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
992 if (! TREE_PUBLIC (vnode
->decl
))
993 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
994 "%<externally_visible%>"
995 " attribute have effect only on public objects");
996 else if (vnode
->finalized
)
997 varpool_mark_needed_node (vnode
);
1002 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
1003 each reachable functions) and build cgraph.
1004 The function can be called multiple times after inserting new nodes
1005 into beginning of queue. Just the new part of queue is re-scanned then. */
1008 cgraph_analyze_functions (void)
1010 /* Keep track of already processed nodes when called multiple times for
1011 intermodule optimization. */
1012 static struct cgraph_node
*first_analyzed
;
1013 struct cgraph_node
*first_processed
= first_analyzed
;
1014 static struct varpool_node
*first_analyzed_var
;
1015 struct cgraph_node
*node
, *next
;
1017 process_function_and_variable_attributes (first_processed
,
1018 first_analyzed_var
);
1019 first_processed
= cgraph_nodes
;
1020 first_analyzed_var
= varpool_nodes
;
1021 varpool_analyze_pending_decls ();
1022 if (cgraph_dump_file
)
1024 fprintf (cgraph_dump_file
, "Initial entry points:");
1025 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1027 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1028 fprintf (cgraph_dump_file
, "\n");
1030 cgraph_process_new_functions ();
1032 /* Propagate reachability flag and lower representation of all reachable
1033 functions. In the future, lowering will introduce new functions and
1034 new entry points on the way (by template instantiation and virtual
1035 method table generation for instance). */
1036 while (cgraph_nodes_queue
)
1038 struct cgraph_edge
*edge
;
1039 tree decl
= cgraph_nodes_queue
->decl
;
1041 node
= cgraph_nodes_queue
;
1042 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
1043 node
->next_needed
= NULL
;
1045 /* ??? It is possible to create extern inline function and later using
1046 weak alias attribute to kill its body. See
1047 gcc.c-torture/compile/20011119-1.c */
1048 if (!DECL_STRUCT_FUNCTION (decl
))
1050 cgraph_reset_node (node
);
1054 if (!node
->analyzed
)
1055 cgraph_analyze_function (node
);
1057 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1058 if (!edge
->callee
->reachable
)
1059 cgraph_mark_reachable_node (edge
->callee
);
1061 if (node
->same_comdat_group
)
1063 for (next
= node
->same_comdat_group
;
1065 next
= next
->same_comdat_group
)
1066 cgraph_mark_reachable_node (next
);
1069 /* If decl is a clone of an abstract function, mark that abstract
1070 function so that we don't release its body. The DECL_INITIAL() of that
1071 abstract function declaration will be later needed to output debug info. */
1072 if (DECL_ABSTRACT_ORIGIN (decl
))
1074 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
1075 origin_node
->abstract_and_needed
= true;
1078 /* We finalize local static variables during constructing callgraph
1079 edges. Process their attributes too. */
1080 process_function_and_variable_attributes (first_processed
,
1081 first_analyzed_var
);
1082 first_processed
= cgraph_nodes
;
1083 first_analyzed_var
= varpool_nodes
;
1084 varpool_analyze_pending_decls ();
1085 cgraph_process_new_functions ();
1088 /* Collect entry points to the unit. */
1089 if (cgraph_dump_file
)
1091 fprintf (cgraph_dump_file
, "Unit entry points:");
1092 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1094 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1095 fprintf (cgraph_dump_file
, "\n\nInitial ");
1096 dump_cgraph (cgraph_dump_file
);
1099 if (cgraph_dump_file
)
1100 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1102 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1104 tree decl
= node
->decl
;
1107 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
1108 cgraph_reset_node (node
);
1110 if (!node
->reachable
&& gimple_has_body_p (decl
))
1112 if (cgraph_dump_file
)
1113 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1114 cgraph_remove_node (node
);
1118 node
->next_needed
= NULL
;
1119 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
1120 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1122 if (cgraph_dump_file
)
1124 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1125 dump_cgraph (cgraph_dump_file
);
1127 first_analyzed
= cgraph_nodes
;
1132 /* Analyze the whole compilation unit once it is parsed completely. */
1135 cgraph_finalize_compilation_unit (void)
1137 timevar_push (TV_CGRAPH
);
1139 /* Do not skip analyzing the functions if there were errors, we
1140 miss diagnostics for following functions otherwise. */
1142 /* Emit size functions we didn't inline. */
1143 finalize_size_functions ();
1145 /* Call functions declared with the "constructor" or "destructor"
1147 cgraph_build_cdtor_fns ();
1149 /* Mark alias targets necessary and emit diagnostics. */
1150 finish_aliases_1 ();
1154 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1158 /* Gimplify and lower all functions, compute reachability and
1159 remove unreachable nodes. */
1160 cgraph_analyze_functions ();
1162 /* Mark alias targets necessary and emit diagnostics. */
1163 finish_aliases_1 ();
1165 /* Gimplify and lower thunks. */
1166 cgraph_analyze_functions ();
1168 /* Finally drive the pass manager. */
1171 timevar_pop (TV_CGRAPH
);
1175 /* Figure out what functions we want to assemble. */
1178 cgraph_mark_functions_to_output (void)
1180 struct cgraph_node
*node
;
1181 #ifdef ENABLE_CHECKING
1182 bool check_same_comdat_groups
= false;
1184 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1185 gcc_assert (!node
->process
);
1188 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1190 tree decl
= node
->decl
;
1191 struct cgraph_edge
*e
;
1193 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1197 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1198 if (e
->inline_failed
)
1201 /* We need to output all local functions that are used and not
1202 always inlined, as well as those that are reachable from
1203 outside the current compilation unit. */
1205 && !node
->global
.inlined_to
1206 && (node
->needed
|| node
->reachable_from_other_partition
1207 || node
->address_taken
1208 || (e
&& node
->reachable
))
1209 && !TREE_ASM_WRITTEN (decl
)
1210 && !DECL_EXTERNAL (decl
))
1213 if (node
->same_comdat_group
)
1215 struct cgraph_node
*next
;
1216 for (next
= node
->same_comdat_group
;
1218 next
= next
->same_comdat_group
)
1222 else if (node
->same_comdat_group
)
1224 #ifdef ENABLE_CHECKING
1225 check_same_comdat_groups
= true;
1230 /* We should've reclaimed all functions that are not needed. */
1231 #ifdef ENABLE_CHECKING
1232 if (!node
->global
.inlined_to
1233 && gimple_has_body_p (decl
)
1234 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1235 are inside partition, we can end up not removing the body since we no longer
1236 have analyzed node pointing to it. */
1237 && !node
->in_other_partition
1238 && !DECL_EXTERNAL (decl
))
1240 dump_cgraph_node (stderr
, node
);
1241 internal_error ("failed to reclaim unneeded function");
1244 gcc_assert (node
->global
.inlined_to
1245 || !gimple_has_body_p (decl
)
1246 || node
->in_other_partition
1247 || DECL_EXTERNAL (decl
));
1252 #ifdef ENABLE_CHECKING
1253 if (check_same_comdat_groups
)
1254 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1255 if (node
->same_comdat_group
&& !node
->process
)
1257 tree decl
= node
->decl
;
1258 if (!node
->global
.inlined_to
1259 && gimple_has_body_p (decl
)
1260 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1261 are inside partition, we can end up not removing the body since we no longer
1262 have analyzed node pointing to it. */
1263 && !node
->in_other_partition
1264 && !DECL_EXTERNAL (decl
))
1266 dump_cgraph_node (stderr
, node
);
1267 internal_error ("failed to reclaim unneeded function");
1273 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1274 in lowered gimple form.
1276 Set current_function_decl and cfun to newly constructed empty function body.
1277 return basic block in the function body. */
1280 init_lowered_empty_function (tree decl
)
1284 current_function_decl
= decl
;
1285 allocate_struct_function (decl
, false);
1286 gimple_register_cfg_hooks ();
1287 init_empty_tree_cfg ();
1288 init_tree_ssa (cfun
);
1289 init_ssa_operands ();
1290 cfun
->gimple_df
->in_ssa_p
= true;
1291 DECL_INITIAL (decl
) = make_node (BLOCK
);
1293 DECL_SAVED_TREE (decl
) = error_mark_node
;
1294 cfun
->curr_properties
|=
1295 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1298 /* Create BB for body of the function and connect it properly. */
1299 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1300 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1301 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1306 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1307 offset indicated by VIRTUAL_OFFSET, if that is
1308 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1309 zero for a result adjusting thunk. */
1312 thunk_adjust (gimple_stmt_iterator
* bsi
,
1313 tree ptr
, bool this_adjusting
,
1314 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1320 && fixed_offset
!= 0)
1322 stmt
= gimple_build_assign (ptr
,
1323 fold_build2_loc (input_location
,
1325 TREE_TYPE (ptr
), ptr
,
1326 size_int (fixed_offset
)));
1327 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1330 /* If there's a virtual offset, look up that value in the vtable and
1331 adjust the pointer again. */
1339 if (!vtable_entry_type
)
1341 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1342 TREE_TYPE (vfunc_type
) = integer_type_node
;
1343 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1344 layout_type (vfunc_type
);
1346 vtable_entry_type
= build_pointer_type (vfunc_type
);
1350 create_tmp_var (build_pointer_type
1351 (build_pointer_type (vtable_entry_type
)), "vptr");
1353 /* The vptr is always at offset zero in the object. */
1354 stmt
= gimple_build_assign (vtabletmp
,
1355 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1357 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1358 mark_symbols_for_renaming (stmt
);
1359 find_referenced_vars_in (stmt
);
1361 /* Form the vtable address. */
1362 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1364 stmt
= gimple_build_assign (vtabletmp2
,
1365 build1 (INDIRECT_REF
,
1366 TREE_TYPE (vtabletmp2
), vtabletmp
));
1367 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1368 mark_symbols_for_renaming (stmt
);
1369 find_referenced_vars_in (stmt
);
1371 /* Find the entry with the vcall offset. */
1372 stmt
= gimple_build_assign (vtabletmp2
,
1373 fold_build2_loc (input_location
,
1375 TREE_TYPE (vtabletmp2
),
1377 fold_convert (sizetype
,
1379 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1381 /* Get the offset itself. */
1382 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1384 stmt
= gimple_build_assign (vtabletmp3
,
1385 build1 (INDIRECT_REF
,
1386 TREE_TYPE (vtabletmp3
),
1388 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1389 mark_symbols_for_renaming (stmt
);
1390 find_referenced_vars_in (stmt
);
1392 /* Cast to sizetype. */
1393 offsettmp
= create_tmp_var (sizetype
, "offset");
1394 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1395 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1396 mark_symbols_for_renaming (stmt
);
1397 find_referenced_vars_in (stmt
);
1399 /* Adjust the `this' pointer. */
1400 ptr
= fold_build2_loc (input_location
,
1401 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1406 && fixed_offset
!= 0)
1407 /* Adjust the pointer by the constant. */
1411 if (TREE_CODE (ptr
) == VAR_DECL
)
1415 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1416 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1417 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1418 mark_symbols_for_renaming (stmt
);
1419 find_referenced_vars_in (stmt
);
1421 ptr
= fold_build2_loc (input_location
,
1422 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1423 size_int (fixed_offset
));
1426 /* Emit the statement and gimplify the adjustment expression. */
1427 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1428 stmt
= gimple_build_assign (ret
, ptr
);
1429 mark_symbols_for_renaming (stmt
);
1430 find_referenced_vars_in (stmt
);
1431 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1436 /* Produce assembler for thunk NODE. */
1439 assemble_thunk (struct cgraph_node
*node
)
1441 bool this_adjusting
= node
->thunk
.this_adjusting
;
1442 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1443 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1444 tree virtual_offset
= NULL
;
1445 tree alias
= node
->thunk
.alias
;
1446 tree thunk_fndecl
= node
->decl
;
1447 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1449 current_function_decl
= thunk_fndecl
;
1452 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1453 virtual_value
, alias
))
1458 DECL_RESULT (thunk_fndecl
)
1459 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1460 RESULT_DECL
, 0, integer_type_node
);
1461 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1463 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1465 fn_block
= make_node (BLOCK
);
1466 BLOCK_VARS (fn_block
) = a
;
1467 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1468 init_function_start (thunk_fndecl
);
1470 assemble_start_function (thunk_fndecl
, fnname
);
1472 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1473 fixed_offset
, virtual_value
, alias
);
1475 assemble_end_function (thunk_fndecl
, fnname
);
1476 init_insn_lengths ();
1477 free_after_compilation (cfun
);
1479 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1484 basic_block bb
, then_bb
, else_bb
, return_bb
;
1485 gimple_stmt_iterator bsi
;
1491 VEC(tree
, heap
) *vargs
;
1496 DECL_IGNORED_P (thunk_fndecl
) = 1;
1497 bitmap_obstack_initialize (NULL
);
1499 if (node
->thunk
.virtual_offset_p
)
1500 virtual_offset
= size_int (virtual_value
);
1502 /* Build the return declaration for the function. */
1503 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1504 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1506 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1507 DECL_ARTIFICIAL (resdecl
) = 1;
1508 DECL_IGNORED_P (resdecl
) = 1;
1509 DECL_RESULT (thunk_fndecl
) = resdecl
;
1512 resdecl
= DECL_RESULT (thunk_fndecl
);
1514 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1516 bsi
= gsi_start_bb (bb
);
1518 /* Build call to the function being thunked. */
1519 if (!VOID_TYPE_P (restype
))
1521 if (!is_gimple_reg_type (restype
))
1524 cfun
->local_decls
= tree_cons (NULL_TREE
, restmp
, cfun
->local_decls
);
1525 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1528 restmp
= create_tmp_var_raw (restype
, "retval");
1531 for (arg
= a
; arg
; arg
= TREE_CHAIN (arg
))
1533 vargs
= VEC_alloc (tree
, heap
, nargs
);
1535 VEC_quick_push (tree
, vargs
,
1540 VEC_quick_push (tree
, vargs
, a
);
1541 for (i
= 1, arg
= TREE_CHAIN (a
); i
< nargs
; i
++, arg
= TREE_CHAIN (arg
))
1542 VEC_quick_push (tree
, vargs
, arg
);
1543 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1544 VEC_free (tree
, heap
, vargs
);
1545 gimple_call_set_cannot_inline (call
, true);
1546 gimple_call_set_from_thunk (call
, true);
1548 gimple_call_set_lhs (call
, restmp
);
1549 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1550 mark_symbols_for_renaming (call
);
1551 find_referenced_vars_in (call
);
1554 if (restmp
&& !this_adjusting
)
1556 tree true_label
= NULL_TREE
;
1558 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1561 /* If the return type is a pointer, we need to
1562 protect against NULL. We know there will be an
1563 adjustment, because that's why we're emitting a
1565 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1566 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1567 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1568 remove_edge (single_succ_edge (bb
));
1569 true_label
= gimple_block_label (then_bb
);
1570 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1571 fold_convert (TREE_TYPE (restmp
),
1573 NULL_TREE
, NULL_TREE
);
1574 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1575 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1576 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1577 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1578 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1579 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1580 bsi
= gsi_last_bb (then_bb
);
1583 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1584 fixed_offset
, virtual_offset
);
1588 bsi
= gsi_last_bb (else_bb
);
1589 stmt
= gimple_build_assign (restmp
, fold_convert (TREE_TYPE (restmp
),
1590 integer_zero_node
));
1591 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1592 bsi
= gsi_last_bb (return_bb
);
1596 gimple_call_set_tail (call
, true);
1598 /* Build return value. */
1599 ret
= gimple_build_return (restmp
);
1600 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1602 delete_unreachable_blocks ();
1603 update_ssa (TODO_update_ssa
);
1605 cgraph_remove_same_body_alias (node
);
1606 /* Since we want to emit the thunk, we explicitly mark its name as
1608 cgraph_add_new_function (thunk_fndecl
, true);
1609 bitmap_obstack_release (NULL
);
1611 current_function_decl
= NULL
;
1614 /* Expand function specified by NODE. */
1617 cgraph_expand_function (struct cgraph_node
*node
)
1619 tree decl
= node
->decl
;
1621 /* We ought to not compile any inline clones. */
1622 gcc_assert (!node
->global
.inlined_to
);
1624 announce_function (decl
);
1627 gcc_assert (node
->lowered
);
1629 /* Generate RTL for the body of DECL. */
1630 tree_rest_of_compilation (decl
);
1632 /* Make sure that BE didn't give up on compiling. */
1633 gcc_assert (TREE_ASM_WRITTEN (decl
));
1634 current_function_decl
= NULL
;
1635 if (node
->same_body
)
1637 struct cgraph_node
*alias
, *next
;
1638 bool saved_alias
= node
->alias
;
1639 for (alias
= node
->same_body
;
1640 alias
&& alias
->next
; alias
= alias
->next
)
1642 /* Walk aliases in the order they were created; it is possible that
1643 thunks reffers to the aliases made earlier. */
1644 for (; alias
; alias
= next
)
1646 next
= alias
->previous
;
1647 if (!alias
->thunk
.thunk_p
)
1648 assemble_alias (alias
->decl
,
1649 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1651 assemble_thunk (alias
);
1653 node
->alias
= saved_alias
;
1655 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1656 cgraph_release_function_body (node
);
1657 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1658 points to the dead function body. */
1659 cgraph_node_remove_callees (node
);
1661 cgraph_function_flags_ready
= true;
1664 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1667 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1669 *reason
= e
->inline_failed
;
1670 return !e
->inline_failed
;
1675 /* Expand all functions that must be output.
1677 Attempt to topologically sort the nodes so function is output when
1678 all called functions are already assembled to allow data to be
1679 propagated across the callgraph. Use a stack to get smaller distance
1680 between a function and its callees (later we may choose to use a more
1681 sophisticated algorithm for function reordering; we will likely want
1682 to use subsections to make the output functions appear in top-down
1686 cgraph_expand_all_functions (void)
1688 struct cgraph_node
*node
;
1689 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1690 int order_pos
, new_order_pos
= 0;
1693 order_pos
= cgraph_postorder (order
);
1694 gcc_assert (order_pos
== cgraph_n_nodes
);
1696 /* Garbage collector may remove inline clones we eliminate during
1697 optimization. So we must be sure to not reference them. */
1698 for (i
= 0; i
< order_pos
; i
++)
1699 if (order
[i
]->process
)
1700 order
[new_order_pos
++] = order
[i
];
1702 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1707 gcc_assert (node
->reachable
);
1709 cgraph_expand_function (node
);
1712 cgraph_process_new_functions ();
1718 /* This is used to sort the node types by the cgraph order number. */
1720 enum cgraph_order_sort_kind
1722 ORDER_UNDEFINED
= 0,
1728 struct cgraph_order_sort
1730 enum cgraph_order_sort_kind kind
;
1733 struct cgraph_node
*f
;
1734 struct varpool_node
*v
;
1735 struct cgraph_asm_node
*a
;
1739 /* Output all functions, variables, and asm statements in the order
1740 according to their order fields, which is the order in which they
1741 appeared in the file. This implements -fno-toplevel-reorder. In
1742 this mode we may output functions and variables which don't really
1743 need to be output. */
1746 cgraph_output_in_order (void)
1749 struct cgraph_order_sort
*nodes
;
1751 struct cgraph_node
*pf
;
1752 struct varpool_node
*pv
;
1753 struct cgraph_asm_node
*pa
;
1756 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1758 varpool_analyze_pending_decls ();
1760 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1765 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1766 nodes
[i
].kind
= ORDER_FUNCTION
;
1771 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1774 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1775 nodes
[i
].kind
= ORDER_VAR
;
1779 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1782 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1783 nodes
[i
].kind
= ORDER_ASM
;
1787 /* In toplevel reorder mode we output all statics; mark them as needed. */
1788 for (i
= 0; i
< max
; ++i
)
1790 if (nodes
[i
].kind
== ORDER_VAR
)
1792 varpool_mark_needed_node (nodes
[i
].u
.v
);
1795 varpool_empty_needed_queue ();
1797 for (i
= 0; i
< max
; ++i
)
1799 switch (nodes
[i
].kind
)
1801 case ORDER_FUNCTION
:
1802 nodes
[i
].u
.f
->process
= 0;
1803 cgraph_expand_function (nodes
[i
].u
.f
);
1807 varpool_assemble_decl (nodes
[i
].u
.v
);
1811 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1814 case ORDER_UNDEFINED
:
1822 cgraph_asm_nodes
= NULL
;
1826 /* Return true when function body of DECL still needs to be kept around
1827 for later re-use. */
1829 cgraph_preserve_function_body_p (tree decl
)
1831 struct cgraph_node
*node
;
1833 gcc_assert (cgraph_global_info_ready
);
1834 /* Look if there is any clone around. */
1835 node
= cgraph_node (decl
);
1845 current_function_decl
= NULL
;
1846 gimple_register_cfg_hooks ();
1847 bitmap_obstack_initialize (NULL
);
1849 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1852 execute_ipa_pass_list (all_small_ipa_passes
);
1854 /* If pass_all_early_optimizations was not scheduled, the state of
1855 the cgraph will not be properly updated. Update it now. */
1856 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1857 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1861 /* Generate coverage variables and constructors. */
1864 /* Process new functions added. */
1866 current_function_decl
= NULL
;
1867 cgraph_process_new_functions ();
1869 execute_ipa_summary_passes
1870 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1873 /* Some targets need to handle LTO assembler output specially. */
1874 if (flag_generate_lto
)
1875 targetm
.asm_out
.lto_start ();
1877 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1880 ipa_write_summaries ();
1882 if (flag_generate_lto
)
1883 targetm
.asm_out
.lto_end ();
1886 execute_ipa_pass_list (all_regular_ipa_passes
);
1887 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1889 bitmap_obstack_release (NULL
);
1893 /* Perform simple optimizations based on callgraph. */
1896 cgraph_optimize (void)
1901 #ifdef ENABLE_CHECKING
1905 /* Frontend may output common variables after the unit has been finalized.
1906 It is safe to deal with them here as they are always zero initialized. */
1907 varpool_analyze_pending_decls ();
1909 timevar_push (TV_CGRAPHOPT
);
1910 if (pre_ipa_mem_report
)
1912 fprintf (stderr
, "Memory consumption before IPA\n");
1913 dump_memory_report (false);
1916 fprintf (stderr
, "Performing interprocedural optimizations\n");
1917 cgraph_state
= CGRAPH_STATE_IPA
;
1919 /* Don't run the IPA passes if there was any error or sorry messages. */
1923 /* Do nothing else if any IPA pass found errors. */
1926 timevar_pop (TV_CGRAPHOPT
);
1930 /* This pass remove bodies of extern inline functions we never inlined.
1931 Do this later so other IPA passes see what is really going on. */
1932 cgraph_remove_unreachable_nodes (false, dump_file
);
1933 cgraph_global_info_ready
= true;
1934 if (cgraph_dump_file
)
1936 fprintf (cgraph_dump_file
, "Optimized ");
1937 dump_cgraph (cgraph_dump_file
);
1938 dump_varpool (cgraph_dump_file
);
1940 if (post_ipa_mem_report
)
1942 fprintf (stderr
, "Memory consumption after IPA\n");
1943 dump_memory_report (false);
1945 timevar_pop (TV_CGRAPHOPT
);
1947 /* Output everything. */
1948 (*debug_hooks
->assembly_start
) ();
1950 fprintf (stderr
, "Assembling functions:\n");
1951 #ifdef ENABLE_CHECKING
1955 cgraph_materialize_all_clones ();
1956 cgraph_mark_functions_to_output ();
1958 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1959 if (!flag_toplevel_reorder
)
1960 cgraph_output_in_order ();
1963 cgraph_output_pending_asms ();
1965 cgraph_expand_all_functions ();
1966 varpool_remove_unreferenced_decls ();
1968 varpool_assemble_pending_decls ();
1970 cgraph_process_new_functions ();
1971 cgraph_state
= CGRAPH_STATE_FINISHED
;
1973 if (cgraph_dump_file
)
1975 fprintf (cgraph_dump_file
, "\nFinal ");
1976 dump_cgraph (cgraph_dump_file
);
1978 #ifdef ENABLE_CHECKING
1980 /* Double check that all inline clones are gone and that all
1981 function bodies have been released from memory. */
1984 struct cgraph_node
*node
;
1985 bool error_found
= false;
1987 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1989 && (node
->global
.inlined_to
1990 || gimple_has_body_p (node
->decl
)))
1993 dump_cgraph_node (stderr
, node
);
1996 internal_error ("nodes with unreleased memory found");
2002 /* Generate and emit a static constructor or destructor. WHICH must
2003 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
2004 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
2005 initialization priority for this constructor or destructor. */
2008 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
2010 static int counter
= 0;
2012 tree decl
, name
, resdecl
;
2014 /* The priority is encoded in the constructor or destructor name.
2015 collect2 will sort the names and arrange that they are called at
2017 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
2018 name
= get_file_function_name (which_buf
);
2020 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
2021 build_function_type (void_type_node
, void_list_node
));
2022 current_function_decl
= decl
;
2024 resdecl
= build_decl (input_location
,
2025 RESULT_DECL
, NULL_TREE
, void_type_node
);
2026 DECL_ARTIFICIAL (resdecl
) = 1;
2027 DECL_RESULT (decl
) = resdecl
;
2028 DECL_CONTEXT (resdecl
) = decl
;
2030 allocate_struct_function (decl
, false);
2032 TREE_STATIC (decl
) = 1;
2033 TREE_USED (decl
) = 1;
2034 DECL_ARTIFICIAL (decl
) = 1;
2035 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
2036 DECL_SAVED_TREE (decl
) = body
;
2037 if (!targetm
.have_ctors_dtors
)
2039 TREE_PUBLIC (decl
) = 1;
2040 DECL_PRESERVE_P (decl
) = 1;
2042 DECL_UNINLINABLE (decl
) = 1;
2044 DECL_INITIAL (decl
) = make_node (BLOCK
);
2045 TREE_USED (DECL_INITIAL (decl
)) = 1;
2047 DECL_SOURCE_LOCATION (decl
) = input_location
;
2048 cfun
->function_end_locus
= input_location
;
2053 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
2054 decl_init_priority_insert (decl
, priority
);
2057 DECL_STATIC_DESTRUCTOR (decl
) = 1;
2058 decl_fini_priority_insert (decl
, priority
);
2064 gimplify_function_tree (decl
);
2066 cgraph_add_new_function (decl
, false);
2067 cgraph_mark_needed_node (cgraph_node (decl
));
2074 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
2077 /* The edges representing the callers of the NEW_VERSION node were
2078 fixed by cgraph_function_versioning (), now the call_expr in their
2079 respective tree code should be updated to call the NEW_VERSION. */
2082 update_call_expr (struct cgraph_node
*new_version
)
2084 struct cgraph_edge
*e
;
2086 gcc_assert (new_version
);
2088 /* Update the call expr on the edges to call the new version. */
2089 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
2091 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
2092 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
2093 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2098 /* Create a new cgraph node which is the new version of
2099 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2100 edges which should be redirected to point to
2101 NEW_VERSION. ALL the callees edges of OLD_VERSION
2102 are cloned to the new version node. Return the new
2105 static struct cgraph_node
*
2106 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2108 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
2110 struct cgraph_node
*new_version
;
2111 struct cgraph_edge
*e
;
2114 gcc_assert (old_version
);
2116 new_version
= cgraph_node (new_decl
);
2118 new_version
->analyzed
= true;
2119 new_version
->local
= old_version
->local
;
2120 new_version
->local
.externally_visible
= false;
2121 new_version
->local
.local
= true;
2122 new_version
->local
.vtable_method
= false;
2123 new_version
->global
= old_version
->global
;
2124 new_version
->rtl
= new_version
->rtl
;
2125 new_version
->reachable
= true;
2126 new_version
->count
= old_version
->count
;
2128 for (e
= old_version
->callees
; e
; e
=e
->next_callee
)
2129 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2130 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2132 e
->loop_nest
, true);
2133 for (e
= old_version
->indirect_calls
; e
; e
=e
->next_callee
)
2134 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2135 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2137 e
->loop_nest
, true);
2138 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
2140 /* Redirect calls to the old version node to point to its new
2142 cgraph_redirect_edge_callee (e
, new_version
);
2148 /* Perform function versioning.
2149 Function versioning includes copying of the tree and
2150 a callgraph update (creating a new cgraph node and updating
2151 its callees and callers).
2153 REDIRECT_CALLERS varray includes the edges to be redirected
2156 TREE_MAP is a mapping of tree nodes we want to replace with
2157 new ones (according to results of prior analysis).
2158 OLD_VERSION_NODE is the node that is versioned.
2159 It returns the new version's cgraph node.
2160 ARGS_TO_SKIP lists arguments to be omitted from functions
2163 struct cgraph_node
*
2164 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2165 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2166 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2167 bitmap args_to_skip
,
2168 const char *clone_name
)
2170 tree old_decl
= old_version_node
->decl
;
2171 struct cgraph_node
*new_version_node
= NULL
;
2174 if (!tree_versionable_function_p (old_decl
))
2177 /* Make a new FUNCTION_DECL tree node for the
2180 new_decl
= copy_node (old_decl
);
2182 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2184 cgraph_make_decl_local (new_decl
);
2185 /* Generate a new name for the new version. */
2186 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
2187 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
2188 SET_DECL_RTL (new_decl
, NULL
);
2190 /* Create the new version's call-graph node.
2191 and update the edges of the new node. */
2193 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2196 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2197 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
);
2199 /* Update the new version's properties.
2200 Make The new version visible only within this translation unit. Make sure
2201 that is not weak also.
2202 ??? We cannot use COMDAT linkage because there is no
2203 ABI support for this. */
2204 cgraph_make_decl_local (new_version_node
->decl
);
2205 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2206 new_version_node
->local
.externally_visible
= 0;
2207 new_version_node
->local
.local
= 1;
2208 new_version_node
->lowered
= true;
2210 /* Update the call_expr on the edges to call the new version node. */
2211 update_call_expr (new_version_node
);
2213 cgraph_call_function_insertion_hooks (new_version_node
);
2214 return new_version_node
;
2217 /* Produce separate function body for inline clones so the offline copy can be
2218 modified without affecting them. */
2219 struct cgraph_node
*
2220 save_inline_function_body (struct cgraph_node
*node
)
2222 struct cgraph_node
*first_clone
, *n
;
2224 gcc_assert (node
== cgraph_node (node
->decl
));
2226 cgraph_lower_function (node
);
2228 first_clone
= node
->clones
;
2230 first_clone
->decl
= copy_node (node
->decl
);
2231 cgraph_insert_node_to_hashtable (first_clone
);
2232 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
2233 if (first_clone
->next_sibling_clone
)
2235 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
2236 n
->clone_of
= first_clone
;
2237 n
->clone_of
= first_clone
;
2238 n
->next_sibling_clone
= first_clone
->clones
;
2239 if (first_clone
->clones
)
2240 first_clone
->clones
->prev_sibling_clone
= n
;
2241 first_clone
->clones
= first_clone
->next_sibling_clone
;
2242 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
2243 first_clone
->next_sibling_clone
= NULL
;
2244 gcc_assert (!first_clone
->prev_sibling_clone
);
2246 first_clone
->clone_of
= NULL
;
2247 node
->clones
= NULL
;
2249 if (first_clone
->clones
)
2250 for (n
= first_clone
->clones
; n
!= first_clone
;)
2252 gcc_assert (n
->decl
== node
->decl
);
2253 n
->decl
= first_clone
->decl
;
2256 else if (n
->next_sibling_clone
)
2257 n
= n
->next_sibling_clone
;
2260 while (n
!= first_clone
&& !n
->next_sibling_clone
)
2262 if (n
!= first_clone
)
2263 n
= n
->next_sibling_clone
;
2267 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2268 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
);
2270 DECL_EXTERNAL (first_clone
->decl
) = 0;
2271 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
2272 TREE_PUBLIC (first_clone
->decl
) = 0;
2273 DECL_COMDAT (first_clone
->decl
) = 0;
2274 VEC_free (ipa_opt_pass
, heap
,
2275 first_clone
->ipa_transforms_to_apply
);
2276 first_clone
->ipa_transforms_to_apply
= NULL
;
2278 #ifdef ENABLE_CHECKING
2279 verify_cgraph_node (first_clone
);
2284 /* Given virtual clone, turn it into actual clone. */
2286 cgraph_materialize_clone (struct cgraph_node
*node
)
2288 bitmap_obstack_initialize (NULL
);
2289 #ifdef ENABLE_CHECKING
2290 node
->former_clone_of
= node
->clone_of
->decl
;
2291 if (node
->clone_of
->former_clone_of
)
2292 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
2294 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2295 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2296 node
->clone
.tree_map
, true,
2297 node
->clone
.args_to_skip
);
2298 if (cgraph_dump_file
)
2300 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2301 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2304 /* Function is no longer clone. */
2305 if (node
->next_sibling_clone
)
2306 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2307 if (node
->prev_sibling_clone
)
2308 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2310 node
->clone_of
->clones
= node
->next_sibling_clone
;
2311 node
->next_sibling_clone
= NULL
;
2312 node
->prev_sibling_clone
= NULL
;
2313 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2315 cgraph_release_function_body (node
->clone_of
);
2316 cgraph_node_remove_callees (node
->clone_of
);
2317 ipa_remove_all_references (&node
->clone_of
->ref_list
);
2319 node
->clone_of
= NULL
;
2320 bitmap_obstack_release (NULL
);
2323 /* If necessary, change the function declaration in the call statement
2324 associated with E so that it corresponds to the edge callee. */
2327 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2329 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2331 gimple_stmt_iterator gsi
;
2333 if (!decl
|| decl
== e
->callee
->decl
2334 /* Don't update call from same body alias to the real function. */
2335 || cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
))
2336 return e
->call_stmt
;
2338 gcc_assert (!cgraph_node (decl
)->clone
.combined_args_to_skip
);
2340 if (cgraph_dump_file
)
2342 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2343 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2344 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2345 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2346 if (e
->callee
->clone
.combined_args_to_skip
)
2348 fprintf (cgraph_dump_file
, " combined args to skip: ");
2349 dump_bitmap (cgraph_dump_file
, e
->callee
->clone
.combined_args_to_skip
);
2353 if (e
->callee
->clone
.combined_args_to_skip
)
2354 new_stmt
= gimple_call_copy_skip_args (e
->call_stmt
,
2355 e
->callee
->clone
.combined_args_to_skip
);
2357 new_stmt
= e
->call_stmt
;
2358 if (gimple_vdef (new_stmt
)
2359 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2360 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2361 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2363 gsi
= gsi_for_stmt (e
->call_stmt
);
2364 gsi_replace (&gsi
, new_stmt
, true);
2365 update_stmt (new_stmt
);
2367 /* Update EH information too, just in case. */
2368 maybe_clean_or_replace_eh_stmt (e
->call_stmt
, new_stmt
);
2370 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2372 if (cgraph_dump_file
)
2374 fprintf (cgraph_dump_file
, " updated to:");
2375 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2380 /* Once all functions from compilation unit are in memory, produce all clones
2381 and update all calls. We might also do this on demand if we don't want to
2382 bring all functions to memory prior compilation, but current WHOPR
2383 implementation does that and it is is bit easier to keep everything right in
2386 cgraph_materialize_all_clones (void)
2388 struct cgraph_node
*node
;
2389 bool stabilized
= false;
2391 if (cgraph_dump_file
)
2392 fprintf (cgraph_dump_file
, "Materializing clones\n");
2393 #ifdef ENABLE_CHECKING
2397 /* We can also do topological order, but number of iterations should be
2398 bounded by number of IPA passes since single IPA pass is probably not
2399 going to create clones of clones it created itself. */
2403 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2405 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2406 && !gimple_has_body_p (node
->decl
))
2408 if (gimple_has_body_p (node
->clone_of
->decl
))
2410 if (cgraph_dump_file
)
2412 fprintf (cgraph_dump_file
, "clonning %s to %s\n",
2413 cgraph_node_name (node
->clone_of
),
2414 cgraph_node_name (node
));
2415 if (node
->clone
.tree_map
)
2418 fprintf (cgraph_dump_file
, " replace map: ");
2419 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2420 node
->clone
.tree_map
);
2423 struct ipa_replace_map
*replace_info
;
2424 replace_info
= VEC_index (ipa_replace_map_p
,
2425 node
->clone
.tree_map
,
2427 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2428 fprintf (cgraph_dump_file
, " -> ");
2429 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2430 fprintf (cgraph_dump_file
, "%s%s;",
2431 replace_info
->replace_p
? "(replace)":"",
2432 replace_info
->ref_p
? "(ref)":"");
2434 fprintf (cgraph_dump_file
, "\n");
2436 if (node
->clone
.args_to_skip
)
2438 fprintf (cgraph_dump_file
, " args_to_skip: ");
2439 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2441 if (node
->clone
.args_to_skip
)
2443 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2444 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2447 cgraph_materialize_clone (node
);
2453 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2454 if (!node
->analyzed
&& node
->callees
)
2455 cgraph_node_remove_callees (node
);
2456 if (cgraph_dump_file
)
2457 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2458 #ifdef ENABLE_CHECKING
2461 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2464 #include "gt-cgraphunit.h"