gcc/tree-streamer-out.c

   1 /* Routines for emitting trees to a file stream.
   2
   3    Copyright (C) 2011-2014 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 "tm.h"
  26 #include "diagnostic.h"
  27 #include "tree.h"
  28 #include "stor-layout.h"
  29 #include "basic-block.h"
  30 #include "tree-ssa-alias.h"
  31 #include "internal-fn.h"
  32 #include "gimple-expr.h"
  33 #include "is-a.h"
  34 #include "gimple.h"
  35 #include "tree-streamer.h"
  36 #include "data-streamer.h"
  37 #include "streamer-hooks.h"
  38
  39 /* Output the STRING constant to the string
  40    table in OB.  Then put the index onto the INDEX_STREAM.  */
  41
  42 void
  43 streamer_write_string_cst (struct output_block *ob,
  44                            struct lto_output_stream *index_stream,
  45                            tree string)
  46 {
  47   streamer_write_string_with_length (ob, index_stream,
  48                                      string ? TREE_STRING_POINTER (string)
  49                                             : NULL,
  50                                      string ? TREE_STRING_LENGTH (string) : 0,
  51                                      true);
  52 }
  53
  54
  55 /* Output the identifier ID to the string
  56    table in OB.  Then put the index onto the INDEX_STREAM.  */
  57
  58 static void
  59 write_identifier (struct output_block *ob,
  60                    struct lto_output_stream *index_stream,
  61                    tree id)
  62 {
  63   streamer_write_string_with_length (ob, index_stream,
  64                                      IDENTIFIER_POINTER (id),
  65                                      IDENTIFIER_LENGTH (id),
  66                                      true);
  67 }
  68
  69
  70 /* Pack all the non-pointer fields of the TS_BASE structure of
  71    expression EXPR into bitpack BP.  */
  72
  73 static void
  74 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
  75 {
  76   bp_pack_value (bp, TREE_CODE (expr), 16);
  77   if (!TYPE_P (expr))
  78     {
  79       bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
  80       bp_pack_value (bp, TREE_CONSTANT (expr), 1);
  81       bp_pack_value (bp, TREE_READONLY (expr), 1);
  82
  83       /* TREE_PUBLIC is used on types to indicate that the type
  84          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
  85          so we skip it here.  */
  86       bp_pack_value (bp, TREE_PUBLIC (expr), 1);
  87     }
  88   else
  89     bp_pack_value (bp, 0, 4);
  90   bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
  91   bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
  92   if (DECL_P (expr))
  93     bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
  94   else if (TYPE_P (expr))
  95     bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
  96   else
  97     bp_pack_value (bp, 0, 1);
  98   /* We write debug info two times, do not confuse the second one.
  99      The only relevant TREE_ASM_WRITTEN use is on SSA names.  */
 100   bp_pack_value (bp, (TREE_CODE (expr) != SSA_NAME
 101                       ? 0 : TREE_ASM_WRITTEN (expr)), 1);
 102   if (TYPE_P (expr))
 103     bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
 104   else
 105     bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
 106   bp_pack_value (bp, TREE_NOTHROW (expr), 1);
 107   bp_pack_value (bp, TREE_STATIC (expr), 1);
 108   if (TREE_CODE (expr) != TREE_BINFO)
 109     bp_pack_value (bp, TREE_PRIVATE (expr), 1);
 110   bp_pack_value (bp, TREE_PROTECTED (expr), 1);
 111   bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
 112   if (TYPE_P (expr))
 113     {
 114       bp_pack_value (bp, TYPE_SATURATING (expr), 1);
 115       bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
 116     }
 117   else if (TREE_CODE (expr) == SSA_NAME)
 118     bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
 119   else
 120     bp_pack_value (bp, 0, 1);
 121 }
 122
 123
 124 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
 125    expression EXPR into bitpack BP.  */
 126
 127 static void
 128 pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
 129 {
 130   int i;
 131   /* Note that the number of elements has already been written out in
 132      streamer_write_tree_header.  */
 133   for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
 134     bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i));
 135 }
 136
 137
 138 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
 139    expression EXPR into bitpack BP.  */
 140
 141 static void
 142 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
 143 {
 144   unsigned i;
 145   REAL_VALUE_TYPE r;
 146
 147   r = TREE_REAL_CST (expr);
 148   bp_pack_value (bp, r.cl, 2);
 149   bp_pack_value (bp, r.decimal, 1);
 150   bp_pack_value (bp, r.sign, 1);
 151   bp_pack_value (bp, r.signalling, 1);
 152   bp_pack_value (bp, r.canonical, 1);
 153   bp_pack_value (bp, r.uexp, EXP_BITS);
 154   for (i = 0; i < SIGSZ; i++)
 155     bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
 156 }
 157
 158
 159 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
 160    expression EXPR into bitpack BP.  */
 161
 162 static void
 163 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
 164 {
 165   struct fixed_value fv = TREE_FIXED_CST (expr);
 166   bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, fv.mode);
 167   bp_pack_var_len_int (bp, fv.data.low);
 168   bp_pack_var_len_int (bp, fv.data.high);
 169 }
 170
 171 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
 172    of expression EXPR into bitpack BP.  */
 173
 174 static void
 175 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
 176 {
 177   bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, DECL_MODE (expr));
 178   bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
 179   bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
 180   bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
 181   bp_pack_value (bp, DECL_ABSTRACT (expr), 1);
 182   bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
 183   bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
 184   bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
 185   bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
 186   bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
 187   bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
 188
 189   if (TREE_CODE (expr) == LABEL_DECL)
 190     {
 191       /* Note that we do not write LABEL_DECL_UID.  The reader will
 192          always assume an initial value of -1 so that the
 193          label_to_block_map is recreated by gimple_set_bb.  */
 194       bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
 195     }
 196
 197   if (TREE_CODE (expr) == FIELD_DECL)
 198     {
 199       bp_pack_value (bp, DECL_PACKED (expr), 1);
 200       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
 201       bp_pack_value (bp, expr->decl_common.off_align, 8);
 202     }
 203
 204   if (TREE_CODE (expr) == VAR_DECL)
 205     {
 206       bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
 207       bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
 208     }
 209
 210   if (TREE_CODE (expr) == RESULT_DECL
 211       || TREE_CODE (expr) == PARM_DECL
 212       || TREE_CODE (expr) == VAR_DECL)
 213     {
 214       bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
 215       if (TREE_CODE (expr) == VAR_DECL
 216           || TREE_CODE (expr) == PARM_DECL)
 217         bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
 218     }
 219 }
 220
 221
 222 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
 223    of expression EXPR into bitpack BP.  */
 224
 225 static void
 226 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
 227 {
 228   bp_pack_value (bp, DECL_REGISTER (expr), 1);
 229 }
 230
 231
 232 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
 233    of expression EXPR into bitpack BP.  */
 234
 235 static void
 236 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
 237 {
 238   bp_pack_value (bp, DECL_COMMON (expr), 1);
 239   bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
 240   bp_pack_value (bp, DECL_WEAK (expr), 1);
 241   bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr),  1);
 242   bp_pack_value (bp, DECL_COMDAT (expr),  1);
 243   bp_pack_value (bp, DECL_VISIBILITY (expr),  2);
 244   bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr),  1);
 245
 246   if (TREE_CODE (expr) == VAR_DECL)
 247     {
 248       bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
 249       /* DECL_IN_TEXT_SECTION is set during final asm output only. */
 250       bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
 251     }
 252
 253   if (TREE_CODE (expr) == FUNCTION_DECL)
 254     {
 255       bp_pack_value (bp, DECL_FINAL_P (expr), 1);
 256       bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1);
 257       bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1);
 258     }
 259 }
 260
 261
 262 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
 263    of expression EXPR into bitpack BP.  */
 264
 265 static void
 266 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
 267 {
 268   /* For normal/md builtins we only write the class and code, so they
 269      should never be handled here.  */
 270   gcc_assert (!streamer_handle_as_builtin_p (expr));
 271
 272   bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
 273                 DECL_BUILT_IN_CLASS (expr));
 274   bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
 275   bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
 276   bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
 277   bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
 278   bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
 279   bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
 280   bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
 281   bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
 282   bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
 283   bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
 284   bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
 285   bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
 286   bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
 287   bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
 288   bp_pack_value (bp, DECL_PURE_P (expr), 1);
 289   bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
 290   if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
 291     bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
 292 }
 293
 294
 295 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
 296    of expression EXPR into bitpack BP.  */
 297
 298 static void
 299 pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
 300 {
 301   bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, TYPE_MODE (expr));
 302   bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
 303   bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
 304   bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
 305   if (RECORD_OR_UNION_TYPE_P (expr))
 306     {
 307       bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
 308       bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
 309     }
 310   else if (TREE_CODE (expr) == ARRAY_TYPE)
 311     bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
 312   bp_pack_value (bp, TYPE_PACKED (expr), 1);
 313   bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
 314   bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
 315   bp_pack_value (bp, TYPE_READONLY (expr), 1);
 316   bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
 317   bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
 318   /* Make sure to preserve the fact whether the frontend would assign
 319      alias-set zero to this type.  */
 320   bp_pack_var_len_int (bp, (TYPE_ALIAS_SET (expr) == 0
 321                             || (!in_lto_p
 322                                 && get_alias_set (expr) == 0)) ? 0 : -1);
 323 }
 324
 325
 326 /* Pack all the non-pointer fields of the TS_BLOCK structure
 327    of expression EXPR into bitpack BP.  */
 328
 329 static void
 330 pack_ts_block_value_fields (struct output_block *ob,
 331                             struct bitpack_d *bp, tree expr)
 332 {
 333   bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
 334   /* BLOCK_NUMBER is recomputed.  */
 335   /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
 336      that represent inlined function scopes.
 337      For the rest them on the floor instead of ICEing in dwarf2out.c.  */
 338   if (inlined_function_outer_scope_p (expr))
 339     stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
 340   else
 341     stream_output_location (ob, bp, UNKNOWN_LOCATION);
 342 }
 343
 344 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
 345    of expression EXPR into bitpack BP.  */
 346
 347 static void
 348 pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
 349                                             struct bitpack_d *bp, tree expr)
 350 {
 351   bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
 352 }
 353
 354 /* Pack a TS_OPTIMIZATION tree in EXPR to BP.  */
 355
 356 static void
 357 pack_ts_optimization (struct bitpack_d *bp, tree expr)
 358 {
 359   struct cl_optimization *t = TREE_OPTIMIZATION (expr);
 360   unsigned i, len;
 361
 362   /* The cl_optimization is generated by the options
 363      awk script, so we just recreate a byte-by-byte copy here. */
 364
 365   len = sizeof (struct cl_optimization);
 366   for (i = 0; i < len; i++)
 367     bp_pack_value (bp, ((unsigned char *)t)[i], 8);
 368   /* Catch struct size mismatches between reader and writer. */
 369   bp_pack_value (bp, 0x12345678, 32);
 370 }
 371
 372
 373 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
 374    of expression EXPR into bitpack BP.  */
 375
 376 static void
 377 pack_ts_omp_clause_value_fields (struct output_block *ob,
 378                                  struct bitpack_d *bp, tree expr)
 379 {
 380   stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
 381   switch (OMP_CLAUSE_CODE (expr))
 382     {
 383     case OMP_CLAUSE_DEFAULT:
 384       bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
 385                     OMP_CLAUSE_DEFAULT_KIND (expr));
 386       break;
 387     case OMP_CLAUSE_SCHEDULE:
 388       bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
 389                     OMP_CLAUSE_SCHEDULE_KIND (expr));
 390       break;
 391     case OMP_CLAUSE_DEPEND:
 392       bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
 393                     OMP_CLAUSE_DEPEND_KIND (expr));
 394       break;
 395     case OMP_CLAUSE_MAP:
 396       bp_pack_enum (bp, omp_clause_map_kind, OMP_CLAUSE_MAP_LAST,
 397                     OMP_CLAUSE_MAP_KIND (expr));
 398       break;
 399     case OMP_CLAUSE_PROC_BIND:
 400       bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
 401                     OMP_CLAUSE_PROC_BIND_KIND (expr));
 402       break;
 403     case OMP_CLAUSE_REDUCTION:
 404       bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
 405                     OMP_CLAUSE_REDUCTION_CODE (expr));
 406       break;
 407     default:
 408       break;
 409     }
 410 }
 411
 412
 413 /* Pack all the bitfields in EXPR into a bit pack.  */
 414
 415 void
 416 streamer_pack_tree_bitfields (struct output_block *ob,
 417                               struct bitpack_d *bp, tree expr)
 418 {
 419   enum tree_code code;
 420
 421   code = TREE_CODE (expr);
 422
 423   /* Note that all these functions are highly sensitive to changes in
 424      the types and sizes of each of the fields being packed.  */
 425   pack_ts_base_value_fields (bp, expr);
 426
 427   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
 428     pack_ts_int_cst_value_fields (bp, expr);
 429
 430   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 431     pack_ts_real_cst_value_fields (bp, expr);
 432
 433   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 434     pack_ts_fixed_cst_value_fields (bp, expr);
 435
 436   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 437     stream_output_location (ob, bp, DECL_SOURCE_LOCATION (expr));
 438
 439   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 440     pack_ts_decl_common_value_fields (bp, expr);
 441
 442   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 443     pack_ts_decl_wrtl_value_fields (bp, expr);
 444
 445   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 446     pack_ts_decl_with_vis_value_fields (bp, expr);
 447
 448   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 449     pack_ts_function_decl_value_fields (bp, expr);
 450
 451   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 452     pack_ts_type_common_value_fields (bp, expr);
 453
 454   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 455     stream_output_location (ob, bp, EXPR_LOCATION (expr));
 456
 457   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 458     pack_ts_block_value_fields (ob, bp, expr);
 459
 460   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 461     pack_ts_translation_unit_decl_value_fields (ob, bp, expr);
 462
 463   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
 464     gcc_unreachable ();
 465
 466   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
 467     pack_ts_optimization (bp, expr);
 468
 469   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 470     bp_pack_var_len_unsigned (bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
 471
 472   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 473     bp_pack_var_len_unsigned (bp, CONSTRUCTOR_NELTS (expr));
 474
 475   if (code == OMP_CLAUSE)
 476     pack_ts_omp_clause_value_fields (ob, bp, expr);
 477 }
 478
 479
 480 /* Write the code and class of builtin EXPR to output block OB.  IX is
 481    the index into the streamer cache where EXPR is stored.*/
 482
 483 void
 484 streamer_write_builtin (struct output_block *ob, tree expr)
 485 {
 486   gcc_assert (streamer_handle_as_builtin_p (expr));
 487
 488   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
 489       && !targetm.builtin_decl)
 490     sorry ("tree bytecode streams do not support machine specific builtin "
 491            "functions on this target");
 492
 493   streamer_write_record_start (ob, LTO_builtin_decl);
 494   streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
 495                        DECL_BUILT_IN_CLASS (expr));
 496   streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
 497
 498   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 499     {
 500       /* When the assembler name of a builtin gets a user name,
 501          the new name is always prefixed with '*' by
 502          set_builtin_user_assembler_name.  So, to prevent the
 503          reader side from adding a second '*', we omit it here.  */
 504       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
 505       if (strlen (str) > 1 && str[0] == '*')
 506         streamer_write_string (ob, ob->main_stream, &str[1], true);
 507       else
 508         streamer_write_string (ob, ob->main_stream, NULL, true);
 509     }
 510   else
 511     streamer_write_string (ob, ob->main_stream, NULL, true);
 512 }
 513
 514
 515 /* Emit the chain of tree nodes starting at T.  OB is the output block
 516    to write to.  REF_P is true if chain elements should be emitted
 517    as references.  */
 518
 519 void
 520 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
 521 {
 522   while (t)
 523     {
 524       /* We avoid outputting external vars or functions by reference
 525          to the global decls section as we do not want to have them
 526          enter decl merging.  This is, of course, only for the call
 527          for streaming BLOCK_VARS, but other callers are safe.  */
 528       /* ???  FIXME wrt SCC streaming.  Drop these for now.  */
 529       if (VAR_OR_FUNCTION_DECL_P (t)
 530           && DECL_EXTERNAL (t))
 531         ; /* stream_write_tree_shallow_non_ref (ob, t, ref_p); */
 532       else
 533         stream_write_tree (ob, t, ref_p);
 534
 535       t = TREE_CHAIN (t);
 536     }
 537
 538   /* Write a sentinel to terminate the chain.  */
 539   stream_write_tree (ob, NULL_TREE, ref_p);
 540 }
 541
 542
 543 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 544    block OB.  If REF_P is true, write a reference to EXPR's pointer
 545    fields.  */
 546
 547 static void
 548 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 549 {
 550   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 551     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
 552 }
 553
 554
 555 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 556    block OB.  If REF_P is true, write a reference to EXPR's pointer
 557    fields.  */
 558
 559 static void
 560 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 561 {
 562   unsigned i;
 563   /* Note that the number of elements for EXPR has already been emitted
 564      in EXPR's header (see streamer_write_tree_header).  */
 565   for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
 566     stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p);
 567 }
 568
 569
 570 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 571    block OB.  If REF_P is true, write a reference to EXPR's pointer
 572    fields.  */
 573
 574 static void
 575 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 576 {
 577   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 578   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 579 }
 580
 581
 582 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 583    to output block OB.  If REF_P is true, write a reference to EXPR's
 584    pointer fields.  */
 585
 586 static void
 587 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 588                                      bool ref_p)
 589 {
 590   /* Drop names that were created for anonymous entities.  */
 591   if (DECL_NAME (expr)
 592       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
 593       && ANON_AGGRNAME_P (DECL_NAME (expr)))
 594     stream_write_tree (ob, NULL_TREE, ref_p);
 595   else
 596     stream_write_tree (ob, DECL_NAME (expr), ref_p);
 597   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 598 }
 599
 600
 601 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 602    output block OB.  If REF_P is true, write a reference to EXPR's
 603    pointer fields.  */
 604
 605 static void
 606 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 607                                     bool ref_p)
 608 {
 609   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 610   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 611
 612   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 613      special handling in LTO, it must be handled by streamer hooks.  */
 614
 615   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 616
 617   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 618      for early inlining so drop it on the floor instead of ICEing in
 619      dwarf2out.c.  */
 620
 621   if ((TREE_CODE (expr) == VAR_DECL
 622        || TREE_CODE (expr) == PARM_DECL)
 623       && DECL_HAS_VALUE_EXPR_P (expr))
 624     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 625
 626   if (TREE_CODE (expr) == VAR_DECL)
 627     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 628 }
 629
 630
 631 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 632    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 633    pointer fields.  */
 634
 635 static void
 636 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 637                                         bool ref_p)
 638 {
 639   if (TREE_CODE (expr) == TYPE_DECL)
 640     stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
 641 }
 642
 643
 644 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 645    to output block OB.  If REF_P is true, write a reference to EXPR's
 646    pointer fields.  */
 647
 648 static void
 649 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 650                                       bool ref_p)
 651 {
 652   /* Make sure we don't inadvertently set the assembler name.  */
 653   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 654     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 655   else
 656     stream_write_tree (ob, NULL_TREE, false);
 657 }
 658
 659
 660 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 661    output block OB.  If REF_P is true, write a reference to EXPR's
 662    pointer fields.  */
 663
 664 static void
 665 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 666                                    bool ref_p)
 667 {
 668   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 669   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 670   stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
 671   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 672   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 673 }
 674
 675
 676 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 677    to output block OB.  If REF_P is true, write a reference to EXPR's
 678    pointer fields.  */
 679
 680 static void
 681 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 682                                       bool ref_p)
 683 {
 684   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 685   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 686      maybe it should be handled here?  */
 687   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 688   /* DECL_FUNCTION_SPECIFIC_TARGET is regenerated.  */
 689   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 690 }
 691
 692
 693 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 694    output block OB.  If REF_P is true, write a reference to EXPR's
 695    pointer fields.  */
 696
 697 static void
 698 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 699                                     bool ref_p)
 700 {
 701   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 702   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 703   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 704   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 705   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 706      reconstructed during fixup.  */
 707   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 708      during fixup.  */
 709   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 710   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 711   /* TYPE_CANONICAL is re-computed during type merging, so no need
 712      to stream it here.  */
 713   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 714 }
 715
 716 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 717    to output block OB.  If REF_P is true, write a reference to EXPR's
 718    pointer fields.  */
 719
 720 static void
 721 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 722                                         bool ref_p)
 723 {
 724   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 725     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 726   else if (TREE_CODE (expr) == ARRAY_TYPE)
 727     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 728   else if (RECORD_OR_UNION_TYPE_P (expr))
 729     streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
 730   else if (TREE_CODE (expr) == FUNCTION_TYPE
 731            || TREE_CODE (expr) == METHOD_TYPE)
 732     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 733
 734   if (!POINTER_TYPE_P (expr))
 735     stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
 736   stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
 737   if (RECORD_OR_UNION_TYPE_P (expr))
 738     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 739 }
 740
 741
 742 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 743    block OB.  If REF_P is true, write a reference to EXPR's pointer
 744    fields.  */
 745
 746 static void
 747 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 748 {
 749   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 750   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 751   stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
 752 }
 753
 754
 755 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 756    block OB.  If REF_P is true, write a reference to EXPR's pointer
 757    fields.  */
 758
 759 static void
 760 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 761 {
 762   int i;
 763
 764   /* Note that the number of slots for EXPR has already been emitted
 765      in EXPR's header (see streamer_write_tree_header).  */
 766   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 767     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 768 }
 769
 770
 771 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 772    block OB.  If REF_P is true, write a reference to EXPR's pointer
 773    fields.  */
 774
 775 static void
 776 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 777 {
 778   int i;
 779
 780   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 781     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 782   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 783 }
 784
 785
 786 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 787    block OB.  If REF_P is true, write a reference to EXPR's pointer
 788    fields.  */
 789
 790 static void
 791 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 792 {
 793   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 794
 795   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 796
 797   /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
 798      that represent inlined function scopes.
 799      For the rest them on the floor instead of ICEing in dwarf2out.c.  */
 800   if (inlined_function_outer_scope_p (expr))
 801     {
 802       tree ultimate_origin = block_ultimate_origin (expr);
 803       stream_write_tree (ob, ultimate_origin, ref_p);
 804     }
 805   else
 806     stream_write_tree (ob, NULL_TREE, ref_p);
 807   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 808      for early inlined BLOCKs so drop it on the floor instead of ICEing in
 809      dwarf2out.c.  */
 810
 811   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
 812      streaming time.  */
 813
 814   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 815      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 816 }
 817
 818
 819 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 820    block OB.  If REF_P is true, write a reference to EXPR's pointer
 821    fields.  */
 822
 823 static void
 824 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 825 {
 826   unsigned i;
 827   tree t;
 828
 829   /* Note that the number of BINFO slots has already been emitted in
 830      EXPR's header (see streamer_write_tree_header) because this length
 831      is needed to build the empty BINFO node on the reader side.  */
 832   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
 833     stream_write_tree (ob, t, ref_p);
 834   stream_write_tree (ob, NULL_TREE, false);
 835
 836   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 837   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 838   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 839
 840   /* The number of BINFO_BASE_ACCESSES has already been emitted in
 841      EXPR's bitfield section.  */
 842   FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
 843     stream_write_tree (ob, t, ref_p);
 844
 845   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
 846      and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
 847 }
 848
 849
 850 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 851    output block OB.  If REF_P is true, write a reference to EXPR's
 852    pointer fields.  */
 853
 854 static void
 855 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 856                                     bool ref_p)
 857 {
 858   unsigned i;
 859   tree index, value;
 860
 861   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 862     {
 863       stream_write_tree (ob, index, ref_p);
 864       stream_write_tree (ob, value, ref_p);
 865     }
 866 }
 867
 868
 869 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
 870    to output block OB.  If REF_P is true, write a reference to EXPR's
 871    pointer fields.  */
 872
 873 static void
 874 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
 875                                    bool ref_p)
 876 {
 877   int i;
 878   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
 879     stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
 880   if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION)
 881     {
 882       /* We don't stream these right now, handle it if streaming
 883          of them is needed.  */
 884       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
 885       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
 886     }
 887   stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
 888 }
 889
 890
 891 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 892    the leaves of EXPR are emitted as references.  */
 893
 894 void
 895 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 896 {
 897   enum tree_code code;
 898
 899   lto_stats.num_tree_bodies_output++;
 900
 901   code = TREE_CODE (expr);
 902
 903   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 904     write_ts_common_tree_pointers (ob, expr, ref_p);
 905
 906   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 907     write_ts_vector_tree_pointers (ob, expr, ref_p);
 908
 909   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 910     write_ts_complex_tree_pointers (ob, expr, ref_p);
 911
 912   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 913     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 914
 915   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 916     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 917
 918   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 919     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 920
 921   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 922     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 923
 924   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 925     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 926
 927   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 928     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 929
 930   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 931     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 932
 933   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 934     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 935
 936   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 937     write_ts_list_tree_pointers (ob, expr, ref_p);
 938
 939   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 940     write_ts_vec_tree_pointers (ob, expr, ref_p);
 941
 942   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 943     write_ts_exp_tree_pointers (ob, expr, ref_p);
 944
 945   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 946     write_ts_block_tree_pointers (ob, expr, ref_p);
 947
 948   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 949     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 950
 951   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 952     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 953
 954   if (code == OMP_CLAUSE)
 955     write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
 956 }
 957
 958
 959 /* Emit header information for tree EXPR to output block OB.  The header
 960    contains everything needed to instantiate an empty skeleton for
 961    EXPR on the reading side.  IX is the index into the streamer cache
 962    where EXPR is stored.  */
 963
 964 void
 965 streamer_write_tree_header (struct output_block *ob, tree expr)
 966 {
 967   enum LTO_tags tag;
 968   enum tree_code code;
 969
 970   /* We should not see any tree nodes not handled by the streamer.  */
 971   code = TREE_CODE (expr);
 972
 973   /* The header of a tree node consists of its tag, the size of
 974      the node, and any other information needed to instantiate
 975      EXPR on the reading side (such as the number of slots in
 976      variable sized nodes).  */
 977   tag = lto_tree_code_to_tag (code);
 978   streamer_write_record_start (ob, tag);
 979
 980   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 981 #ifdef LTO_STREAMER_DEBUG
 982   /* This is used mainly for debugging purposes.  When the reader
 983      and the writer do not agree on a streamed node, the pointer
 984      value for EXPR can be used to track down the differences in
 985      the debugger.  */
 986   gcc_assert ((HOST_WIDE_INT) (intptr_t) expr == (intptr_t) expr);
 987   streamer_write_hwi (ob, (HOST_WIDE_INT) (intptr_t) expr);
 988 #endif
 989
 990   /* The text in strings and identifiers are completely emitted in
 991      the header.  */
 992   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
 993     streamer_write_string_cst (ob, ob->main_stream, expr);
 994   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
 995     write_identifier (ob, ob->main_stream, expr);
 996   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 997     streamer_write_hwi (ob, VECTOR_CST_NELTS (expr));
 998   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 999     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1000   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1001     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1002   else if (TREE_CODE (expr) == CALL_EXPR)
1003     streamer_write_uhwi (ob, call_expr_nargs (expr));
1004   else if (TREE_CODE (expr) == OMP_CLAUSE)
1005     streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
1006   else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1007     {
1008       gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
1009       streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
1010       streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
1011     }
1012 }
1013
1014
1015 /* Emit the integer constant CST to output block OB.  If REF_P is true,
1016    CST's type will be emitted as a reference.  */
1017
1018 void
1019 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1020 {
1021   int i;
1022   int len = TREE_INT_CST_NUNITS (cst);
1023   gcc_assert (!TREE_OVERFLOW (cst));
1024   streamer_write_record_start (ob, LTO_integer_cst);
1025   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
1026   /* We're effectively streaming a non-sign-extended wide_int here,
1027      so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1028      array members beyond LEN.  We'll recreate the tree from the
1029      wide_int and the type.  */
1030   streamer_write_uhwi (ob, len);
1031   for (i = 0; i < len; i++)
1032     streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
1033 }