gcc/tree-streamer-out.c

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