gcc/ipa-visibility.c

   1 /* IPA visibility pass
   2    Copyright (C) 2003-2017 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   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.
  10
  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.
  15
  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/>.  */
  19
  20 /* This file implements two related passes:
  21
  22      - pass_data_ipa_function_and_variable_visibility run just after
  23        symbol table, references and callgraph are built
  24
  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.
  28
  29    Purpose of both passes is to set correctly visibility properties
  30    of all symbols.  This includes:
  31
  32     - Symbol privatization:
  33
  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)
  37
  38     - Discovery of local functions:
  39
  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.
  44
  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.
  48
  49     - Dismantling of comdat groups:
  50
  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.
  58
  59     - Local aliases:
  60
  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.
  67
  68       TODO: This should be done for references, too.
  69
  70     - Removal of static ocnstructors and destructors that have no side effects.
  71
  72     - Regularization of several oddities introduced by frontends that may
  73       be impractical later in the optimization queue.  */
  74
  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"
  86
  87 /* Return true when NODE can not be local. Worker for cgraph_local_node_p.  */
  88
  89 static bool
  90 non_local_p (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
  91 {
  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);
 101 }
 102
 103 /* Return true when function can be marked local.  */
 104
 105 bool
 106 cgraph_node::local_p (void)
 107 {
 108    cgraph_node *n = ultimate_alias_target ();
 109
 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);
 114
 115 }
 116
 117 /* A helper for comdat_can_be_unshared_p.  */
 118
 119 static bool
 120 comdat_can_be_unshared_p_1 (symtab_node *node)
 121 {
 122   if (!node->externally_visible)
 123     return true;
 124   if (node->address_can_be_compared_p ())
 125     {
 126       struct ipa_ref *ref;
 127
 128       for (unsigned int i = 0; node->iterate_referring (i, ref); i++)
 129         if (ref->address_matters_p ())
 130           return false;
 131     }
 132
 133   /* If the symbol is used in some weird way, better to not touch it.  */
 134   if (node->force_output)
 135     return false;
 136
 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;
 144
 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;
 151 }
 152
 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.
 158
 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.  */
 161
 162 static bool
 163 comdat_can_be_unshared_p (symtab_node *node)
 164 {
 165   if (!comdat_can_be_unshared_p_1 (node))
 166     return false;
 167   if (node->same_comdat_group)
 168     {
 169       symtab_node *next;
 170
 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;
 178     }
 179   return true;
 180 }
 181
 182 /* Return true when function NODE should be considered externally visible.  */
 183
 184 static bool
 185 cgraph_externally_visible_p (struct cgraph_node *node,
 186                              bool whole_program)
 187 {
 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;
 195
 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;
 203
 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;
 226
 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)
 234     ;
 235   else if (!whole_program)
 236     return true;
 237
 238   if (MAIN_NAME_P (DECL_NAME (node->decl)))
 239     return true;
 240
 241   if (node->instrumentation_clone
 242       && MAIN_NAME_P (DECL_NAME (node->orig_decl)))
 243     return true;
 244
 245   return false;
 246 }
 247
 248 /* Return true when variable should be considered externally visible.  */
 249
 250 bool
 251 varpool_node::externally_visible_p (void)
 252 {
 253   while (transparent_alias && definition)
 254     return get_alias_target ()->externally_visible_p ();
 255   if (DECL_EXTERNAL (decl))
 256     return true;
 257
 258   if (!TREE_PUBLIC (decl))
 259     return false;
 260
 261   /* If linker counts on us, we must preserve the function.  */
 262   if (used_from_object_file_p ())
 263     return true;
 264
 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;
 271
 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;
 283
 284   /* See if we have linker information about symbol not being used or
 285      if we need to make guess based on the declaration.
 286
 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;
 294
 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;
 304
 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)
 312     ;
 313   else if (!flag_whole_program)
 314     return true;
 315
 316   /* Do not attempt to privatize COMDATS by default.
 317      This would break linking with C++ libraries sharing
 318      inline definitions.
 319
 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;
 326 }
 327
 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.
 330  */
 331
 332 static bool
 333 can_replace_by_local_alias (symtab_node *node)
 334 {
 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;
 345
 346   return (node->get_availability () > AVAIL_INTERPOSABLE
 347           && !decl_binds_to_current_def_p (node->decl)
 348           && !node->can_be_discarded_p ());
 349 }
 350
 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.  */
 354
 355 static bool
 356 can_replace_by_local_alias_in_vtable (symtab_node *node)
 357 {
 358   if (is_a <varpool_node *> (node)
 359       && !DECL_VIRTUAL_P (node->decl))
 360     return false;
 361   return can_replace_by_local_alias (node);
 362 }
 363
 364 /* walk_tree callback that rewrites initializer references.   */
 365
 366 static tree
 367 update_vtable_references (tree *tp, int *walk_subtrees,
 368                           void *data ATTRIBUTE_UNUSED)
 369 {
 370   if (VAR_OR_FUNCTION_DECL_P (*tp))
 371     {
 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;
 375     }
 376   else if (IS_TYPE_OR_DECL_P (*tp))
 377     *walk_subtrees = 0;
 378   return NULL;
 379 }
 380
 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.  */
 384
 385 static void
 386 update_visibility_by_resolution_info (symtab_node * node)
 387 {
 388   bool define;
 389
 390   if (!node->externally_visible
 391       || (!DECL_WEAK (node->decl) && !DECL_ONE_ONLY (node->decl))
 392       || node->resolution == LDPR_UNKNOWN)
 393     return;
 394
 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);
 399
 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)
 404       {
 405         if (!next->externally_visible || next->transparent_alias)
 406           continue;
 407
 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;
 416       }
 417
 418   if (node->same_comdat_group)
 419     for (symtab_node *next = node->same_comdat_group;
 420          next != node; next = next->same_comdat_group)
 421       {
 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)
 426           {
 427             DECL_WEAK (next->decl) = false;
 428             next->set_comdat_group (NULL);
 429           }
 430         if (!define)
 431           {
 432             if (next->externally_visible)
 433               DECL_EXTERNAL (next->decl) = true;
 434             next->set_comdat_group (NULL);
 435           }
 436       }
 437
 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)
 441     {
 442       DECL_WEAK (node->decl) = false;
 443       node->set_comdat_group (NULL);
 444       node->dissolve_same_comdat_group_list ();
 445     }
 446   if (!define)
 447     {
 448       DECL_EXTERNAL (node->decl) = true;
 449       node->set_comdat_group (NULL);
 450       node->dissolve_same_comdat_group_list ();
 451     }
 452 }
 453
 454 /* Try to get rid of weakref.  */
 455
 456 static void
 457 optimize_weakref (symtab_node *node)
 458 {
 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;
 466
 467   gcc_assert (node->weakref);
 468
 469   /* Weakrefs with no target defined can not be optimized.  */
 470   if (!node->analyzed)
 471     return;
 472   symtab_node *target = node->get_alias_target ();
 473
 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;
 479
 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));
 504
 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");
 509
 510   if (static_alias)
 511     {
 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;
 521     }
 522   else
 523     {
 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);
 528     }
 529   gcc_assert (node->alias);
 530 }
 531
 532 /* NODE is an externally visible definition, which we've discovered is
 533    not needed externally.  Make it local to this compilation.  */
 534
 535 static void
 536 localize_node (bool whole_program, symtab_node *node)
 537 {
 538   gcc_assert (whole_program || in_lto_p || !TREE_PUBLIC (node->decl));
 539
 540   if (node->same_comdat_group && TREE_PUBLIC (node->decl))
 541     {
 542       for (symtab_node *next = node->same_comdat_group;
 543            next != node; next = next->same_comdat_group)
 544         {
 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);
 555         }
 556
 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 ();
 560     }
 561
 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);
 567
 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)
 573     {
 574       node->resolution = LDPR_PREVAILING_DEF_IRONLY;
 575       node->make_decl_local ();
 576     }
 577 }
 578
 579 /* Decide on visibility of all symbols.  */
 580
 581 static unsigned int
 582 function_and_variable_visibility (bool whole_program)
 583 {
 584   struct cgraph_node *node;
 585   varpool_node *vnode;
 586
 587   /* All aliases should be procssed at this point.  */
 588   gcc_checking_assert (!alias_pairs || !alias_pairs->length ());
 589
 590   FOR_EACH_FUNCTION (node)
 591     {
 592       int flags = flags_from_decl_or_type (node->decl);
 593
 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))
 598         {
 599           DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
 600           DECL_STATIC_DESTRUCTOR (node->decl) = 0;
 601         }
 602
 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)
 607         {
 608           node->force_output = 0;
 609           node->forced_by_abi = 0;
 610         }
 611
 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;
 618
 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.
 621
 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)
 626         {
 627           if (flag_checking)
 628             {
 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));
 635             }
 636           node->dissolve_same_comdat_group_list ();
 637         }
 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))
 644         {
 645           gcc_assert (!node->global.inlined_to);
 646           node->externally_visible = true;
 647         }
 648       else
 649         {
 650           node->externally_visible = false;
 651           node->forced_by_abi = false;
 652         }
 653       if (!node->externally_visible
 654           && node->definition && !node->weakref
 655           && !DECL_EXTERNAL (node->decl))
 656         localize_node (whole_program, node);
 657
 658       if (node->thunk.thunk_p
 659           && !node->thunk.add_pointer_bounds_args
 660           && TREE_PUBLIC (node->decl))
 661         {
 662           struct cgraph_node *decl_node = node;
 663
 664           decl_node = decl_node->callees->callee->function_symbol ();
 665
 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))
 669             {
 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);
 674             }
 675           node->forced_by_abi = decl_node->forced_by_abi;
 676           if (DECL_EXTERNAL (decl_node->decl))
 677             DECL_EXTERNAL (node->decl) = 1;
 678         }
 679
 680       update_visibility_by_resolution_info (node);
 681       if (node->weakref)
 682         optimize_weakref (node);
 683     }
 684   FOR_EACH_DEFINED_FUNCTION (node)
 685     {
 686       if (!node->local.local)
 687         node->local.local |= node->local_p ();
 688
 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.
 694
 695          TODO: We can also update virtual tables.  */
 696       if (node->callers
 697           && can_replace_by_local_alias (node))
 698         {
 699           cgraph_node *alias = dyn_cast<cgraph_node *>
 700             (node->noninterposable_alias ());
 701
 702           if (alias && alias != node)
 703             {
 704               while (node->callers)
 705                 {
 706                   struct cgraph_edge *e = node->callers;
 707
 708                   e->redirect_callee (alias);
 709                   if (gimple_has_body_p (e->caller->decl))
 710                     {
 711                       push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
 712                       e->redirect_call_stmt_to_callee ();
 713                       pop_cfun ();
 714                     }
 715                 }
 716             }
 717         }
 718     }
 719   FOR_EACH_VARIABLE (vnode)
 720     {
 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:
 727
 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:
 735
 736              static int a __attribute__ ((common))
 737
 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);
 751     }
 752   FOR_EACH_DEFINED_VARIABLE (vnode)
 753     {
 754       if (!vnode->definition)
 755         continue;
 756       if (vnode->externally_visible_p ())
 757         vnode->externally_visible = true;
 758       else
 759         {
 760           vnode->externally_visible = false;
 761           vnode->forced_by_abi = false;
 762         }
 763       if (lookup_attribute ("no_reorder",
 764                             DECL_ATTRIBUTES (vnode->decl)))
 765         vnode->no_reorder = 1;
 766
 767       if (!vnode->externally_visible
 768           && !vnode->transparent_alias)
 769         localize_node (whole_program, vnode);
 770
 771       update_visibility_by_resolution_info (vnode);
 772
 773       /* Update virtual tables to point to local aliases where possible.  */
 774       if (DECL_VIRTUAL_P (vnode->decl)
 775           && !DECL_EXTERNAL (vnode->decl))
 776         {
 777           int i;
 778           struct ipa_ref *ref;
 779           bool found = false;
 780
 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))
 785               {
 786                 found = true;
 787                 break;
 788               }
 789           if (found)
 790             {
 791               hash_set<tree> visited_nodes;
 792
 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);
 798             }
 799         }
 800     }
 801
 802   if (dump_file)
 803     {
 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");
 819     }
 820   symtab->function_flags_ready = true;
 821   return 0;
 822 }
 823
 824 /* Local function pass handling visibilities.  This happens before LTO streaming
 825    so in particular -fwhole-program should be ignored at this level.  */
 826
 827 namespace {
 828
 829 const pass_data pass_data_ipa_function_and_variable_visibility =
 830 {
 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 */
 840 };
 841
 842 /* Bring functions local at LTO time with -fwhole-program.  */
 843
 844 static unsigned int
 845 whole_program_function_and_variable_visibility (void)
 846 {
 847   function_and_variable_visibility (flag_whole_program);
 848   if (optimize)
 849     ipa_discover_readonly_nonaddressable_vars ();
 850   return 0;
 851 }
 852
 853 } // anon namespace
 854
 855 namespace {
 856
 857 const pass_data pass_data_ipa_whole_program_visibility =
 858 {
 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 */
 868 };
 869
 870 class pass_ipa_whole_program_visibility : public ipa_opt_pass_d
 871 {
 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 */
 884   {}
 885
 886   /* opt_pass methods: */
 887
 888   virtual bool gate (function *)
 889     {
 890       /* Do not re-run on ltrans stage.  */
 891       return !flag_ltrans;
 892     }
 893   virtual unsigned int execute (function *)
 894     {
 895       return whole_program_function_and_variable_visibility ();
 896     }
 897
 898 }; // class pass_ipa_whole_program_visibility
 899
 900 } // anon namespace
 901
 902 ipa_opt_pass_d *
 903 make_pass_ipa_whole_program_visibility (gcc::context *ctxt)
 904 {
 905   return new pass_ipa_whole_program_visibility (ctxt);
 906 }
 907
 908 class pass_ipa_function_and_variable_visibility : public simple_ipa_opt_pass
 909 {
 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)
 914   {}
 915
 916   /* opt_pass methods: */
 917   virtual unsigned int execute (function *)
 918     {
 919       return function_and_variable_visibility (flag_whole_program && !flag_lto);
 920     }
 921
 922 }; // class pass_ipa_function_and_variable_visibility
 923
 924 simple_ipa_opt_pass *
 925 make_pass_ipa_function_and_variable_visibility (gcc::context *ctxt)
 926 {
 927   return new pass_ipa_function_and_variable_visibility (ctxt);
 928 }