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
)
230 edge
->redirect_call_stmt_to_callee ();
232 /* Call to __builtin_unreachable shouldn't be instrumented. */
233 if (!targets
.length ())
234 gimple_call_set_with_bounds (edge
->call_stmt
, false);
240 /* Perform reachability analysis and reclaim all unreachable nodes.
242 The algorithm is basically mark&sweep but with some extra refinements:
244 - reachable extern inline functions needs special handling; the bodies needs
245 to stay in memory until inlining in hope that they will be inlined.
246 After inlining we release their bodies and turn them into unanalyzed
247 nodes even when they are reachable.
249 BEFORE_INLINING_P specify whether we are before or after inlining.
251 - virtual functions are kept in callgraph even if they seem unreachable in
252 hope calls to them will be devirtualized.
254 Again we remove them after inlining. In late optimization some
255 devirtualization may happen, but it is not important since we won't inline
256 the call. In theory early opts and IPA should work out all important cases.
258 - virtual clones needs bodies of their origins for later materialization;
259 this means that we want to keep the body even if the origin is unreachable
260 otherwise. To avoid origin from sitting in the callgraph and being
261 walked by IPA passes, we turn them into unanalyzed nodes with body
264 We maintain set of function declaration where body needs to stay in
265 body_needed_for_clonning
267 Inline clones represent special case: their declaration match the
268 declaration of origin and cgraph_remove_node already knows how to
269 reshape callgraph and preserve body when offline copy of function or
270 inline clone is being removed.
272 - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
273 variables with DECL_INITIAL set. We finalize these and keep reachable
274 ones around for constant folding purposes. After inlining we however
275 stop walking their references to let everything static referneced by them
276 to be removed when it is otherwise unreachable.
278 We maintain queue of both reachable symbols (i.e. defined symbols that needs
279 to stay) and symbols that are in boundary (i.e. external symbols referenced
280 by reachable symbols or origins of clones). The queue is represented
281 as linked list by AUX pointer terminated by 1.
283 At the end we keep all reachable symbols. For symbols in boundary we always
284 turn definition into a declaration, but we may keep function body around
285 based on body_needed_for_clonning
287 All symbols that enter the queue have AUX pointer non-zero and are in the
288 boundary. Pointer set REACHABLE is used to track reachable symbols.
290 Every symbol can be visited twice - once as part of boundary and once
291 as real reachable symbol. enqueue_node needs to decide whether the
292 node needs to be re-queued for second processing. For this purpose
293 we set AUX pointer of processed symbols in the boundary to constant 2. */
296 symbol_table::remove_unreachable_nodes (bool before_inlining_p
, FILE *file
)
298 symtab_node
*first
= (symtab_node
*) (void *) 1;
299 struct cgraph_node
*node
, *next
;
300 varpool_node
*vnode
, *vnext
;
301 bool changed
= false;
302 hash_set
<symtab_node
*> reachable
;
303 hash_set
<tree
> body_needed_for_clonning
;
304 hash_set
<void *> reachable_call_targets
;
306 timevar_push (TV_IPA_UNREACHABLE
);
307 if (optimize
&& flag_devirtualize
)
308 build_type_inheritance_graph ();
310 fprintf (file
, "\nReclaiming functions:");
311 #ifdef ENABLE_CHECKING
312 FOR_EACH_FUNCTION (node
)
313 gcc_assert (!node
->aux
);
314 FOR_EACH_VARIABLE (vnode
)
315 gcc_assert (!vnode
->aux
);
317 /* Mark functions whose bodies are obviously needed.
318 This is mostly when they can be referenced externally. Inline clones
319 are special since their declarations are shared with master clone and thus
320 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
321 FOR_EACH_FUNCTION (node
)
323 node
->used_as_abstract_origin
= false;
325 && !node
->global
.inlined_to
326 && !node
->in_other_partition
327 && !node
->can_remove_if_no_direct_calls_and_refs_p ())
329 gcc_assert (!node
->global
.inlined_to
);
330 reachable
.add (node
);
331 enqueue_node (node
, &first
, &reachable
);
334 gcc_assert (!node
->aux
);
337 /* Mark variables that are obviously needed. */
338 FOR_EACH_DEFINED_VARIABLE (vnode
)
339 if (!vnode
->can_remove_if_no_refs_p()
340 && !vnode
->in_other_partition
)
342 reachable
.add (vnode
);
343 enqueue_node (vnode
, &first
, &reachable
);
346 /* Perform reachability analysis. */
347 while (first
!= (symtab_node
*) (void *) 1)
349 bool in_boundary_p
= !reachable
.contains (first
);
350 symtab_node
*node
= first
;
352 first
= (symtab_node
*)first
->aux
;
354 /* If we are processing symbol in boundary, mark its AUX pointer for
355 possible later re-processing in enqueue_node. */
357 node
->aux
= (void *)2;
360 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
361 && DECL_ABSTRACT_ORIGIN (node
->decl
))
363 struct cgraph_node
*origin_node
364 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (node
->decl
));
365 origin_node
->used_as_abstract_origin
= true;
366 enqueue_node (origin_node
, &first
, &reachable
);
368 /* If any symbol in a comdat group is reachable, force
369 all externally visible symbols in the same comdat
370 group to be reachable as well. Comdat-local symbols
371 can be discarded if all uses were inlined. */
372 if (node
->same_comdat_group
)
375 for (next
= node
->same_comdat_group
;
377 next
= next
->same_comdat_group
)
378 if (!next
->comdat_local_p ()
379 && !reachable
.add (next
))
380 enqueue_node (next
, &first
, &reachable
);
382 /* Mark references as reachable. */
383 process_references (node
, &first
, before_inlining_p
, &reachable
);
386 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
388 /* Mark the callees reachable unless they are direct calls to extern
389 inline functions we decided to not inline. */
392 struct cgraph_edge
*e
;
393 /* Keep alive possible targets for devirtualization. */
394 if (optimize
&& flag_devirtualize
)
396 struct cgraph_edge
*next
;
397 for (e
= cnode
->indirect_calls
; e
; e
= next
)
399 next
= e
->next_callee
;
400 if (e
->indirect_info
->polymorphic
)
401 walk_polymorphic_call_targets (&reachable_call_targets
,
402 e
, &first
, &reachable
,
406 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
408 if (e
->callee
->definition
409 && !e
->callee
->in_other_partition
410 && (!e
->inline_failed
411 || !DECL_EXTERNAL (e
->callee
->decl
)
413 || before_inlining_p
))
415 /* Be sure that we will not optimize out alias target
417 if (DECL_EXTERNAL (e
->callee
->decl
)
419 && before_inlining_p
)
420 reachable
.add (e
->callee
->function_symbol ());
421 reachable
.add (e
->callee
);
423 enqueue_node (e
->callee
, &first
, &reachable
);
426 /* When inline clone exists, mark body to be preserved so when removing
427 offline copy of the function we don't kill it. */
428 if (cnode
->global
.inlined_to
)
429 body_needed_for_clonning
.add (cnode
->decl
);
431 /* For non-inline clones, force their origins to the boundary and ensure
432 that body is not removed. */
433 while (cnode
->clone_of
)
435 bool noninline
= cnode
->clone_of
->decl
!= cnode
->decl
;
436 cnode
= cnode
->clone_of
;
439 body_needed_for_clonning
.add (cnode
->decl
);
440 enqueue_node (cnode
, &first
, &reachable
);
445 /* If any reachable function has simd clones, mark them as
446 reachable as well. */
447 if (cnode
->simd_clones
)
450 for (next
= cnode
->simd_clones
;
452 next
= next
->simdclone
->next_clone
)
454 || !reachable
.add (next
))
455 enqueue_node (next
, &first
, &reachable
);
458 /* When we see constructor of external variable, keep referred nodes in the
459 boundary. This will also hold initializers of the external vars NODE
461 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
463 && DECL_EXTERNAL (node
->decl
)
467 struct ipa_ref
*ref
= NULL
;
468 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
469 enqueue_node (ref
->referred
, &first
, &reachable
);
473 /* Remove unreachable functions. */
474 for (node
= first_function (); node
; node
= next
)
476 next
= next_function (node
);
478 /* If node is not needed at all, remove it. */
482 fprintf (file
, " %s/%i", node
->name (), node
->order
);
486 /* If node is unreachable, remove its body. */
487 else if (!reachable
.contains (node
))
489 if (!body_needed_for_clonning
.contains (node
->decl
))
490 node
->release_body ();
491 else if (!node
->clone_of
)
492 gcc_assert (in_lto_p
|| DECL_RESULT (node
->decl
));
493 if (node
->definition
)
496 fprintf (file
, " %s/%i", node
->name (), node
->order
);
497 node
->body_removed
= true;
498 node
->analyzed
= false;
499 node
->definition
= false;
500 node
->cpp_implicit_alias
= false;
502 node
->thunk
.thunk_p
= false;
503 node
->weakref
= false;
504 /* After early inlining we drop always_inline attributes on
505 bodies of functions that are still referenced (have their
507 DECL_ATTRIBUTES (node
->decl
)
508 = remove_attribute ("always_inline",
509 DECL_ATTRIBUTES (node
->decl
));
510 if (!node
->in_other_partition
)
511 node
->local
.local
= false;
512 node
->remove_callees ();
513 node
->remove_from_same_comdat_group ();
514 node
->remove_all_references ();
516 if (node
->thunk
.thunk_p
517 && node
->thunk
.add_pointer_bounds_args
)
519 node
->thunk
.thunk_p
= false;
520 node
->thunk
.add_pointer_bounds_args
= false;
525 gcc_assert (node
->clone_of
|| !node
->has_gimple_body_p ()
526 || in_lto_p
|| DECL_RESULT (node
->decl
));
529 /* Inline clones might be kept around so their materializing allows further
530 cloning. If the function the clone is inlined into is removed, we need
531 to turn it into normal cone. */
532 FOR_EACH_FUNCTION (node
)
534 if (node
->global
.inlined_to
537 gcc_assert (node
->clones
);
538 node
->global
.inlined_to
= NULL
;
539 update_inlined_to_pointer (node
, node
);
544 /* Remove unreachable variables. */
546 fprintf (file
, "\nReclaiming variables:");
547 for (vnode
= first_variable (); vnode
; vnode
= vnext
)
549 vnext
= next_variable (vnode
);
551 /* For can_refer_decl_in_current_unit_p we want to track for
552 all external variables if they are defined in other partition
554 && (!flag_ltrans
|| !DECL_EXTERNAL (vnode
->decl
)))
557 fprintf (file
, " %s/%i", vnode
->name (), vnode
->order
);
561 else if (!reachable
.contains (vnode
))
564 if (vnode
->definition
)
567 fprintf (file
, " %s", vnode
->name ());
570 /* Keep body if it may be useful for constant folding. */
571 if ((init
= ctor_for_folding (vnode
->decl
)) == error_mark_node
572 && !POINTER_BOUNDS_P (vnode
->decl
))
573 vnode
->remove_initializer ();
575 DECL_INITIAL (vnode
->decl
) = init
;
576 vnode
->body_removed
= true;
577 vnode
->definition
= false;
578 vnode
->analyzed
= false;
581 vnode
->remove_from_same_comdat_group ();
583 vnode
->remove_all_references ();
589 /* Now update address_taken flags and try to promote functions to be local. */
591 fprintf (file
, "\nClearing address taken flags:");
592 FOR_EACH_DEFINED_FUNCTION (node
)
593 if (node
->address_taken
594 && !node
->used_from_other_partition
)
596 if (!node
->call_for_symbol_thunks_and_aliases
597 (has_addr_references_p
, NULL
, true)
598 && (!node
->instrumentation_clone
599 || !node
->instrumented_version
600 || !node
->instrumented_version
->address_taken
))
603 fprintf (file
, " %s", node
->name ());
604 node
->address_taken
= false;
606 if (node
->local_p ())
608 node
->local
.local
= true;
610 fprintf (file
, " (local)");
615 fprintf (file
, "\n");
617 #ifdef ENABLE_CHECKING
618 symtab_node::verify_symtab_nodes ();
621 /* If we removed something, perhaps profile could be improved. */
622 if (changed
&& optimize
&& inline_edge_summary_vec
.exists ())
623 FOR_EACH_DEFINED_FUNCTION (node
)
624 ipa_propagate_frequency (node
);
626 timevar_pop (TV_IPA_UNREACHABLE
);
630 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
631 as needed, also clear EXPLICIT_REFS if the references to given variable
632 do not need to be explicit. */
635 process_references (varpool_node
*vnode
,
636 bool *written
, bool *address_taken
,
637 bool *read
, bool *explicit_refs
)
642 if (!vnode
->all_refs_explicit_p ()
643 || TREE_THIS_VOLATILE (vnode
->decl
))
644 *explicit_refs
= false;
646 for (i
= 0; vnode
->iterate_referring (i
, ref
)
647 && *explicit_refs
&& (!*written
|| !*address_taken
|| !*read
); i
++)
651 *address_taken
= true;
660 process_references (dyn_cast
<varpool_node
*> (ref
->referring
), written
,
661 address_taken
, read
, explicit_refs
);
668 /* Set TREE_READONLY bit. */
671 set_readonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
673 TREE_READONLY (vnode
->decl
) = true;
677 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
680 set_writeonly_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
682 vnode
->writeonly
= true;
685 DECL_INITIAL (vnode
->decl
) = NULL
;
687 vnode
->remove_all_references ();
692 /* Clear addressale bit of VNODE. */
695 clear_addressable_bit (varpool_node
*vnode
, void *data ATTRIBUTE_UNUSED
)
697 vnode
->address_taken
= false;
698 TREE_ADDRESSABLE (vnode
->decl
) = 0;
702 /* Discover variables that have no longer address taken or that are read only
703 and update their flags.
705 FIXME: This can not be done in between gimplify and omp_expand since
706 readonly flag plays role on what is shared and what is not. Currently we do
707 this transformation as part of whole program visibility and re-do at
708 ipa-reference pass (to take into account clonning), but it would
709 make sense to do it before early optimizations. */
712 ipa_discover_readonly_nonaddressable_vars (void)
716 fprintf (dump_file
, "Clearing variable flags:");
717 FOR_EACH_VARIABLE (vnode
)
719 && (TREE_ADDRESSABLE (vnode
->decl
)
721 || !TREE_READONLY (vnode
->decl
)))
723 bool written
= false;
724 bool address_taken
= false;
726 bool explicit_refs
= true;
728 process_references (vnode
, &written
, &address_taken
, &read
, &explicit_refs
);
733 if (TREE_ADDRESSABLE (vnode
->decl
) && dump_file
)
734 fprintf (dump_file
, " %s (non-addressable)", vnode
->name ());
735 vnode
->call_for_node_and_aliases (clear_addressable_bit
, NULL
, true);
737 if (!address_taken
&& !written
738 /* Making variable in explicit section readonly can cause section
740 See e.g. gcc.c-torture/compile/pr23237.c */
741 && vnode
->get_section () == NULL
)
743 if (!TREE_READONLY (vnode
->decl
) && dump_file
)
744 fprintf (dump_file
, " %s (read-only)", vnode
->name ());
745 vnode
->call_for_node_and_aliases (set_readonly_bit
, NULL
, true);
747 if (!vnode
->writeonly
&& !read
&& !address_taken
&& written
)
750 fprintf (dump_file
, " %s (write-only)", vnode
->name ());
751 vnode
->call_for_node_and_aliases (set_writeonly_bit
, NULL
, true);
755 fprintf (dump_file
, "\n");
758 /* Free inline summary. */
762 const pass_data pass_data_ipa_free_inline_summary
=
764 SIMPLE_IPA_PASS
, /* type */
765 "free-inline-summary", /* name */
766 OPTGROUP_NONE
, /* optinfo_flags */
767 TV_IPA_FREE_INLINE_SUMMARY
, /* tv_id */
768 0, /* properties_required */
769 0, /* properties_provided */
770 0, /* properties_destroyed */
771 0, /* todo_flags_start */
772 /* Early optimizations may make function unreachable. We can not
773 remove unreachable functions as part of the ealry opts pass because
774 TODOs are run before subpasses. Do it here. */
775 ( TODO_remove_functions
| TODO_dump_symtab
), /* todo_flags_finish */
778 class pass_ipa_free_inline_summary
: public simple_ipa_opt_pass
781 pass_ipa_free_inline_summary (gcc::context
*ctxt
)
782 : simple_ipa_opt_pass (pass_data_ipa_free_inline_summary
, ctxt
)
785 /* opt_pass methods: */
786 virtual unsigned int execute (function
*)
788 inline_free_summary ();
792 }; // class pass_ipa_free_inline_summary
796 simple_ipa_opt_pass
*
797 make_pass_ipa_free_inline_summary (gcc::context
*ctxt
)
799 return new pass_ipa_free_inline_summary (ctxt
);
802 /* Generate and emit a static constructor or destructor. WHICH must
803 be one of 'I' (for a constructor), 'D' (for a destructor), 'P'
804 (for chp static vars constructor) or 'B' (for chkp static bounds
805 constructor). BODY is a STATEMENT_LIST containing GENERIC
806 statements. PRIORITY is the initialization priority for this
807 constructor or destructor.
809 FINAL specify whether the externally visible name for collect2 should
813 cgraph_build_static_cdtor_1 (char which
, tree body
, int priority
, bool final
)
815 static int counter
= 0;
817 tree decl
, name
, resdecl
;
819 /* The priority is encoded in the constructor or destructor name.
820 collect2 will sort the names and arrange that they are called at
823 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
825 /* Proudce sane name but one not recognizable by collect2, just for the
826 case we fail to inline the function. */
827 sprintf (which_buf
, "sub_%c_%.5d_%d", which
, priority
, counter
++);
828 name
= get_file_function_name (which_buf
);
830 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
831 build_function_type_list (void_type_node
, NULL_TREE
));
832 current_function_decl
= decl
;
834 resdecl
= build_decl (input_location
,
835 RESULT_DECL
, NULL_TREE
, void_type_node
);
836 DECL_ARTIFICIAL (resdecl
) = 1;
837 DECL_RESULT (decl
) = resdecl
;
838 DECL_CONTEXT (resdecl
) = decl
;
840 allocate_struct_function (decl
, false);
842 TREE_STATIC (decl
) = 1;
843 TREE_USED (decl
) = 1;
844 DECL_ARTIFICIAL (decl
) = 1;
845 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
846 DECL_SAVED_TREE (decl
) = body
;
847 if (!targetm
.have_ctors_dtors
&& final
)
849 TREE_PUBLIC (decl
) = 1;
850 DECL_PRESERVE_P (decl
) = 1;
852 DECL_UNINLINABLE (decl
) = 1;
854 DECL_INITIAL (decl
) = make_node (BLOCK
);
855 TREE_USED (DECL_INITIAL (decl
)) = 1;
857 DECL_SOURCE_LOCATION (decl
) = input_location
;
858 cfun
->function_end_locus
= input_location
;
863 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
864 decl_init_priority_insert (decl
, priority
);
867 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
868 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("chkp ctor"),
871 decl_init_priority_insert (decl
, priority
);
874 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
875 DECL_ATTRIBUTES (decl
) = tree_cons (get_identifier ("bnd_legacy"),
878 decl_init_priority_insert (decl
, priority
);
881 DECL_STATIC_DESTRUCTOR (decl
) = 1;
882 decl_fini_priority_insert (decl
, priority
);
888 gimplify_function_tree (decl
);
890 cgraph_node::add_new_function (decl
, false);
893 current_function_decl
= NULL
;
896 /* Generate and emit a static constructor or destructor. WHICH must
897 be one of 'I' (for a constructor), 'D' (for a destructor), 'P'
898 (for chkp static vars constructor) or 'B' (for chkp static bounds
899 constructor). BODY is a STATEMENT_LIST containing GENERIC
900 statements. PRIORITY is the initialization priority for this
901 constructor or destructor. */
904 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
906 cgraph_build_static_cdtor_1 (which
, body
, priority
, false);
909 /* A vector of FUNCTION_DECLs declared as static constructors. */
910 static vec
<tree
> static_ctors
;
911 /* A vector of FUNCTION_DECLs declared as static destructors. */
912 static vec
<tree
> static_dtors
;
914 /* When target does not have ctors and dtors, we call all constructor
915 and destructor by special initialization/destruction function
916 recognized by collect2.
918 When we are going to build this function, collect all constructors and
919 destructors and turn them into normal functions. */
922 record_cdtor_fn (struct cgraph_node
*node
)
924 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
925 static_ctors
.safe_push (node
->decl
);
926 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
927 static_dtors
.safe_push (node
->decl
);
928 node
= cgraph_node::get (node
->decl
);
929 DECL_DISREGARD_INLINE_LIMITS (node
->decl
) = 1;
932 /* Define global constructors/destructor functions for the CDTORS, of
933 which they are LEN. The CDTORS are sorted by initialization
934 priority. If CTOR_P is true, these are constructors; otherwise,
935 they are destructors. */
938 build_cdtor (bool ctor_p
, vec
<tree
> cdtors
)
941 size_t len
= cdtors
.length ();
948 priority_type priority
;
957 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
960 else if (p
!= priority
)
966 /* When there is only one cdtor and target supports them, do nothing. */
968 && targetm
.have_ctors_dtors
)
973 /* Find the next batch of constructors/destructors with the same
974 initialization priority. */
979 call
= build_call_expr (fn
, 0);
981 DECL_STATIC_CONSTRUCTOR (fn
) = 0;
983 DECL_STATIC_DESTRUCTOR (fn
) = 0;
984 /* We do not want to optimize away pure/const calls here.
985 When optimizing, these should be already removed, when not
986 optimizing, we want user to be able to breakpoint in them. */
987 TREE_SIDE_EFFECTS (call
) = 1;
988 append_to_statement_list (call
, &body
);
990 gcc_assert (body
!= NULL_TREE
);
991 /* Generate a function to call all the function of like
993 cgraph_build_static_cdtor_1 (ctor_p
? 'I' : 'D', body
, priority
, true);
997 /* Comparison function for qsort. P1 and P2 are actually of type
998 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
999 used to determine the sort order. */
1002 compare_ctor (const void *p1
, const void *p2
)
1009 f1
= *(const tree
*)p1
;
1010 f2
= *(const tree
*)p2
;
1011 priority1
= DECL_INIT_PRIORITY (f1
);
1012 priority2
= DECL_INIT_PRIORITY (f2
);
1014 if (priority1
< priority2
)
1016 else if (priority1
> priority2
)
1019 /* Ensure a stable sort. Constructors are executed in backwarding
1020 order to make LTO initialize braries first. */
1021 return DECL_UID (f2
) - DECL_UID (f1
);
1024 /* Comparison function for qsort. P1 and P2 are actually of type
1025 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
1026 used to determine the sort order. */
1029 compare_dtor (const void *p1
, const void *p2
)
1036 f1
= *(const tree
*)p1
;
1037 f2
= *(const tree
*)p2
;
1038 priority1
= DECL_FINI_PRIORITY (f1
);
1039 priority2
= DECL_FINI_PRIORITY (f2
);
1041 if (priority1
< priority2
)
1043 else if (priority1
> priority2
)
1046 /* Ensure a stable sort. */
1047 return DECL_UID (f1
) - DECL_UID (f2
);
1050 /* Generate functions to call static constructors and destructors
1051 for targets that do not support .ctors/.dtors sections. These
1052 functions have magic names which are detected by collect2. */
1055 build_cdtor_fns (void)
1057 if (!static_ctors
.is_empty ())
1059 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1060 static_ctors
.qsort (compare_ctor
);
1061 build_cdtor (/*ctor_p=*/true, static_ctors
);
1064 if (!static_dtors
.is_empty ())
1066 gcc_assert (!targetm
.have_ctors_dtors
|| in_lto_p
);
1067 static_dtors
.qsort (compare_dtor
);
1068 build_cdtor (/*ctor_p=*/false, static_dtors
);
1072 /* Look for constructors and destructors and produce function calling them.
1073 This is needed for targets not supporting ctors or dtors, but we perform the
1074 transformation also at linktime to merge possibly numerous
1075 constructors/destructors into single function to improve code locality and
1079 ipa_cdtor_merge (void)
1081 struct cgraph_node
*node
;
1082 FOR_EACH_DEFINED_FUNCTION (node
)
1083 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
1084 || DECL_STATIC_DESTRUCTOR (node
->decl
))
1085 record_cdtor_fn (node
);
1087 static_ctors
.release ();
1088 static_dtors
.release ();
1094 const pass_data pass_data_ipa_cdtor_merge
=
1096 IPA_PASS
, /* type */
1098 OPTGROUP_NONE
, /* optinfo_flags */
1099 TV_CGRAPHOPT
, /* tv_id */
1100 0, /* properties_required */
1101 0, /* properties_provided */
1102 0, /* properties_destroyed */
1103 0, /* todo_flags_start */
1104 0, /* todo_flags_finish */
1107 class pass_ipa_cdtor_merge
: public ipa_opt_pass_d
1110 pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1111 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge
, ctxt
,
1112 NULL
, /* generate_summary */
1113 NULL
, /* write_summary */
1114 NULL
, /* read_summary */
1115 NULL
, /* write_optimization_summary */
1116 NULL
, /* read_optimization_summary */
1117 NULL
, /* stmt_fixup */
1118 0, /* function_transform_todo_flags_start */
1119 NULL
, /* function_transform */
1120 NULL
) /* variable_transform */
1123 /* opt_pass methods: */
1124 virtual bool gate (function
*);
1125 virtual unsigned int execute (function
*) { return ipa_cdtor_merge (); }
1127 }; // class pass_ipa_cdtor_merge
1130 pass_ipa_cdtor_merge::gate (function
*)
1132 /* Perform the pass when we have no ctors/dtors support
1133 or at LTO time to merge multiple constructors into single
1135 return !targetm
.have_ctors_dtors
|| (optimize
&& in_lto_p
);
1141 make_pass_ipa_cdtor_merge (gcc::context
*ctxt
)
1143 return new pass_ipa_cdtor_merge (ctxt
);
1146 /* Invalid pointer representing BOTTOM for single user dataflow. */
1147 #define BOTTOM ((cgraph_node *)(size_t) 2)
1149 /* Meet operation for single user dataflow.
1150 Here we want to associate variables with sigle function that may access it.
1152 FUNCTION is current single user of a variable, VAR is variable that uses it.
1153 Latttice is stored in SINGLE_USER_MAP.
1156 - TOP by no entry in SIGNLE_USER_MAP
1157 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
1158 - known single user by cgraph pointer in SINGLE_USER_MAP. */
1161 meet (cgraph_node
*function
, varpool_node
*var
,
1162 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1164 struct cgraph_node
*user
, **f
;
1166 if (var
->aux
== BOTTOM
)
1169 f
= single_user_map
.get (var
);
1175 else if (function
!= user
)
1181 /* Propagation step of single-use dataflow.
1183 Check all uses of VNODE and see if they are used by single function FUNCTION.
1184 SINGLE_USER_MAP represents the dataflow lattice. */
1187 propagate_single_user (varpool_node
*vnode
, cgraph_node
*function
,
1188 hash_map
<varpool_node
*, cgraph_node
*> &single_user_map
)
1191 struct ipa_ref
*ref
;
1193 gcc_assert (!vnode
->externally_visible
);
1195 /* If node is an alias, first meet with its target. */
1197 function
= meet (function
, vnode
->get_alias_target (), single_user_map
);
1199 /* Check all users and see if they correspond to a single function. */
1200 for (i
= 0; vnode
->iterate_referring (i
, ref
) && function
!= BOTTOM
; i
++)
1202 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1205 if (cnode
->global
.inlined_to
)
1206 cnode
= cnode
->global
.inlined_to
;
1209 else if (function
!= cnode
)
1213 function
= meet (function
, dyn_cast
<varpool_node
*> (ref
->referring
), single_user_map
);
1218 /* Pass setting used_by_single_function flag.
1219 This flag is set on variable when there is only one function that may possibly
1223 ipa_single_use (void)
1225 varpool_node
*first
= (varpool_node
*) (void *) 1;
1227 hash_map
<varpool_node
*, cgraph_node
*> single_user_map
;
1229 FOR_EACH_DEFINED_VARIABLE (var
)
1230 if (!var
->all_refs_explicit_p ())
1234 /* Enqueue symbol for dataflow. */
1239 /* The actual dataflow. */
1241 while (first
!= (void *) 1)
1243 cgraph_node
*user
, *orig_user
, **f
;
1246 first
= (varpool_node
*)first
->aux
;
1248 f
= single_user_map
.get (var
);
1253 user
= propagate_single_user (var
, orig_user
, single_user_map
);
1255 gcc_checking_assert (var
->aux
!= BOTTOM
);
1257 /* If user differs, enqueue all references. */
1258 if (user
!= orig_user
)
1263 single_user_map
.put (var
, user
);
1265 /* Enqueue all aliases for re-processing. */
1266 for (i
= 0; var
->iterate_referring (i
, ref
); i
++)
1267 if (ref
->use
== IPA_REF_ALIAS
1268 && !ref
->referring
->aux
)
1270 ref
->referring
->aux
= first
;
1271 first
= dyn_cast
<varpool_node
*> (ref
->referring
);
1273 /* Enqueue all users for re-processing. */
1274 for (i
= 0; var
->iterate_reference (i
, ref
); i
++)
1275 if (!ref
->referred
->aux
1276 && ref
->referred
->definition
1277 && is_a
<varpool_node
*> (ref
->referred
))
1279 ref
->referred
->aux
= first
;
1280 first
= dyn_cast
<varpool_node
*> (ref
->referred
);
1283 /* If user is BOTTOM, just punt on this var. */
1293 FOR_EACH_DEFINED_VARIABLE (var
)
1295 if (var
->aux
!= BOTTOM
)
1297 #ifdef ENABLE_CHECKING
1298 if (!single_user_map
.get (var
))
1299 gcc_assert (single_user_map
.get (var
));
1303 fprintf (dump_file
, "Variable %s/%i is used by single function\n",
1304 var
->name (), var
->order
);
1306 var
->used_by_single_function
= true;
1315 const pass_data pass_data_ipa_single_use
=
1317 IPA_PASS
, /* type */
1318 "single-use", /* name */
1319 OPTGROUP_NONE
, /* optinfo_flags */
1320 TV_CGRAPHOPT
, /* tv_id */
1321 0, /* properties_required */
1322 0, /* properties_provided */
1323 0, /* properties_destroyed */
1324 0, /* todo_flags_start */
1325 0, /* todo_flags_finish */
1328 class pass_ipa_single_use
: public ipa_opt_pass_d
1331 pass_ipa_single_use (gcc::context
*ctxt
)
1332 : ipa_opt_pass_d (pass_data_ipa_single_use
, ctxt
,
1333 NULL
, /* generate_summary */
1334 NULL
, /* write_summary */
1335 NULL
, /* read_summary */
1336 NULL
, /* write_optimization_summary */
1337 NULL
, /* read_optimization_summary */
1338 NULL
, /* stmt_fixup */
1339 0, /* function_transform_todo_flags_start */
1340 NULL
, /* function_transform */
1341 NULL
) /* variable_transform */
1344 /* opt_pass methods: */
1345 virtual bool gate (function
*);
1346 virtual unsigned int execute (function
*) { return ipa_single_use (); }
1348 }; // class pass_ipa_single_use
1351 pass_ipa_single_use::gate (function
*)
1359 make_pass_ipa_single_use (gcc::context
*ctxt
)
1361 return new pass_ipa_single_use (ctxt
);