gcc/tree-streamer-in.c

   1 /* Routines for reading trees from a file stream.
   2
   3    Copyright 2011 Free Software Foundation, Inc.
   4    Contributed by Diego Novillo <dnovillo@google.com>
   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 "diagnostic.h"
  26 #include "tree.h"
  27 #include "tree-flow.h"
  28 #include "tree-streamer.h"
  29 #include "data-streamer.h"
  30 #include "streamer-hooks.h"
  31 #include "lto-streamer.h"
  32
  33 /* Read a STRING_CST from the string table in DATA_IN using input
  34    block IB.  */
  35
  36 tree
  37 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
  38 {
  39   unsigned int len;
  40   const char * ptr;
  41
  42   ptr = input_string_internal (data_in, ib, &len);
  43   if (!ptr)
  44     return NULL;
  45   return build_string (len, ptr);
  46 }
  47
  48
  49 /* Read an IDENTIFIER from the string table in DATA_IN using input
  50    block IB.  */
  51
  52 static tree
  53 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
  54 {
  55   unsigned int len;
  56   const char *ptr;
  57
  58   ptr = input_string_internal (data_in, ib, &len);
  59   if (!ptr)
  60     return NULL;
  61   return get_identifier_with_length (ptr, len);
  62 }
  63
  64
  65 /* Read a chain of tree nodes from input block IB. DATA_IN contains
  66    tables and descriptors for the file being read.  */
  67
  68 static tree
  69 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
  70 {
  71   int i, count;
  72   tree first, prev, curr;
  73
  74   first = prev = NULL_TREE;
  75   count = lto_input_sleb128 (ib);
  76   for (i = 0; i < count; i++)
  77     {
  78       curr = lto_input_tree (ib, data_in);
  79       if (prev)
  80         TREE_CHAIN (prev) = curr;
  81       else
  82         first = curr;
  83
  84       TREE_CHAIN (curr) = NULL_TREE;
  85       prev = curr;
  86     }
  87
  88   return first;
  89 }
  90
  91
  92 /* Unpack all the non-pointer fields of the TS_BASE structure of
  93    expression EXPR from bitpack BP.  */
  94
  95 static void
  96 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
  97 {
  98   /* Note that the code for EXPR has already been unpacked to create EXPR in
  99      lto_materialize_tree.  */
 100   if (!TYPE_P (expr))
 101     {
 102       TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
 103       TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
 104       TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
 105
 106       /* TREE_PUBLIC is used on types to indicate that the type
 107          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
 108          so we skip it here.  */
 109       TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
 110     }
 111   else
 112     bp_unpack_value (bp, 4);
 113   TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
 114   TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
 115   if (DECL_P (expr))
 116     DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
 117   else if (TYPE_P (expr))
 118     TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
 119   else
 120     bp_unpack_value (bp, 1);
 121   TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
 122   if (TYPE_P (expr))
 123     TYPE_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
 124   else
 125     TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
 126   TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
 127   TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
 128   TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
 129   TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
 130   TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
 131   TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
 132   if (TYPE_P (expr))
 133     TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
 134   else if (TREE_CODE (expr) == SSA_NAME)
 135     SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
 136   else
 137     bp_unpack_value (bp, 1);
 138 }
 139
 140
 141 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
 142    expression EXPR from bitpack BP.  */
 143
 144 static void
 145 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
 146 {
 147   unsigned i;
 148   REAL_VALUE_TYPE r;
 149   REAL_VALUE_TYPE *rp;
 150
 151   r.cl = (unsigned) bp_unpack_value (bp, 2);
 152   r.decimal = (unsigned) bp_unpack_value (bp, 1);
 153   r.sign = (unsigned) bp_unpack_value (bp, 1);
 154   r.signalling = (unsigned) bp_unpack_value (bp, 1);
 155   r.canonical = (unsigned) bp_unpack_value (bp, 1);
 156   r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
 157   for (i = 0; i < SIGSZ; i++)
 158     r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
 159
 160   rp = ggc_alloc_real_value ();
 161   memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
 162   TREE_REAL_CST_PTR (expr) = rp;
 163 }
 164
 165
 166 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
 167    expression EXPR from bitpack BP.  */
 168
 169 static void
 170 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
 171 {
 172   struct fixed_value fv;
 173
 174   fv.mode = bp_unpack_enum (bp, machine_mode, MAX_MACHINE_MODE);
 175   fv.data.low = bp_unpack_var_len_int (bp);
 176   fv.data.high = bp_unpack_var_len_int (bp);
 177   TREE_FIXED_CST (expr) = fv;
 178 }
 179
 180
 181 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
 182    of expression EXPR from bitpack BP.  */
 183
 184 static void
 185 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
 186 {
 187   DECL_MODE (expr) = bp_unpack_enum (bp, machine_mode, MAX_MACHINE_MODE);
 188   DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
 189   DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 190   DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 191   DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
 192   DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
 193   DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
 194   DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 195   DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
 196   DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
 197   DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 198   DECL_ALIGN (expr) = (unsigned) bp_unpack_var_len_unsigned (bp);
 199
 200   if (TREE_CODE (expr) == LABEL_DECL)
 201     {
 202       DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
 203       EH_LANDING_PAD_NR (expr) = (int) bp_unpack_var_len_unsigned (bp);
 204
 205       /* Always assume an initial value of -1 for LABEL_DECL_UID to
 206          force gimple_set_bb to recreate label_to_block_map.  */
 207       LABEL_DECL_UID (expr) = -1;
 208     }
 209
 210   if (TREE_CODE (expr) == FIELD_DECL)
 211     {
 212       DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
 213       DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 214       expr->decl_common.off_align = bp_unpack_value (bp, 8);
 215     }
 216
 217   if (TREE_CODE (expr) == RESULT_DECL
 218       || TREE_CODE (expr) == PARM_DECL
 219       || TREE_CODE (expr) == VAR_DECL)
 220     {
 221       DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
 222       if (TREE_CODE (expr) == VAR_DECL
 223           || TREE_CODE (expr) == PARM_DECL)
 224         DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 225       DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 226     }
 227 }
 228
 229
 230 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
 231    of expression EXPR from bitpack BP.  */
 232
 233 static void
 234 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
 235 {
 236   DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
 237 }
 238
 239
 240 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
 241    of expression EXPR from bitpack BP.  */
 242
 243 static void
 244 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
 245 {
 246   DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
 247   DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
 248   DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 249   DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
 250   DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp,  1);
 251   DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp,  1);
 252   DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp,  2);
 253   DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp,  1);
 254
 255   if (TREE_CODE (expr) == VAR_DECL)
 256     {
 257       DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
 258       DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
 259       DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
 260       DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp,  3);
 261     }
 262
 263   if (VAR_OR_FUNCTION_DECL_P (expr))
 264     {
 265       priority_type p;
 266       p = (priority_type) bp_unpack_var_len_unsigned (bp);
 267       SET_DECL_INIT_PRIORITY (expr, p);
 268     }
 269 }
 270
 271
 272 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
 273    of expression EXPR from bitpack BP.  */
 274
 275 static void
 276 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
 277 {
 278   DECL_BUILT_IN_CLASS (expr) = bp_unpack_enum (bp, built_in_class,
 279                                                BUILT_IN_LAST);
 280   DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
 281   DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
 282   DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
 283   DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
 284   DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
 285   DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
 286   DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
 287   DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
 288   DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 289   DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
 290   DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 291   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
 292                         = (unsigned) bp_unpack_value (bp, 1);
 293   DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
 294   DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
 295   DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 296   DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
 297   if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
 298     {
 299       DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp,
 300                                                                             11);
 301       if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_NORMAL
 302           && DECL_FUNCTION_CODE (expr) >= END_BUILTINS)
 303         fatal_error ("machine independent builtin code out of range");
 304       else if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD)
 305         {
 306           tree result = targetm.builtin_decl (DECL_FUNCTION_CODE (expr), true);
 307           if (!result || result == error_mark_node)
 308             fatal_error ("target specific builtin not available");
 309         }
 310     }
 311   if (DECL_STATIC_DESTRUCTOR (expr))
 312     {
 313       priority_type p;
 314       p = (priority_type) bp_unpack_var_len_unsigned (bp);
 315       SET_DECL_FINI_PRIORITY (expr, p);
 316     }
 317 }
 318
 319
 320 /* Unpack all the non-pointer fields of the TS_TYPE_COMMON structure
 321    of expression EXPR from bitpack BP.  */
 322
 323 static void
 324 unpack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
 325 {
 326   enum machine_mode mode;
 327
 328   mode = bp_unpack_enum (bp, machine_mode, MAX_MACHINE_MODE);
 329   SET_TYPE_MODE (expr, mode);
 330   TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
 331   TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
 332   TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
 333   if (RECORD_OR_UNION_TYPE_P (expr))
 334     TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
 335   TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
 336   TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
 337   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
 338         = (unsigned) bp_unpack_value (bp, 2);
 339   TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
 340   TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
 341   TYPE_PRECISION (expr) = bp_unpack_var_len_unsigned (bp);
 342   TYPE_ALIGN (expr) = bp_unpack_var_len_unsigned (bp);
 343   TYPE_ALIAS_SET (expr) = bp_unpack_var_len_int (bp);
 344 }
 345
 346
 347 /* Unpack all the non-pointer fields of the TS_BLOCK structure
 348    of expression EXPR from bitpack BP.  */
 349
 350 static void
 351 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
 352 {
 353   BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
 354   /* BLOCK_NUMBER is recomputed.  */
 355 }
 356
 357 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
 358    structure of expression EXPR from bitpack BP.  */
 359
 360 static void
 361 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
 362 {
 363 }
 364
 365 /* Unpack all the non-pointer fields in EXPR into a bit pack.  */
 366
 367 static void
 368 unpack_value_fields (struct bitpack_d *bp, tree expr)
 369 {
 370   enum tree_code code;
 371
 372   code = TREE_CODE (expr);
 373
 374   /* Note that all these functions are highly sensitive to changes in
 375      the types and sizes of each of the fields being packed.  */
 376   unpack_ts_base_value_fields (bp, expr);
 377
 378   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 379     unpack_ts_real_cst_value_fields (bp, expr);
 380
 381   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 382     unpack_ts_fixed_cst_value_fields (bp, expr);
 383
 384   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 385     unpack_ts_decl_common_value_fields (bp, expr);
 386
 387   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 388     unpack_ts_decl_wrtl_value_fields (bp, expr);
 389
 390   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 391     unpack_ts_decl_with_vis_value_fields (bp, expr);
 392
 393   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 394     unpack_ts_function_decl_value_fields (bp, expr);
 395
 396   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 397     unpack_ts_type_common_value_fields (bp, expr);
 398
 399   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 400     unpack_ts_block_value_fields (bp, expr);
 401
 402   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 403     unpack_ts_translation_unit_decl_value_fields (bp, expr);
 404
 405   if (streamer_hooks.unpack_value_fields)
 406     streamer_hooks.unpack_value_fields (bp, expr);
 407 }
 408
 409
 410 /* Materialize a new tree from input block IB using descriptors in
 411    DATA_IN.  The code for the new tree should match TAG.  Store in
 412    *IX_P the index into the reader cache where the new tree is stored.  */
 413
 414 static tree
 415 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
 416                       enum LTO_tags tag)
 417 {
 418   struct bitpack_d bp;
 419   enum tree_code code;
 420   tree result;
 421 #ifdef LTO_STREAMER_DEBUG
 422   HOST_WIDEST_INT orig_address_in_writer;
 423 #endif
 424
 425   result = NULL_TREE;
 426
 427 #ifdef LTO_STREAMER_DEBUG
 428   /* Read the word representing the memory address for the tree
 429      as it was written by the writer.  This is useful when
 430      debugging differences between the writer and reader.  */
 431   orig_address_in_writer = lto_input_sleb128 (ib);
 432   gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
 433 #endif
 434
 435   code = lto_tag_to_tree_code (tag);
 436
 437   /* We should never see an SSA_NAME tree.  Only the version numbers of
 438      SSA names are ever written out.  See input_ssa_names.  */
 439   gcc_assert (code != SSA_NAME);
 440
 441   /* Instantiate a new tree using the header data.  */
 442   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
 443     result = input_string_cst (data_in, ib);
 444   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
 445     result = input_identifier (data_in, ib);
 446   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 447     {
 448       HOST_WIDE_INT len = lto_input_sleb128 (ib);
 449       result = make_tree_vec (len);
 450     }
 451   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 452     {
 453       unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
 454       result = make_tree_binfo (len);
 455     }
 456   else
 457     {
 458       /* For all other nodes, see if the streamer knows how to allocate
 459          it.  */
 460       if (streamer_hooks.alloc_tree)
 461         result = streamer_hooks.alloc_tree (code, ib, data_in);
 462
 463       /* If the hook did not handle it, materialize the tree with a raw
 464          make_node call.  */
 465       if (result == NULL_TREE)
 466         result = make_node (code);
 467     }
 468
 469 #ifdef LTO_STREAMER_DEBUG
 470   /* Store the original address of the tree as seen by the writer
 471      in RESULT's aux field.  This is useful when debugging streaming
 472      problems.  This way, a debugging session can be started on
 473      both writer and reader with a breakpoint using this address
 474      value in both.  */
 475   lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
 476 #endif
 477
 478   /* Read the bitpack of non-pointer values from IB.  */
 479   bp = lto_input_bitpack (ib);
 480
 481   /* The first word in BP contains the code of the tree that we
 482      are about to read.  */
 483   code = (enum tree_code) bp_unpack_value (&bp, 16);
 484   lto_tag_check (lto_tree_code_to_tag (code), tag);
 485
 486   /* Unpack all the value fields from BP.  */
 487   unpack_value_fields (&bp, result);
 488
 489   /* Enter RESULT in the reader cache.  This will make RESULT
 490      available so that circular references in the rest of the tree
 491      structure can be resolved in subsequent calls to lto_input_tree.  */
 492   lto_streamer_cache_append (data_in->reader_cache, result);
 493
 494   return result;
 495 }
 496
 497
 498 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
 499    block IB.  DATA_IN contains tables and descriptors for the
 500    file being read.  */
 501
 502
 503 static void
 504 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
 505                                    struct data_in *data_in, tree expr)
 506 {
 507   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 508     TREE_TYPE (expr) = lto_input_tree (ib, data_in);
 509 }
 510
 511
 512 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
 513    block IB.  DATA_IN contains tables and descriptors for the
 514    file being read.  */
 515
 516 static void
 517 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
 518                                    struct data_in *data_in, tree expr)
 519 {
 520   TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
 521 }
 522
 523
 524 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
 525    block IB.  DATA_IN contains tables and descriptors for the
 526    file being read.  */
 527
 528 static void
 529 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
 530                                     struct data_in *data_in, tree expr)
 531 {
 532   TREE_REALPART (expr) = lto_input_tree (ib, data_in);
 533   TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
 534 }
 535
 536
 537 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 538    from input block IB.  DATA_IN contains tables and descriptors for the
 539    file being read.  */
 540
 541 static void
 542 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
 543                                          struct data_in *data_in, tree expr)
 544 {
 545   DECL_NAME (expr) = lto_input_tree (ib, data_in);
 546   DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
 547   DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
 548 }
 549
 550
 551 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
 552    input block IB.  DATA_IN contains tables and descriptors for the
 553    file being read.  */
 554
 555 static void
 556 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
 557                                         struct data_in *data_in, tree expr)
 558 {
 559   DECL_SIZE (expr) = lto_input_tree (ib, data_in);
 560   DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
 561   DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
 562
 563   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 564      for early inlining so drop it on the floor instead of ICEing in
 565      dwarf2out.c.  */
 566
 567   if (TREE_CODE (expr) == PARM_DECL)
 568     TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
 569
 570   if ((TREE_CODE (expr) == VAR_DECL
 571        || TREE_CODE (expr) == PARM_DECL)
 572       && DECL_HAS_VALUE_EXPR_P (expr))
 573     SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
 574
 575   if (TREE_CODE (expr) == VAR_DECL)
 576     {
 577       tree dexpr = lto_input_tree (ib, data_in);
 578       if (dexpr)
 579         SET_DECL_DEBUG_EXPR (expr, dexpr);
 580     }
 581 }
 582
 583
 584 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
 585    EXPR from input block IB.  DATA_IN contains tables and descriptors for the
 586    file being read.  */
 587
 588 static void
 589 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
 590                                             struct data_in *data_in, tree expr)
 591 {
 592   if (TREE_CODE (expr) == FUNCTION_DECL)
 593     {
 594       DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
 595       DECL_RESULT (expr) = lto_input_tree (ib, data_in);
 596     }
 597   DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
 598 }
 599
 600
 601 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 602    from input block IB.  DATA_IN contains tables and descriptors for the
 603    file being read.  */
 604
 605 static void
 606 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
 607                                           struct data_in *data_in, tree expr)
 608 {
 609   tree id;
 610
 611   id = lto_input_tree (ib, data_in);
 612   if (id)
 613     {
 614       gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
 615       SET_DECL_ASSEMBLER_NAME (expr, id);
 616     }
 617
 618   DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
 619   DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
 620 }
 621
 622
 623 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
 624    input block IB.  DATA_IN contains tables and descriptors for the
 625    file being read.  */
 626
 627 static void
 628 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
 629                                        struct data_in *data_in, tree expr)
 630 {
 631   DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
 632   DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
 633   DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
 634   DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
 635   DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
 636   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
 637 }
 638
 639
 640 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 641    from input block IB.  DATA_IN contains tables and descriptors for the
 642    file being read.  */
 643
 644 static void
 645 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
 646                                           struct data_in *data_in, tree expr)
 647 {
 648   /* DECL_STRUCT_FUNCTION is handled by lto_input_function.  FIXME lto,
 649      maybe it should be handled here?  */
 650   DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
 651   DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
 652   DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
 653
 654   /* If the file contains a function with an EH personality set,
 655      then it was compiled with -fexceptions.  In that case, initialize
 656      the backend EH machinery.  */
 657   if (DECL_FUNCTION_PERSONALITY (expr))
 658     lto_init_eh ();
 659 }
 660
 661
 662 /* Read all pointer fields in the TS_TYPE_COMMON structure of EXPR from
 663    input block IB.  DATA_IN contains tables and descriptors for the file
 664    being read.  */
 665
 666 static void
 667 lto_input_ts_type_common_tree_pointers (struct lto_input_block *ib,
 668                                         struct data_in *data_in, tree expr)
 669 {
 670   TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
 671   TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
 672   TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
 673   TYPE_NAME (expr) = lto_input_tree (ib, data_in);
 674   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 675      reconstructed during fixup.  */
 676   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 677      during fixup.  */
 678   TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
 679   TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
 680   /* TYPE_CANONICAL gets re-computed during type merging.  */
 681   TYPE_CANONICAL (expr) = NULL_TREE;
 682   TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
 683 }
 684
 685 /* Read all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 686    from input block IB.  DATA_IN contains tables and descriptors for the
 687    file being read.  */
 688
 689 static void
 690 lto_input_ts_type_non_common_tree_pointers (struct lto_input_block *ib,
 691                                             struct data_in *data_in,
 692                                             tree expr)
 693 {
 694   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 695     TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
 696   else if (TREE_CODE (expr) == ARRAY_TYPE)
 697     TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
 698   else if (RECORD_OR_UNION_TYPE_P (expr))
 699     TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
 700   else if (TREE_CODE (expr) == FUNCTION_TYPE
 701            || TREE_CODE (expr) == METHOD_TYPE)
 702     TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
 703
 704   if (!POINTER_TYPE_P (expr))
 705     TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
 706   TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
 707   if (RECORD_OR_UNION_TYPE_P (expr))
 708     TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
 709 }
 710
 711
 712 /* Read all pointer fields in the TS_LIST structure of EXPR from input
 713    block IB.  DATA_IN contains tables and descriptors for the
 714    file being read.  */
 715
 716 static void
 717 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
 718                                  struct data_in *data_in, tree expr)
 719 {
 720   TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
 721   TREE_VALUE (expr) = lto_input_tree (ib, data_in);
 722   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
 723 }
 724
 725
 726 /* Read all pointer fields in the TS_VEC structure of EXPR from input
 727    block IB.  DATA_IN contains tables and descriptors for the
 728    file being read.  */
 729
 730 static void
 731 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
 732                                 struct data_in *data_in, tree expr)
 733 {
 734   int i;
 735
 736   /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
 737      instantiate EXPR.  */
 738   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 739     TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
 740 }
 741
 742
 743 /* Read all pointer fields in the TS_EXP structure of EXPR from input
 744    block IB.  DATA_IN contains tables and descriptors for the
 745    file being read.  */
 746
 747
 748 static void
 749 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
 750                                 struct data_in *data_in, tree expr)
 751 {
 752   int i, length;
 753   location_t loc;
 754
 755   length = lto_input_sleb128 (ib);
 756   gcc_assert (length == TREE_OPERAND_LENGTH (expr));
 757
 758   for (i = 0; i < length; i++)
 759     TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
 760
 761   loc = lto_input_location (ib, data_in);
 762   SET_EXPR_LOCATION (expr, loc);
 763   TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
 764 }
 765
 766
 767 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
 768    block IB.  DATA_IN contains tables and descriptors for the
 769    file being read.  */
 770
 771 static void
 772 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
 773                                   struct data_in *data_in, tree expr)
 774 {
 775   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
 776      for early inlining so drop it on the floor instead of ICEing in
 777      dwarf2out.c.  */
 778   BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
 779
 780   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 781      for early inlining so drop it on the floor instead of ICEing in
 782      dwarf2out.c.  */
 783
 784   BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
 785
 786   /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information
 787      for early inlining so drop it on the floor instead of ICEing in
 788      dwarf2out.c.  */
 789   BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
 790   BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
 791
 792   /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
 793      of streaming it.  For non-BLOCK BLOCK_SUPERCONTEXTs we still
 794      stream the child relationship explicitly.  */
 795   if (BLOCK_SUPERCONTEXT (expr)
 796       && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
 797     {
 798       BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
 799       BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
 800     }
 801
 802   /* The global block is rooted at the TU decl.  Hook it here to
 803      avoid the need to stream in this block during WPA time.  */
 804   else if (BLOCK_SUPERCONTEXT (expr)
 805            && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
 806     DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
 807
 808   /* The function-level block is connected at the time we read in
 809      function bodies for the same reason.  */
 810 }
 811
 812
 813 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
 814    block IB.  DATA_IN contains tables and descriptors for the
 815    file being read.  */
 816
 817 static void
 818 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
 819                                   struct data_in *data_in, tree expr)
 820 {
 821   unsigned i, len;
 822   tree t;
 823
 824   /* Note that the number of slots in EXPR was read in
 825      lto_materialize_tree when instantiating EXPR.  However, the
 826      vector is empty so we cannot rely on VEC_length to know how many
 827      elements to read.  So, this list is emitted as a 0-terminated
 828      list on the writer side.  */
 829   do
 830     {
 831       t = lto_input_tree (ib, data_in);
 832       if (t)
 833         VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
 834     }
 835   while (t);
 836
 837   BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
 838   BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
 839   BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
 840   BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
 841
 842   len = lto_input_uleb128 (ib);
 843   if (len > 0)
 844     {
 845       VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
 846       for (i = 0; i < len; i++)
 847         {
 848           tree a = lto_input_tree (ib, data_in);
 849           VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
 850         }
 851     }
 852
 853   BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
 854   BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
 855   BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
 856 }
 857
 858
 859 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
 860    input block IB.  DATA_IN contains tables and descriptors for the
 861    file being read.  */
 862
 863 static void
 864 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
 865                                         struct data_in *data_in, tree expr)
 866 {
 867   unsigned i, len;
 868
 869   len = lto_input_uleb128 (ib);
 870   for (i = 0; i < len; i++)
 871     {
 872       tree index, value;
 873
 874       index = lto_input_tree (ib, data_in);
 875       value = lto_input_tree (ib, data_in);
 876       CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
 877     }
 878 }
 879
 880
 881 /* Input a TS_TARGET_OPTION tree from IB into EXPR.  */
 882
 883 static void
 884 lto_input_ts_target_option (struct lto_input_block *ib, tree expr)
 885 {
 886   unsigned i, len;
 887   struct bitpack_d bp;
 888   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
 889
 890   bp = lto_input_bitpack (ib);
 891   len = sizeof (struct cl_target_option);
 892   for (i = 0; i < len; i++)
 893     ((unsigned char *)t)[i] = bp_unpack_value (&bp, 8);
 894   if (bp_unpack_value (&bp, 32) != 0x12345678)
 895     fatal_error ("cl_target_option size mismatch in LTO reader and writer");
 896 }
 897
 898 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR.  */
 899
 900 static void
 901 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block *ib,
 902                                                   struct data_in *data_in,
 903                                                   tree expr)
 904 {
 905   TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (lto_input_string (data_in, ib));
 906   VEC_safe_push (tree, gc, all_translation_units, expr);
 907 }
 908
 909 /* Helper for lto_input_tree.  Read all pointer fields in EXPR from
 910    input block IB.  DATA_IN contains tables and descriptors for the
 911    file being read.  */
 912
 913 static void
 914 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
 915                          tree expr)
 916 {
 917   enum tree_code code;
 918
 919   code = TREE_CODE (expr);
 920
 921   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 922     lto_input_ts_common_tree_pointers (ib, data_in, expr);
 923
 924   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 925     lto_input_ts_vector_tree_pointers (ib, data_in, expr);
 926
 927   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 928     lto_input_ts_complex_tree_pointers (ib, data_in, expr);
 929
 930   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 931     lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
 932
 933   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 934     lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
 935
 936   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 937     lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
 938
 939   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 940     lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
 941
 942   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 943     lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
 944
 945   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 946     lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
 947
 948   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 949     lto_input_ts_type_common_tree_pointers (ib, data_in, expr);
 950
 951   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 952     lto_input_ts_type_non_common_tree_pointers (ib, data_in, expr);
 953
 954   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 955     lto_input_ts_list_tree_pointers (ib, data_in, expr);
 956
 957   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 958     lto_input_ts_vec_tree_pointers (ib, data_in, expr);
 959
 960   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 961     lto_input_ts_exp_tree_pointers (ib, data_in, expr);
 962
 963   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 964     lto_input_ts_block_tree_pointers (ib, data_in, expr);
 965
 966   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 967     lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
 968
 969   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 970     lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
 971
 972   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
 973     lto_input_ts_target_option (ib, expr);
 974
 975   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 976     lto_input_ts_translation_unit_decl_tree_pointers (ib, data_in, expr);
 977 }
 978
 979
 980 /* Read the physical representation of a tree node with tag TAG from
 981    input block IB using the per-file context in DATA_IN.  */
 982
 983 static tree
 984 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
 985                enum LTO_tags tag)
 986 {
 987   tree result;
 988
 989   result = lto_materialize_tree (ib, data_in, tag);
 990
 991   /* Read all the pointer fields in RESULT.  */
 992   lto_input_tree_pointers (ib, data_in, result);
 993
 994   /* Call back into the streaming module to read anything else it
 995      may need.  */
 996   if (streamer_hooks.read_tree)
 997     streamer_hooks.read_tree (ib, data_in, result);
 998
 999   /* We should never try to instantiate an MD or NORMAL builtin here.  */
1000   if (TREE_CODE (result) == FUNCTION_DECL)
1001     gcc_assert (!lto_stream_as_builtin_p (result));
1002
1003   /* end_marker = */ lto_input_1_unsigned (ib);
1004
1005 #ifdef LTO_STREAMER_DEBUG
1006   /* Remove the mapping to RESULT's original address set by
1007      lto_materialize_tree.  */
1008   lto_orig_address_remove (result);
1009 #endif
1010
1011   return result;
1012 }
1013
1014
1015 /* Read and INTEGER_CST node from input block IB using the per-file
1016    context in DATA_IN.  */
1017
1018 static tree
1019 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
1020 {
1021   tree result, type;
1022   HOST_WIDE_INT low, high;
1023   bool overflow_p;
1024
1025   type = lto_input_tree (ib, data_in);
1026   overflow_p = (lto_input_1_unsigned (ib) != 0);
1027   low = lto_input_uleb128 (ib);
1028   high = lto_input_uleb128 (ib);
1029   result = build_int_cst_wide (type, low, high);
1030
1031   /* If the original constant had overflown, build a replica of RESULT to
1032      avoid modifying the shared constant returned by build_int_cst_wide.  */
1033   if (overflow_p)
1034     {
1035       result = copy_node (result);
1036       TREE_OVERFLOW (result) = 1;
1037     }
1038
1039   return result;
1040 }
1041
1042
1043 /* Read an index IX from input block IB and return the tree node at
1044    DATA_IN->FILE_DATA->GLOBALS_INDEX[IX].  */
1045
1046 static tree
1047 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
1048 {
1049   unsigned HOST_WIDE_INT ix;
1050   tree result;
1051   enum LTO_tags expected_tag;
1052
1053   ix = lto_input_uleb128 (ib);
1054   expected_tag = lto_input_enum (ib, LTO_tags, LTO_NUM_TAGS);
1055
1056   result = lto_streamer_cache_get (data_in->reader_cache, ix);
1057   gcc_assert (result
1058               && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
1059
1060   return result;
1061 }
1062
1063
1064 /* Read a code and class from input block IB and return the
1065    corresponding builtin.  DATA_IN is as in lto_input_tree.  */
1066
1067 static tree
1068 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
1069 {
1070   enum built_in_class fclass;
1071   enum built_in_function fcode;
1072   const char *asmname;
1073   tree result;
1074
1075   fclass = lto_input_enum (ib, built_in_class, BUILT_IN_LAST);
1076   gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
1077
1078   fcode = (enum built_in_function) lto_input_uleb128 (ib);
1079
1080   if (fclass == BUILT_IN_NORMAL)
1081     {
1082       if (fcode >= END_BUILTINS)
1083         fatal_error ("machine independent builtin code out of range");
1084       result = built_in_decls[fcode];
1085       gcc_assert (result);
1086     }
1087   else if (fclass == BUILT_IN_MD)
1088     {
1089       result = targetm.builtin_decl (fcode, true);
1090       if (!result || result == error_mark_node)
1091         fatal_error ("target specific builtin not available");
1092     }
1093   else
1094     gcc_unreachable ();
1095
1096   asmname = lto_input_string (data_in, ib);
1097   if (asmname)
1098     set_builtin_user_assembler_name (result, asmname);
1099
1100   lto_streamer_cache_append (data_in->reader_cache, result);
1101
1102   return result;
1103 }
1104
1105
1106 /* Read a tree from input block IB using the per-file context in
1107    DATA_IN.  This context is used, for example, to resolve references
1108    to previously read nodes.  */
1109
1110 tree
1111 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
1112 {
1113   enum LTO_tags tag;
1114   tree result;
1115
1116   tag = input_record_start (ib);
1117   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
1118
1119   if (tag == LTO_null)
1120     result = NULL_TREE;
1121   else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
1122     {
1123       /* If TAG is a reference to an indexable tree, the next value
1124          in IB is the index into the table where we expect to find
1125          that tree.  */
1126       result = lto_input_tree_ref (ib, data_in, cfun, tag);
1127     }
1128   else if (tag == LTO_tree_pickle_reference)
1129     {
1130       /* If TAG is a reference to a previously read tree, look it up in
1131          the reader cache.  */
1132       result = lto_get_pickled_tree (ib, data_in);
1133     }
1134   else if (tag == LTO_builtin_decl)
1135     {
1136       /* If we are going to read a built-in function, all we need is
1137          the code and class.  */
1138       result = lto_get_builtin_tree (ib, data_in);
1139     }
1140   else if (tag == lto_tree_code_to_tag (INTEGER_CST))
1141     {
1142       /* For integer constants we only need the type and its hi/low
1143          words.  */
1144       result = lto_input_integer_cst (ib, data_in);
1145     }
1146   else
1147     {
1148       /* Otherwise, materialize a new node from IB.  */
1149       result = lto_read_tree (ib, data_in, tag);
1150     }
1151
1152   return result;
1153 }