gcc/tree-streamer-out.cc

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