gcc/tree-streamer-out.c

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