gcc/varpool.c

   1 /* Callgraph handling code.
   2    Copyright (C) 2003-2021 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "backend.h"
  25 #include "target.h"
  26 #include "tree.h"
  27 #include "gimple.h"
  28 #include "timevar.h"
  29 #include "cgraph.h"
  30 #include "lto-streamer.h"
  31 #include "varasm.h"
  32 #include "debug.h"
  33 #include "output.h"
  34 #include "omp-offload.h"
  35 #include "context.h"
  36 #include "stringpool.h"
  37 #include "attribs.h"
  38 #include "tree-pass.h"
  39
  40 const char * const tls_model_names[]={"none", "emulated",
  41                                       "global-dynamic", "local-dynamic",
  42                                       "initial-exec", "local-exec"};
  43
  44 /* List of hooks triggered on varpool_node events.  */
  45 struct varpool_node_hook_list {
  46   varpool_node_hook hook;
  47   void *data;
  48   struct varpool_node_hook_list *next;
  49 };
  50
  51 /* Register HOOK to be called with DATA on each removed node.  */
  52 varpool_node_hook_list *
  53 symbol_table::add_varpool_removal_hook (varpool_node_hook hook, void *data)
  54 {
  55   varpool_node_hook_list *entry;
  56   varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
  57
  58   entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
  59   entry->hook = hook;
  60   entry->data = data;
  61   entry->next = NULL;
  62   while (*ptr)
  63     ptr = &(*ptr)->next;
  64   *ptr = entry;
  65   return entry;
  66 }
  67
  68 /* Remove ENTRY from the list of hooks called on removing nodes.  */
  69 void
  70 symbol_table::remove_varpool_removal_hook (varpool_node_hook_list *entry)
  71 {
  72   varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
  73
  74   while (*ptr != entry)
  75     ptr = &(*ptr)->next;
  76   *ptr = entry->next;
  77   free (entry);
  78 }
  79
  80 /* Call all node removal hooks.  */
  81 void
  82 symbol_table::call_varpool_removal_hooks (varpool_node *node)
  83 {
  84   varpool_node_hook_list *entry = m_first_varpool_removal_hook;
  85   while (entry)
  86   {
  87     entry->hook (node, entry->data);
  88     entry = entry->next;
  89   }
  90 }
  91
  92 /* Register HOOK to be called with DATA on each inserted node.  */
  93 varpool_node_hook_list *
  94 symbol_table::add_varpool_insertion_hook (varpool_node_hook hook, void *data)
  95 {
  96   varpool_node_hook_list *entry;
  97   varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
  98
  99   entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
 100   entry->hook = hook;
 101   entry->data = data;
 102   entry->next = NULL;
 103   while (*ptr)
 104     ptr = &(*ptr)->next;
 105   *ptr = entry;
 106   return entry;
 107 }
 108
 109 /* Remove ENTRY from the list of hooks called on inserted nodes.  */
 110 void
 111 symbol_table::remove_varpool_insertion_hook (varpool_node_hook_list *entry)
 112 {
 113   varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
 114
 115   while (*ptr != entry)
 116     ptr = &(*ptr)->next;
 117   *ptr = entry->next;
 118   free (entry);
 119 }
 120
 121 /* Call all node insertion hooks.  */
 122 void
 123 symbol_table::call_varpool_insertion_hooks (varpool_node *node)
 124 {
 125   varpool_node_hook_list *entry = m_first_varpool_insertion_hook;
 126   while (entry)
 127   {
 128     entry->hook (node, entry->data);
 129     entry = entry->next;
 130   }
 131 }
 132
 133 /* Allocate new callgraph node and insert it into basic data structures.  */
 134
 135 varpool_node *
 136 varpool_node::create_empty (void)
 137 {
 138   return new (ggc_alloc<varpool_node> ()) varpool_node ();
 139 }
 140
 141 /* Return varpool node assigned to DECL.  Create new one when needed.  */
 142 varpool_node *
 143 varpool_node::get_create (tree decl)
 144 {
 145   varpool_node *node = varpool_node::get (decl);
 146   gcc_checking_assert (VAR_P (decl));
 147   if (node)
 148     return node;
 149
 150   node = varpool_node::create_empty ();
 151   node->decl = decl;
 152
 153   if ((flag_openacc || flag_openmp)
 154       && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)))
 155     {
 156       node->offloadable = 1;
 157       if (ENABLE_OFFLOADING && !DECL_EXTERNAL (decl))
 158         {
 159           g->have_offload = true;
 160           if (!in_lto_p)
 161             vec_safe_push (offload_vars, decl);
 162         }
 163     }
 164
 165   node->register_symbol ();
 166   return node;
 167 }
 168
 169 /* Remove variable from symbol table.  */
 170
 171 void
 172 varpool_node::remove (void)
 173 {
 174   symtab->call_varpool_removal_hooks (this);
 175   if (lto_file_data)
 176     {
 177       lto_free_function_in_decl_state_for_node (this);
 178       lto_file_data = NULL;
 179     }
 180
 181   /* When streaming we can have multiple nodes associated with decl.  */
 182   if (symtab->state == LTO_STREAMING)
 183     ;
 184   /* Keep constructor when it may be used for folding. We remove
 185      references to external variables before final compilation.  */
 186   else if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node
 187            && !ctor_useable_for_folding_p ())
 188     remove_initializer ();
 189
 190   unregister (NULL);
 191   ggc_free (this);
 192 }
 193
 194 /* Remove node initializer when it is no longer needed.  */
 195 void
 196 varpool_node::remove_initializer (void)
 197 {
 198   if (DECL_INITIAL (decl)
 199       && !DECL_IN_CONSTANT_POOL (decl)
 200       /* Keep vtables for BINFO folding.  */
 201       && !DECL_VIRTUAL_P (decl)
 202       /* FIXME: http://gcc.gnu.org/PR55395 */
 203       && debug_info_level == DINFO_LEVEL_NONE
 204       /* When doing declaration merging we have duplicate
 205          entries for given decl.  Do not attempt to remove
 206          the bodies, or we will end up removing
 207          wrong one.  */
 208       && symtab->state != LTO_STREAMING)
 209     DECL_INITIAL (decl) = error_mark_node;
 210 }
 211
 212 /* Dump given varpool node to F.  */
 213 void
 214 varpool_node::dump (FILE *f)
 215 {
 216   dump_base (f);
 217   fprintf (f, "  Availability: %s\n",
 218            symtab->function_flags_ready
 219            ? cgraph_availability_names[get_availability ()]
 220            : "not-ready");
 221   fprintf (f, "  Varpool flags:");
 222   if (DECL_INITIAL (decl))
 223     fprintf (f, " initialized");
 224   if (output)
 225     fprintf (f, " output");
 226   if (used_by_single_function)
 227     fprintf (f, " used-by-single-function");
 228   if (TREE_READONLY (decl))
 229     fprintf (f, " read-only");
 230   if (ctor_useable_for_folding_p ())
 231     fprintf (f, " const-value-known");
 232   if (writeonly)
 233     fprintf (f, " write-only");
 234   if (tls_model)
 235     fprintf (f, " tls-%s", tls_model_names [tls_model]);
 236   fprintf (f, "\n");
 237 }
 238
 239
 240 /* Dump given varpool node to stderr.  */
 241 void varpool_node::debug (void)
 242 {
 243   varpool_node::dump (stderr);
 244 }
 245
 246 /* Dump the variable pool to F.  */
 247 void
 248 varpool_node::dump_varpool (FILE *f)
 249 {
 250   varpool_node *node;
 251
 252   fprintf (f, "variable pool:\n\n");
 253   FOR_EACH_VARIABLE (node)
 254     node->dump (f);
 255 }
 256
 257 /* Dump the variable pool to stderr.  */
 258
 259 DEBUG_FUNCTION void
 260 varpool_node::debug_varpool (void)
 261 {
 262   dump_varpool (stderr);
 263 }
 264
 265 /* Given an assembler name, lookup node.  */
 266 varpool_node *
 267 varpool_node::get_for_asmname (tree asmname)
 268 {
 269   if (symtab_node *node = symtab_node::get_for_asmname (asmname))
 270     return dyn_cast <varpool_node *> (node);
 271   else
 272     return NULL;
 273 }
 274
 275 /* When doing LTO, read variable's constructor from disk if
 276    it is not already present.  */
 277
 278 tree
 279 varpool_node::get_constructor (void)
 280 {
 281   lto_file_decl_data *file_data;
 282   const char *data, *name;
 283   size_t len;
 284
 285   if (DECL_INITIAL (decl) != error_mark_node
 286       || !in_lto_p
 287       || !lto_file_data)
 288     return DECL_INITIAL (decl);
 289
 290   timevar_push (TV_IPA_LTO_CTORS_IN);
 291
 292   file_data = lto_file_data;
 293   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 294
 295   /* We may have renamed the declaration, e.g., a static function.  */
 296   name = lto_get_decl_name_mapping (file_data, name);
 297   struct lto_in_decl_state *decl_state
 298          = lto_get_function_in_decl_state (file_data, decl);
 299
 300   data = lto_get_section_data (file_data, LTO_section_function_body,
 301                                name, order - file_data->order_base,
 302                                &len, decl_state->compressed);
 303   if (!data)
 304     fatal_error (input_location, "%s: section %s.%d is missing",
 305                  file_data->file_name,
 306                  name, order - file_data->order_base);
 307
 308   if (!quiet_flag)
 309     fprintf (stderr, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
 310   lto_input_variable_constructor (file_data, this, data);
 311   gcc_assert (DECL_INITIAL (decl) != error_mark_node);
 312   lto_stats.num_function_bodies++;
 313   lto_free_section_data (file_data, LTO_section_function_body, name,
 314                          data, len, decl_state->compressed);
 315   lto_free_function_in_decl_state_for_node (this);
 316   timevar_pop (TV_IPA_LTO_CTORS_IN);
 317   return DECL_INITIAL (decl);
 318 }
 319
 320 /* Return true if variable has constructor that can be used for folding.  */
 321
 322 bool
 323 varpool_node::ctor_useable_for_folding_p (void)
 324 {
 325   varpool_node *real_node = this;
 326
 327   if (real_node->alias && real_node->definition)
 328     real_node = ultimate_alias_target ();
 329
 330   if (TREE_CODE (decl) == CONST_DECL
 331       || DECL_IN_CONSTANT_POOL (decl))
 332     return true;
 333   if (TREE_THIS_VOLATILE (decl))
 334     return false;
 335
 336   /* Avoid attempts to load constructors that was not streamed.  */
 337   if (in_lto_p && DECL_INITIAL (real_node->decl) == error_mark_node
 338       && real_node->body_removed)
 339     return false;
 340
 341   /* If we do not have a constructor, we can't use it.  */
 342   if (DECL_INITIAL (real_node->decl) == error_mark_node
 343       && !real_node->lto_file_data)
 344     return false;
 345
 346   /* Vtables are defined by their types and must match no matter of interposition
 347      rules.  */
 348   if (DECL_VIRTUAL_P (decl))
 349     {
 350       /* The C++ front end creates VAR_DECLs for vtables of typeinfo
 351          classes not defined in the current TU so that it can refer
 352          to them from typeinfo objects.  Avoid returning NULL_TREE.  */
 353       return DECL_INITIAL (real_node->decl) != NULL;
 354     }
 355
 356   /* An alias of a read-only variable is also read-only, since the variable
 357      is stored in read-only memory.  We also accept read-only aliases of
 358      non-read-only locations assuming that the user knows what he is asking
 359      for.  */
 360   if (!TREE_READONLY (decl) && !TREE_READONLY (real_node->decl))
 361     return false;
 362
 363   /* Variables declared 'const' without an initializer
 364      have zero as the initializer if they may not be
 365      overridden at link or run time.
 366
 367      It is actually requirement for C++ compiler to optimize const variables
 368      consistently. As a GNU extension, do not enforce this rule for user defined
 369      weak variables, so we support interposition on:
 370      static const int dummy = 0;
 371      extern const int foo __attribute__((__weak__, __alias__("dummy")));
 372    */
 373   if ((!DECL_INITIAL (real_node->decl)
 374        || (DECL_WEAK (decl) && !DECL_COMDAT (decl)))
 375       && (DECL_EXTERNAL (decl) || decl_replaceable_p (decl)))
 376     return false;
 377
 378   /* Variables declared `const' with an initializer are considered
 379      to not be overwritable with different initializer by default.
 380
 381      ??? Previously we behaved so for scalar variables but not for array
 382      accesses.  */
 383   return true;
 384 }
 385
 386 /* If DECLARATION is constant variable and its initial value is known
 387    (so we can do constant folding), return its constructor (DECL_INITIAL).
 388    This may be an expression or NULL when DECL is initialized to 0.
 389    Return ERROR_MARK_NODE otherwise.
 390
 391    In LTO this may actually trigger reading the constructor from disk.
 392    For this reason varpool_ctor_useable_for_folding_p should be used when
 393    the actual constructor value is not needed.  */
 394
 395 tree
 396 ctor_for_folding (tree decl)
 397 {
 398   varpool_node *node, *real_node;
 399   tree real_decl;
 400
 401   if (!VAR_P (decl) && TREE_CODE (decl) != CONST_DECL)
 402     return error_mark_node;
 403
 404   if (TREE_CODE (decl) == CONST_DECL
 405       || DECL_IN_CONSTANT_POOL (decl))
 406     return DECL_INITIAL (decl);
 407
 408   if (TREE_THIS_VOLATILE (decl))
 409     return error_mark_node;
 410
 411   /* Do not care about automatic variables.  Those are never initialized
 412      anyway, because gimplifier expands the code.  */
 413   if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
 414     {
 415       gcc_assert (!TREE_PUBLIC (decl));
 416       /* Unless this is called during FE folding.  */
 417       if (cfun
 418           && (cfun->curr_properties & (PROP_gimple | PROP_rtl)) == 0
 419           && TREE_READONLY (decl)
 420           && !TREE_SIDE_EFFECTS (decl)
 421           && DECL_INITIAL (decl))
 422         return DECL_INITIAL (decl);
 423       return error_mark_node;
 424     }
 425
 426   gcc_assert (VAR_P (decl));
 427
 428   real_node = node = varpool_node::get (decl);
 429   if (node)
 430     {
 431       real_node = node->ultimate_alias_target ();
 432       real_decl = real_node->decl;
 433     }
 434   else
 435     real_decl = decl;
 436
 437   /* See if we are dealing with alias.
 438      In most cases alias is just alternative symbol pointing to a given
 439      constructor.  This allows us to use interposition rules of DECL
 440      constructor of REAL_NODE.  However weakrefs are special by being just
 441      alternative name of their target (if defined).  */
 442   if (decl != real_decl)
 443     {
 444       gcc_assert (!DECL_INITIAL (decl)
 445                   || (node->alias && node->get_alias_target () == real_node)
 446                   || DECL_INITIAL (decl) == error_mark_node);
 447       while (node->transparent_alias && node->analyzed)
 448         {
 449           node = node->get_alias_target ();
 450           decl = node->decl;
 451         }
 452     }
 453
 454   if ((!DECL_VIRTUAL_P (real_decl)
 455        || DECL_INITIAL (real_decl) == error_mark_node
 456        || !DECL_INITIAL (real_decl))
 457       && (!node || !node->ctor_useable_for_folding_p ()))
 458     return error_mark_node;
 459
 460   /* OK, we can return constructor.  See if we need to fetch it from disk
 461      in LTO mode.  */
 462   if (DECL_INITIAL (real_decl) != error_mark_node
 463       || !in_lto_p)
 464     return DECL_INITIAL (real_decl);
 465   return real_node->get_constructor ();
 466 }
 467
 468 /* Add the variable DECL to the varpool.
 469    Unlike finalize_decl function is intended to be used
 470    by middle end and allows insertion of new variable at arbitrary point
 471    of compilation.  */
 472 void
 473 varpool_node::add (tree decl)
 474 {
 475   varpool_node *node;
 476   varpool_node::finalize_decl (decl);
 477   node = varpool_node::get_create (decl);
 478   symtab->call_varpool_insertion_hooks (node);
 479   if (node->externally_visible_p ())
 480     node->externally_visible = true;
 481   if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl)))
 482     node->no_reorder = 1;
 483 }
 484
 485 /* Return variable availability.  See cgraph.h for description of individual
 486    return values.  */
 487 enum availability
 488 varpool_node::get_availability (symtab_node *ref)
 489 {
 490   if (!definition && !in_other_partition)
 491     return AVAIL_NOT_AVAILABLE;
 492   if (!TREE_PUBLIC (decl))
 493     return AVAIL_AVAILABLE;
 494   if (DECL_IN_CONSTANT_POOL (decl)
 495       || DECL_VIRTUAL_P (decl))
 496     return AVAIL_AVAILABLE;
 497   if (transparent_alias && definition)
 498     {
 499       enum availability avail;
 500
 501       ultimate_alias_target (&avail, ref);
 502       return avail;
 503     }
 504   /* If this is a reference from symbol itself and there are no aliases, we
 505      may be sure that the symbol was not interposed by something else because
 506      the symbol itself would be unreachable otherwise.  */
 507   if ((this == ref && !has_aliases_p ())
 508       || (ref && get_comdat_group ()
 509           && get_comdat_group () == ref->get_comdat_group ()))
 510     return AVAIL_AVAILABLE;
 511   /* If the variable can be overwritten, return OVERWRITABLE.  Takes
 512      care of at least one notable extension - the COMDAT variables
 513      used to share template instantiations in C++.  */
 514   if (decl_replaceable_p (decl)
 515       || DECL_EXTERNAL (decl))
 516     return AVAIL_INTERPOSABLE;
 517   return AVAIL_AVAILABLE;
 518 }
 519
 520 void
 521 varpool_node::analyze (void)
 522 {
 523   /* When reading back varpool at LTO time, we re-construct the queue in order
 524      to have "needed" list right by inserting all needed nodes into varpool.
 525      We however don't want to re-analyze already analyzed nodes.  */
 526   if (!analyzed)
 527     {
 528       gcc_assert (!in_lto_p || symtab->function_flags_ready);
 529       /* Compute the alignment early so function body expanders are
 530          already informed about increased alignment.  */
 531       align_variable (decl, 0);
 532     }
 533   if (alias)
 534     resolve_alias (varpool_node::get (alias_target));
 535   else if (DECL_INITIAL (decl))
 536     record_references_in_initializer (decl, analyzed);
 537   analyzed = true;
 538 }
 539
 540 /* Assemble thunks and aliases associated to varpool node.  */
 541
 542 void
 543 varpool_node::assemble_aliases (void)
 544 {
 545   ipa_ref *ref;
 546
 547   FOR_EACH_ALIAS (this, ref)
 548     {
 549       varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
 550       if (alias->symver)
 551         do_assemble_symver (alias->decl,
 552                             DECL_ASSEMBLER_NAME (decl));
 553       else if (!alias->transparent_alias)
 554         do_assemble_alias (alias->decl,
 555                            DECL_ASSEMBLER_NAME (decl));
 556       alias->assemble_aliases ();
 557     }
 558 }
 559
 560 /* Output one variable, if necessary.  Return whether we output it.  */
 561
 562 bool
 563 varpool_node::assemble_decl (void)
 564 {
 565   /* Aliases are output when their target is produced or by
 566      output_weakrefs.  */
 567   if (alias)
 568     return false;
 569
 570   /* Constant pool is output from RTL land when the reference
 571      survive till this level.  */
 572   if (DECL_IN_CONSTANT_POOL (decl) && TREE_ASM_WRITTEN (decl))
 573     return false;
 574
 575   /* Decls with VALUE_EXPR should not be in the varpool at all.  They
 576      are not real variables, but just info for debugging and codegen.
 577      Unfortunately at the moment emutls is not updating varpool correctly
 578      after turning real vars into value_expr vars.  */
 579   if (DECL_HAS_VALUE_EXPR_P (decl)
 580       && !targetm.have_tls)
 581     return false;
 582
 583   /* Hard register vars do not need to be output.  */
 584   if (DECL_HARD_REGISTER (decl))
 585     return false;
 586
 587   gcc_checking_assert (!TREE_ASM_WRITTEN (decl)
 588                        && VAR_P (decl)
 589                        && !DECL_HAS_VALUE_EXPR_P (decl));
 590
 591   if (!in_other_partition
 592       && !DECL_EXTERNAL (decl))
 593     {
 594       get_constructor ();
 595       assemble_variable (decl, 0, 1, 0);
 596       gcc_assert (TREE_ASM_WRITTEN (decl));
 597       gcc_assert (definition);
 598       assemble_aliases ();
 599       /* After the parser has generated debugging information, augment
 600          this information with any new location/etc information that may
 601          have become available after the compilation proper.  */
 602       debug_hooks->late_global_decl (decl);
 603       return true;
 604     }
 605
 606   return false;
 607 }
 608
 609 /* Add NODE to queue starting at FIRST.
 610    The queue is linked via AUX pointers and terminated by pointer to 1.  */
 611
 612 static void
 613 enqueue_node (varpool_node *node, varpool_node **first)
 614 {
 615   if (node->aux)
 616     return;
 617   gcc_checking_assert (*first);
 618   node->aux = *first;
 619   *first = node;
 620 }
 621
 622 /* Optimization of function bodies might've rendered some variables as
 623    unnecessary so we want to avoid these from being compiled.  Re-do
 624    reachability starting from variables that are either externally visible
 625    or was referred from the asm output routines.  */
 626
 627 void
 628 symbol_table::remove_unreferenced_decls (void)
 629 {
 630   varpool_node *next, *node;
 631   varpool_node *first = (varpool_node *)(void *)1;
 632   int i;
 633   ipa_ref *ref = NULL;
 634   hash_set<varpool_node *> referenced;
 635
 636   if (seen_error ())
 637     return;
 638
 639   if (dump_file)
 640     fprintf (dump_file, "Trivially needed variables:");
 641   FOR_EACH_DEFINED_VARIABLE (node)
 642     {
 643       if (node->analyzed
 644           && (!node->can_remove_if_no_refs_p ()
 645               /* We just expanded all function bodies.  See if any of
 646                  them needed the variable.  */
 647               || DECL_RTL_SET_P (node->decl)))
 648         {
 649           enqueue_node (node, &first);
 650           if (dump_file)
 651             fprintf (dump_file, " %s", node->dump_asm_name ());
 652         }
 653     }
 654   while (first != (varpool_node *)(void *)1)
 655     {
 656       node = first;
 657       first = (varpool_node *)first->aux;
 658
 659       if (node->same_comdat_group)
 660         {
 661           symtab_node *next;
 662           for (next = node->same_comdat_group;
 663                next != node;
 664                next = next->same_comdat_group)
 665             {
 666               varpool_node *vnext = dyn_cast <varpool_node *> (next);
 667               if (vnext && vnext->analyzed && !next->comdat_local_p ())
 668                 enqueue_node (vnext, &first);
 669             }
 670         }
 671       for (i = 0; node->iterate_reference (i, ref); i++)
 672         {
 673           varpool_node *vnode = dyn_cast <varpool_node *> (ref->referred);
 674           if (vnode
 675               && !vnode->in_other_partition
 676               && (!DECL_EXTERNAL (ref->referred->decl)
 677                   || vnode->alias)
 678               && vnode->analyzed)
 679             enqueue_node (vnode, &first);
 680           else
 681             {
 682               referenced.add (vnode);
 683               while (vnode && vnode->alias && vnode->definition)
 684                 {
 685                   vnode = vnode->get_alias_target ();
 686                   referenced.add (vnode);
 687                 }
 688             }
 689         }
 690     }
 691   if (dump_file)
 692     fprintf (dump_file, "\nRemoving variables:");
 693   for (node = first_defined_variable (); node; node = next)
 694     {
 695       next = next_defined_variable (node);
 696       if (!node->aux && !node->no_reorder)
 697         {
 698           if (dump_file)
 699             fprintf (dump_file, " %s", node->dump_asm_name ());
 700           if (referenced.contains(node))
 701             node->remove_initializer ();
 702           else
 703             node->remove ();
 704         }
 705     }
 706
 707   if (dump_file)
 708     fprintf (dump_file, "\n");
 709 }
 710
 711 /* For variables in named sections make sure get_variable_section
 712    is called before we switch to those sections.  Then section
 713    conflicts between read-only and read-only requiring relocations
 714    sections can be resolved.  */
 715 void
 716 varpool_node::finalize_named_section_flags (void)
 717 {
 718   if (!TREE_ASM_WRITTEN (decl)
 719       && !alias
 720       && !in_other_partition
 721       && !DECL_EXTERNAL (decl)
 722       && VAR_P (decl)
 723       && !DECL_HAS_VALUE_EXPR_P (decl)
 724       && get_section ())
 725     get_variable_section (decl, false);
 726 }
 727
 728 /* Output all variables enqueued to be assembled.  */
 729 bool
 730 symbol_table::output_variables (void)
 731 {
 732   bool changed = false;
 733   varpool_node *node;
 734
 735   if (seen_error ())
 736     return false;
 737
 738   remove_unreferenced_decls ();
 739
 740   timevar_push (TV_VAROUT);
 741
 742   FOR_EACH_DEFINED_VARIABLE (node)
 743     {
 744       /* Handled in output_in_order.  */
 745       if (node->no_reorder)
 746         continue;
 747
 748       node->finalize_named_section_flags ();
 749     }
 750
 751   /* There is a similar loop in output_in_order.  Please keep them in sync.  */
 752   FOR_EACH_VARIABLE (node)
 753     {
 754       /* Handled in output_in_order.  */
 755       if (node->no_reorder)
 756         continue;
 757       if (DECL_HARD_REGISTER (node->decl)
 758           || DECL_HAS_VALUE_EXPR_P (node->decl))
 759         continue;
 760       if (node->definition)
 761         changed |= node->assemble_decl ();
 762       else
 763         assemble_undefined_decl (node->decl);
 764     }
 765   timevar_pop (TV_VAROUT);
 766   return changed;
 767 }
 768
 769 /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
 770    Extra name aliases are output whenever DECL is output.  */
 771
 772 varpool_node *
 773 varpool_node::create_alias (tree alias, tree decl)
 774 {
 775   varpool_node *alias_node;
 776
 777   gcc_assert (VAR_P (decl));
 778   gcc_assert (VAR_P (alias));
 779   alias_node = varpool_node::get_create (alias);
 780   alias_node->alias = true;
 781   alias_node->definition = true;
 782   alias_node->alias_target = decl;
 783   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
 784     alias_node->weakref = alias_node->transparent_alias = true;
 785   return alias_node;
 786 }
 787
 788 /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
 789    Extra name aliases are output whenever DECL is output.  */
 790
 791 varpool_node *
 792 varpool_node::create_extra_name_alias (tree alias, tree decl)
 793 {
 794   varpool_node *alias_node;
 795
 796   /* If aliases aren't supported by the assembler, fail.  */
 797   if (!TARGET_SUPPORTS_ALIASES)
 798     return NULL;
 799
 800   alias_node = varpool_node::create_alias (alias, decl);
 801   alias_node->cpp_implicit_alias = true;
 802
 803   /* Extra name alias mechanism creates aliases really late
 804      via DECL_ASSEMBLER_NAME mechanism.
 805      This is unfortunate because they are not going through the
 806      standard channels.  Ensure they get output.  */
 807   if (symtab->cpp_implicit_aliases_done)
 808     alias_node->resolve_alias (varpool_node::get_create (decl));
 809   return alias_node;
 810 }
 811
 812 /* Worker for call_for_symbol_and_aliases.  */
 813
 814 bool
 815 varpool_node::call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *,
 816                                                                void *),
 817                                              void *data,
 818                                              bool include_overwritable)
 819 {
 820   ipa_ref *ref;
 821
 822   FOR_EACH_ALIAS (this, ref)
 823     {
 824       varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
 825       if (include_overwritable
 826           || alias->get_availability () > AVAIL_INTERPOSABLE)
 827         if (alias->call_for_symbol_and_aliases (callback, data,
 828                                                 include_overwritable))
 829           return true;
 830     }
 831   return false;
 832 }