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