2 Copyright (C) 2003-2015 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/>. */
20 /* This file implements two related passes:
22 - pass_data_ipa_function_and_variable_visibility run just after
23 symbol table, references and callgraph are built
25 - pass_data_ipa_function_and_variable_visibility run as first
26 proper IPA pass (that is after early optimization, or, (with LTO)
27 as a first pass done at link-time.
29 Purpose of both passes is to set correctly visibility properties
30 of all symbols. This includes:
32 - Symbol privatization:
34 Some symbols that are declared public by frontend may be
35 turned local (either by -fwhole-program flag, by linker plugin feedback
38 - Discovery of local functions:
40 A local function is one whose calls can occur only in the current
41 compilation unit and all its calls are explicit, so we can change
42 its calling convention. We simply mark all static functions whose
43 address is not taken as local.
45 externally_visible flag is set for symbols that can not be privatized.
46 For privatized symbols we clear TREE_PUBLIC flag and dismantle comdat
49 - Dismantling of comdat groups:
51 Comdat group represent a section that may be replaced by linker by
52 a different copy of the same section from other unit.
53 If we have resolution information (from linker plugin) and we know that
54 a given comdat gorup is prevailing, we can dismantle it and turn symbols
55 into normal symbols. If the resolution information says that the
56 section was previaled by copy from non-LTO code, we can also dismantle
57 it and turn all symbols into external.
61 Some symbols can be interposed by dynamic linker. Refering to these
62 symbols is expensive, since it needs to be overwritable by the dynamic
63 linker. In some cases we know that the interposition does not change
64 semantic and we can always refer to a local copy (as in the case of
65 inline function). In this case we produce a local alias and redirect
68 TODO: This should be done for references, too.
70 - Removal of static ocnstructors and destructors that have no side effects.
72 - Regularization of several oddities introduced by frontends that may
73 be impractical later in the optimization queue. */
77 #include "coretypes.h"
82 #include "double-int.h"
91 #include "plugin-api.h"
92 #include "hard-reg-set.h"
97 #include "tree-pass.h"
99 #include "gimple-expr.h"
102 /* Return true when NODE can not be local. Worker for cgraph_local_node_p. */
105 cgraph_node::non_local_p (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
107 /* FIXME: Aliases can be local, but i386 gets thunks wrong then. */
108 return !(node
->only_called_directly_or_aliased_p ()
109 && !node
->has_aliases_p ()
111 && !DECL_EXTERNAL (node
->decl
)
112 && !node
->externally_visible
113 && !node
->used_from_other_partition
114 && !node
->in_other_partition
);
117 /* Return true when function can be marked local. */
120 cgraph_node::local_p (void)
122 cgraph_node
*n
= ultimate_alias_target ();
124 /* FIXME: thunks can be considered local, but we need prevent i386
125 from attempting to change calling convention of them. */
126 if (n
->thunk
.thunk_p
)
128 return !n
->call_for_symbol_thunks_and_aliases (cgraph_node::non_local_p
,
133 /* Return true when there is a reference to node and it is not vtable. */
136 symtab_node::address_taken_from_non_vtable_p (void)
139 struct ipa_ref
*ref
= NULL
;
141 for (i
= 0; iterate_referring (i
, ref
); i
++)
142 if (ref
->use
== IPA_REF_ADDR
)
145 if (is_a
<cgraph_node
*> (ref
->referring
))
147 node
= dyn_cast
<varpool_node
*> (ref
->referring
);
148 if (!DECL_VIRTUAL_P (node
->decl
))
154 /* A helper for comdat_can_be_unshared_p. */
157 comdat_can_be_unshared_p_1 (symtab_node
*node
)
159 if (!node
->externally_visible
)
161 /* When address is taken, we don't know if equality comparison won't
162 break eventually. Exception are virutal functions, C++
163 constructors/destructors and vtables, where this is not possible by
164 language standard. */
165 if (!DECL_VIRTUAL_P (node
->decl
)
166 && (TREE_CODE (node
->decl
) != FUNCTION_DECL
167 || (!DECL_CXX_CONSTRUCTOR_P (node
->decl
)
168 && !DECL_CXX_DESTRUCTOR_P (node
->decl
)))
169 && node
->address_taken_from_non_vtable_p ())
172 /* If the symbol is used in some weird way, better to not touch it. */
173 if (node
->force_output
)
176 /* Explicit instantiations needs to be output when possibly
178 if (node
->forced_by_abi
179 && TREE_PUBLIC (node
->decl
)
180 && (node
->resolution
!= LDPR_PREVAILING_DEF_IRONLY
181 && !flag_whole_program
))
184 /* Non-readonly and volatile variables can not be duplicated. */
185 if (is_a
<varpool_node
*> (node
)
186 && (!TREE_READONLY (node
->decl
)
187 || TREE_THIS_VOLATILE (node
->decl
)))
192 /* COMDAT functions must be shared only if they have address taken,
193 otherwise we can produce our own private implementation with
195 Return true when turning COMDAT functoin static can not lead to wrong
196 code when the resulting object links with a library defining same COMDAT.
198 Virtual functions do have their addresses taken from the vtables,
199 but in C++ there is no way to compare their addresses for equality. */
202 comdat_can_be_unshared_p (symtab_node
*node
)
204 if (!comdat_can_be_unshared_p_1 (node
))
206 if (node
->same_comdat_group
)
210 /* If more than one function is in the same COMDAT group, it must
211 be shared even if just one function in the comdat group has
213 for (next
= node
->same_comdat_group
;
214 next
!= node
; next
= next
->same_comdat_group
)
215 if (!comdat_can_be_unshared_p_1 (next
))
221 /* Return true when function NODE should be considered externally visible. */
224 cgraph_externally_visible_p (struct cgraph_node
*node
,
227 if (!node
->definition
)
229 if (!TREE_PUBLIC (node
->decl
)
230 || DECL_EXTERNAL (node
->decl
))
233 /* Do not try to localize built-in functions yet. One of problems is that we
234 end up mangling their asm for WHOPR that makes it impossible to call them
235 using the implicit built-in declarations anymore. Similarly this enables
236 us to remove them as unreachable before actual calls may appear during
237 expansion or folding. */
238 if (DECL_BUILT_IN (node
->decl
))
241 /* If linker counts on us, we must preserve the function. */
242 if (node
->used_from_object_file_p ())
244 if (DECL_PRESERVE_P (node
->decl
))
246 if (lookup_attribute ("externally_visible",
247 DECL_ATTRIBUTES (node
->decl
)))
249 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
250 && lookup_attribute ("dllexport",
251 DECL_ATTRIBUTES (node
->decl
)))
253 if (node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
)
255 /* When doing LTO or whole program, we can bring COMDAT functoins static.
256 This improves code quality and we know we will duplicate them at most twice
257 (in the case that we are not using plugin and link with object file
258 implementing same COMDAT) */
259 if ((in_lto_p
|| whole_program
)
260 && DECL_COMDAT (node
->decl
)
261 && comdat_can_be_unshared_p (node
))
264 /* When doing link time optimizations, hidden symbols become local. */
266 && (DECL_VISIBILITY (node
->decl
) == VISIBILITY_HIDDEN
267 || DECL_VISIBILITY (node
->decl
) == VISIBILITY_INTERNAL
)
268 /* Be sure that node is defined in IR file, not in other object
269 file. In that case we don't set used_from_other_object_file. */
272 else if (!whole_program
)
275 if (MAIN_NAME_P (DECL_NAME (node
->decl
)))
278 if (node
->instrumentation_clone
279 && MAIN_NAME_P (DECL_NAME (node
->orig_decl
)))
285 /* Return true when variable should be considered externally visible. */
288 varpool_node::externally_visible_p (void)
290 if (DECL_EXTERNAL (decl
))
293 if (!TREE_PUBLIC (decl
))
296 /* If linker counts on us, we must preserve the function. */
297 if (used_from_object_file_p ())
300 /* Bringing TLS variables local may cause dynamic linker failures
301 on limits of static TLS vars. */
302 if (DECL_THREAD_LOCAL_P (decl
)
303 && (DECL_TLS_MODEL (decl
) != TLS_MODEL_EMULATED
304 && DECL_TLS_MODEL (decl
) != TLS_MODEL_INITIAL_EXEC
))
307 if (DECL_HARD_REGISTER (decl
))
309 if (DECL_PRESERVE_P (decl
))
311 if (lookup_attribute ("externally_visible",
312 DECL_ATTRIBUTES (decl
)))
314 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
315 && lookup_attribute ("dllexport",
316 DECL_ATTRIBUTES (decl
)))
319 /* See if we have linker information about symbol not being used or
320 if we need to make guess based on the declaration.
322 Even if the linker clams the symbol is unused, never bring internal
323 symbols that are declared by user as used or externally visible.
324 This is needed for i.e. references from asm statements. */
325 if (used_from_object_file_p ())
327 if (resolution
== LDPR_PREVAILING_DEF_IRONLY
)
330 /* As a special case, the COMDAT virtual tables can be unshared.
331 In LTO mode turn vtables into static variables. The variable is readonly,
332 so this does not enable more optimization, but referring static var
333 is faster for dynamic linking. Also this match logic hidding vtables
334 from LTO symbol tables. */
335 if ((in_lto_p
|| flag_whole_program
)
336 && DECL_COMDAT (decl
)
337 && comdat_can_be_unshared_p (this))
340 /* When doing link time optimizations, hidden symbols become local. */
342 && (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
343 || DECL_VISIBILITY (decl
) == VISIBILITY_INTERNAL
)
344 /* Be sure that node is defined in IR file, not in other object
345 file. In that case we don't set used_from_other_object_file. */
348 else if (!flag_whole_program
)
351 /* Do not attempt to privatize COMDATS by default.
352 This would break linking with C++ libraries sharing
355 FIXME: We can do so for readonly vars with no address taken and
356 possibly also for vtables since no direct pointer comparsion is done.
357 It might be interesting to do so to reduce linking overhead. */
358 if (DECL_COMDAT (decl
) || DECL_WEAK (decl
))
363 /* Return true if reference to NODE can be replaced by a local alias.
364 Local aliases save dynamic linking overhead and enable more optimizations.
368 can_replace_by_local_alias (symtab_node
*node
)
370 return (node
->get_availability () > AVAIL_INTERPOSABLE
371 && !decl_binds_to_current_def_p (node
->decl
)
372 && !node
->can_be_discarded_p ());
375 /* Return true if we can replace refernece to NODE by local alias
376 within a virtual table. Generally we can replace function pointers
377 and virtual table pointers. */
380 can_replace_by_local_alias_in_vtable (symtab_node
*node
)
382 if (is_a
<varpool_node
*> (node
)
383 && !DECL_VIRTUAL_P (node
->decl
))
385 return can_replace_by_local_alias (node
);
388 /* walk_tree callback that rewrites initializer references. */
391 update_vtable_references (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
393 if (TREE_CODE (*tp
) == VAR_DECL
394 || TREE_CODE (*tp
) == FUNCTION_DECL
)
396 if (can_replace_by_local_alias_in_vtable (symtab_node::get (*tp
)))
397 *tp
= symtab_node::get (*tp
)->noninterposable_alias ()->decl
;
400 else if (IS_TYPE_OR_DECL_P (*tp
))
405 /* In LTO we can remove COMDAT groups and weak symbols.
406 Either turn them into normal symbols or external symbol depending on
410 update_visibility_by_resolution_info (symtab_node
* node
)
414 if (!node
->externally_visible
415 || (!DECL_WEAK (node
->decl
) && !DECL_ONE_ONLY (node
->decl
))
416 || node
->resolution
== LDPR_UNKNOWN
)
419 define
= (node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
420 || node
->resolution
== LDPR_PREVAILING_DEF
421 || node
->resolution
== LDPR_UNDEF
422 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
);
424 /* The linker decisions ought to agree in the whole group. */
425 if (node
->same_comdat_group
)
426 for (symtab_node
*next
= node
->same_comdat_group
;
427 next
!= node
; next
= next
->same_comdat_group
)
428 gcc_assert (!next
->externally_visible
429 || define
== (next
->resolution
== LDPR_PREVAILING_DEF_IRONLY
430 || next
->resolution
== LDPR_PREVAILING_DEF
431 || next
->resolution
== LDPR_UNDEF
432 || next
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
));
434 if (node
->same_comdat_group
)
435 for (symtab_node
*next
= node
->same_comdat_group
;
436 next
!= node
; next
= next
->same_comdat_group
)
438 next
->set_comdat_group (NULL
);
439 DECL_WEAK (next
->decl
) = false;
440 if (next
->externally_visible
442 DECL_EXTERNAL (next
->decl
) = true;
444 node
->set_comdat_group (NULL
);
445 DECL_WEAK (node
->decl
) = false;
447 DECL_EXTERNAL (node
->decl
) = true;
448 node
->dissolve_same_comdat_group_list ();
451 /* Decide on visibility of all symbols. */
454 function_and_variable_visibility (bool whole_program
)
456 struct cgraph_node
*node
;
459 /* All aliases should be procssed at this point. */
460 gcc_checking_assert (!alias_pairs
|| !alias_pairs
->length ());
462 FOR_EACH_FUNCTION (node
)
464 int flags
= flags_from_decl_or_type (node
->decl
);
466 /* Optimize away PURE and CONST constructors and destructors. */
468 && (flags
& (ECF_CONST
| ECF_PURE
))
469 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
471 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
472 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
475 /* Frontends and alias code marks nodes as needed before parsing is finished.
476 We may end up marking as node external nodes where this flag is meaningless
478 if (DECL_EXTERNAL (node
->decl
) || !node
->definition
)
480 node
->force_output
= 0;
481 node
->forced_by_abi
= 0;
484 /* C++ FE on lack of COMDAT support create local COMDAT functions
485 (that ought to be shared but can not due to object format
486 limitations). It is necessary to keep the flag to make rest of C++ FE
487 happy. Clear the flag here to avoid confusion in middle-end. */
488 if (DECL_COMDAT (node
->decl
) && !TREE_PUBLIC (node
->decl
))
489 DECL_COMDAT (node
->decl
) = 0;
491 /* For external decls stop tracking same_comdat_group. It doesn't matter
492 what comdat group they are in when they won't be emitted in this TU. */
493 if (node
->same_comdat_group
&& DECL_EXTERNAL (node
->decl
))
495 #ifdef ENABLE_CHECKING
498 for (n
= node
->same_comdat_group
;
500 n
= n
->same_comdat_group
)
501 /* If at least one of same comdat group functions is external,
502 all of them have to be, otherwise it is a front-end bug. */
503 gcc_assert (DECL_EXTERNAL (n
->decl
));
505 node
->dissolve_same_comdat_group_list ();
507 gcc_assert ((!DECL_WEAK (node
->decl
)
508 && !DECL_COMDAT (node
->decl
))
509 || TREE_PUBLIC (node
->decl
)
511 || DECL_EXTERNAL (node
->decl
));
512 if (cgraph_externally_visible_p (node
, whole_program
))
514 gcc_assert (!node
->global
.inlined_to
);
515 node
->externally_visible
= true;
519 node
->externally_visible
= false;
520 node
->forced_by_abi
= false;
522 if (!node
->externally_visible
523 && node
->definition
&& !node
->weakref
524 && !DECL_EXTERNAL (node
->decl
))
526 gcc_assert (whole_program
|| in_lto_p
527 || !TREE_PUBLIC (node
->decl
));
528 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
530 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
531 && TREE_PUBLIC (node
->decl
));
532 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
533 if (node
->same_comdat_group
&& TREE_PUBLIC (node
->decl
))
535 symtab_node
*next
= node
;
537 /* Set all members of comdat group local. */
538 if (node
->same_comdat_group
)
539 for (next
= node
->same_comdat_group
;
541 next
= next
->same_comdat_group
)
543 next
->set_comdat_group (NULL
);
545 next
->set_section (NULL
);
546 next
->make_decl_local ();
547 next
->unique_name
= ((next
->resolution
== LDPR_PREVAILING_DEF_IRONLY
549 || next
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
550 && TREE_PUBLIC (next
->decl
));
552 /* cgraph_externally_visible_p has already checked all other nodes
553 in the group and they will all be made local. We need to
554 dissolve the group at once so that the predicate does not
556 node
->dissolve_same_comdat_group_list ();
558 if (TREE_PUBLIC (node
->decl
))
559 node
->set_comdat_group (NULL
);
560 if (DECL_COMDAT (node
->decl
) && !node
->alias
)
561 node
->set_section (NULL
);
562 node
->make_decl_local ();
565 if (node
->thunk
.thunk_p
566 && !node
->thunk
.add_pointer_bounds_args
567 && TREE_PUBLIC (node
->decl
))
569 struct cgraph_node
*decl_node
= node
;
571 decl_node
= decl_node
->callees
->callee
->function_symbol ();
573 /* Thunks have the same visibility as function they are attached to.
574 Make sure the C++ front end set this up properly. */
575 if (DECL_ONE_ONLY (decl_node
->decl
))
577 gcc_checking_assert (DECL_COMDAT (node
->decl
)
578 == DECL_COMDAT (decl_node
->decl
));
579 gcc_checking_assert (node
->in_same_comdat_group_p (decl_node
));
580 gcc_checking_assert (node
->same_comdat_group
);
582 node
->forced_by_abi
= decl_node
->forced_by_abi
;
583 if (DECL_EXTERNAL (decl_node
->decl
))
584 DECL_EXTERNAL (node
->decl
) = 1;
587 update_visibility_by_resolution_info (node
);
589 FOR_EACH_DEFINED_FUNCTION (node
)
591 node
->local
.local
|= node
->local_p ();
593 /* If we know that function can not be overwritten by a different semantics
594 and moreover its section can not be discarded, replace all direct calls
595 by calls to an noninterposable alias. This make dynamic linking
596 cheaper and enable more optimization.
598 TODO: We can also update virtual tables. */
600 && can_replace_by_local_alias (node
))
602 cgraph_node
*alias
= dyn_cast
<cgraph_node
*>
603 (node
->noninterposable_alias ());
605 if (alias
&& alias
!= node
)
607 while (node
->callers
)
609 struct cgraph_edge
*e
= node
->callers
;
611 e
->redirect_callee (alias
);
612 if (gimple_has_body_p (e
->caller
->decl
))
614 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
615 e
->redirect_call_stmt_to_callee ();
622 FOR_EACH_VARIABLE (vnode
)
624 /* weak flag makes no sense on local variables. */
625 gcc_assert (!DECL_WEAK (vnode
->decl
)
627 || TREE_PUBLIC (vnode
->decl
)
628 || DECL_EXTERNAL (vnode
->decl
));
629 /* In several cases declarations can not be common:
631 - when declaration has initializer
633 - when it has specific section
634 - when it resides in non-generic address space.
635 - if declaration is local, it will get into .local common section
636 so common flag is not needed. Frontends still produce these in
637 certain cases, such as for:
639 static int a __attribute__ ((common))
641 Canonicalize things here and clear the redundant flag. */
642 if (DECL_COMMON (vnode
->decl
)
643 && (!(TREE_PUBLIC (vnode
->decl
)
644 || DECL_EXTERNAL (vnode
->decl
))
645 || (DECL_INITIAL (vnode
->decl
)
646 && DECL_INITIAL (vnode
->decl
) != error_mark_node
)
647 || DECL_WEAK (vnode
->decl
)
648 || DECL_SECTION_NAME (vnode
->decl
) != NULL
649 || ! (ADDR_SPACE_GENERIC_P
650 (TYPE_ADDR_SPACE (TREE_TYPE (vnode
->decl
))))))
651 DECL_COMMON (vnode
->decl
) = 0;
653 FOR_EACH_DEFINED_VARIABLE (vnode
)
655 if (!vnode
->definition
)
657 if (vnode
->externally_visible_p ())
658 vnode
->externally_visible
= true;
661 vnode
->externally_visible
= false;
662 vnode
->forced_by_abi
= false;
664 if (lookup_attribute ("no_reorder",
665 DECL_ATTRIBUTES (vnode
->decl
)))
666 vnode
->no_reorder
= 1;
667 if (!vnode
->externally_visible
670 gcc_assert (in_lto_p
|| whole_program
|| !TREE_PUBLIC (vnode
->decl
));
671 vnode
->unique_name
= ((vnode
->resolution
== LDPR_PREVAILING_DEF_IRONLY
672 || vnode
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
673 && TREE_PUBLIC (vnode
->decl
));
674 if (vnode
->same_comdat_group
&& TREE_PUBLIC (vnode
->decl
))
676 symtab_node
*next
= vnode
;
678 /* Set all members of comdat group local. */
679 if (vnode
->same_comdat_group
)
680 for (next
= vnode
->same_comdat_group
;
682 next
= next
->same_comdat_group
)
684 next
->set_comdat_group (NULL
);
686 next
->set_section (NULL
);
687 next
->make_decl_local ();
688 next
->unique_name
= ((next
->resolution
== LDPR_PREVAILING_DEF_IRONLY
690 || next
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
691 && TREE_PUBLIC (next
->decl
));
693 vnode
->dissolve_same_comdat_group_list ();
695 if (TREE_PUBLIC (vnode
->decl
))
696 vnode
->set_comdat_group (NULL
);
697 if (DECL_COMDAT (vnode
->decl
) && !vnode
->alias
)
698 vnode
->set_section (NULL
);
699 vnode
->make_decl_local ();
700 vnode
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
702 update_visibility_by_resolution_info (vnode
);
704 /* Update virtual tables to point to local aliases where possible. */
705 if (DECL_VIRTUAL_P (vnode
->decl
)
706 && !DECL_EXTERNAL (vnode
->decl
))
712 /* See if there is something to update. */
713 for (i
= 0; vnode
->iterate_referring (i
, ref
); i
++)
714 if (ref
->use
== IPA_REF_ADDR
715 && can_replace_by_local_alias_in_vtable (ref
->referred
))
722 hash_set
<tree
> visited_nodes
;
724 vnode
->get_constructor ();
725 walk_tree (&DECL_INITIAL (vnode
->decl
),
726 update_vtable_references
, NULL
, &visited_nodes
);
727 vnode
->remove_all_references ();
728 record_references_in_initializer (vnode
->decl
, false);
735 fprintf (dump_file
, "\nMarking local functions:");
736 FOR_EACH_DEFINED_FUNCTION (node
)
737 if (node
->local
.local
)
738 fprintf (dump_file
, " %s", node
->name ());
739 fprintf (dump_file
, "\n\n");
740 fprintf (dump_file
, "\nMarking externally visible functions:");
741 FOR_EACH_DEFINED_FUNCTION (node
)
742 if (node
->externally_visible
)
743 fprintf (dump_file
, " %s", node
->name ());
744 fprintf (dump_file
, "\n\n");
745 fprintf (dump_file
, "\nMarking externally visible variables:");
746 FOR_EACH_DEFINED_VARIABLE (vnode
)
747 if (vnode
->externally_visible
)
748 fprintf (dump_file
, " %s", vnode
->name ());
749 fprintf (dump_file
, "\n\n");
751 symtab
->function_flags_ready
= true;
755 /* Local function pass handling visibilities. This happens before LTO streaming
756 so in particular -fwhole-program should be ignored at this level. */
760 const pass_data pass_data_ipa_function_and_variable_visibility
=
762 SIMPLE_IPA_PASS
, /* type */
763 "visibility", /* name */
764 OPTGROUP_NONE
, /* optinfo_flags */
765 TV_CGRAPHOPT
, /* tv_id */
766 0, /* properties_required */
767 0, /* properties_provided */
768 0, /* properties_destroyed */
769 0, /* todo_flags_start */
770 ( TODO_remove_functions
| TODO_dump_symtab
), /* todo_flags_finish */
773 /* Bring functions local at LTO time with -fwhole-program. */
776 whole_program_function_and_variable_visibility (void)
778 function_and_variable_visibility (flag_whole_program
);
780 ipa_discover_readonly_nonaddressable_vars ();
788 const pass_data pass_data_ipa_whole_program_visibility
=
791 "whole-program", /* name */
792 OPTGROUP_NONE
, /* optinfo_flags */
793 TV_CGRAPHOPT
, /* tv_id */
794 0, /* properties_required */
795 0, /* properties_provided */
796 0, /* properties_destroyed */
797 0, /* todo_flags_start */
798 ( TODO_remove_functions
| TODO_dump_symtab
), /* todo_flags_finish */
801 class pass_ipa_whole_program_visibility
: public ipa_opt_pass_d
804 pass_ipa_whole_program_visibility (gcc::context
*ctxt
)
805 : ipa_opt_pass_d (pass_data_ipa_whole_program_visibility
, ctxt
,
806 NULL
, /* generate_summary */
807 NULL
, /* write_summary */
808 NULL
, /* read_summary */
809 NULL
, /* write_optimization_summary */
810 NULL
, /* read_optimization_summary */
811 NULL
, /* stmt_fixup */
812 0, /* function_transform_todo_flags_start */
813 NULL
, /* function_transform */
814 NULL
) /* variable_transform */
817 /* opt_pass methods: */
819 virtual bool gate (function
*)
821 /* Do not re-run on ltrans stage. */
824 virtual unsigned int execute (function
*)
826 return whole_program_function_and_variable_visibility ();
829 }; // class pass_ipa_whole_program_visibility
834 make_pass_ipa_whole_program_visibility (gcc::context
*ctxt
)
836 return new pass_ipa_whole_program_visibility (ctxt
);
839 class pass_ipa_function_and_variable_visibility
: public simple_ipa_opt_pass
842 pass_ipa_function_and_variable_visibility (gcc::context
*ctxt
)
843 : simple_ipa_opt_pass (pass_data_ipa_function_and_variable_visibility
,
847 /* opt_pass methods: */
848 virtual unsigned int execute (function
*)
850 return function_and_variable_visibility (flag_whole_program
&& !flag_lto
);
853 }; // class pass_ipa_function_and_variable_visibility
855 simple_ipa_opt_pass
*
856 make_pass_ipa_function_and_variable_visibility (gcc::context
*ctxt
)
858 return new pass_ipa_function_and_variable_visibility (ctxt
);