gcc/varpool.c

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