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