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_alloc_cleared_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       return DECL_INITIAL (real_decl);
 310     }
 311
 312   /* If there is no constructor, we have nothing to do.  */
 313   if (DECL_INITIAL (real_decl) == error_mark_node)
 314     return error_mark_node;
 315
 316   /* Non-readonly alias of readonly variable is also de-facto readonly,
 317      because the variable itself is in readonly section.
 318      We also honnor READONLY flag on alias assuming that user knows
 319      what he is doing.  */
 320   if (!TREE_READONLY (decl) && !TREE_READONLY (real_decl))
 321     return error_mark_node;
 322
 323   /* Variables declared 'const' without an initializer
 324      have zero as the initializer if they may not be
 325      overridden at link or run time.  */
 326   if (!DECL_INITIAL (real_decl)
 327       && (DECL_EXTERNAL (decl) || decl_replaceable_p (decl)))
 328     return error_mark_node;
 329
 330   /* Variables declared `const' with an initializer are considered
 331      to not be overwritable with different initializer by default.
 332
 333      ??? Previously we behaved so for scalar variables but not for array
 334      accesses.  */
 335   return DECL_INITIAL (real_decl);
 336 }
 337
 338 /* Add the variable DECL to the varpool.
 339    Unlike varpool_finalize_decl function is intended to be used
 340    by middle end and allows insertion of new variable at arbitrary point
 341    of compilation.  */
 342 void
 343 varpool_add_new_variable (tree decl)
 344 {
 345   varpool_node *node;
 346   varpool_finalize_decl (decl);
 347   node = varpool_node_for_decl (decl);
 348   varpool_call_variable_insertion_hooks (node);
 349   if (varpool_externally_visible_p (node))
 350     node->externally_visible = true;
 351 }
 352
 353 /* Return variable availability.  See cgraph.h for description of individual
 354    return values.  */
 355 enum availability
 356 cgraph_variable_initializer_availability (varpool_node *node)
 357 {
 358   gcc_assert (cgraph_function_flags_ready);
 359   if (!node->definition)
 360     return AVAIL_NOT_AVAILABLE;
 361   if (!TREE_PUBLIC (node->decl))
 362     return AVAIL_AVAILABLE;
 363   if (DECL_IN_CONSTANT_POOL (node->decl)
 364       || DECL_VIRTUAL_P (node->decl))
 365     return AVAIL_AVAILABLE;
 366   if (node->alias && node->weakref)
 367     {
 368       enum availability avail;
 369
 370       cgraph_variable_initializer_availability
 371               (varpool_variable_node (node, &avail));
 372       return avail;
 373     }
 374   /* If the variable can be overwritten, return OVERWRITABLE.  Takes
 375      care of at least one notable extension - the COMDAT variables
 376      used to share template instantiations in C++.  */
 377   if (decl_replaceable_p (node->decl)
 378       || DECL_EXTERNAL (node->decl))
 379     return AVAIL_OVERWRITABLE;
 380   return AVAIL_AVAILABLE;
 381 }
 382
 383 void
 384 varpool_analyze_node (varpool_node *node)
 385 {
 386   tree decl = node->decl;
 387
 388   /* When reading back varpool at LTO time, we re-construct the queue in order
 389      to have "needed" list right by inserting all needed nodes into varpool.
 390      We however don't want to re-analyze already analyzed nodes.  */
 391   if (!node->analyzed)
 392     {
 393       gcc_assert (!in_lto_p || cgraph_function_flags_ready);
 394       /* Compute the alignment early so function body expanders are
 395          already informed about increased alignment.  */
 396       align_variable (decl, 0);
 397     }
 398   if (node->alias)
 399     symtab_resolve_alias
 400        (node, varpool_get_node (node->alias_target));
 401   else if (DECL_INITIAL (decl))
 402     record_references_in_initializer (decl, node->analyzed);
 403   node->analyzed = true;
 404 }
 405
 406 /* Assemble thunks and aliases associated to NODE.  */
 407
 408 static void
 409 assemble_aliases (varpool_node *node)
 410 {
 411   int i;
 412   struct ipa_ref *ref;
 413   for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
 414     if (ref->use == IPA_REF_ALIAS)
 415       {
 416         varpool_node *alias = ipa_ref_referring_varpool_node (ref);
 417         do_assemble_alias (alias->decl,
 418                            DECL_ASSEMBLER_NAME (node->decl));
 419         assemble_aliases (alias);
 420       }
 421 }
 422
 423 /* Output one variable, if necessary.  Return whether we output it.  */
 424
 425 bool
 426 varpool_assemble_decl (varpool_node *node)
 427 {
 428   tree decl = node->decl;
 429
 430   /* Aliases are outout when their target is produced or by
 431      output_weakrefs.  */
 432   if (node->alias)
 433     return false;
 434
 435   /* Constant pool is output from RTL land when the reference
 436      survive till this level.  */
 437   if (DECL_IN_CONSTANT_POOL (decl) && TREE_ASM_WRITTEN (decl))
 438     return false;
 439
 440   /* Decls with VALUE_EXPR should not be in the varpool at all.  They
 441      are not real variables, but just info for debugging and codegen.
 442      Unfortunately at the moment emutls is not updating varpool correctly
 443      after turning real vars into value_expr vars.  */
 444   if (DECL_HAS_VALUE_EXPR_P (decl)
 445       && !targetm.have_tls)
 446     return false;
 447
 448   /* Hard register vars do not need to be output.  */
 449   if (DECL_HARD_REGISTER (decl))
 450     return false;
 451
 452   gcc_checking_assert (!TREE_ASM_WRITTEN (decl)
 453                        && TREE_CODE (decl) == VAR_DECL
 454                        && !DECL_HAS_VALUE_EXPR_P (decl));
 455
 456   if (!node->in_other_partition
 457       && !DECL_EXTERNAL (decl))
 458     {
 459       assemble_variable (decl, 0, 1, 0);
 460       gcc_assert (TREE_ASM_WRITTEN (decl));
 461       node->definition = true;
 462       assemble_aliases (node);
 463       return true;
 464     }
 465
 466   return false;
 467 }
 468
 469 /* Add NODE to queue starting at FIRST.
 470    The queue is linked via AUX pointers and terminated by pointer to 1.  */
 471
 472 static void
 473 enqueue_node (varpool_node *node, varpool_node **first)
 474 {
 475   if (node->aux)
 476     return;
 477   gcc_checking_assert (*first);
 478   node->aux = *first;
 479   *first = node;
 480 }
 481
 482 /* Optimization of function bodies might've rendered some variables as
 483    unnecessary so we want to avoid these from being compiled.  Re-do
 484    reachability starting from variables that are either externally visible
 485    or was referred from the asm output routines.  */
 486
 487 static void
 488 varpool_remove_unreferenced_decls (void)
 489 {
 490   varpool_node *next, *node;
 491   varpool_node *first = (varpool_node *)(void *)1;
 492   int i;
 493   struct ipa_ref *ref;
 494   struct pointer_set_t *referenced = pointer_set_create ();
 495
 496   if (seen_error ())
 497     return;
 498
 499   if (cgraph_dump_file)
 500     fprintf (cgraph_dump_file, "Trivially needed variables:");
 501   FOR_EACH_DEFINED_VARIABLE (node)
 502     {
 503       if (node->analyzed
 504           && (!varpool_can_remove_if_no_refs (node)
 505               /* We just expanded all function bodies.  See if any of
 506                  them needed the variable.  */
 507               || DECL_RTL_SET_P (node->decl)))
 508         {
 509           enqueue_node (node, &first);
 510           if (cgraph_dump_file)
 511             fprintf (cgraph_dump_file, " %s", node->asm_name ());
 512         }
 513     }
 514   while (first != (varpool_node *)(void *)1)
 515     {
 516       node = first;
 517       first = (varpool_node *)first->aux;
 518
 519       if (node->same_comdat_group)
 520         {
 521           symtab_node *next;
 522           for (next = node->same_comdat_group;
 523                next != node;
 524                next = next->same_comdat_group)
 525             {
 526               varpool_node *vnext = dyn_cast <varpool_node *> (next);
 527               if (vnext && vnext->analyzed && !symtab_comdat_local_p (next))
 528                 enqueue_node (vnext, &first);
 529             }
 530         }
 531       for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
 532         {
 533           varpool_node *vnode = dyn_cast <varpool_node *> (ref->referred);
 534           if (vnode
 535               && !vnode->in_other_partition
 536               && (!DECL_EXTERNAL (ref->referred->decl)
 537                   || vnode->alias)
 538               && vnode->analyzed)
 539             enqueue_node (vnode, &first);
 540           else
 541             pointer_set_insert (referenced, node);
 542         }
 543     }
 544   if (cgraph_dump_file)
 545     fprintf (cgraph_dump_file, "\nRemoving variables:");
 546   for (node = varpool_first_defined_variable (); node; node = next)
 547     {
 548       next = varpool_next_defined_variable (node);
 549       if (!node->aux)
 550         {
 551           if (cgraph_dump_file)
 552             fprintf (cgraph_dump_file, " %s", node->asm_name ());
 553           if (pointer_set_contains (referenced, node))
 554             varpool_remove_initializer (node);
 555           else
 556             varpool_remove_node (node);
 557         }
 558     }
 559   pointer_set_destroy (referenced);
 560   if (cgraph_dump_file)
 561     fprintf (cgraph_dump_file, "\n");
 562 }
 563
 564 /* For variables in named sections make sure get_variable_section
 565    is called before we switch to those sections.  Then section
 566    conflicts between read-only and read-only requiring relocations
 567    sections can be resolved.  */
 568 void
 569 varpool_finalize_named_section_flags (varpool_node *node)
 570 {
 571   if (!TREE_ASM_WRITTEN (node->decl)
 572       && !node->alias
 573       && !node->in_other_partition
 574       && !DECL_EXTERNAL (node->decl)
 575       && TREE_CODE (node->decl) == VAR_DECL
 576       && !DECL_HAS_VALUE_EXPR_P (node->decl)
 577       && DECL_SECTION_NAME (node->decl))
 578     get_variable_section (node->decl, false);
 579 }
 580
 581 /* Output all variables enqueued to be assembled.  */
 582 bool
 583 varpool_output_variables (void)
 584 {
 585   bool changed = false;
 586   varpool_node *node;
 587
 588   if (seen_error ())
 589     return false;
 590
 591   varpool_remove_unreferenced_decls ();
 592
 593   timevar_push (TV_VAROUT);
 594
 595   FOR_EACH_DEFINED_VARIABLE (node)
 596     varpool_finalize_named_section_flags (node);
 597
 598   FOR_EACH_DEFINED_VARIABLE (node)
 599     if (varpool_assemble_decl (node))
 600       changed = true;
 601   timevar_pop (TV_VAROUT);
 602   return changed;
 603 }
 604
 605 /* Create a new global variable of type TYPE.  */
 606 tree
 607 add_new_static_var (tree type)
 608 {
 609   tree new_decl;
 610   varpool_node *new_node;
 611
 612   new_decl = create_tmp_var_raw (type, NULL);
 613   DECL_NAME (new_decl) = create_tmp_var_name (NULL);
 614   TREE_READONLY (new_decl) = 0;
 615   TREE_STATIC (new_decl) = 1;
 616   TREE_USED (new_decl) = 1;
 617   DECL_CONTEXT (new_decl) = NULL_TREE;
 618   DECL_ABSTRACT (new_decl) = 0;
 619   lang_hooks.dup_lang_specific_decl (new_decl);
 620   new_node = varpool_node_for_decl (new_decl);
 621   varpool_finalize_decl (new_decl);
 622
 623   return new_node->decl;
 624 }
 625
 626 /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
 627    Extra name aliases are output whenever DECL is output.  */
 628
 629 varpool_node *
 630 varpool_create_variable_alias (tree alias, tree decl)
 631 {
 632   varpool_node *alias_node;
 633
 634   gcc_assert (TREE_CODE (decl) == VAR_DECL);
 635   gcc_assert (TREE_CODE (alias) == VAR_DECL);
 636   alias_node = varpool_node_for_decl (alias);
 637   alias_node->alias = true;
 638   alias_node->definition = true;
 639   alias_node->alias_target = decl;
 640   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
 641     alias_node->weakref = true;
 642   return alias_node;
 643 }
 644
 645 /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
 646    Extra name aliases are output whenever DECL is output.  */
 647
 648 varpool_node *
 649 varpool_extra_name_alias (tree alias, tree decl)
 650 {
 651   varpool_node *alias_node;
 652
 653 #ifndef ASM_OUTPUT_DEF
 654   /* If aliases aren't supported by the assembler, fail.  */
 655   return NULL;
 656 #endif
 657   alias_node = varpool_create_variable_alias (alias, decl);
 658   alias_node->cpp_implicit_alias = true;
 659
 660   /* Extra name alias mechanizm creates aliases really late
 661      via DECL_ASSEMBLER_NAME mechanizm.
 662      This is unfortunate because they are not going through the
 663      standard channels.  Ensure they get output.  */
 664   if (cpp_implicit_aliases_done)
 665     symtab_resolve_alias (alias_node,
 666                           varpool_node_for_decl (decl));
 667   return alias_node;
 668 }
 669
 670 /* Call calback on NODE and aliases associated to NODE.
 671    When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
 672    skipped. */
 673
 674 bool
 675 varpool_for_node_and_aliases (varpool_node *node,
 676                               bool (*callback) (varpool_node *, void *),
 677                               void *data,
 678                               bool include_overwritable)
 679 {
 680   int i;
 681   struct ipa_ref *ref;
 682
 683   if (callback (node, data))
 684     return true;
 685   for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
 686     if (ref->use == IPA_REF_ALIAS)
 687       {
 688         varpool_node *alias = ipa_ref_referring_varpool_node (ref);
 689         if (include_overwritable
 690             || cgraph_variable_initializer_availability (alias) > AVAIL_OVERWRITABLE)
 691           if (varpool_for_node_and_aliases (alias, callback, data,
 692                                            include_overwritable))
 693             return true;
 694       }
 695   return false;
 696 }