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