gcc/tree-streamer-out.cc

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