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