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