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