gcc/tree-streamer-out.cc

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