[ARM] Add source mode to coprocessor pattern SETs
[official-gcc.git] / gcc / ipa-visibility.c
blobde96b692a0de882dd60405166944e44cdaa4f1b5
1 /* IPA visibility pass
2 Copyright (C) 2003-2017 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
9 version.
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
14 for more details.
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
36 or by other reasons)
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
47 group.
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.
59 - Local aliases:
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
66 calls to it.
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. */
75 #include "config.h"
76 #include "system.h"
77 #include "coretypes.h"
78 #include "tm.h"
79 #include "function.h"
80 #include "tree.h"
81 #include "gimple-expr.h"
82 #include "tree-pass.h"
83 #include "cgraph.h"
84 #include "calls.h"
85 #include "varasm.h"
87 /* Return true when NODE can not be local. Worker for cgraph_local_node_p. */
89 static bool
90 non_local_p (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
92 return !(node->only_called_directly_or_aliased_p ()
93 /* i386 would need update to output thunk with locak calling
94 ocnvetions. */
95 && !node->thunk.thunk_p
96 && node->definition
97 && !DECL_EXTERNAL (node->decl)
98 && !node->externally_visible
99 && !node->used_from_other_partition
100 && !node->in_other_partition);
103 /* Return true when function can be marked local. */
105 bool
106 cgraph_node::local_p (void)
108 cgraph_node *n = ultimate_alias_target ();
110 if (n->thunk.thunk_p)
111 return n->callees->callee->local_p ();
112 return !n->call_for_symbol_thunks_and_aliases (non_local_p,
113 NULL, true);
117 /* A helper for comdat_can_be_unshared_p. */
119 static bool
120 comdat_can_be_unshared_p_1 (symtab_node *node)
122 if (!node->externally_visible)
123 return true;
124 if (node->address_can_be_compared_p ())
126 struct ipa_ref *ref;
128 for (unsigned int i = 0; node->iterate_referring (i, ref); i++)
129 if (ref->address_matters_p ())
130 return false;
133 /* If the symbol is used in some weird way, better to not touch it. */
134 if (node->force_output)
135 return false;
137 /* Explicit instantiations needs to be output when possibly
138 used externally. */
139 if (node->forced_by_abi
140 && TREE_PUBLIC (node->decl)
141 && (node->resolution != LDPR_PREVAILING_DEF_IRONLY
142 && !flag_whole_program))
143 return false;
145 /* Non-readonly and volatile variables can not be duplicated. */
146 if (is_a <varpool_node *> (node)
147 && (!TREE_READONLY (node->decl)
148 || TREE_THIS_VOLATILE (node->decl)))
149 return false;
150 return true;
153 /* COMDAT functions must be shared only if they have address taken,
154 otherwise we can produce our own private implementation with
155 -fwhole-program.
156 Return true when turning COMDAT functoin static can not lead to wrong
157 code when the resulting object links with a library defining same COMDAT.
159 Virtual functions do have their addresses taken from the vtables,
160 but in C++ there is no way to compare their addresses for equality. */
162 static bool
163 comdat_can_be_unshared_p (symtab_node *node)
165 if (!comdat_can_be_unshared_p_1 (node))
166 return false;
167 if (node->same_comdat_group)
169 symtab_node *next;
171 /* If more than one function is in the same COMDAT group, it must
172 be shared even if just one function in the comdat group has
173 address taken. */
174 for (next = node->same_comdat_group;
175 next != node; next = next->same_comdat_group)
176 if (!comdat_can_be_unshared_p_1 (next))
177 return false;
179 return true;
182 /* Return true when function NODE should be considered externally visible. */
184 static bool
185 cgraph_externally_visible_p (struct cgraph_node *node,
186 bool whole_program)
188 while (node->transparent_alias && node->definition)
189 node = node->get_alias_target ();
190 if (!node->definition)
191 return false;
192 if (!TREE_PUBLIC (node->decl)
193 || DECL_EXTERNAL (node->decl))
194 return false;
196 /* Do not try to localize built-in functions yet. One of problems is that we
197 end up mangling their asm for WHOPR that makes it impossible to call them
198 using the implicit built-in declarations anymore. Similarly this enables
199 us to remove them as unreachable before actual calls may appear during
200 expansion or folding. */
201 if (DECL_BUILT_IN (node->decl))
202 return true;
204 /* If linker counts on us, we must preserve the function. */
205 if (node->used_from_object_file_p ())
206 return true;
207 if (DECL_PRESERVE_P (node->decl))
208 return true;
209 if (lookup_attribute ("externally_visible",
210 DECL_ATTRIBUTES (node->decl)))
211 return true;
212 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
213 && lookup_attribute ("dllexport",
214 DECL_ATTRIBUTES (node->decl)))
215 return true;
216 if (node->resolution == LDPR_PREVAILING_DEF_IRONLY)
217 return false;
218 /* When doing LTO or whole program, we can bring COMDAT functoins static.
219 This improves code quality and we know we will duplicate them at most twice
220 (in the case that we are not using plugin and link with object file
221 implementing same COMDAT) */
222 if (((in_lto_p || whole_program) && !flag_incremental_link)
223 && DECL_COMDAT (node->decl)
224 && comdat_can_be_unshared_p (node))
225 return false;
227 /* When doing link time optimizations, hidden symbols become local. */
228 if ((in_lto_p && !flag_incremental_link)
229 && (DECL_VISIBILITY (node->decl) == VISIBILITY_HIDDEN
230 || DECL_VISIBILITY (node->decl) == VISIBILITY_INTERNAL)
231 /* Be sure that node is defined in IR file, not in other object
232 file. In that case we don't set used_from_other_object_file. */
233 && node->definition)
235 else if (!whole_program)
236 return true;
238 if (MAIN_NAME_P (DECL_NAME (node->decl)))
239 return true;
241 if (node->instrumentation_clone
242 && MAIN_NAME_P (DECL_NAME (node->orig_decl)))
243 return true;
245 return false;
248 /* Return true when variable should be considered externally visible. */
250 bool
251 varpool_node::externally_visible_p (void)
253 while (transparent_alias && definition)
254 return get_alias_target ()->externally_visible_p ();
255 if (DECL_EXTERNAL (decl))
256 return true;
258 if (!TREE_PUBLIC (decl))
259 return false;
261 /* If linker counts on us, we must preserve the function. */
262 if (used_from_object_file_p ())
263 return true;
265 /* Bringing TLS variables local may cause dynamic linker failures
266 on limits of static TLS vars. */
267 if (DECL_THREAD_LOCAL_P (decl)
268 && (DECL_TLS_MODEL (decl) != TLS_MODEL_EMULATED
269 && DECL_TLS_MODEL (decl) != TLS_MODEL_INITIAL_EXEC))
270 return true;
272 if (DECL_HARD_REGISTER (decl))
273 return true;
274 if (DECL_PRESERVE_P (decl))
275 return true;
276 if (lookup_attribute ("externally_visible",
277 DECL_ATTRIBUTES (decl)))
278 return true;
279 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
280 && lookup_attribute ("dllexport",
281 DECL_ATTRIBUTES (decl)))
282 return true;
284 /* See if we have linker information about symbol not being used or
285 if we need to make guess based on the declaration.
287 Even if the linker clams the symbol is unused, never bring internal
288 symbols that are declared by user as used or externally visible.
289 This is needed for i.e. references from asm statements. */
290 if (used_from_object_file_p ())
291 return true;
292 if (resolution == LDPR_PREVAILING_DEF_IRONLY)
293 return false;
295 /* As a special case, the COMDAT virtual tables can be unshared.
296 In LTO mode turn vtables into static variables. The variable is readonly,
297 so this does not enable more optimization, but referring static var
298 is faster for dynamic linking. Also this match logic hidding vtables
299 from LTO symbol tables. */
300 if (((in_lto_p || flag_whole_program) && !flag_incremental_link)
301 && DECL_COMDAT (decl)
302 && comdat_can_be_unshared_p (this))
303 return false;
305 /* When doing link time optimizations, hidden symbols become local. */
306 if (in_lto_p && !flag_incremental_link
307 && (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN
308 || DECL_VISIBILITY (decl) == VISIBILITY_INTERNAL)
309 /* Be sure that node is defined in IR file, not in other object
310 file. In that case we don't set used_from_other_object_file. */
311 && definition)
313 else if (!flag_whole_program)
314 return true;
316 /* Do not attempt to privatize COMDATS by default.
317 This would break linking with C++ libraries sharing
318 inline definitions.
320 FIXME: We can do so for readonly vars with no address taken and
321 possibly also for vtables since no direct pointer comparsion is done.
322 It might be interesting to do so to reduce linking overhead. */
323 if (DECL_COMDAT (decl) || DECL_WEAK (decl))
324 return true;
325 return false;
328 /* Return true if reference to NODE can be replaced by a local alias.
329 Local aliases save dynamic linking overhead and enable more optimizations.
332 static bool
333 can_replace_by_local_alias (symtab_node *node)
335 #ifndef ASM_OUTPUT_DEF
336 /* If aliases aren't supported, we can't do replacement. */
337 return false;
338 #endif
339 /* Weakrefs have a reason to be non-local. Be sure we do not replace
340 them. */
341 while (node->transparent_alias && node->definition && !node->weakref)
342 node = node->get_alias_target ();
343 if (node->weakref)
344 return false;
346 return (node->get_availability () > AVAIL_INTERPOSABLE
347 && !decl_binds_to_current_def_p (node->decl)
348 && !node->can_be_discarded_p ());
351 /* Return true if we can replace reference to NODE by local alias
352 within a virtual table. Generally we can replace function pointers
353 and virtual table pointers. */
355 static bool
356 can_replace_by_local_alias_in_vtable (symtab_node *node)
358 if (is_a <varpool_node *> (node)
359 && !DECL_VIRTUAL_P (node->decl))
360 return false;
361 return can_replace_by_local_alias (node);
364 /* walk_tree callback that rewrites initializer references. */
366 static tree
367 update_vtable_references (tree *tp, int *walk_subtrees,
368 void *data ATTRIBUTE_UNUSED)
370 if (VAR_OR_FUNCTION_DECL_P (*tp))
372 if (can_replace_by_local_alias_in_vtable (symtab_node::get (*tp)))
373 *tp = symtab_node::get (*tp)->noninterposable_alias ()->decl;
374 *walk_subtrees = 0;
376 else if (IS_TYPE_OR_DECL_P (*tp))
377 *walk_subtrees = 0;
378 return NULL;
381 /* In LTO we can remove COMDAT groups and weak symbols.
382 Either turn them into normal symbols or external symbol depending on
383 resolution info. */
385 static void
386 update_visibility_by_resolution_info (symtab_node * node)
388 bool define;
390 if (!node->externally_visible
391 || (!DECL_WEAK (node->decl) && !DECL_ONE_ONLY (node->decl))
392 || node->resolution == LDPR_UNKNOWN)
393 return;
395 define = (node->resolution == LDPR_PREVAILING_DEF_IRONLY
396 || node->resolution == LDPR_PREVAILING_DEF
397 || node->resolution == LDPR_UNDEF
398 || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP);
400 /* The linker decisions ought to agree in the whole group. */
401 if (node->same_comdat_group)
402 for (symtab_node *next = node->same_comdat_group;
403 next != node; next = next->same_comdat_group)
405 if (!next->externally_visible || next->transparent_alias)
406 continue;
408 bool same_def
409 = define == (next->resolution == LDPR_PREVAILING_DEF_IRONLY
410 || next->resolution == LDPR_PREVAILING_DEF
411 || next->resolution == LDPR_UNDEF
412 || next->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP);
413 gcc_assert (in_lto_p || same_def);
414 if (!same_def)
415 return;
418 if (node->same_comdat_group)
419 for (symtab_node *next = node->same_comdat_group;
420 next != node; next = next->same_comdat_group)
422 /* During incremental linking we need to keep symbol weak for future
423 linking. We can still drop definition if we know non-LTO world
424 prevails. */
425 if (!flag_incremental_link)
427 DECL_WEAK (next->decl) = false;
428 next->set_comdat_group (NULL);
430 if (!define)
432 if (next->externally_visible)
433 DECL_EXTERNAL (next->decl) = true;
434 next->set_comdat_group (NULL);
438 /* During incremental linking we need to keep symbol weak for future
439 linking. We can still drop definition if we know non-LTO world prevails. */
440 if (!flag_incremental_link)
442 DECL_WEAK (node->decl) = false;
443 node->set_comdat_group (NULL);
444 node->dissolve_same_comdat_group_list ();
446 if (!define)
448 DECL_EXTERNAL (node->decl) = true;
449 node->set_comdat_group (NULL);
450 node->dissolve_same_comdat_group_list ();
454 /* Try to get rid of weakref. */
456 static void
457 optimize_weakref (symtab_node *node)
459 #ifdef ASM_OUTPUT_DEF
460 bool aliases_supported = true;
461 #else
462 bool aliases_supported = false;
463 #endif
464 bool strip_weakref = false;
465 bool static_alias = false;
467 gcc_assert (node->weakref);
469 /* Weakrefs with no target defined can not be optimized. */
470 if (!node->analyzed)
471 return;
472 symtab_node *target = node->get_alias_target ();
474 /* Weakrefs to weakrefs can be optimized only if target can be. */
475 if (target->weakref)
476 optimize_weakref (target);
477 if (target->weakref)
478 return;
480 /* If we have definition of weakref's target and we know it binds locally,
481 we can turn weakref to static alias. */
482 if (target->definition && decl_binds_to_current_def_p (target->decl)
483 && aliases_supported)
484 strip_weakref = static_alias = true;
485 /* Otherwise we can turn weakref into transparent alias. This transformation
486 may break asm statements which directly refers to symbol name and expect
487 GNU as to translate it via .weakref directive. So do not optimize when
488 DECL_PRESERVED is set and .weakref is supported. */
489 else if ((!DECL_PRESERVE_P (target->decl)
490 || IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (node->decl)))
491 && !DECL_WEAK (target->decl)
492 && !DECL_EXTERNAL (target->decl)
493 && ((target->definition && !target->can_be_discarded_p ())
494 || target->resolution != LDPR_UNDEF))
495 strip_weakref = true;
496 if (!strip_weakref)
497 return;
498 node->weakref = false;
499 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (node->decl)) = 0;
500 TREE_CHAIN (DECL_ASSEMBLER_NAME (node->decl)) = NULL_TREE;
501 DECL_ATTRIBUTES (node->decl) = remove_attribute ("weakref",
502 DECL_ATTRIBUTES
503 (node->decl));
505 if (dump_file)
506 fprintf (dump_file, "Optimizing weakref %s %s\n",
507 node->name(),
508 static_alias ? "as static alias" : "as transparent alias");
510 if (static_alias)
512 /* make_decl_local will shortcircuit if it doesn't see TREE_PUBLIC.
513 be sure it really clears the WEAK flag. */
514 TREE_PUBLIC (node->decl) = true;
515 node->make_decl_local ();
516 node->forced_by_abi = false;
517 node->resolution = LDPR_PREVAILING_DEF_IRONLY;
518 node->externally_visible = false;
519 gcc_assert (!DECL_WEAK (node->decl));
520 node->transparent_alias = false;
522 else
524 symtab->change_decl_assembler_name
525 (node->decl, DECL_ASSEMBLER_NAME (node->get_alias_target ()->decl));
526 node->transparent_alias = true;
527 node->copy_visibility_from (target);
529 gcc_assert (node->alias);
532 /* NODE is an externally visible definition, which we've discovered is
533 not needed externally. Make it local to this compilation. */
535 static void
536 localize_node (bool whole_program, symtab_node *node)
538 gcc_assert (whole_program || in_lto_p || !TREE_PUBLIC (node->decl));
540 if (node->same_comdat_group && TREE_PUBLIC (node->decl))
542 for (symtab_node *next = node->same_comdat_group;
543 next != node; next = next->same_comdat_group)
545 next->set_comdat_group (NULL);
546 if (!next->alias)
547 next->set_section (NULL);
548 if (!next->transparent_alias)
549 next->make_decl_local ();
550 next->unique_name
551 |= ((next->resolution == LDPR_PREVAILING_DEF_IRONLY
552 || next->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP)
553 && TREE_PUBLIC (next->decl)
554 && !flag_incremental_link);
557 /* Now everything's localized, the grouping has no meaning, and
558 will cause crashes if we keep it around. */
559 node->dissolve_same_comdat_group_list ();
562 node->unique_name
563 |= ((node->resolution == LDPR_PREVAILING_DEF_IRONLY
564 || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP)
565 && TREE_PUBLIC (node->decl)
566 && !flag_incremental_link);
568 if (TREE_PUBLIC (node->decl))
569 node->set_comdat_group (NULL);
570 if (DECL_COMDAT (node->decl) && !node->alias)
571 node->set_section (NULL);
572 if (!node->transparent_alias)
574 node->resolution = LDPR_PREVAILING_DEF_IRONLY;
575 node->make_decl_local ();
579 /* Decide on visibility of all symbols. */
581 static unsigned int
582 function_and_variable_visibility (bool whole_program)
584 struct cgraph_node *node;
585 varpool_node *vnode;
587 /* All aliases should be procssed at this point. */
588 gcc_checking_assert (!alias_pairs || !alias_pairs->length ());
590 FOR_EACH_FUNCTION (node)
592 int flags = flags_from_decl_or_type (node->decl);
594 /* Optimize away PURE and CONST constructors and destructors. */
595 if (optimize
596 && (flags & (ECF_CONST | ECF_PURE))
597 && !(flags & ECF_LOOPING_CONST_OR_PURE))
599 DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
600 DECL_STATIC_DESTRUCTOR (node->decl) = 0;
603 /* Frontends and alias code marks nodes as needed before parsing
604 is finished. We may end up marking as node external nodes
605 where this flag is meaningless strip it. */
606 if (DECL_EXTERNAL (node->decl) || !node->definition)
608 node->force_output = 0;
609 node->forced_by_abi = 0;
612 /* C++ FE on lack of COMDAT support create local COMDAT functions
613 (that ought to be shared but can not due to object format
614 limitations). It is necessary to keep the flag to make rest of C++ FE
615 happy. Clear the flag here to avoid confusion in middle-end. */
616 if (DECL_COMDAT (node->decl) && !TREE_PUBLIC (node->decl))
617 DECL_COMDAT (node->decl) = 0;
619 /* For external decls stop tracking same_comdat_group. It doesn't matter
620 what comdat group they are in when they won't be emitted in this TU.
622 An exception is LTO where we may end up with both external
623 and non-external declarations in the same comdat group in
624 the case declarations was not merged. */
625 if (node->same_comdat_group && DECL_EXTERNAL (node->decl) && !in_lto_p)
627 if (flag_checking)
629 for (symtab_node *n = node->same_comdat_group;
630 n != node;
631 n = n->same_comdat_group)
632 /* If at least one of same comdat group functions is external,
633 all of them have to be, otherwise it is a front-end bug. */
634 gcc_assert (DECL_EXTERNAL (n->decl));
636 node->dissolve_same_comdat_group_list ();
638 gcc_assert ((!DECL_WEAK (node->decl)
639 && !DECL_COMDAT (node->decl))
640 || TREE_PUBLIC (node->decl)
641 || node->weakref
642 || DECL_EXTERNAL (node->decl));
643 if (cgraph_externally_visible_p (node, whole_program))
645 gcc_assert (!node->global.inlined_to);
646 node->externally_visible = true;
648 else
650 node->externally_visible = false;
651 node->forced_by_abi = false;
653 if (!node->externally_visible
654 && node->definition && !node->weakref
655 && !DECL_EXTERNAL (node->decl))
656 localize_node (whole_program, node);
658 if (node->thunk.thunk_p
659 && !node->thunk.add_pointer_bounds_args
660 && TREE_PUBLIC (node->decl))
662 struct cgraph_node *decl_node = node;
664 decl_node = decl_node->callees->callee->function_symbol ();
666 /* Thunks have the same visibility as function they are attached to.
667 Make sure the C++ front end set this up properly. */
668 if (DECL_ONE_ONLY (decl_node->decl))
670 gcc_checking_assert (DECL_COMDAT (node->decl)
671 == DECL_COMDAT (decl_node->decl));
672 gcc_checking_assert (node->in_same_comdat_group_p (decl_node));
673 gcc_checking_assert (node->same_comdat_group);
675 node->forced_by_abi = decl_node->forced_by_abi;
676 if (DECL_EXTERNAL (decl_node->decl))
677 DECL_EXTERNAL (node->decl) = 1;
680 update_visibility_by_resolution_info (node);
681 if (node->weakref)
682 optimize_weakref (node);
684 FOR_EACH_DEFINED_FUNCTION (node)
686 if (!node->local.local)
687 node->local.local |= node->local_p ();
689 /* If we know that function can not be overwritten by a
690 different semantics and moreover its section can not be
691 discarded, replace all direct calls by calls to an
692 noninterposable alias. This make dynamic linking cheaper and
693 enable more optimization.
695 TODO: We can also update virtual tables. */
696 if (node->callers
697 && can_replace_by_local_alias (node))
699 cgraph_node *alias = dyn_cast<cgraph_node *>
700 (node->noninterposable_alias ());
702 if (alias && alias != node)
704 while (node->callers)
706 struct cgraph_edge *e = node->callers;
708 e->redirect_callee (alias);
709 if (gimple_has_body_p (e->caller->decl))
711 push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
712 e->redirect_call_stmt_to_callee ();
713 pop_cfun ();
719 FOR_EACH_VARIABLE (vnode)
721 /* weak flag makes no sense on local variables. */
722 gcc_assert (!DECL_WEAK (vnode->decl)
723 || vnode->weakref
724 || TREE_PUBLIC (vnode->decl)
725 || DECL_EXTERNAL (vnode->decl));
726 /* In several cases declarations can not be common:
728 - when declaration has initializer
729 - when it is in weak
730 - when it has specific section
731 - when it resides in non-generic address space.
732 - if declaration is local, it will get into .local common section
733 so common flag is not needed. Frontends still produce these in
734 certain cases, such as for:
736 static int a __attribute__ ((common))
738 Canonicalize things here and clear the redundant flag. */
739 if (DECL_COMMON (vnode->decl)
740 && (!(TREE_PUBLIC (vnode->decl)
741 || DECL_EXTERNAL (vnode->decl))
742 || (DECL_INITIAL (vnode->decl)
743 && DECL_INITIAL (vnode->decl) != error_mark_node)
744 || DECL_WEAK (vnode->decl)
745 || DECL_SECTION_NAME (vnode->decl) != NULL
746 || ! (ADDR_SPACE_GENERIC_P
747 (TYPE_ADDR_SPACE (TREE_TYPE (vnode->decl))))))
748 DECL_COMMON (vnode->decl) = 0;
749 if (vnode->weakref)
750 optimize_weakref (vnode);
752 FOR_EACH_DEFINED_VARIABLE (vnode)
754 if (!vnode->definition)
755 continue;
756 if (vnode->externally_visible_p ())
757 vnode->externally_visible = true;
758 else
760 vnode->externally_visible = false;
761 vnode->forced_by_abi = false;
763 if (lookup_attribute ("no_reorder",
764 DECL_ATTRIBUTES (vnode->decl)))
765 vnode->no_reorder = 1;
767 if (!vnode->externally_visible
768 && !vnode->transparent_alias)
769 localize_node (whole_program, vnode);
771 update_visibility_by_resolution_info (vnode);
773 /* Update virtual tables to point to local aliases where possible. */
774 if (DECL_VIRTUAL_P (vnode->decl)
775 && !DECL_EXTERNAL (vnode->decl))
777 int i;
778 struct ipa_ref *ref;
779 bool found = false;
781 /* See if there is something to update. */
782 for (i = 0; vnode->iterate_reference (i, ref); i++)
783 if (ref->use == IPA_REF_ADDR
784 && can_replace_by_local_alias_in_vtable (ref->referred))
786 found = true;
787 break;
789 if (found)
791 hash_set<tree> visited_nodes;
793 vnode->get_constructor ();
794 walk_tree (&DECL_INITIAL (vnode->decl),
795 update_vtable_references, NULL, &visited_nodes);
796 vnode->remove_all_references ();
797 record_references_in_initializer (vnode->decl, false);
802 if (dump_file)
804 fprintf (dump_file, "\nMarking local functions:");
805 FOR_EACH_DEFINED_FUNCTION (node)
806 if (node->local.local)
807 fprintf (dump_file, " %s", node->name ());
808 fprintf (dump_file, "\n\n");
809 fprintf (dump_file, "\nMarking externally visible functions:");
810 FOR_EACH_DEFINED_FUNCTION (node)
811 if (node->externally_visible)
812 fprintf (dump_file, " %s", node->name ());
813 fprintf (dump_file, "\n\n");
814 fprintf (dump_file, "\nMarking externally visible variables:");
815 FOR_EACH_DEFINED_VARIABLE (vnode)
816 if (vnode->externally_visible)
817 fprintf (dump_file, " %s", vnode->name ());
818 fprintf (dump_file, "\n\n");
820 symtab->function_flags_ready = true;
821 return 0;
824 /* Local function pass handling visibilities. This happens before LTO streaming
825 so in particular -fwhole-program should be ignored at this level. */
827 namespace {
829 const pass_data pass_data_ipa_function_and_variable_visibility =
831 SIMPLE_IPA_PASS, /* type */
832 "visibility", /* name */
833 OPTGROUP_NONE, /* optinfo_flags */
834 TV_CGRAPHOPT, /* tv_id */
835 0, /* properties_required */
836 0, /* properties_provided */
837 0, /* properties_destroyed */
838 0, /* todo_flags_start */
839 ( TODO_remove_functions | TODO_dump_symtab ), /* todo_flags_finish */
842 /* Bring functions local at LTO time with -fwhole-program. */
844 static unsigned int
845 whole_program_function_and_variable_visibility (void)
847 function_and_variable_visibility (flag_whole_program);
848 if (optimize)
849 ipa_discover_readonly_nonaddressable_vars ();
850 return 0;
853 } // anon namespace
855 namespace {
857 const pass_data pass_data_ipa_whole_program_visibility =
859 IPA_PASS, /* type */
860 "whole-program", /* name */
861 OPTGROUP_NONE, /* optinfo_flags */
862 TV_CGRAPHOPT, /* tv_id */
863 0, /* properties_required */
864 0, /* properties_provided */
865 0, /* properties_destroyed */
866 0, /* todo_flags_start */
867 ( TODO_remove_functions | TODO_dump_symtab ), /* todo_flags_finish */
870 class pass_ipa_whole_program_visibility : public ipa_opt_pass_d
872 public:
873 pass_ipa_whole_program_visibility (gcc::context *ctxt)
874 : ipa_opt_pass_d (pass_data_ipa_whole_program_visibility, ctxt,
875 NULL, /* generate_summary */
876 NULL, /* write_summary */
877 NULL, /* read_summary */
878 NULL, /* write_optimization_summary */
879 NULL, /* read_optimization_summary */
880 NULL, /* stmt_fixup */
881 0, /* function_transform_todo_flags_start */
882 NULL, /* function_transform */
883 NULL) /* variable_transform */
886 /* opt_pass methods: */
888 virtual bool gate (function *)
890 /* Do not re-run on ltrans stage. */
891 return !flag_ltrans;
893 virtual unsigned int execute (function *)
895 return whole_program_function_and_variable_visibility ();
898 }; // class pass_ipa_whole_program_visibility
900 } // anon namespace
902 ipa_opt_pass_d *
903 make_pass_ipa_whole_program_visibility (gcc::context *ctxt)
905 return new pass_ipa_whole_program_visibility (ctxt);
908 class pass_ipa_function_and_variable_visibility : public simple_ipa_opt_pass
910 public:
911 pass_ipa_function_and_variable_visibility (gcc::context *ctxt)
912 : simple_ipa_opt_pass (pass_data_ipa_function_and_variable_visibility,
913 ctxt)
916 /* opt_pass methods: */
917 virtual unsigned int execute (function *)
919 return function_and_variable_visibility (flag_whole_program && !flag_lto);
922 }; // class pass_ipa_function_and_variable_visibility
924 simple_ipa_opt_pass *
925 make_pass_ipa_function_and_variable_visibility (gcc::context *ctxt)
927 return new pass_ipa_function_and_variable_visibility (ctxt);