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