gcc/tree-streamer-out.c

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