gcc/tree-streamer-out.c

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