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