gcc/lto-streamer.c

   1 /* Miscellaneous utilities for GIMPLE streaming.  Things that are used
   2    in both input and output are here.
   3
   4    Copyright 2009, 2010 Free Software Foundation, Inc.
   5    Contributed by Doug Kwan <dougkwan@google.com>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "toplev.h"
  28 #include "flags.h"
  29 #include "tree.h"
  30 #include "gimple.h"
  31 #include "tree-flow.h"
  32 #include "diagnostic-core.h"
  33 #include "bitmap.h"
  34 #include "vec.h"
  35 #include "lto-streamer.h"
  36
  37 /* Statistics gathered during LTO, WPA and LTRANS.  */
  38 struct lto_stats_d lto_stats;
  39
  40 /* LTO uses bitmaps with different life-times.  So use a seperate
  41    obstack for all LTO bitmaps.  */
  42 static bitmap_obstack lto_obstack;
  43 static bool lto_obstack_initialized;
  44
  45
  46 /* Return a string representing LTO tag TAG.  */
  47
  48 const char *
  49 lto_tag_name (enum LTO_tags tag)
  50 {
  51   if (lto_tag_is_tree_code_p (tag))
  52     {
  53       /* For tags representing tree nodes, return the name of the
  54          associated tree code.  */
  55       return tree_code_name[lto_tag_to_tree_code (tag)];
  56     }
  57
  58   if (lto_tag_is_gimple_code_p (tag))
  59     {
  60       /* For tags representing gimple statements, return the name of
  61          the associated gimple code.  */
  62       return gimple_code_name[lto_tag_to_gimple_code (tag)];
  63     }
  64
  65   switch (tag)
  66     {
  67     case LTO_null:
  68       return "LTO_null";
  69     case LTO_bb0:
  70       return "LTO_bb0";
  71     case LTO_bb1:
  72       return "LTO_bb1";
  73     case LTO_eh_region:
  74       return "LTO_eh_region";
  75     case LTO_function:
  76       return "LTO_function";
  77     case LTO_eh_table:
  78       return "LTO_eh_table";
  79     case LTO_ert_cleanup:
  80       return "LTO_ert_cleanup";
  81     case LTO_ert_try:
  82       return "LTO_ert_try";
  83     case LTO_ert_allowed_exceptions:
  84       return "LTO_ert_allowed_exceptions";
  85     case LTO_ert_must_not_throw:
  86       return "LTO_ert_must_not_throw";
  87     case LTO_tree_pickle_reference:
  88       return "LTO_tree_pickle_reference";
  89     case LTO_field_decl_ref:
  90       return "LTO_field_decl_ref";
  91     case LTO_function_decl_ref:
  92       return "LTO_function_decl_ref";
  93     case LTO_label_decl_ref:
  94       return "LTO_label_decl_ref";
  95     case LTO_namespace_decl_ref:
  96       return "LTO_namespace_decl_ref";
  97     case LTO_result_decl_ref:
  98       return "LTO_result_decl_ref";
  99     case LTO_ssa_name_ref:
 100       return "LTO_ssa_name_ref";
 101     case LTO_type_decl_ref:
 102       return "LTO_type_decl_ref";
 103     case LTO_type_ref:
 104       return "LTO_type_ref";
 105     case LTO_global_decl_ref:
 106       return "LTO_global_decl_ref";
 107     default:
 108       return "LTO_UNKNOWN";
 109     }
 110 }
 111
 112
 113 /* Allocate a bitmap from heap.  Initializes the LTO obstack if necessary.  */
 114
 115 bitmap
 116 lto_bitmap_alloc (void)
 117 {
 118   if (!lto_obstack_initialized)
 119     {
 120       bitmap_obstack_initialize (&lto_obstack);
 121       lto_obstack_initialized = true;
 122     }
 123   return BITMAP_ALLOC (&lto_obstack);
 124 }
 125
 126 /* Free bitmap B.  */
 127
 128 void
 129 lto_bitmap_free (bitmap b)
 130 {
 131   BITMAP_FREE (b);
 132 }
 133
 134
 135 /* Get a section name for a particular type or name.  The NAME field
 136    is only used if SECTION_TYPE is LTO_section_function_body. For all
 137    others it is ignored.  The callee of this function is responsible
 138    to free the returned name.  */
 139
 140 char *
 141 lto_get_section_name (int section_type, const char *name, struct lto_file_decl_data *f)
 142 {
 143   const char *add;
 144   char post[32];
 145   const char *sep;
 146
 147   if (section_type == LTO_section_function_body)
 148     {
 149       gcc_assert (name != NULL);
 150       if (name[0] == '*')
 151         name++;
 152       add = name;
 153       sep = "";
 154     }
 155   else if (section_type < LTO_N_SECTION_TYPES)
 156     {
 157       add = lto_section_name[section_type];
 158       sep = ".";
 159     }
 160   else
 161     internal_error ("bytecode stream: unexpected LTO section %s", name);
 162
 163   /* Make the section name unique so that ld -r combining sections
 164      doesn't confuse the reader with merged sections.
 165
 166      For options don't add a ID, the option reader cannot deal with them
 167      and merging should be ok here.
 168
 169      XXX: use crc64 to minimize collisions? */
 170   if (section_type == LTO_section_opts)
 171     strcpy (post, "");
 172   else
 173     sprintf (post, ".%x", f ? f->id : crc32_string(0, get_random_seed (false)));
 174   return concat (LTO_SECTION_NAME_PREFIX, sep, add, post, NULL);
 175 }
 176
 177
 178 /* Show various memory usage statistics related to LTO.  */
 179
 180 void
 181 print_lto_report (void)
 182 {
 183   const char *s = (flag_lto) ? "LTO" : (flag_wpa) ? "WPA" : "LTRANS";
 184   unsigned i;
 185
 186   fprintf (stderr, "%s statistics\n", s);
 187   fprintf (stderr, "[%s] # of input files: "
 188            HOST_WIDE_INT_PRINT_UNSIGNED "\n", s, lto_stats.num_input_files);
 189
 190   fprintf (stderr, "[%s] # of input cgraph nodes: "
 191            HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
 192            lto_stats.num_input_cgraph_nodes);
 193
 194   fprintf (stderr, "[%s] # of function bodies: "
 195            HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
 196            lto_stats.num_function_bodies);
 197
 198   fprintf (stderr, "[%s] ", s);
 199   print_gimple_types_stats ();
 200
 201   for (i = 0; i < NUM_TREE_CODES; i++)
 202     if (lto_stats.num_trees[i])
 203       fprintf (stderr, "[%s] # of '%s' objects read: "
 204                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
 205                tree_code_name[i], lto_stats.num_trees[i]);
 206
 207   if (flag_lto)
 208     {
 209       fprintf (stderr, "[%s] Compression: "
 210                HOST_WIDE_INT_PRINT_UNSIGNED " output bytes, "
 211                HOST_WIDE_INT_PRINT_UNSIGNED " compressed bytes", s,
 212                lto_stats.num_output_il_bytes,
 213                lto_stats.num_compressed_il_bytes);
 214       if (lto_stats.num_output_il_bytes > 0)
 215         {
 216           const float dividend = (float) lto_stats.num_compressed_il_bytes;
 217           const float divisor = (float) lto_stats.num_output_il_bytes;
 218           fprintf (stderr, " (ratio: %f)", dividend / divisor);
 219         }
 220       fprintf (stderr, "\n");
 221     }
 222
 223   if (flag_wpa)
 224     {
 225       fprintf (stderr, "[%s] # of output files: "
 226                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
 227                lto_stats.num_output_files);
 228
 229       fprintf (stderr, "[%s] # of output cgraph nodes: "
 230                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
 231                lto_stats.num_output_cgraph_nodes);
 232
 233       fprintf (stderr, "[%s] # callgraph partitions: "
 234                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
 235                lto_stats.num_cgraph_partitions);
 236
 237       fprintf (stderr, "[%s] Compression: "
 238                HOST_WIDE_INT_PRINT_UNSIGNED " input bytes, "
 239                HOST_WIDE_INT_PRINT_UNSIGNED " uncompressed bytes", s,
 240                lto_stats.num_input_il_bytes,
 241                lto_stats.num_uncompressed_il_bytes);
 242       if (lto_stats.num_input_il_bytes > 0)
 243         {
 244           const float dividend = (float) lto_stats.num_uncompressed_il_bytes;
 245           const float divisor = (float) lto_stats.num_input_il_bytes;
 246           fprintf (stderr, " (ratio: %f)", dividend / divisor);
 247         }
 248       fprintf (stderr, "\n");
 249     }
 250
 251   for (i = 0; i < LTO_N_SECTION_TYPES; i++)
 252     fprintf (stderr, "[%s] Size of mmap'd section %s: "
 253              HOST_WIDE_INT_PRINT_UNSIGNED " bytes\n", s,
 254              lto_section_name[i], lto_stats.section_size[i]);
 255 }
 256
 257
 258 /* Check that all the TS_* structures handled by the lto_output_* and
 259    lto_input_* routines are exactly ALL the structures defined in
 260    treestruct.def.  */
 261
 262 static void
 263 check_handled_ts_structures (void)
 264 {
 265   bool handled_p[LAST_TS_ENUM];
 266   unsigned i;
 267
 268   memset (&handled_p, 0, sizeof (handled_p));
 269
 270   /* These are the TS_* structures that are either handled or
 271      explicitly ignored by the streamer routines.  */
 272   handled_p[TS_BASE] = true;
 273   handled_p[TS_TYPED] = true;
 274   handled_p[TS_COMMON] = true;
 275   handled_p[TS_INT_CST] = true;
 276   handled_p[TS_REAL_CST] = true;
 277   handled_p[TS_FIXED_CST] = true;
 278   handled_p[TS_VECTOR] = true;
 279   handled_p[TS_STRING] = true;
 280   handled_p[TS_COMPLEX] = true;
 281   handled_p[TS_IDENTIFIER] = true;
 282   handled_p[TS_DECL_MINIMAL] = true;
 283   handled_p[TS_DECL_COMMON] = true;
 284   handled_p[TS_DECL_WRTL] = true;
 285   handled_p[TS_DECL_NON_COMMON] = true;
 286   handled_p[TS_DECL_WITH_VIS] = true;
 287   handled_p[TS_FIELD_DECL] = true;
 288   handled_p[TS_VAR_DECL] = true;
 289   handled_p[TS_PARM_DECL] = true;
 290   handled_p[TS_LABEL_DECL] = true;
 291   handled_p[TS_RESULT_DECL] = true;
 292   handled_p[TS_CONST_DECL] = true;
 293   handled_p[TS_TYPE_DECL] = true;
 294   handled_p[TS_FUNCTION_DECL] = true;
 295   handled_p[TS_TYPE] = true;
 296   handled_p[TS_LIST] = true;
 297   handled_p[TS_VEC] = true;
 298   handled_p[TS_EXP] = true;
 299   handled_p[TS_SSA_NAME] = true;
 300   handled_p[TS_BLOCK] = true;
 301   handled_p[TS_BINFO] = true;
 302   handled_p[TS_STATEMENT_LIST] = true;
 303   handled_p[TS_CONSTRUCTOR] = true;
 304   handled_p[TS_OMP_CLAUSE] = true;
 305   handled_p[TS_OPTIMIZATION] = true;
 306   handled_p[TS_TARGET_OPTION] = true;
 307   handled_p[TS_TRANSLATION_UNIT_DECL] = true;
 308
 309   /* Anything not marked above will trigger the following assertion.
 310      If this assertion triggers, it means that there is a new TS_*
 311      structure that should be handled by the streamer.  */
 312   for (i = 0; i < LAST_TS_ENUM; i++)
 313     gcc_assert (handled_p[i]);
 314 }
 315
 316
 317 /* Helper for lto_streamer_cache_insert_1.  Add T to CACHE->NODES at
 318    slot IX.  */
 319
 320 static void
 321 lto_streamer_cache_add_to_node_array (struct lto_streamer_cache_d *cache,
 322                                       unsigned ix, tree t)
 323 {
 324   /* Make sure we're either replacing an old element or
 325      appending consecutively.  */
 326   gcc_assert (ix <= VEC_length (tree, cache->nodes));
 327
 328   if (ix == VEC_length (tree, cache->nodes))
 329     VEC_safe_push (tree, heap, cache->nodes, t);
 330   else
 331     VEC_replace (tree, cache->nodes, ix, t);
 332 }
 333
 334
 335 /* Helper for lto_streamer_cache_insert and lto_streamer_cache_insert_at.
 336    CACHE, T, and IX_P are as in lto_streamer_cache_insert.
 337
 338    If INSERT_AT_NEXT_SLOT_P is true, T is inserted at the next available
 339    slot in the cache.  Otherwise, T is inserted at the position indicated
 340    in *IX_P.
 341
 342    If T already existed in CACHE, return true.  Otherwise,
 343    return false.  */
 344
 345 static bool
 346 lto_streamer_cache_insert_1 (struct lto_streamer_cache_d *cache,
 347                              tree t, unsigned *ix_p,
 348                              bool insert_at_next_slot_p)
 349 {
 350   void **slot;
 351   unsigned ix;
 352   bool existed_p;
 353
 354   gcc_assert (t);
 355
 356   slot = pointer_map_insert (cache->node_map, t);
 357   if (!*slot)
 358     {
 359       /* Determine the next slot to use in the cache.  */
 360       if (insert_at_next_slot_p)
 361         ix = VEC_length (tree, cache->nodes);
 362       else
 363         ix = *ix_p;
 364        *slot = (void *)(size_t) (ix + 1);
 365
 366       lto_streamer_cache_add_to_node_array (cache, ix, t);
 367
 368       /* Indicate that the item was not present in the cache.  */
 369       existed_p = false;
 370     }
 371   else
 372     {
 373       ix = (size_t) *slot - 1;
 374
 375       if (!insert_at_next_slot_p && ix != *ix_p)
 376         {
 377           /* If the caller wants to insert T at a specific slot
 378              location, and ENTRY->TO does not match *IX_P, add T to
 379              the requested location slot.  */
 380           ix = *ix_p;
 381           lto_streamer_cache_add_to_node_array (cache, ix, t);
 382         }
 383
 384       /* Indicate that T was already in the cache.  */
 385       existed_p = true;
 386     }
 387
 388   if (ix_p)
 389     *ix_p = ix;
 390
 391   return existed_p;
 392 }
 393
 394
 395 /* Insert tree node T in CACHE.  If T already existed in the cache
 396    return true.  Otherwise, return false.
 397
 398    If IX_P is non-null, update it with the index into the cache where
 399    T has been stored.  */
 400
 401 bool
 402 lto_streamer_cache_insert (struct lto_streamer_cache_d *cache, tree t,
 403                            unsigned *ix_p)
 404 {
 405   return lto_streamer_cache_insert_1 (cache, t, ix_p, true);
 406 }
 407
 408
 409 /* Insert tree node T in CACHE at slot IX.  If T already
 410    existed in the cache return true.  Otherwise, return false.  */
 411
 412 bool
 413 lto_streamer_cache_insert_at (struct lto_streamer_cache_d *cache,
 414                               tree t, unsigned ix)
 415 {
 416   return lto_streamer_cache_insert_1 (cache, t, &ix, false);
 417 }
 418
 419
 420 /* Appends tree node T to CACHE, even if T already existed in it.  */
 421
 422 void
 423 lto_streamer_cache_append (struct lto_streamer_cache_d *cache, tree t)
 424 {
 425   unsigned ix = VEC_length (tree, cache->nodes);
 426   lto_streamer_cache_insert_1 (cache, t, &ix, false);
 427 }
 428
 429 /* Return true if tree node T exists in CACHE, otherwise false.  If IX_P is
 430    not NULL, write to *IX_P the index into the cache where T is stored
 431    ((unsigned)-1 if T is not found).  */
 432
 433 bool
 434 lto_streamer_cache_lookup (struct lto_streamer_cache_d *cache, tree t,
 435                            unsigned *ix_p)
 436 {
 437   void **slot;
 438   bool retval;
 439   unsigned ix;
 440
 441   gcc_assert (t);
 442
 443   slot = pointer_map_contains  (cache->node_map, t);
 444   if (slot == NULL)
 445     {
 446       retval = false;
 447       ix = -1;
 448     }
 449   else
 450     {
 451       retval = true;
 452       ix = (size_t) *slot - 1;
 453     }
 454
 455   if (ix_p)
 456     *ix_p = ix;
 457
 458   return retval;
 459 }
 460
 461
 462 /* Return the tree node at slot IX in CACHE.  */
 463
 464 tree
 465 lto_streamer_cache_get (struct lto_streamer_cache_d *cache, unsigned ix)
 466 {
 467   gcc_assert (cache);
 468
 469   /* Make sure we're not requesting something we don't have.  */
 470   gcc_assert (ix < VEC_length (tree, cache->nodes));
 471
 472   return VEC_index (tree, cache->nodes, ix);
 473 }
 474
 475
 476 /* Record NODE in COMMON_NODES if it is not NULL and is not already in
 477    SEEN_NODES.  */
 478
 479 static void
 480 lto_record_common_node (tree *nodep, VEC(tree, heap) **common_nodes,
 481                         struct pointer_set_t *seen_nodes)
 482 {
 483   tree node = *nodep;
 484
 485   if (node == NULL_TREE)
 486     return;
 487
 488   if (TYPE_P (node))
 489     {
 490       /* Type merging will get confused by the canonical types as they
 491          are set by the middle-end.  */
 492       if (in_lto_p)
 493         TYPE_CANONICAL (node) = NULL_TREE;
 494       node = gimple_register_type (node);
 495       TYPE_CANONICAL (node) = gimple_register_canonical_type (node);
 496       if (in_lto_p)
 497         TYPE_CANONICAL (*nodep) = TYPE_CANONICAL (node);
 498       *nodep = node;
 499     }
 500
 501   /* Return if node is already seen.  */
 502   if (pointer_set_insert (seen_nodes, node))
 503     return;
 504
 505   VEC_safe_push (tree, heap, *common_nodes, node);
 506
 507   if (POINTER_TYPE_P (node)
 508       || TREE_CODE (node) == COMPLEX_TYPE
 509       || TREE_CODE (node) == ARRAY_TYPE)
 510     lto_record_common_node (&TREE_TYPE (node), common_nodes, seen_nodes);
 511 }
 512
 513
 514 /* Generate a vector of common nodes and make sure they are merged
 515    properly according to the gimple type table.  */
 516
 517 static VEC(tree,heap) *
 518 lto_get_common_nodes (void)
 519 {
 520   unsigned i;
 521   VEC(tree,heap) *common_nodes = NULL;
 522   struct pointer_set_t *seen_nodes;
 523
 524   /* The MAIN_IDENTIFIER_NODE is normally set up by the front-end, but the
 525      LTO back-end must agree. Currently, the only languages that set this
 526      use the name "main".  */
 527   if (main_identifier_node)
 528     {
 529       const char *main_name = IDENTIFIER_POINTER (main_identifier_node);
 530       gcc_assert (strcmp (main_name, "main") == 0);
 531     }
 532   else
 533     main_identifier_node = get_identifier ("main");
 534
 535   gcc_assert (ptrdiff_type_node == integer_type_node);
 536
 537   /* FIXME lto.  In the C++ front-end, fileptr_type_node is defined as a
 538      variant copy of of ptr_type_node, rather than ptr_node itself.  The
 539      distinction should only be relevant to the front-end, so we always
 540      use the C definition here in lto1.
 541
 542      These should be assured in pass_ipa_free_lang_data.  */
 543   gcc_assert (fileptr_type_node == ptr_type_node);
 544   gcc_assert (TYPE_MAIN_VARIANT (fileptr_type_node) == ptr_type_node);
 545
 546   seen_nodes = pointer_set_create ();
 547
 548   /* Skip itk_char.  char_type_node is shared with the appropriately
 549      signed variant.  */
 550   for (i = itk_signed_char; i < itk_none; i++)
 551     lto_record_common_node (&integer_types[i], &common_nodes, seen_nodes);
 552
 553   for (i = 0; i < TYPE_KIND_LAST; i++)
 554     lto_record_common_node (&sizetype_tab[i], &common_nodes, seen_nodes);
 555
 556   for (i = 0; i < TI_MAX; i++)
 557     lto_record_common_node (&global_trees[i], &common_nodes, seen_nodes);
 558
 559   pointer_set_destroy (seen_nodes);
 560
 561   return common_nodes;
 562 }
 563
 564
 565 /* Assign an index to tree node T and enter it in the streamer cache
 566    CACHE.  */
 567
 568 static void
 569 preload_common_node (struct lto_streamer_cache_d *cache, tree t)
 570 {
 571   gcc_assert (t);
 572
 573   lto_streamer_cache_insert (cache, t, NULL);
 574
 575  /* The FIELD_DECLs of structures should be shared, so that every
 576     COMPONENT_REF uses the same tree node when referencing a field.
 577     Pointer equality between FIELD_DECLs is used by the alias
 578     machinery to compute overlapping memory references (See
 579     nonoverlapping_component_refs_p).  */
 580  if (TREE_CODE (t) == RECORD_TYPE)
 581    {
 582      tree f;
 583
 584      for (f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f))
 585        preload_common_node (cache, f);
 586    }
 587 }
 588
 589
 590 /* Create a cache of pickled nodes.  */
 591
 592 struct lto_streamer_cache_d *
 593 lto_streamer_cache_create (void)
 594 {
 595   struct lto_streamer_cache_d *cache;
 596   VEC(tree, heap) *common_nodes;
 597   unsigned i;
 598   tree node;
 599
 600   cache = XCNEW (struct lto_streamer_cache_d);
 601
 602   cache->node_map = pointer_map_create ();
 603
 604   /* Load all the well-known tree nodes that are always created by
 605      the compiler on startup.  This prevents writing them out
 606      unnecessarily.  */
 607   common_nodes = lto_get_common_nodes ();
 608
 609   FOR_EACH_VEC_ELT (tree, common_nodes, i, node)
 610     preload_common_node (cache, node);
 611
 612   VEC_free(tree, heap, common_nodes);
 613
 614   return cache;
 615 }
 616
 617
 618 /* Delete the streamer cache C.  */
 619
 620 void
 621 lto_streamer_cache_delete (struct lto_streamer_cache_d *c)
 622 {
 623   if (c == NULL)
 624     return;
 625
 626   pointer_map_destroy (c->node_map);
 627   VEC_free (tree, heap, c->nodes);
 628   free (c);
 629 }
 630
 631
 632 #ifdef LTO_STREAMER_DEBUG
 633 static htab_t tree_htab;
 634
 635 struct tree_hash_entry
 636 {
 637   tree key;
 638   intptr_t value;
 639 };
 640
 641 static hashval_t
 642 hash_tree (const void *p)
 643 {
 644   const struct tree_hash_entry *e = (const struct tree_hash_entry *) p;
 645   return htab_hash_pointer (e->key);
 646 }
 647
 648 static int
 649 eq_tree (const void *p1, const void *p2)
 650 {
 651   const struct tree_hash_entry *e1 = (const struct tree_hash_entry *) p1;
 652   const struct tree_hash_entry *e2 = (const struct tree_hash_entry *) p2;
 653   return (e1->key == e2->key);
 654 }
 655 #endif
 656
 657 /* Initialization common to the LTO reader and writer.  */
 658
 659 void
 660 lto_streamer_init (void)
 661 {
 662   /* Check that all the TS_* handled by the reader and writer routines
 663      match exactly the structures defined in treestruct.def.  When a
 664      new TS_* astructure is added, the streamer should be updated to
 665      handle it.  */
 666   check_handled_ts_structures ();
 667
 668 #ifdef LTO_STREAMER_DEBUG
 669   tree_htab = htab_create (31, hash_tree, eq_tree, NULL);
 670 #endif
 671 }
 672
 673
 674 /* Gate function for all LTO streaming passes.  */
 675
 676 bool
 677 gate_lto_out (void)
 678 {
 679   return ((flag_generate_lto || in_lto_p)
 680           /* Don't bother doing anything if the program has errors.  */
 681           && !seen_error ());
 682 }
 683
 684
 685 #ifdef LTO_STREAMER_DEBUG
 686 /* Add a mapping between T and ORIG_T, which is the numeric value of
 687    the original address of T as it was seen by the LTO writer.  This
 688    mapping is useful when debugging streaming problems.  A debugging
 689    session can be started on both reader and writer using ORIG_T
 690    as a breakpoint value in both sessions.
 691
 692    Note that this mapping is transient and only valid while T is
 693    being reconstructed.  Once T is fully built, the mapping is
 694    removed.  */
 695
 696 void
 697 lto_orig_address_map (tree t, intptr_t orig_t)
 698 {
 699   struct tree_hash_entry ent;
 700   struct tree_hash_entry **slot;
 701
 702   ent.key = t;
 703   ent.value = orig_t;
 704   slot
 705     = (struct tree_hash_entry **) htab_find_slot (tree_htab, &ent, INSERT);
 706   gcc_assert (!*slot);
 707   *slot = XNEW (struct tree_hash_entry);
 708   **slot = ent;
 709 }
 710
 711
 712 /* Get the original address of T as it was seen by the writer.  This
 713    is only valid while T is being reconstructed.  */
 714
 715 intptr_t
 716 lto_orig_address_get (tree t)
 717 {
 718   struct tree_hash_entry ent;
 719   struct tree_hash_entry **slot;
 720
 721   ent.key = t;
 722   slot
 723     = (struct tree_hash_entry **) htab_find_slot (tree_htab, &ent, NO_INSERT);
 724   return (slot ? (*slot)->value : 0);
 725 }
 726
 727
 728 /* Clear the mapping of T to its original address.  */
 729
 730 void
 731 lto_orig_address_remove (tree t)
 732 {
 733   struct tree_hash_entry ent;
 734   struct tree_hash_entry **slot;
 735
 736   ent.key = t;
 737   slot
 738     = (struct tree_hash_entry **) htab_find_slot (tree_htab, &ent, NO_INSERT);
 739   gcc_assert (slot);
 740   free (*slot);
 741   htab_clear_slot (tree_htab, (PTR *)slot);
 742 }
 743 #endif
 744
 745
 746 /* Check that the version MAJOR.MINOR is the correct version number.  */
 747
 748 void
 749 lto_check_version (int major, int minor)
 750 {
 751   if (major != LTO_major_version || minor != LTO_minor_version)
 752     fatal_error ("bytecode stream generated with LTO version %d.%d instead "
 753                  "of the expected %d.%d",
 754                  major, minor,
 755                  LTO_major_version, LTO_minor_version);
 756 }