gcc/tree-streamer-out.c

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