gcc/tree-streamer-out.c

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