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 "tree.h"
  26 #include "gimple.h"
  27 #include "hard-reg-set.h"
  28 #include "alias.h"
  29 #include "fold-const.h"
  30 #include "varasm.h"
  31 #include "cgraph.h"
  32 #include "langhooks.h"
  33 #include "diagnostic-core.h"
  34 #include "timevar.h"
  35 #include "debug.h"
  36 #include "target.h"
  37 #include "output.h"
  38 #include "flags.h"
  39 #include "lto-streamer.h"
  40 #include "context.h"
  41 #include "omp-low.h"
  42
  43 const char * const tls_model_names[]={"none", "emulated",
  44                                       "global-dynamic", "local-dynamic",
  45                                       "initial-exec", "local-exec"};
  46
  47 /* List of hooks triggered on varpool_node events.  */
  48 struct varpool_node_hook_list {
  49   varpool_node_hook hook;
  50   void *data;
  51   struct varpool_node_hook_list *next;
  52 };
  53
  54 /* Register HOOK to be called with DATA on each removed node.  */
  55 varpool_node_hook_list *
  56 symbol_table::add_varpool_removal_hook (varpool_node_hook hook, void *data)
  57 {
  58   varpool_node_hook_list *entry;
  59   varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
  60
  61   entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
  62   entry->hook = hook;
  63   entry->data = data;
  64   entry->next = NULL;
  65   while (*ptr)
  66     ptr = &(*ptr)->next;
  67   *ptr = entry;
  68   return entry;
  69 }
  70
  71 /* Remove ENTRY from the list of hooks called on removing nodes.  */
  72 void
  73 symbol_table::remove_varpool_removal_hook (varpool_node_hook_list *entry)
  74 {
  75   varpool_node_hook_list **ptr = &m_first_varpool_removal_hook;
  76
  77   while (*ptr != entry)
  78     ptr = &(*ptr)->next;
  79   *ptr = entry->next;
  80   free (entry);
  81 }
  82
  83 /* Call all node removal hooks.  */
  84 void
  85 symbol_table::call_varpool_removal_hooks (varpool_node *node)
  86 {
  87   varpool_node_hook_list *entry = m_first_varpool_removal_hook;
  88   while (entry)
  89   {
  90     entry->hook (node, entry->data);
  91     entry = entry->next;
  92   }
  93 }
  94
  95 /* Register HOOK to be called with DATA on each inserted node.  */
  96 varpool_node_hook_list *
  97 symbol_table::add_varpool_insertion_hook (varpool_node_hook hook, void *data)
  98 {
  99   varpool_node_hook_list *entry;
 100   varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
 101
 102   entry = (varpool_node_hook_list *) xmalloc (sizeof (*entry));
 103   entry->hook = hook;
 104   entry->data = data;
 105   entry->next = NULL;
 106   while (*ptr)
 107     ptr = &(*ptr)->next;
 108   *ptr = entry;
 109   return entry;
 110 }
 111
 112 /* Remove ENTRY from the list of hooks called on inserted nodes.  */
 113 void
 114 symbol_table::remove_varpool_insertion_hook (varpool_node_hook_list *entry)
 115 {
 116   varpool_node_hook_list **ptr = &m_first_varpool_insertion_hook;
 117
 118   while (*ptr != entry)
 119     ptr = &(*ptr)->next;
 120   *ptr = entry->next;
 121   free (entry);
 122 }
 123
 124 /* Call all node insertion hooks.  */
 125 void
 126 symbol_table::call_varpool_insertion_hooks (varpool_node *node)
 127 {
 128   varpool_node_hook_list *entry = m_first_varpool_insertion_hook;
 129   while (entry)
 130   {
 131     entry->hook (node, entry->data);
 132     entry = entry->next;
 133   }
 134 }
 135
 136 /* Allocate new callgraph node and insert it into basic data structures.  */
 137
 138 varpool_node *
 139 varpool_node::create_empty (void)
 140 {
 141   varpool_node *node = ggc_cleared_alloc<varpool_node> ();
 142   node->type = SYMTAB_VARIABLE;
 143   return node;
 144 }
 145
 146 /* Return varpool node assigned to DECL.  Create new one when needed.  */
 147 varpool_node *
 148 varpool_node::get_create (tree decl)
 149 {
 150   varpool_node *node = varpool_node::get (decl);
 151   gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
 152   if (node)
 153     return node;
 154
 155   node = varpool_node::create_empty ();
 156   node->decl = decl;
 157
 158   if ((flag_openacc || flag_openmp) && !DECL_EXTERNAL (decl)
 159       && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)))
 160     {
 161       node->offloadable = 1;
 162 #ifdef ENABLE_OFFLOADING
 163       g->have_offload = true;
 164       if (!in_lto_p)
 165         vec_safe_push (offload_vars, decl);
 166       node->force_output = 1;
 167 #endif
 168     }
 169
 170   node->register_symbol ();
 171   return node;
 172 }
 173
 174 /* Remove variable from symbol table.  */
 175
 176 void
 177 varpool_node::remove (void)
 178 {
 179   symtab->call_varpool_removal_hooks (this);
 180   if (lto_file_data)
 181     {
 182       lto_free_function_in_decl_state_for_node (this);
 183       lto_file_data = NULL;
 184     }
 185
 186   /* When streaming we can have multiple nodes associated with decl.  */
 187   if (symtab->state == LTO_STREAMING)
 188     ;
 189   /* Keep constructor when it may be used for folding. We remove
 190      references to external variables before final compilation.  */
 191   else if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node
 192            && !ctor_useable_for_folding_p ())
 193     remove_initializer ();
 194
 195   unregister ();
 196   ggc_free (this);
 197 }
 198
 199 /* Remove node initializer when it is no longer needed.  */
 200 void
 201 varpool_node::remove_initializer (void)
 202 {
 203   if (DECL_INITIAL (decl)
 204       && !DECL_IN_CONSTANT_POOL (decl)
 205       /* Keep vtables for BINFO folding.  */
 206       && !DECL_VIRTUAL_P (decl)
 207       /* FIXME: http://gcc.gnu.org/PR55395 */
 208       && debug_info_level == DINFO_LEVEL_NONE
 209       /* When doing declaration merging we have duplicate
 210          entries for given decl.  Do not attempt to remove
 211          the boides, or we will end up remiving
 212          wrong one.  */
 213       && symtab->state != LTO_STREAMING)
 214     DECL_INITIAL (decl) = error_mark_node;
 215 }
 216
 217 /* Dump given varpool node to F.  */
 218 void
 219 varpool_node::dump (FILE *f)
 220 {
 221   dump_base (f);
 222   fprintf (f, "  Availability: %s\n",
 223            symtab->function_flags_ready
 224            ? cgraph_availability_names[get_availability ()]
 225            : "not-ready");
 226   fprintf (f, "  Varpool flags:");
 227   if (DECL_INITIAL (decl))
 228     fprintf (f, " initialized");
 229   if (output)
 230     fprintf (f, " output");
 231   if (used_by_single_function)
 232     fprintf (f, " used-by-single-function");
 233   if (need_bounds_init)
 234     fprintf (f, " need-bounds-init");
 235   if (TREE_READONLY (decl))
 236     fprintf (f, " read-only");
 237   if (ctor_useable_for_folding_p ())
 238     fprintf (f, " const-value-known");
 239   if (writeonly)
 240     fprintf (f, " write-only");
 241   if (tls_model)
 242     fprintf (f, " tls-%s", tls_model_names [tls_model]);
 243   fprintf (f, "\n");
 244 }
 245
 246
 247 /* Dump given varpool node to stderr.  */
 248 void varpool_node::debug (void)
 249 {
 250   varpool_node::dump (stderr);
 251 }
 252
 253 /* Dump the variable pool to F.  */
 254 void
 255 varpool_node::dump_varpool (FILE *f)
 256 {
 257   varpool_node *node;
 258
 259   fprintf (f, "variable pool:\n\n");
 260   FOR_EACH_VARIABLE (node)
 261     node->dump (f);
 262 }
 263
 264 /* Dump the variable pool to stderr.  */
 265
 266 DEBUG_FUNCTION void
 267 varpool_node::debug_varpool (void)
 268 {
 269   dump_varpool (stderr);
 270 }
 271
 272 /* Given an assembler name, lookup node.  */
 273 varpool_node *
 274 varpool_node::get_for_asmname (tree asmname)
 275 {
 276   if (symtab_node *node = symtab_node::get_for_asmname (asmname))
 277     return dyn_cast <varpool_node *> (node);
 278   else
 279     return NULL;
 280 }
 281
 282 /* When doing LTO, read variable's constructor from disk if
 283    it is not already present.  */
 284
 285 tree
 286 varpool_node::get_constructor (void)
 287 {
 288   lto_file_decl_data *file_data;
 289   const char *data, *name;
 290   size_t len;
 291
 292   if (DECL_INITIAL (decl) != error_mark_node
 293       || !in_lto_p
 294       || !lto_file_data)
 295     return DECL_INITIAL (decl);
 296
 297   timevar_push (TV_IPA_LTO_CTORS_IN);
 298
 299   file_data = lto_file_data;
 300   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 301
 302   /* We may have renamed the declaration, e.g., a static function.  */
 303   name = lto_get_decl_name_mapping (file_data, name);
 304
 305   data = lto_get_section_data (file_data, LTO_section_function_body,
 306                                name, &len);
 307   if (!data)
 308     fatal_error (input_location, "%s: section %s is missing",
 309                  file_data->file_name,
 310                  name);
 311
 312   lto_input_variable_constructor (file_data, this, data);
 313   gcc_assert (DECL_INITIAL (decl) != error_mark_node);
 314   lto_stats.num_function_bodies++;
 315   lto_free_section_data (file_data, LTO_section_function_body, name,
 316                          data, len);
 317   lto_free_function_in_decl_state_for_node (this);
 318   timevar_pop (TV_IPA_LTO_CTORS_IN);
 319   return DECL_INITIAL (decl);
 320 }
 321
 322 /* Return true if variable has constructor that can be used for folding.  */
 323
 324 bool
 325 varpool_node::ctor_useable_for_folding_p (void)
 326 {
 327   varpool_node *real_node = this;
 328
 329   if (real_node->alias && real_node->definition)
 330     real_node = ultimate_alias_target ();
 331
 332   if (TREE_CODE (decl) == CONST_DECL
 333       || DECL_IN_CONSTANT_POOL (decl))
 334     return true;
 335   if (TREE_THIS_VOLATILE (decl))
 336     return false;
 337
 338   /* If we do not have a constructor, we can't use it.  */
 339   if (DECL_INITIAL (real_node->decl) == error_mark_node
 340       && !real_node->lto_file_data)
 341     return false;
 342
 343   /* Avoid attempts to load constructors that was not streamed.  */
 344   if (flag_ltrans && DECL_INITIAL (real_node->decl) == error_mark_node
 345       && real_node->body_removed)
 346     return false;
 347
 348   /* Vtables are defined by their types and must match no matter of interposition
 349      rules.  */
 350   if (DECL_VIRTUAL_P (decl))
 351     {
 352       /* The C++ front end creates VAR_DECLs for vtables of typeinfo
 353          classes not defined in the current TU so that it can refer
 354          to them from typeinfo objects.  Avoid returning NULL_TREE.  */
 355       return DECL_INITIAL (real_node->decl) != NULL;
 356     }
 357
 358   /* Alias of readonly variable is also readonly, since the variable is stored
 359      in readonly memory.  We also accept readonly aliases of non-readonly
 360      locations assuming that user knows what he is asking for.  */
 361   if (!TREE_READONLY (decl) && !TREE_READONLY (real_node->decl))
 362     return false;
 363
 364   /* Variables declared 'const' without an initializer
 365      have zero as the initializer if they may not be
 366      overridden at link or run time.
 367
 368      It is actually requirement for C++ compiler to optimize const variables
 369      consistently. As a GNU extension, do not enfore this rule for user defined
 370      weak variables, so we support interposition on:
 371      static const int dummy = 0;
 372      extern const int foo __attribute__((__weak__, __alias__("dummy")));
 373    */
 374   if ((!DECL_INITIAL (real_node->decl)
 375        || (DECL_WEAK (decl) && !DECL_COMDAT (decl)))
 376       && (DECL_EXTERNAL (decl) || decl_replaceable_p (decl)))
 377     return false;
 378
 379   /* Variables declared `const' with an initializer are considered
 380      to not be overwritable with different initializer by default.
 381
 382      ??? Previously we behaved so for scalar variables but not for array
 383      accesses.  */
 384   return true;
 385 }
 386
 387 /* If DECLARATION is constant variable and its initial value is known
 388    (so we can do constant folding), return its constructor (DECL_INITIAL).
 389    This may be an expression or NULL when DECL is initialized to 0.
 390    Return ERROR_MARK_NODE otherwise.
 391
 392    In LTO this may actually trigger reading the constructor from disk.
 393    For this reason varpool_ctor_useable_for_folding_p should be used when
 394    the actual constructor value is not needed.  */
 395
 396 tree
 397 ctor_for_folding (tree decl)
 398 {
 399   varpool_node *node, *real_node;
 400   tree real_decl;
 401
 402   if (TREE_CODE (decl) != VAR_DECL
 403       && TREE_CODE (decl) != CONST_DECL)
 404     return error_mark_node;
 405
 406   /* Static constant bounds are created to be
 407      used instead of constants and therefore
 408      do not let folding it.  */
 409   if (POINTER_BOUNDS_P (decl))
 410     return error_mark_node;
 411
 412   if (TREE_CODE (decl) == CONST_DECL
 413       || DECL_IN_CONSTANT_POOL (decl))
 414     return DECL_INITIAL (decl);
 415
 416   if (TREE_THIS_VOLATILE (decl))
 417     return error_mark_node;
 418
 419   /* Do not care about automatic variables.  Those are never initialized
 420      anyway, because gimplifier exapnds the code.  */
 421   if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
 422     {
 423       gcc_assert (!TREE_PUBLIC (decl));
 424       return error_mark_node;
 425     }
 426
 427   gcc_assert (TREE_CODE (decl) == VAR_DECL);
 428
 429   real_node = node = varpool_node::get (decl);
 430   if (node)
 431     {
 432       real_node = node->ultimate_alias_target ();
 433       real_decl = real_node->decl;
 434     }
 435   else
 436     real_decl = decl;
 437
 438   /* See if we are dealing with alias.
 439      In most cases alias is just alternative symbol pointing to a given
 440      constructor.  This allows us to use interposition rules of DECL
 441      constructor of REAL_NODE.  However weakrefs are special by being just
 442      alternative name of their target (if defined).  */
 443   if (decl != real_decl)
 444     {
 445       gcc_assert (!DECL_INITIAL (decl)
 446                   || (node->alias && node->get_alias_target () == real_node)
 447                   || DECL_INITIAL (decl) == error_mark_node);
 448       if (node->weakref)
 449         {
 450           node = node->get_alias_target ();
 451           decl = node->decl;
 452         }
 453     }
 454
 455   if ((!DECL_VIRTUAL_P (real_decl)
 456        || DECL_INITIAL (real_decl) == error_mark_node
 457        || !DECL_INITIAL (real_decl))
 458       && (!node || !node->ctor_useable_for_folding_p ()))
 459     return error_mark_node;
 460
 461   /* OK, we can return constructor.  See if we need to fetch it from disk
 462      in LTO mode.  */
 463   if (DECL_INITIAL (real_decl) != error_mark_node
 464       || !in_lto_p)
 465     return DECL_INITIAL (real_decl);
 466   return real_node->get_constructor ();
 467 }
 468
 469 /* Add the variable DECL to the varpool.
 470    Unlike finalize_decl function is intended to be used
 471    by middle end and allows insertion of new variable at arbitrary point
 472    of compilation.  */
 473 void
 474 varpool_node::add (tree decl)
 475 {
 476   varpool_node *node;
 477   varpool_node::finalize_decl (decl);
 478   node = varpool_node::get_create (decl);
 479   symtab->call_varpool_insertion_hooks (node);
 480   if (node->externally_visible_p ())
 481     node->externally_visible = true;
 482   if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl)))
 483     node->no_reorder = 1;
 484 }
 485
 486 /* Return variable availability.  See cgraph.h for description of individual
 487    return values.  */
 488 enum availability
 489 varpool_node::get_availability (void)
 490 {
 491   if (!definition)
 492     return AVAIL_NOT_AVAILABLE;
 493   if (!TREE_PUBLIC (decl))
 494     return AVAIL_AVAILABLE;
 495   if (DECL_IN_CONSTANT_POOL (decl)
 496       || DECL_VIRTUAL_P (decl))
 497     return AVAIL_AVAILABLE;
 498   if (alias && weakref)
 499     {
 500       enum availability avail;
 501
 502       ultimate_alias_target (&avail)->get_availability ();
 503       return avail;
 504     }
 505   /* If the variable can be overwritten, return OVERWRITABLE.  Takes
 506      care of at least one notable extension - the COMDAT variables
 507      used to share template instantiations in C++.  */
 508   if (decl_replaceable_p (decl)
 509       || DECL_EXTERNAL (decl))
 510     return AVAIL_INTERPOSABLE;
 511   return AVAIL_AVAILABLE;
 512 }
 513
 514 void
 515 varpool_node::analyze (void)
 516 {
 517   /* When reading back varpool at LTO time, we re-construct the queue in order
 518      to have "needed" list right by inserting all needed nodes into varpool.
 519      We however don't want to re-analyze already analyzed nodes.  */
 520   if (!analyzed)
 521     {
 522       gcc_assert (!in_lto_p || symtab->function_flags_ready);
 523       /* Compute the alignment early so function body expanders are
 524          already informed about increased alignment.  */
 525       align_variable (decl, 0);
 526     }
 527   if (alias)
 528     resolve_alias (varpool_node::get (alias_target));
 529   else if (DECL_INITIAL (decl))
 530     record_references_in_initializer (decl, analyzed);
 531   analyzed = true;
 532 }
 533
 534 /* Assemble thunks and aliases associated to varpool node.  */
 535
 536 void
 537 varpool_node::assemble_aliases (void)
 538 {
 539   ipa_ref *ref;
 540
 541   FOR_EACH_ALIAS (this, ref)
 542     {
 543       varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
 544       do_assemble_alias (alias->decl,
 545                          DECL_ASSEMBLER_NAME (decl));
 546       alias->assemble_aliases ();
 547     }
 548 }
 549
 550 /* Output one variable, if necessary.  Return whether we output it.  */
 551
 552 bool
 553 varpool_node::assemble_decl (void)
 554 {
 555   /* Aliases are outout when their target is produced or by
 556      output_weakrefs.  */
 557   if (alias)
 558     return false;
 559
 560   /* Constant pool is output from RTL land when the reference
 561      survive till this level.  */
 562   if (DECL_IN_CONSTANT_POOL (decl) && TREE_ASM_WRITTEN (decl))
 563     return false;
 564
 565   /* Decls with VALUE_EXPR should not be in the varpool at all.  They
 566      are not real variables, but just info for debugging and codegen.
 567      Unfortunately at the moment emutls is not updating varpool correctly
 568      after turning real vars into value_expr vars.  */
 569   if (DECL_HAS_VALUE_EXPR_P (decl)
 570       && !targetm.have_tls)
 571     return false;
 572
 573   /* Hard register vars do not need to be output.  */
 574   if (DECL_HARD_REGISTER (decl))
 575     return false;
 576
 577   gcc_checking_assert (!TREE_ASM_WRITTEN (decl)
 578                        && TREE_CODE (decl) == VAR_DECL
 579                        && !DECL_HAS_VALUE_EXPR_P (decl));
 580
 581   if (!in_other_partition
 582       && !DECL_EXTERNAL (decl))
 583     {
 584       get_constructor ();
 585       assemble_variable (decl, 0, 1, 0);
 586       gcc_assert (TREE_ASM_WRITTEN (decl));
 587       gcc_assert (definition);
 588       assemble_aliases ();
 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 }