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