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), 11);
 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 /* Pack a TS_OPTIMIZATION tree in EXPR to BP.  */
 367
 368 static void
 369 pack_ts_optimization (struct bitpack_d *bp, tree expr)
 370 {
 371   struct cl_optimization *t = TREE_OPTIMIZATION (expr);
 372   unsigned i, len;
 373
 374   /* The cl_optimization is generated by the options
 375      awk script, so we just recreate a byte-by-byte copy here. */
 376
 377   len = sizeof (struct cl_optimization);
 378   for (i = 0; i < len; i++)
 379     bp_pack_value (bp, ((unsigned char *)t)[i], 8);
 380   /* Catch struct size mismatches between reader and writer. */
 381   bp_pack_value (bp, 0x12345678, 32);
 382 }
 383
 384
 385 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
 386    of expression EXPR into bitpack BP.  */
 387
 388 static void
 389 pack_ts_omp_clause_value_fields (struct output_block *ob,
 390                                  struct bitpack_d *bp, tree expr)
 391 {
 392   stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
 393   switch (OMP_CLAUSE_CODE (expr))
 394     {
 395     case OMP_CLAUSE_DEFAULT:
 396       bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
 397                     OMP_CLAUSE_DEFAULT_KIND (expr));
 398       break;
 399     case OMP_CLAUSE_SCHEDULE:
 400       bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
 401                     OMP_CLAUSE_SCHEDULE_KIND (expr));
 402       break;
 403     case OMP_CLAUSE_DEPEND:
 404       bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
 405                     OMP_CLAUSE_DEPEND_KIND (expr));
 406       break;
 407     case OMP_CLAUSE_MAP:
 408       bp_pack_enum (bp, omp_clause_map_kind, OMP_CLAUSE_MAP_LAST,
 409                     OMP_CLAUSE_MAP_KIND (expr));
 410       break;
 411     case OMP_CLAUSE_PROC_BIND:
 412       bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
 413                     OMP_CLAUSE_PROC_BIND_KIND (expr));
 414       break;
 415     case OMP_CLAUSE_REDUCTION:
 416       bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
 417                     OMP_CLAUSE_REDUCTION_CODE (expr));
 418       break;
 419     default:
 420       break;
 421     }
 422 }
 423
 424
 425 /* Pack all the bitfields in EXPR into a bit pack.  */
 426
 427 void
 428 streamer_pack_tree_bitfields (struct output_block *ob,
 429                               struct bitpack_d *bp, tree expr)
 430 {
 431   enum tree_code code;
 432
 433   code = TREE_CODE (expr);
 434
 435   /* Note that all these functions are highly sensitive to changes in
 436      the types and sizes of each of the fields being packed.  */
 437   pack_ts_base_value_fields (bp, expr);
 438
 439   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
 440     pack_ts_int_cst_value_fields (bp, expr);
 441
 442   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 443     pack_ts_real_cst_value_fields (bp, expr);
 444
 445   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 446     pack_ts_fixed_cst_value_fields (bp, expr);
 447
 448   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 449     stream_output_location (ob, bp, DECL_SOURCE_LOCATION (expr));
 450
 451   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 452     pack_ts_decl_common_value_fields (bp, expr);
 453
 454   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 455     pack_ts_decl_wrtl_value_fields (bp, expr);
 456
 457   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 458     pack_ts_decl_with_vis_value_fields (bp, expr);
 459
 460   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 461     pack_ts_function_decl_value_fields (bp, expr);
 462
 463   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 464     pack_ts_type_common_value_fields (bp, expr);
 465
 466   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 467     stream_output_location (ob, bp, EXPR_LOCATION (expr));
 468
 469   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 470     pack_ts_block_value_fields (ob, bp, expr);
 471
 472   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 473     pack_ts_translation_unit_decl_value_fields (ob, bp, expr);
 474
 475   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
 476     gcc_unreachable ();
 477
 478   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
 479     pack_ts_optimization (bp, expr);
 480
 481   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 482     bp_pack_var_len_unsigned (bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
 483
 484   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 485     bp_pack_var_len_unsigned (bp, CONSTRUCTOR_NELTS (expr));
 486
 487   if (code == OMP_CLAUSE)
 488     pack_ts_omp_clause_value_fields (ob, bp, expr);
 489 }
 490
 491
 492 /* Write the code and class of builtin EXPR to output block OB.  IX is
 493    the index into the streamer cache where EXPR is stored.*/
 494
 495 void
 496 streamer_write_builtin (struct output_block *ob, tree expr)
 497 {
 498   gcc_assert (streamer_handle_as_builtin_p (expr));
 499
 500   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
 501       && !targetm.builtin_decl)
 502     sorry ("tree bytecode streams do not support machine specific builtin "
 503            "functions on this target");
 504
 505   streamer_write_record_start (ob, LTO_builtin_decl);
 506   streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
 507                        DECL_BUILT_IN_CLASS (expr));
 508   streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
 509
 510   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 511     {
 512       /* When the assembler name of a builtin gets a user name,
 513          the new name is always prefixed with '*' by
 514          set_builtin_user_assembler_name.  So, to prevent the
 515          reader side from adding a second '*', we omit it here.  */
 516       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
 517       if (strlen (str) > 1 && str[0] == '*')
 518         streamer_write_string (ob, ob->main_stream, &str[1], true);
 519       else
 520         streamer_write_string (ob, ob->main_stream, NULL, true);
 521     }
 522   else
 523     streamer_write_string (ob, ob->main_stream, NULL, true);
 524 }
 525
 526
 527 /* Emit the chain of tree nodes starting at T.  OB is the output block
 528    to write to.  REF_P is true if chain elements should be emitted
 529    as references.  */
 530
 531 void
 532 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
 533 {
 534   while (t)
 535     {
 536       /* We avoid outputting external vars or functions by reference
 537          to the global decls section as we do not want to have them
 538          enter decl merging.  This is, of course, only for the call
 539          for streaming BLOCK_VARS, but other callers are safe.
 540          See also lto-streamer-out.c:DFS_write_tree_body.  */
 541       if (VAR_OR_FUNCTION_DECL_P (t)
 542           && DECL_EXTERNAL (t))
 543         stream_write_tree_shallow_non_ref (ob, t, ref_p);
 544       else
 545         stream_write_tree (ob, t, ref_p);
 546
 547       t = TREE_CHAIN (t);
 548     }
 549
 550   /* Write a sentinel to terminate the chain.  */
 551   stream_write_tree (ob, NULL_TREE, ref_p);
 552 }
 553
 554
 555 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 556    block OB.  If REF_P is true, write a reference to EXPR's pointer
 557    fields.  */
 558
 559 static void
 560 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 561 {
 562   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 563     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
 564 }
 565
 566
 567 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 568    block OB.  If REF_P is true, write a reference to EXPR's pointer
 569    fields.  */
 570
 571 static void
 572 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 573 {
 574   unsigned i;
 575   /* Note that the number of elements for EXPR has already been emitted
 576      in EXPR's header (see streamer_write_tree_header).  */
 577   for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
 578     stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p);
 579 }
 580
 581
 582 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 583    block OB.  If REF_P is true, write a reference to EXPR's pointer
 584    fields.  */
 585
 586 static void
 587 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 588 {
 589   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 590   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 591 }
 592
 593
 594 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 595    to output block OB.  If REF_P is true, write a reference to EXPR's
 596    pointer fields.  */
 597
 598 static void
 599 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 600                                      bool ref_p)
 601 {
 602   /* Drop names that were created for anonymous entities.  */
 603   if (DECL_NAME (expr)
 604       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
 605       && ANON_AGGRNAME_P (DECL_NAME (expr)))
 606     stream_write_tree (ob, NULL_TREE, ref_p);
 607   else
 608     stream_write_tree (ob, DECL_NAME (expr), ref_p);
 609   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 610 }
 611
 612
 613 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 614    output block OB.  If REF_P is true, write a reference to EXPR's
 615    pointer fields.  */
 616
 617 static void
 618 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 619                                     bool ref_p)
 620 {
 621   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 622   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 623
 624   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 625      special handling in LTO, it must be handled by streamer hooks.  */
 626
 627   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 628
 629   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 630      for early inlining so drop it on the floor instead of ICEing in
 631      dwarf2out.c.  */
 632
 633   if ((TREE_CODE (expr) == VAR_DECL
 634        || TREE_CODE (expr) == PARM_DECL)
 635       && DECL_HAS_VALUE_EXPR_P (expr))
 636     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 637
 638   if (TREE_CODE (expr) == VAR_DECL)
 639     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 640 }
 641
 642
 643 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 644    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 645    pointer fields.  */
 646
 647 static void
 648 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 649                                         bool ref_p)
 650 {
 651   if (TREE_CODE (expr) == TYPE_DECL)
 652     stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
 653 }
 654
 655
 656 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 657    to output block OB.  If REF_P is true, write a reference to EXPR's
 658    pointer fields.  */
 659
 660 static void
 661 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 662                                       bool ref_p)
 663 {
 664   /* Make sure we don't inadvertently set the assembler name.  */
 665   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 666     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 667   else
 668     stream_write_tree (ob, NULL_TREE, false);
 669 }
 670
 671
 672 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 673    output block OB.  If REF_P is true, write a reference to EXPR's
 674    pointer fields.  */
 675
 676 static void
 677 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 678                                    bool ref_p)
 679 {
 680   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 681   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 682   stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
 683   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 684   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 685 }
 686
 687
 688 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 689    to output block OB.  If REF_P is true, write a reference to EXPR's
 690    pointer fields.  */
 691
 692 static void
 693 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 694                                       bool ref_p)
 695 {
 696   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 697   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 698      maybe it should be handled here?  */
 699   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 700   /* DECL_FUNCTION_SPECIFIC_TARGET is regenerated.  */
 701   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 702 }
 703
 704
 705 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 706    output block OB.  If REF_P is true, write a reference to EXPR's
 707    pointer fields.  */
 708
 709 static void
 710 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 711                                     bool ref_p)
 712 {
 713   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 714   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 715   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 716   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 717   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 718      reconstructed during fixup.  */
 719   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 720      during fixup.  */
 721   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 722   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 723   /* TYPE_CANONICAL is re-computed during type merging, so no need
 724      to stream it here.  */
 725   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 726 }
 727
 728 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 729    to output block OB.  If REF_P is true, write a reference to EXPR's
 730    pointer fields.  */
 731
 732 static void
 733 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 734                                         bool ref_p)
 735 {
 736   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 737     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 738   else if (TREE_CODE (expr) == ARRAY_TYPE)
 739     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 740   else if (RECORD_OR_UNION_TYPE_P (expr))
 741     streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
 742   else if (TREE_CODE (expr) == FUNCTION_TYPE
 743            || TREE_CODE (expr) == METHOD_TYPE)
 744     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 745
 746   if (!POINTER_TYPE_P (expr))
 747     stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
 748   stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
 749   if (RECORD_OR_UNION_TYPE_P (expr))
 750     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 751 }
 752
 753
 754 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 755    block OB.  If REF_P is true, write a reference to EXPR's pointer
 756    fields.  */
 757
 758 static void
 759 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 760 {
 761   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 762   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 763   stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
 764 }
 765
 766
 767 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 768    block OB.  If REF_P is true, write a reference to EXPR's pointer
 769    fields.  */
 770
 771 static void
 772 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 773 {
 774   int i;
 775
 776   /* Note that the number of slots for EXPR has already been emitted
 777      in EXPR's header (see streamer_write_tree_header).  */
 778   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 779     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 780 }
 781
 782
 783 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 784    block OB.  If REF_P is true, write a reference to EXPR's pointer
 785    fields.  */
 786
 787 static void
 788 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 789 {
 790   int i;
 791
 792   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 793     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 794   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 795 }
 796
 797
 798 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 799    block OB.  If REF_P is true, write a reference to EXPR's pointer
 800    fields.  */
 801
 802 static void
 803 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 804 {
 805   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 806
 807   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 808
 809   /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
 810      that represent inlined function scopes.
 811      For the rest them on the floor instead of ICEing in dwarf2out.c.  */
 812   if (inlined_function_outer_scope_p (expr))
 813     {
 814       tree ultimate_origin = block_ultimate_origin (expr);
 815       stream_write_tree (ob, ultimate_origin, ref_p);
 816     }
 817   else
 818     stream_write_tree (ob, NULL_TREE, ref_p);
 819   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 820      for early inlined BLOCKs so drop it on the floor instead of ICEing in
 821      dwarf2out.c.  */
 822
 823   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
 824      streaming time.  */
 825
 826   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 827      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 828 }
 829
 830
 831 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 832    block OB.  If REF_P is true, write a reference to EXPR's pointer
 833    fields.  */
 834
 835 static void
 836 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 837 {
 838   unsigned i;
 839   tree t;
 840
 841   /* Note that the number of BINFO slots has already been emitted in
 842      EXPR's header (see streamer_write_tree_header) because this length
 843      is needed to build the empty BINFO node on the reader side.  */
 844   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
 845     stream_write_tree (ob, t, ref_p);
 846   stream_write_tree (ob, NULL_TREE, false);
 847
 848   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 849   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 850   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 851
 852   /* The number of BINFO_BASE_ACCESSES has already been emitted in
 853      EXPR's bitfield section.  */
 854   FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
 855     stream_write_tree (ob, t, ref_p);
 856
 857   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
 858      and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
 859 }
 860
 861
 862 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 863    output block OB.  If REF_P is true, write a reference to EXPR's
 864    pointer fields.  */
 865
 866 static void
 867 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 868                                     bool ref_p)
 869 {
 870   unsigned i;
 871   tree index, value;
 872
 873   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 874     {
 875       stream_write_tree (ob, index, ref_p);
 876       stream_write_tree (ob, value, ref_p);
 877     }
 878 }
 879
 880
 881 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
 882    to output block OB.  If REF_P is true, write a reference to EXPR's
 883    pointer fields.  */
 884
 885 static void
 886 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
 887                                    bool ref_p)
 888 {
 889   int i;
 890   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
 891     stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
 892   if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION)
 893     {
 894       /* We don't stream these right now, handle it if streaming
 895          of them is needed.  */
 896       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
 897       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
 898     }
 899   stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
 900 }
 901
 902
 903 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 904    the leaves of EXPR are emitted as references.  */
 905
 906 void
 907 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 908 {
 909   enum tree_code code;
 910
 911   lto_stats.num_tree_bodies_output++;
 912
 913   code = TREE_CODE (expr);
 914
 915   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 916     write_ts_common_tree_pointers (ob, expr, ref_p);
 917
 918   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 919     write_ts_vector_tree_pointers (ob, expr, ref_p);
 920
 921   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 922     write_ts_complex_tree_pointers (ob, expr, ref_p);
 923
 924   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 925     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 926
 927   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 928     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 929
 930   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 931     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 932
 933   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 934     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 935
 936   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 937     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 938
 939   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 940     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 941
 942   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 943     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 944
 945   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 946     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 947
 948   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 949     write_ts_list_tree_pointers (ob, expr, ref_p);
 950
 951   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 952     write_ts_vec_tree_pointers (ob, expr, ref_p);
 953
 954   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 955     write_ts_exp_tree_pointers (ob, expr, ref_p);
 956
 957   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 958     write_ts_block_tree_pointers (ob, expr, ref_p);
 959
 960   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 961     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 962
 963   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 964     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 965
 966   if (code == OMP_CLAUSE)
 967     write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
 968 }
 969
 970
 971 /* Emit header information for tree EXPR to output block OB.  The header
 972    contains everything needed to instantiate an empty skeleton for
 973    EXPR on the reading side.  IX is the index into the streamer cache
 974    where EXPR is stored.  */
 975
 976 void
 977 streamer_write_tree_header (struct output_block *ob, tree expr)
 978 {
 979   enum LTO_tags tag;
 980   enum tree_code code;
 981
 982   /* We should not see any tree nodes not handled by the streamer.  */
 983   code = TREE_CODE (expr);
 984
 985   /* The header of a tree node consists of its tag, the size of
 986      the node, and any other information needed to instantiate
 987      EXPR on the reading side (such as the number of slots in
 988      variable sized nodes).  */
 989   tag = lto_tree_code_to_tag (code);
 990   streamer_write_record_start (ob, tag);
 991
 992   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 993 #ifdef LTO_STREAMER_DEBUG
 994   /* This is used mainly for debugging purposes.  When the reader
 995      and the writer do not agree on a streamed node, the pointer
 996      value for EXPR can be used to track down the differences in
 997      the debugger.  */
 998   gcc_assert ((HOST_WIDE_INT) (intptr_t) expr == (intptr_t) expr);
 999   streamer_write_hwi (ob, (HOST_WIDE_INT) (intptr_t) expr);
1000 #endif
1001
1002   /* The text in strings and identifiers are completely emitted in
1003      the header.  */
1004   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1005     streamer_write_string_cst (ob, ob->main_stream, expr);
1006   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1007     write_identifier (ob, ob->main_stream, expr);
1008   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1009     streamer_write_hwi (ob, VECTOR_CST_NELTS (expr));
1010   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1011     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1012   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1013     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1014   else if (TREE_CODE (expr) == CALL_EXPR)
1015     streamer_write_uhwi (ob, call_expr_nargs (expr));
1016   else if (TREE_CODE (expr) == OMP_CLAUSE)
1017     streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
1018   else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1019     {
1020       gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
1021       streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
1022       streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
1023     }
1024 }
1025
1026
1027 /* Emit the integer constant CST to output block OB.  If REF_P is true,
1028    CST's type will be emitted as a reference.  */
1029
1030 void
1031 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1032 {
1033   int i;
1034   int len = TREE_INT_CST_NUNITS (cst);
1035   gcc_assert (!TREE_OVERFLOW (cst));
1036   streamer_write_record_start (ob, LTO_integer_cst);
1037   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
1038   /* We're effectively streaming a non-sign-extended wide_int here,
1039      so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1040      array members beyond LEN.  We'll recreate the tree from the
1041      wide_int and the type.  */
1042   streamer_write_uhwi (ob, len);
1043   for (i = 0; i < len; i++)
1044     streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
1045 }