gcc/varpool.c

   1 /* Callgraph handling code.
   2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
   3    Free Software Foundation, Inc.
   4    Contributed by Jan Hubicka
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "cgraph.h"
  28 #include "langhooks.h"
  29 #include "diagnostic.h"
  30 #include "hashtab.h"
  31 #include "ggc.h"
  32 #include "timevar.h"
  33 #include "debug.h"
  34 #include "target.h"
  35 #include "output.h"
  36 #include "gimple.h"
  37 #include "tree-flow.h"
  38 #include "flags.h"
  39
  40 /*  This file contains basic routines manipulating variable pool.
  41
  42     Varpool acts as interface in between the front-end and middle-end
  43     and drives the decision process on what variables and when are
  44     going to be compiled.
  45
  46     The varpool nodes are allocated lazily for declarations
  47     either by frontend or at callgraph construction time.
  48     All variables supposed to be output into final file needs to be
  49     explicitly marked by frontend via VARPOOL_FINALIZE_DECL function.  */
  50
  51 /* Hash table used to convert declarations into nodes.  */
  52 static GTY((param_is (struct varpool_node))) htab_t varpool_hash;
  53
  54 /* The linked list of cgraph varpool nodes.
  55    Linked via node->next pointer.  */
  56 struct varpool_node *varpool_nodes;
  57
  58 /* Queue of cgraph nodes scheduled to be lowered and output.
  59    The queue is maintained via mark_needed_node, linked via node->next_needed
  60    pointer.
  61
  62    LAST_NEEDED_NODE points to the end of queue, so it can be
  63    maintained in forward order.  GTY is needed to make it friendly to
  64    PCH.
  65
  66    During compilation we construct the queue of needed variables
  67    twice: first time it is during cgraph construction, second time it is at the
  68    end of compilation in VARPOOL_REMOVE_UNREFERENCED_DECLS so we can avoid
  69    optimized out variables being output.
  70
  71    Each variable is thus first analyzed and then later possibly output.
  72    FIRST_UNANALYZED_NODE points to first node in queue that was not analyzed
  73    yet and is moved via VARPOOL_ANALYZE_PENDING_DECLS.  */
  74
  75 struct varpool_node *varpool_nodes_queue;
  76 static GTY(()) struct varpool_node *varpool_last_needed_node;
  77 static GTY(()) struct varpool_node *varpool_first_unanalyzed_node;
  78
  79 /* Lists all assembled variables to be sent to debugger output later on.  */
  80 static GTY(()) struct varpool_node *varpool_assembled_nodes_queue;
  81
  82 /* Return name of the node used in debug output.  */
  83 static const char *
  84 varpool_node_name (struct varpool_node *node)
  85 {
  86   return lang_hooks.decl_printable_name (node->decl, 2);
  87 }
  88
  89 /* Returns a hash code for P.  */
  90 static hashval_t
  91 hash_varpool_node (const void *p)
  92 {
  93   const struct varpool_node *n = (const struct varpool_node *) p;
  94   return (hashval_t) DECL_UID (n->decl);
  95 }
  96
  97 /* Returns nonzero if P1 and P2 are equal.  */
  98 static int
  99 eq_varpool_node (const void *p1, const void *p2)
 100 {
 101   const struct varpool_node *n1 =
 102     (const struct varpool_node *) p1;
 103   const struct varpool_node *n2 =
 104     (const struct varpool_node *) p2;
 105   return DECL_UID (n1->decl) == DECL_UID (n2->decl);
 106 }
 107
 108 /* Return varpool node assigned to DECL.  Create new one when needed.  */
 109 struct varpool_node *
 110 varpool_node (tree decl)
 111 {
 112   struct varpool_node key, *node, **slot;
 113
 114   gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
 115
 116   if (!varpool_hash)
 117     varpool_hash = htab_create_ggc (10, hash_varpool_node,
 118                                            eq_varpool_node, NULL);
 119   key.decl = decl;
 120   slot = (struct varpool_node **)
 121     htab_find_slot (varpool_hash, &key, INSERT);
 122   if (*slot)
 123     return *slot;
 124   node = GGC_CNEW (struct varpool_node);
 125   node->decl = decl;
 126   node->order = cgraph_order++;
 127   node->next = varpool_nodes;
 128   varpool_nodes = node;
 129   *slot = node;
 130   return node;
 131 }
 132
 133 /* Dump given cgraph node.  */
 134 void
 135 dump_varpool_node (FILE *f, struct varpool_node *node)
 136 {
 137   fprintf (f, "%s:", varpool_node_name (node));
 138   fprintf (f, " availability:%s",
 139            cgraph_function_flags_ready
 140            ? cgraph_availability_names[cgraph_variable_initializer_availability (node)]
 141            : "not-ready");
 142   if (DECL_INITIAL (node->decl))
 143     fprintf (f, " initialized");
 144   if (node->needed)
 145     fprintf (f, " needed");
 146   if (node->analyzed)
 147     fprintf (f, " analyzed");
 148   if (node->finalized)
 149     fprintf (f, " finalized");
 150   if (node->output)
 151     fprintf (f, " output");
 152   if (node->externally_visible)
 153     fprintf (f, " externally_visible");
 154   fprintf (f, "\n");
 155 }
 156
 157 /* Dump the variable pool.  */
 158 void
 159 dump_varpool (FILE *f)
 160 {
 161   struct varpool_node *node;
 162
 163   fprintf (f, "variable pool:\n\n");
 164   for (node = varpool_nodes; node; node = node->next)
 165     dump_varpool_node (f, node);
 166 }
 167
 168 /* Dump the variable pool to stderr.  */
 169
 170 void
 171 debug_varpool (void)
 172 {
 173   dump_varpool (stderr);
 174 }
 175
 176 /* Given an assembler name, lookup node.  */
 177 struct varpool_node *
 178 varpool_node_for_asm (tree asmname)
 179 {
 180   struct varpool_node *node;
 181
 182   for (node = varpool_nodes; node ; node = node->next)
 183     if (decl_assembler_name_equal (node->decl, asmname))
 184       return node;
 185
 186   return NULL;
 187 }
 188
 189 /* Helper function for finalization code - add node into lists so it will
 190    be analyzed and compiled.  */
 191 static void
 192 varpool_enqueue_needed_node (struct varpool_node *node)
 193 {
 194   if (varpool_last_needed_node)
 195     varpool_last_needed_node->next_needed = node;
 196   varpool_last_needed_node = node;
 197   node->next_needed = NULL;
 198   if (!varpool_nodes_queue)
 199     varpool_nodes_queue = node;
 200   if (!varpool_first_unanalyzed_node)
 201     varpool_first_unanalyzed_node = node;
 202   notice_global_symbol (node->decl);
 203 }
 204
 205 /* Notify finalize_compilation_unit that given node is reachable
 206    or needed.  */
 207 void
 208 varpool_mark_needed_node (struct varpool_node *node)
 209 {
 210   if (!node->needed && node->finalized
 211       && !TREE_ASM_WRITTEN (node->decl))
 212     varpool_enqueue_needed_node (node);
 213   node->needed = 1;
 214 }
 215
 216 /* Reset the queue of needed nodes.  */
 217 static void
 218 varpool_reset_queue (void)
 219 {
 220   varpool_last_needed_node = NULL;
 221   varpool_nodes_queue = NULL;
 222   varpool_first_unanalyzed_node = NULL;
 223 }
 224
 225 /* Determine if variable DECL is needed.  That is, visible to something
 226    either outside this translation unit, something magic in the system
 227    configury */
 228 bool
 229 decide_is_variable_needed (struct varpool_node *node, tree decl)
 230 {
 231   /* If the user told us it is used, then it must be so.  */
 232   if (node->externally_visible || node->force_output)
 233     return true;
 234
 235   /* ??? If the assembler name is set by hand, it is possible to assemble
 236      the name later after finalizing the function and the fact is noticed
 237      in assemble_name then.  This is arguably a bug.  */
 238   if (DECL_ASSEMBLER_NAME_SET_P (decl)
 239       && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
 240     return true;
 241
 242   /* If we decided it was needed before, but at the time we didn't have
 243      the definition available, then it's still needed.  */
 244   if (node->needed)
 245     return true;
 246
 247   /* Externally visible variables must be output.  The exception is
 248      COMDAT variables that must be output only when they are needed.  */
 249   if (TREE_PUBLIC (decl)
 250       && !flag_whole_program
 251       && !flag_lto
 252       && !flag_whopr
 253       && !DECL_COMDAT (decl)
 254       && !DECL_EXTERNAL (decl))
 255     return true;
 256
 257   /* When emulating tls, we actually see references to the control
 258      variable, rather than the user-level variable.  */
 259   if (!targetm.have_tls
 260       && TREE_CODE (decl) == VAR_DECL
 261       && DECL_THREAD_LOCAL_P (decl))
 262     {
 263       tree control = emutls_decl (decl);
 264       if (decide_is_variable_needed (varpool_node (control), control))
 265         return true;
 266     }
 267
 268   /* When not reordering top level variables, we have to assume that
 269      we are going to keep everything.  */
 270   if (flag_toplevel_reorder)
 271     return false;
 272
 273   /* We want to emit COMDAT variables only when absolutely necessary.  */
 274   if (DECL_COMDAT (decl))
 275     return false;
 276   return true;
 277 }
 278
 279 /* Mark DECL as finalized.  By finalizing the declaration, frontend instruct the
 280    middle end to output the variable to asm file, if needed or externally
 281    visible.  */
 282 void
 283 varpool_finalize_decl (tree decl)
 284 {
 285   struct varpool_node *node = varpool_node (decl);
 286
 287   /* FIXME: We don't really stream varpool datastructure and instead rebuild it
 288      by varpool_finalize_decl.  This is not quite correct since this way we can't
 289      attach any info to varpool.  Eventually we will want to stream varpool nodes
 290      and the flags.
 291
 292      For the moment just prevent analysis of varpool nodes to happen again, so
 293      we will re-try to compute "address_taken" flag of varpool that breaks
 294      in presence of clones.  */
 295   if (in_lto_p)
 296     node->analyzed = true;
 297
 298   /* The first declaration of a variable that comes through this function
 299      decides whether it is global (in C, has external linkage)
 300      or local (in C, has internal linkage).  So do nothing more
 301      if this function has already run.  */
 302   if (node->finalized)
 303     {
 304       if (cgraph_global_info_ready)
 305         varpool_assemble_pending_decls ();
 306       return;
 307     }
 308   if (node->needed)
 309     varpool_enqueue_needed_node (node);
 310   node->finalized = true;
 311
 312   if (decide_is_variable_needed (node, decl))
 313     varpool_mark_needed_node (node);
 314   /* Since we reclaim unreachable nodes at the end of every language
 315      level unit, we need to be conservative about possible entry points
 316      there.  */
 317   else if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
 318     varpool_mark_needed_node (node);
 319   if (cgraph_global_info_ready)
 320     varpool_assemble_pending_decls ();
 321 }
 322
 323 /* Return variable availability.  See cgraph.h for description of individual
 324    return values.  */
 325 enum availability
 326 cgraph_variable_initializer_availability (struct varpool_node *node)
 327 {
 328   gcc_assert (cgraph_function_flags_ready);
 329   if (!node->finalized)
 330     return AVAIL_NOT_AVAILABLE;
 331   if (!TREE_PUBLIC (node->decl))
 332     return AVAIL_AVAILABLE;
 333   /* If the variable can be overwritten, return OVERWRITABLE.  Takes
 334      care of at least two notable extensions - the COMDAT variables
 335      used to share template instantiations in C++.  */
 336   if (!(*targetm.binds_local_p) (node->decl) && !DECL_COMDAT (node->decl))
 337     return AVAIL_OVERWRITABLE;
 338   return AVAIL_AVAILABLE;
 339 }
 340
 341 /* Walk the decls we marked as necessary and see if they reference new
 342    variables or functions and add them into the worklists.  */
 343 bool
 344 varpool_analyze_pending_decls (void)
 345 {
 346   bool changed = false;
 347   timevar_push (TV_CGRAPH);
 348
 349   while (varpool_first_unanalyzed_node)
 350     {
 351       tree decl = varpool_first_unanalyzed_node->decl;
 352       bool analyzed = varpool_first_unanalyzed_node->analyzed;
 353
 354       varpool_first_unanalyzed_node->analyzed = true;
 355
 356       varpool_first_unanalyzed_node = varpool_first_unanalyzed_node->next_needed;
 357
 358       /* When reading back varpool at LTO time, we re-construct the queue in order
 359          to have "needed" list right by inserting all needed nodes into varpool.
 360          We however don't want to re-analyze already analyzed nodes.  */
 361       if (!analyzed)
 362         {
 363           gcc_assert (!in_lto_p);
 364           /* Compute the alignment early so function body expanders are
 365              already informed about increased alignment.  */
 366           align_variable (decl, 0);
 367
 368           if (DECL_INITIAL (decl))
 369             record_references_in_initializer (decl);
 370         }
 371       changed = true;
 372     }
 373   timevar_pop (TV_CGRAPH);
 374   return changed;
 375 }
 376
 377 /* Output one variable, if necessary.  Return whether we output it.  */
 378 bool
 379 varpool_assemble_decl (struct varpool_node *node)
 380 {
 381   tree decl = node->decl;
 382
 383   if (!TREE_ASM_WRITTEN (decl)
 384       && !node->alias
 385       && !DECL_EXTERNAL (decl)
 386       && (TREE_CODE (decl) != VAR_DECL || !DECL_HAS_VALUE_EXPR_P (decl)))
 387     {
 388       assemble_variable (decl, 0, 1, 0);
 389       if (TREE_ASM_WRITTEN (decl))
 390         {
 391           node->next_needed = varpool_assembled_nodes_queue;
 392           varpool_assembled_nodes_queue = node;
 393           node->finalized = 1;
 394           return true;
 395         }
 396     }
 397
 398   return false;
 399 }
 400
 401 /* Optimization of function bodies might've rendered some variables as
 402    unnecessary so we want to avoid these from being compiled.
 403
 404    This is done by pruning the queue and keeping only the variables that
 405    really appear needed (ie they are either externally visible or referenced
 406    by compiled function). Re-doing the reachability analysis on variables
 407    brings back the remaining variables referenced by these.  */
 408 void
 409 varpool_remove_unreferenced_decls (void)
 410 {
 411   struct varpool_node *next, *node = varpool_nodes_queue;
 412
 413   varpool_reset_queue ();
 414
 415   if (errorcount || sorrycount)
 416     return;
 417
 418   while (node)
 419     {
 420       tree decl = node->decl;
 421       next = node->next_needed;
 422       node->needed = 0;
 423
 424       if (node->finalized
 425           && (decide_is_variable_needed (node, decl)
 426               /* ??? Cgraph does not yet rule the world with an iron hand,
 427                  and does not control the emission of debug information.
 428                  After a variable has its DECL_RTL set, we must assume that
 429                  it may be referenced by the debug information, and we can
 430                  no longer elide it.  */
 431               || DECL_RTL_SET_P (decl)))
 432         varpool_mark_needed_node (node);
 433
 434       node = next;
 435     }
 436   /* Make sure we mark alias targets as used targets.  */
 437   finish_aliases_1 ();
 438   varpool_analyze_pending_decls ();
 439 }
 440
 441 /* Output all variables enqueued to be assembled.  */
 442 bool
 443 varpool_assemble_pending_decls (void)
 444 {
 445   bool changed = false;
 446
 447   if (errorcount || sorrycount)
 448     return false;
 449
 450   /* EH might mark decls as needed during expansion.  This should be safe since
 451      we don't create references to new function, but it should not be used
 452      elsewhere.  */
 453   varpool_analyze_pending_decls ();
 454
 455   while (varpool_nodes_queue)
 456     {
 457       struct varpool_node *node = varpool_nodes_queue;
 458
 459       varpool_nodes_queue = varpool_nodes_queue->next_needed;
 460       if (varpool_assemble_decl (node))
 461         changed = true;
 462       else
 463         node->next_needed = NULL;
 464     }
 465   /* varpool_nodes_queue is now empty, clear the pointer to the last element
 466      in the queue.  */
 467   varpool_last_needed_node = NULL;
 468   return changed;
 469 }
 470
 471 /* Remove all elements from the queue so we can re-use it for debug output.  */
 472 void
 473 varpool_empty_needed_queue (void)
 474 {
 475   /* EH might mark decls as needed during expansion.  This should be safe since
 476      we don't create references to new function, but it should not be used
 477      elsewhere.  */
 478   varpool_analyze_pending_decls ();
 479
 480   while (varpool_nodes_queue)
 481     {
 482       struct varpool_node *node = varpool_nodes_queue;
 483       varpool_nodes_queue = varpool_nodes_queue->next_needed;
 484       node->next_needed = NULL;
 485     }
 486   /* varpool_nodes_queue is now empty, clear the pointer to the last element
 487      in the queue.  */
 488   varpool_last_needed_node = NULL;
 489 }
 490
 491 /* Create a new global variable of type TYPE.  */
 492 tree
 493 add_new_static_var (tree type)
 494 {
 495   tree new_decl;
 496   struct varpool_node *new_node;
 497
 498   new_decl = create_tmp_var (type, NULL);
 499   DECL_NAME (new_decl) = create_tmp_var_name (NULL);
 500   TREE_READONLY (new_decl) = 0;
 501   TREE_STATIC (new_decl) = 1;
 502   TREE_USED (new_decl) = 1;
 503   DECL_CONTEXT (new_decl) = NULL_TREE;
 504   DECL_ABSTRACT (new_decl) = 0;
 505   lang_hooks.dup_lang_specific_decl (new_decl);
 506   create_var_ann (new_decl);
 507   new_node = varpool_node (new_decl);
 508   varpool_mark_needed_node (new_node);
 509   add_referenced_var (new_decl);
 510   varpool_finalize_decl (new_decl);
 511
 512   return new_node->decl;
 513 }
 514
 515 #include "gt-varpool.h"