gcc/varpool.c

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