gcc/tree-streamer-out.cc

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