1 /* Basic IPA optimizations and utilities.
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "stringpool.h"
28 #include "basic-block.h"
31 #include "plugin-api.h"
36 #include "hard-reg-set.h"
41 #include "tree-pass.h"
42 #include "gimple-expr.h"
46 #include "tree-iterator.h"
47 #include "ipa-utils.h"
48 #include "alloc-pool.h"
50 #include "ipa-inline.h"
51 #include "tree-inline.h"
54 #include "internal-fn.h"
55 #include "tree-ssa-alias.h"
60 /* Return true when NODE has ADDR reference. */
63 has_addr_references_p (struct cgraph_node
*node
,
64 void *data ATTRIBUTE_UNUSED
)
67 struct ipa_ref
*ref
= NULL
;
69 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
70 if (ref
->use
== IPA_REF_ADDR
)
75 /* Look for all functions inlined to NODE and update their inlined_to pointers
79 update_inlined_to_pointer (struct cgraph_node
*node
, struct cgraph_node
*inlined_to
)
81 struct cgraph_edge
*e
;
82 for (e
= node
->callees
; e
; e
= e
->next_callee
)
83 if (e
->callee
->global
.inlined_to
)
85 e
->callee
->global
.inlined_to
= inlined_to
;
86 update_inlined_to_pointer (e
->callee
, inlined_to
);
90 /* Add symtab NODE to queue starting at FIRST.
92 The queue is linked via AUX pointers and terminated by pointer to 1.
93 We enqueue nodes at two occasions: when we find them reachable or when we find
94 their bodies needed for further clonning. In the second case we mark them
95 by pointer to 2 after processing so they are re-queue when they become
99 enqueue_node (symtab_node
*node
, symtab_node
**first
,
100 hash_set
<symtab_node
*> *reachable
)
102 /* Node is still in queue; do nothing. */
103 if (node
->aux
&& node
->aux
!= (void *) 2)
105 /* Node was already processed as unreachable, re-enqueue
106 only if it became reachable now. */
107 if (node
->aux
== (void *)2 && !reachable
->contains (node
))
113 /* Process references. */
116 process_references (symtab_node
*snode
,
118 bool before_inlining_p
,
119 hash_set
<symtab_node
*> *reachable
)
122 struct ipa_ref
*ref
= NULL
;
123 for (i
= 0; snode
->iterate_reference (i
, ref
); i
++)
125 symtab_node
*node
= ref
->referred
;
127 if (node
->definition
&& !node
->in_other_partition
128 && ((!DECL_EXTERNAL (node
->decl
) || node
->alias
)
129 || (((before_inlining_p
130 && (symtab
->state
< IPA_SSA
131 || !lookup_attribute ("always_inline",
132 DECL_ATTRIBUTES (node
->decl
)))))
133 /* We use variable constructors during late complation for
134 constant folding. Keep references alive so partitioning
135 knows about potential references. */
136 || (TREE_CODE (node
->decl
) == VAR_DECL
138 && ctor_for_folding (node
->decl
)
139 != error_mark_node
))))
140 reachable
->add (node
);
141 enqueue_node (node
, first
, reachable
);
145 /* EDGE is an polymorphic call. If BEFORE_INLINING_P is set, mark
146 all its potential targets as reachable to permit later inlining if
147 devirtualization happens. After inlining still keep their declarations
148 around, so we can devirtualize to a direct call.
150 Also try to make trivial devirutalization when no or only one target is
154 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
155 struct cgraph_edge
*edge
,
157 hash_set
<symtab_node
*> *reachable
,
158 bool before_inlining_p
)
163 vec
<cgraph_node
*>targets
164 = possible_polymorphic_call_targets
165 (edge
, &final
, &cache_token
);
167 if (!reachable_call_targets
->add (cache_token
))
169 for (i
= 0; i
< targets
.length (); i
++)
171 struct cgraph_node
*n
= targets
[i
];
173 /* Do not bother to mark virtual methods in anonymous namespace;
174 either we will find use of virtual table defining it, or it is
176 if (TREE_CODE (TREE_TYPE (n
->decl
)) == METHOD_TYPE
177 && type_in_anonymous_namespace_p
178 (method_class_type (TREE_TYPE (n
->decl
))))
181 /* Prior inlining, keep alive bodies of possible targets for
184 && (before_inlining_p
185 && (symtab
->state
< IPA_SSA
186 || !lookup_attribute ("always_inline",
187 DECL_ATTRIBUTES (n
->decl
)))))
190 /* Even after inlining we want to keep the possible targets in the
191 boundary, so late passes can still produce direct call even if
192 the chance for inlining is lost. */
193 enqueue_node (n
, first
, reachable
);
197 /* Very trivial devirtualization; when the type is
198 final or anonymous (so we know all its derivation)
199 and there is only one possible virtual call target,
200 make the edge direct. */
203 if (targets
.length () <= 1 && dbg_cnt (devirt
))
205 cgraph_node
*target
, *node
= edge
->caller
;
206 if (targets
.length () == 1)
209 target
= cgraph_node::get_create
210 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
212 if (dump_enabled_p ())
216 locus
= gimple_location (edge
->call_stmt
);
218 locus
= UNKNOWN_LOCATION
;
219 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
220 "devirtualizing call in %s/%i to %s/%i\n",
221 edge
->caller
->name (), edge
->caller
->order
,
225 edge
= edge
->make_direct (target
);
226 if (inline_summary_vec
)
227 inline_update_overall_summary (node
);
228 else if (edge
->call_stmt
)
229 edge
->redirect_call_stmt_to_callee ();
234 /* Perform reachability analysis and reclaim all unreachable nodes.
236 The algorithm is basically mark&sweep but with some extra refinements:
238 - reachable extern inline functions needs special handling; the bodies needs
239 to stay in memory until inlining in hope that they will be inlined.
240 After inlining we release their bodies and turn them into unanalyzed
241 nodes even when they are reachable.
243 BEFORE_INLINING_P specify whether we are before or after inlining.
245 - virtual functions are kept in callgraph even if they seem unreachable in
246 hope calls to them will be devirtualized.
248 Again we remove them after inlining. In late optimization some
249 devirtualization may happen, but it is not important since we won't inline
250 the call. In theory early opts and IPA should work out all important cases.
252 - virtual clones needs bodies of their origins for later materialization;
253 this means that we want to keep the body even if the origin is unreachable
254 otherwise. To avoid origin from sitting in the callgraph and being
255 walked by IPA passes, we turn them into unanalyzed nodes with body
258 We maintain set of function declaration where body needs to stay in
259 body_needed_for_clonning
261 Inline clones represent special case: their declaration match the
262 declaration of origin and cgraph_remove_node already knows how to
263 reshape callgraph and preserve body when offline copy of function or
264 inline clone is being removed.
266 - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
267 variables with DECL_INITIAL set. We finalize these and keep reachable
268 ones around for constant folding purposes. After inlining we however
269 stop walking their references to let everything static referneced by them
270 to be removed when it is otherwise unreachable.
272 We maintain queue of both reachable symbols (i.e. defined symbols that needs
273 to stay) and symbols that are in boundary (i.e. external symbols referenced
274 by reachable symbols or origins of clones). The queue is represented
275 as linked list by AUX pointer terminated by 1.
277 At the end we keep all reachable symbols. For symbols in boundary we always
278 turn definition into a declaration, but we may keep function body around
279 based on body_needed_for_clonning
281 All symbols that enter the queue have AUX pointer non-zero and are in the
282 boundary. Pointer set REACHABLE is used to track reachable symbols.
284 Every symbol can be visited twice - once as part of boundary and once
285 as real reachable symbol. enqueue_node needs to decide whether the
286 node needs to be re-queued for second processing. For this purpose
287 we set AUX pointer of processed symbols in the boundary to constant 2. */
290 symbol_table::remove_unreachable_nodes (bool before_inlining_p
, FILE *file
)
292 symtab_node
*first
= (symtab_node
*) (void *) 1;
293 struct cgraph_node
*node
, *next
;
294 varpool_node
*vnode
, *vnext
;
295 bool changed
= false;
296 hash_set
<symtab_node
*> reachable
;
297 hash_set
<tree
> body_needed_for_clonning
;
298 hash_set
<void *> reachable_call_targets
;
300 timevar_push (TV_IPA_UNREACHABLE
);
301 if (optimize
&& flag_devirtualize
)
302 build_type_inheritance_graph ();
304 fprintf (file
, "\nReclaiming functions:");
305 #ifdef ENABLE_CHECKING
306 FOR_EACH_FUNCTION (node
)
307 gcc_assert (!node
->aux
);
308 FOR_EACH_VARIABLE (vnode
)
309 gcc_assert (!vnode
->aux
);
311 /* Mark functions whose bodies are obviously needed.
312 This is mostly when they can be referenced externally. Inline clones
313 are special since their declarations are shared with master clone and thus
314 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
315 FOR_EACH_FUNCTION (node
)
317 node
->used_as_abstract_origin
= false;
319 && !node
->global
.inlined_to
320 && !node
->in_other_partition
321 && !node
->can_remove_if_no_direct_calls_and_refs_p ())
323 gcc_assert (!node
->global
.inlined_to
);
324 reachable
.add (node
);
325 enqueue_node (node
, &first
, &reachable
);
328 gcc_assert (!node
->aux
);
331 /* Mark variables that are obviously needed. */
332 FOR_EACH_DEFINED_VARIABLE (vnode
)
333 if (!vnode
->can_remove_if_no_refs_p()
334 && !vnode
->in_other_partition
)
336 reachable
.add (vnode
);
337 enqueue_node (vnode
, &first
, &reachable
);
340 /* Perform reachability analysis. */
341 while (first
!= (symtab_node
*) (void *) 1)
343 bool in_boundary_p
= !reachable
.contains (first
);
344 symtab_node
*node
= first
;
346 first
= (symtab_node
*)first
->aux
;
348 /* If we are processing symbol in boundary, mark its AUX pointer for
349 possible later re-processing in enqueue_node. */
351 node
->aux
= (void *)2;
354 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
355 && DECL_ABSTRACT_ORIGIN (node
->decl
))
357 struct cgraph_node
*origin_node
358 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (node
->decl
));
359 origin_node
->used_as_abstract_origin
= true;
360 enqueue_node (origin_node
, &first
, &reachable
);
362 /* If any symbol in a comdat group is reachable, force
363 all externally visible symbols in the same comdat
364 group to be reachable as well. Comdat-local symbols
365 can be discarded if all uses were inlined. */
366 if (node
->same_comdat_group
)
369 for (next
= node
->same_comdat_group
;
371 next
= next
->same_comdat_group
)
372 if (!next
->comdat_local_p ()
373 && !reachable
.add (next
))
374 enqueue_node (next
, &first
, &reachable
);
376 /* Mark references as reachable. */
377 process_references (node
, &first
, before_inlining_p
, &reachable
);
380 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
382 /* Mark the callees reachable unless they are direct calls to extern
383 inline functions we decided to not inline. */
386 struct cgraph_edge
*e
;
387 /* Keep alive possible targets for devirtualization. */
388 if (optimize
&& flag_devirtualize
)
390 struct cgraph_edge
*next
;
391 for (e
= cnode
->indirect_calls
; e
; e
= next
)
393 next
= e
->next_callee
;
394 if (e
->indirect_info
->polymorphic
)
395 walk_polymorphic_call_targets (&reachable_call_targets
,
396 e
, &first
, &reachable
,
400 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
402 if (e
->callee
->definition
403 && !e
->callee
->in_other_partition
404 && (!e
->inline_failed
405 || !DECL_EXTERNAL (e
->callee
->decl
)
407 || before_inlining_p
))
409 /* Be sure that we will not optimize out alias target
411 if (DECL_EXTERNAL (e
->callee
->decl
)
413 && before_inlining_p
)
414 reachable
.add (e
->callee
->function_symbol ());
415 reachable
.add (e
->callee
);
417 enqueue_node (e
->callee
, &first
, &reachable
);
420 /* When inline clone exists, mark body to be preserved so when removing
421 offline copy of the function we don't kill it. */
422 if (cnode
->global
.inlined_to
)
423 body_needed_for_clonning
.add (cnode
->decl
);
425 /* For non-inline clones, force their origins to the boundary and ensure
426 that body is not removed. */
427 while (cnode
->clone_of
)
429 bool noninline
= cnode
->clone_of
->decl
!= cnode
->decl
;
430 cnode
= cnode
->clone_of
;
433 body_needed_for_clonning
.add (cnode
->decl
);
434 enqueue_node (cnode
, &first
, &reachable
);
439 /* If any reachable function has simd clones, mark them as
440 reachable as well. */
441 if (cnode
->simd_clones
)
444 for (next
= cnode
->simd_clones
;
446 next
= next
->simdclone
->next_clone
)
448 || !reachable
.add (next
))
449 enqueue_node (next
, &first
, &reachable
);
452 /* When we see constructor of external variable, keep referred nodes in the
453 boundary. This will also hold initializers of the external vars NODE
455 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
457 && DECL_EXTERNAL (node
->decl
)
461 struct ipa_ref
*ref
= NULL
;
462 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
463 enqueue_node (ref
->referred
, &first
, &reachable
);
467 /* Remove unreachable functions. */
468 for (node
= first_function (); node
; node
= next
)
470 next
= next_function (node
);
472 /* If node is not needed at all, remove it. */
476 fprintf (file
, " %s/%i", node
->name (), node
->order
);
480 /* If node is unreachable, remove its body. */
481 else if (!reachable
.contains (node
))
483 if (!body_needed_for_clonning
.contains (node
->decl
))
484 node
->release_body ();
485 else if (!node
->clone_of
)
486 gcc_assert (in_lto_p
|| DECL_RESULT (node
->decl
));
487 if (node
->definition
)
490 fprintf (file
, " %s/%i", node
->name (), node
->order
);
491 node
->body_removed
= true;
492 node
->analyzed
= false;
493 node
->definition
= false;
494 node
->cpp_implicit_alias
= false;
496 node
->thunk
.thunk_p
= false;
497 node
->weakref
= false;
498 /* After early inlining we drop always_inline attributes on
499 bodies of functions that are still referenced (have their
501 DECL_ATTRIBUTES (node
->decl
)
502 = remove_attribute ("always_inline",
503 DECL_ATTRIBUTES (node
->decl
));
504 if (!node
->in_other_partition
)
505 node
->local
.local
= false;
506 node
->remove_callees ();
507 node
->remove_from_same_comdat_group ();
508 node
->remove_all_references ();
513 gcc_assert (node
->clone_of
|| !node
->has_gimple_body_p ()
514 || in_lto_p
|| DECL_RESULT (node
->decl
));
517 /* Inline clones might be kept around so their materializing allows further
518 cloning. If the function the clone is inlined into is removed, we need
519 to turn it into normal cone. */
520 FOR_EACH_FUNCTION (node
)
522 if (node
->global
.inlined_to
525 gcc_assert (node
->clones
);
526 node
->global
.inlined_to
= NULL
;
527 update_inlined_to_pointer (node
, node
);
532 /* Remove unreachable variables. */
534 fprintf (file
, "\nReclaiming variables:");
535 for (vnode
= first_variable (); vnode
; vnode
= vnext
)
537 vnext
= next_variable (vnode
);
539 /* For can_refer_decl_in_current_unit_p we want to track for
540 all external variables if they are defined in other partition
542 && (!flag_ltrans
|| !DECL_EXTERNAL (vnode
->decl
)))
545 fprintf (file
, " %s/%i", vnode
->name (), vnode
->order
);
549 else if (!reachable
.contains (vnode
))
552 if (vnode
->definition
)
555 fprintf (file
, " %s", vnode
->name ());
558 /* Keep body if it may be useful for constant folding. */
559 if ((init
= ctor_for_folding (vnode
->decl
)) == error_mark_node
)
560 vnode
->remove_initializer ();
562 DECL_INITIAL (vnode
->decl
) = init
;
563 vnode
->body_removed
= true;
564 vnode
->definition
= false;
565 vnode
->analyzed
= false;
568 vnode
->remove_from_same_comdat_group ();
570 vnode
->remove_all_references ();
576 /* Now update address_taken flags and try to promote functions to be local. */
578 fprintf (file
, "\nClearing address taken flags:");
579 FOR_EACH_DEFINED_FUNCTION (node
)
580 if (node
->address_taken
581 && !node
->used_from_other_partition
)
583 if (!node
->call_for_symbol_thunks_and_aliases
584 (has_addr_references_p
, NULL
, true))
587 fprintf (file
, " %s", node
->name ());
588 node
->address_taken
= false;
590 if (node
->local_p ())
592 node
->local
.local
= true;
594 fprintf (file
, " (local)");
599 fprintf (file
, "\n");
601 #ifdef ENABLE_CHECKING
602 symtab_node::verify_symtab_nodes ();
605 /* If we removed something, perhaps profile could be improved. */
606 if (changed
&& optimize
&& inline_edge_summary_vec
.exists ())
607 FOR_EACH_DEFINED_FUNCTION (node
)
608 ipa_propagate_frequency (node
);
610 timevar_pop (TV_IPA_UNREACHABLE
);
614 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
615 as needed, also clear EXPLICIT_REFS if the references to given variable
616 do not need to be explicit. */
619 process_references (varpool_node
*vnode
,
620 bool *written
, bool *address_taken
,
621 bool *read
, bool *explicit_refs
)
626 if (!vnode
->all_refs_explicit_p ()
627 || TREE_THIS_VOLATILE (vnode
->decl
))
628 *explicit_refs
= false;
630 for (i
= 0; vnode
->iterate_referring (i
, ref
)
631 && *explicit_refs
&& (!*written
|| !*address_taken
|| !*read
); i
++)
635 *address_taken
= true;
644 process_references (dyn_cast
<varpool_node
*> (ref
->referring
), written
,
645 address_taken
, read
, explicit_refs
);
650 /* Set TREE_READONLY bit. */
653 set_readonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
655 TREE_READONLY (vnode
->decl
) = true;
659 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
662 set_writeonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
664 vnode
->writeonly
= true;
667 DECL_INITIAL (vnode
->decl
) = NULL
;
669 vnode
->remove_all_references ();
674 /* Clear addressale bit of VNODE. */
677 clear_addressable_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
679 vnode
->address_taken
= false;
680 TREE_ADDRESSABLE (vnode
->decl
) = 0;
684 /* Discover variables that have no longer address taken or that are read only
685 and update their flags.
687 FIXME: This can not be done in between gimplify and omp_expand since
688 readonly flag plays role on what is shared and what is not. Currently we do
689 this transformation as part of whole program visibility and re-do at
690 ipa-reference pass (to take into account clonning), but it would
691 make sense to do it before early optimizations. */
694 ipa_discover_readonly_nonaddressable_vars (void)
698 fprintf (dump_file
, "Clearing variable flags:");
699 FOR_EACH_VARIABLE (vnode
)
701 && (TREE_ADDRESSABLE (vnode
->decl
)
703 || !TREE_READONLY (vnode
->decl
)))
705 bool written
= false;
706 bool address_taken
= false;
708 bool explicit_refs
= true;
710 process_references (vnode
, &written
, &address_taken
, &read
, &explicit_refs
);
715 if (TREE_ADDRESSABLE (vnode
->decl
) && dump_file
)
716 fprintf (dump_file
, " %s (non-addressable)", vnode
->name ());
717 vnode
->call_for_node_and_aliases (clear_addressable_bit
, NULL
, true);
719 if (!address_taken
&& !written
720 /* Making variable in explicit section readonly can cause section
722 See e.g. gcc.c-torture/compile/pr23237.c */
723 && vnode
->get_section () == NULL
)
725 if (!TREE_READONLY (vnode
->decl
) && dump_file
)
726 fprintf (dump_file
, " %s (read-only)", vnode
->name ());
727 vnode
->call_for_node_and_aliases (set_readonly_bit
, NULL
, true);
729 if (!vnode
->writeonly
&& !read
&& !address_taken
&& written
)
732 fprintf (dump_file
, " %s (write-only)", vnode
->name ());
733 vnode
->call_for_node_and_aliases (set_writeonly_bit
, NULL
, true);
737 fprintf (dump_file
, "\n");
740 /* Free inline summary. */
744 const pass_data pass_data_ipa_free_inline_summary
=
746 SIMPLE_IPA_PASS
, /* type */
747 "free-inline-summary", /* name */
748 OPTGROUP_NONE
, /* optinfo_flags */
749 TV_IPA_FREE_INLINE_SUMMARY
, /* tv_id */
750 0, /* properties_required */
751 0, /* properties_provided */
752 0, /* properties_destroyed */
753 0, /* todo_flags_start */
754 /* Early optimizations may make function unreachable. We can not
755 remove unreachable functions as part of the ealry opts pass because
756 TODOs are run before subpasses. Do it here. */
757 ( TODO_remove_functions
| TODO_dump_symtab
), /* todo_flags_finish */
760 class pass_ipa_free_inline_summary
: public simple_ipa_opt_pass
763 pass_ipa_free_inline_summary (gcc::context
*ctxt
)
764 : simple_ipa_opt_pass (pass_data_ipa_free_inline_summary
, ctxt
)
767 /* opt_pass methods: */
768 virtual unsigned int execute (function
*)
770 inline_free_summary ();
774 }; // class pass_ipa_free_inline_summary
778 simple_ipa_opt_pass
*
779 make_pass_ipa_free_inline_summary (gcc::context
*ctxt
)
781 return new pass_ipa_free_inline_summary (ctxt
);
784 /* Generate and emit a static constructor or destructor. WHICH must
785 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
786 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
787 initialization priority for this constructor or destructor.
789 FINAL specify whether the externally visible name for collect2 should
793 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
795 static int counter
= 0;
797 tree decl
, name
, resdecl
;
799 /* The priority is encoded in the constructor or destructor name.
800 collect2 will sort the names and arrange that they are called at
803 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
805 /* Proudce sane name but one not recognizable by collect2, just for the
806 case we fail to inline the function. */
807 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
808 name
= get_file_function_name (which_buf
);
810 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
811 build_function_type_list (void_type_node
, NULL_TREE
));
812 current_function_decl
= decl
;
814 resdecl
= build_decl (input_location
,
815 RESULT_DECL
, NULL_TREE
, void_type_node
);
816 DECL_ARTIFICIAL (resdecl
) = 1;
817 DECL_RESULT (decl
) = resdecl
;
818 DECL_CONTEXT (resdecl
) = decl
;
820 allocate_struct_function (decl
, false);
822 TREE_STATIC (decl
) = 1;
823 TREE_USED (decl
) = 1;
824 DECL_ARTIFICIAL (decl
) = 1;
825 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
826 DECL_SAVED_TREE (decl
) = body
;
827 if (!targetm
.have_ctors_dtors
&& final
)
829 TREE_PUBLIC (decl
) = 1;
830 DECL_PRESERVE_P (decl
) = 1;
832 DECL_UNINLINABLE (decl
) = 1;
834 DECL_INITIAL (decl
) = make_node (BLOCK
);
835 TREE_USED (DECL_INITIAL (decl
)) = 1;
837 DECL_SOURCE_LOCATION (decl
) = input_location
;
838 cfun
->function_end_locus
= input_location
;
843 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
844 decl_init_priority_insert (decl
, priority
);
847 DECL_STATIC_DESTRUCTOR (decl
) = 1;
848 decl_fini_priority_insert (decl
, priority
);
854 gimplify_function_tree (decl
);
856 cgraph_node::add_new_function (decl
, false);
859 current_function_decl
= NULL
;
862 /* Generate and emit a static constructor or destructor. WHICH must
863 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
864 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
865 initialization priority for this constructor or destructor. */
868 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
870 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
873 /* A vector of FUNCTION_DECLs declared as static constructors. */
874 static vec
<tree
> static_ctors
;
875 /* A vector of FUNCTION_DECLs declared as static destructors. */
876 static vec
<tree
> static_dtors
;
878 /* When target does not have ctors and dtors, we call all constructor
879 and destructor by special initialization/destruction function
880 recognized by collect2.
882 When we are going to build this function, collect all constructors and
883 destructors and turn them into normal functions. */
886 record_cdtor_fn (struct cgraph_node
*node
)
888 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
889 static_ctors
.safe_push (node
->decl
);
890 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
891 static_dtors
.safe_push (node
->decl
);
892 node
= cgraph_node::get (node
->decl
);
893 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
896 /* Define global constructors/destructor functions for the CDTORS, of
897 which they are LEN. The CDTORS are sorted by initialization
898 priority. If CTOR_P is true, these are constructors; otherwise,
899 they are destructors. */
902 build_cdtor (bool ctor_p
, vec
<tree
> cdtors
)
905 size_t len
= cdtors
.length ();
912 priority_type priority
;
921 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
924 else if (p
!= priority
)
930 /* When there is only one cdtor and target supports them, do nothing. */
932 && targetm
.have_ctors_dtors
)
937 /* Find the next batch of constructors/destructors with the same
938 initialization priority. */
943 call
= build_call_expr (fn
, 0);
945 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
947 DECL_STATIC_DESTRUCTOR (fn
) = 0;
948 /* We do not want to optimize away pure/const calls here.
949 When optimizing, these should be already removed, when not
950 optimizing, we want user to be able to breakpoint in them. */
951 TREE_SIDE_EFFECTS (call
) = 1;
952 append_to_statement_list (call
, &body
);
954 gcc_assert (body
!= NULL_TREE
);
955 /* Generate a function to call all the function of like
957 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
961 /* Comparison function for qsort. P1 and P2 are actually of type
962 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
963 used to determine the sort order. */
966 compare_ctor (const void *p1
, const void *p2
)
973 f1
= *(const tree
*)p1
;
974 f2
= *(const tree
*)p2
;
975 priority1
= DECL_INIT_PRIORITY (f1
);
976 priority2
= DECL_INIT_PRIORITY (f2
);
978 if (priority1
< priority2
)
980 else if (priority1
> priority2
)
983 /* Ensure a stable sort. Constructors are executed in backwarding
984 order to make LTO initialize braries first. */
985 return DECL_UID (f2
) - DECL_UID (f1
);
988 /* Comparison function for qsort. P1 and P2 are actually of type
989 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
990 used to determine the sort order. */
993 compare_dtor (const void *p1
, const void *p2
)
1000 f1
= *(const tree
*)p1
;
1001 f2
= *(const tree
*)p2
;
1002 priority1
= DECL_FINI_PRIORITY (f1
);
1003 priority2
= DECL_FINI_PRIORITY (f2
);
1005 if (priority1
< priority2
)
1007 else if (priority1
> priority2
)
1010 /* Ensure a stable sort. */
1011 return DECL_UID (f1
) - DECL_UID (f2
);
1014 /* Generate functions to call static constructors and destructors
1015 for targets that do not support .ctors/.dtors sections. These
1016 functions have magic names which are detected by collect2. */
1019 build_cdtor_fns (void)
1021 if (!static_ctors
.is_empty ())
1023 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1024 static_ctors
.qsort (compare_ctor
);
1025 build_cdtor (/*ctor_p=*/true, static_ctors
);
1028 if (!static_dtors
.is_empty ())
1030 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1031 static_dtors
.qsort (compare_dtor
);
1032 build_cdtor (/*ctor_p=*/false, static_dtors
);
1036 /* Look for constructors and destructors and produce function calling them.
1037 This is needed for targets not supporting ctors or dtors, but we perform the
1038 transformation also at linktime to merge possibly numerous
1039 constructors/destructors into single function to improve code locality and
1043 ipa_cdtor_merge (void)
1045 struct cgraph_node
*node
;
1046 FOR_EACH_DEFINED_FUNCTION (node
)
1047 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1048 || DECL_STATIC_DESTRUCTOR (node
->decl
))
1049 record_cdtor_fn (node
);
1051 static_ctors
.release ();
1052 static_dtors
.release ();
1058 const pass_data pass_data_ipa_cdtor_merge
=
1060 IPA_PASS
, /* type */
1062 OPTGROUP_NONE
, /* optinfo_flags */
1063 TV_CGRAPHOPT
, /* tv_id */
1064 0, /* properties_required */
1065 0, /* properties_provided */
1066 0, /* properties_destroyed */
1067 0, /* todo_flags_start */
1068 0, /* todo_flags_finish */
1071 class pass_ipa_cdtor_merge
: public ipa_opt_pass_d
1074 pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1075 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge
, ctxt
,
1076 NULL
, /* generate_summary */
1077 NULL
, /* write_summary */
1078 NULL
, /* read_summary */
1079 NULL
, /* write_optimization_summary */
1080 NULL
, /* read_optimization_summary */
1081 NULL
, /* stmt_fixup */
1082 0, /* function_transform_todo_flags_start */
1083 NULL
, /* function_transform */
1084 NULL
) /* variable_transform */
1087 /* opt_pass methods: */
1088 virtual bool gate (function
*);
1089 virtual unsigned int execute (function
*) { return ipa_cdtor_merge (); }
1091 }; // class pass_ipa_cdtor_merge
1094 pass_ipa_cdtor_merge::gate (function
*)
1096 /* Perform the pass when we have no ctors/dtors support
1097 or at LTO time to merge multiple constructors into single
1099 return !targetm
.have_ctors_dtors
|| (optimize
&& in_lto_p
);
1105 make_pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1107 return new pass_ipa_cdtor_merge (ctxt
);
1110 /* Invalid pointer representing BOTTOM for single user dataflow. */
1111 #define BOTTOM ((cgraph_node *)(size_t) 2)
1113 /* Meet operation for single user dataflow.
1114 Here we want to associate variables with sigle function that may access it.
1116 FUNCTION is current single user of a variable, VAR is variable that uses it.
1117 Latttice is stored in SINGLE_USER_MAP.
1120 - TOP by no entry in SIGNLE_USER_MAP
1121 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
1122 - known single user by cgraph pointer in SINGLE_USER_MAP. */
1125 meet (cgraph_node
*function
, varpool_node
*var
,
1126 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1128 struct cgraph_node
*user
, **f
;
1130 if (var
->aux
== BOTTOM
)
1133 f
= single_user_map
.get (var
);
1139 else if (function
!= user
)
1145 /* Propagation step of single-use dataflow.
1147 Check all uses of VNODE and see if they are used by single function FUNCTION.
1148 SINGLE_USER_MAP represents the dataflow lattice. */
1151 propagate_single_user (varpool_node
*vnode
, cgraph_node
*function
,
1152 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1155 struct ipa_ref
*ref
;
1157 gcc_assert (!vnode
->externally_visible
);
1159 /* If node is an alias, first meet with its target. */
1161 function
= meet (function
, vnode
->get_alias_target (), single_user_map
);
1163 /* Check all users and see if they correspond to a single function. */
1164 for (i
= 0; vnode
->iterate_referring (i
, ref
) && function
!= BOTTOM
; i
++)
1166 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1169 if (cnode
->global
.inlined_to
)
1170 cnode
= cnode
->global
.inlined_to
;
1173 else if (function
!= cnode
)
1177 function
= meet (function
, dyn_cast
<varpool_node
*> (ref
->referring
), single_user_map
);
1182 /* Pass setting used_by_single_function flag.
1183 This flag is set on variable when there is only one function that may possibly
1187 ipa_single_use (void)
1189 varpool_node
*first
= (varpool_node
*) (void *) 1;
1191 hash_map
<varpool_node
*, cgraph_node
*> single_user_map
;
1193 FOR_EACH_DEFINED_VARIABLE (var
)
1194 if (!var
->all_refs_explicit_p ())
1198 /* Enqueue symbol for dataflow. */
1203 /* The actual dataflow. */
1205 while (first
!= (void *) 1)
1207 cgraph_node
*user
, *orig_user
, **f
;
1210 first
= (varpool_node
*)first
->aux
;
1212 f
= single_user_map
.get (var
);
1217 user
= propagate_single_user (var
, orig_user
, single_user_map
);
1219 gcc_checking_assert (var
->aux
!= BOTTOM
);
1221 /* If user differs, enqueue all references. */
1222 if (user
!= orig_user
)
1227 single_user_map
.put (var
, user
);
1229 /* Enqueue all aliases for re-processing. */
1230 for (i
= 0; var
->iterate_referring (i
, ref
); i
++)
1231 if (ref
->use
== IPA_REF_ALIAS
1232 && !ref
->referring
->aux
)
1234 ref
->referring
->aux
= first
;
1235 first
= dyn_cast
<varpool_node
*> (ref
->referring
);
1237 /* Enqueue all users for re-processing. */
1238 for (i
= 0; var
->iterate_reference (i
, ref
); i
++)
1239 if (!ref
->referred
->aux
1240 && ref
->referred
->definition
1241 && is_a
<varpool_node
*> (ref
->referred
))
1243 ref
->referred
->aux
= first
;
1244 first
= dyn_cast
<varpool_node
*> (ref
->referred
);
1247 /* If user is BOTTOM, just punt on this var. */
1257 FOR_EACH_DEFINED_VARIABLE (var
)
1259 if (var
->aux
!= BOTTOM
)
1261 #ifdef ENABLE_CHECKING
1262 if (!single_user_map
.get (var
))
1263 gcc_assert (single_user_map
.get (var
));
1267 fprintf (dump_file
, "Variable %s/%i is used by single function\n",
1268 var
->name (), var
->order
);
1270 var
->used_by_single_function
= true;
1279 const pass_data pass_data_ipa_single_use
=
1281 IPA_PASS
, /* type */
1282 "single-use", /* name */
1283 OPTGROUP_NONE
, /* optinfo_flags */
1284 TV_CGRAPHOPT
, /* tv_id */
1285 0, /* properties_required */
1286 0, /* properties_provided */
1287 0, /* properties_destroyed */
1288 0, /* todo_flags_start */
1289 0, /* todo_flags_finish */
1292 class pass_ipa_single_use
: public ipa_opt_pass_d
1295 pass_ipa_single_use (gcc::context
*ctxt
)
1296 : ipa_opt_pass_d (pass_data_ipa_single_use
, ctxt
,
1297 NULL
, /* generate_summary */
1298 NULL
, /* write_summary */
1299 NULL
, /* read_summary */
1300 NULL
, /* write_optimization_summary */
1301 NULL
, /* read_optimization_summary */
1302 NULL
, /* stmt_fixup */
1303 0, /* function_transform_todo_flags_start */
1304 NULL
, /* function_transform */
1305 NULL
) /* variable_transform */
1308 /* opt_pass methods: */
1309 virtual bool gate (function
*);
1310 virtual unsigned int execute (function
*) { return ipa_single_use (); }
1312 }; // class pass_ipa_single_use
1315 pass_ipa_single_use::gate (function
*)
1323 make_pass_ipa_single_use (gcc::context
*ctxt
)
1325 return new pass_ipa_single_use (ctxt
);