gcc/tree-streamer-out.cc

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