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