gcc/tree-streamer-out.c

   1 /* Routines for emitting trees to a file stream.
   2
   3    Copyright (C) 2011-2015 Free Software Foundation, Inc.
   4    Contributed by Diego Novillo <dnovillo@google.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "diagnostic.h"
  27 #include "alias.h"
  28 #include "symtab.h"
  29 #include "tree.h"
  30 #include "fold-const.h"
  31 #include "stor-layout.h"
  32 #include "predict.h"
  33 #include "hard-reg-set.h"
  34 #include "function.h"
  35 #include "basic-block.h"
  36 #include "tree-ssa-alias.h"
  37 #include "internal-fn.h"
  38 #include "gimple-expr.h"
  39 #include "gimple.h"
  40 #include "plugin-api.h"
  41 #include "ipa-ref.h"
  42 #include "cgraph.h"
  43 #include "tree-streamer.h"
  44 #include "data-streamer.h"
  45 #include "streamer-hooks.h"
  46 #include "gomp-constants.h"
  47
  48
  49 /* Output the STRING constant to the string
  50    table in OB.  Then put the index onto the INDEX_STREAM.  */
  51
  52 void
  53 streamer_write_string_cst (struct output_block *ob,
  54                            struct lto_output_stream *index_stream,
  55                            tree string)
  56 {
  57   streamer_write_string_with_length (ob, index_stream,
  58                                      string ? TREE_STRING_POINTER (string)
  59                                             : NULL,
  60                                      string ? TREE_STRING_LENGTH (string) : 0,
  61                                      true);
  62 }
  63
  64
  65 /* Output the identifier ID to the string
  66    table in OB.  Then put the index onto the INDEX_STREAM.  */
  67
  68 static void
  69 write_identifier (struct output_block *ob,
  70                    struct lto_output_stream *index_stream,
  71                    tree id)
  72 {
  73   streamer_write_string_with_length (ob, index_stream,
  74                                      IDENTIFIER_POINTER (id),
  75                                      IDENTIFIER_LENGTH (id),
  76                                      true);
  77 }
  78
  79
  80 /* Pack all the non-pointer fields of the TS_BASE structure of
  81    expression EXPR into bitpack BP.  */
  82
  83 static inline void
  84 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
  85 {
  86   bp_pack_value (bp, TREE_CODE (expr), 16);
  87   if (!TYPE_P (expr))
  88     {
  89       bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
  90       bp_pack_value (bp, TREE_CONSTANT (expr), 1);
  91       bp_pack_value (bp, TREE_READONLY (expr), 1);
  92
  93       /* TREE_PUBLIC is used on types to indicate that the type
  94          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
  95          so we skip it here.  */
  96       bp_pack_value (bp, TREE_PUBLIC (expr), 1);
  97     }
  98   else
  99     bp_pack_value (bp, 0, 4);
 100   bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
 101   bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
 102   if (DECL_P (expr))
 103     bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
 104   else if (TYPE_P (expr))
 105     bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
 106   else
 107     bp_pack_value (bp, 0, 1);
 108   /* We write debug info two times, do not confuse the second one.
 109      The only relevant TREE_ASM_WRITTEN use is on SSA names.  */
 110   bp_pack_value (bp, (TREE_CODE (expr) != SSA_NAME
 111                       ? 0 : TREE_ASM_WRITTEN (expr)), 1);
 112   if (TYPE_P (expr))
 113     bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
 114   else
 115     bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
 116   bp_pack_value (bp, TREE_NOTHROW (expr), 1);
 117   bp_pack_value (bp, TREE_STATIC (expr), 1);
 118   if (TREE_CODE (expr) != TREE_BINFO)
 119     bp_pack_value (bp, TREE_PRIVATE (expr), 1);
 120   else
 121     bp_pack_value (bp, 0, 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     {
 131       bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
 132       bp_pack_value (bp, 0, 8);
 133     }
 134   else
 135     bp_pack_value (bp, 0, 9);
 136 }
 137
 138
 139 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
 140    expression EXPR into bitpack BP.  */
 141
 142 static void
 143 pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
 144 {
 145   int i;
 146   /* Note that the number of elements has already been written out in
 147      streamer_write_tree_header.  */
 148   for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
 149     bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i));
 150 }
 151
 152
 153 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
 154    expression EXPR into bitpack BP.  */
 155
 156 static void
 157 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
 158 {
 159   unsigned i;
 160   REAL_VALUE_TYPE r;
 161
 162   r = TREE_REAL_CST (expr);
 163   bp_pack_value (bp, r.cl, 2);
 164   bp_pack_value (bp, r.decimal, 1);
 165   bp_pack_value (bp, r.sign, 1);
 166   bp_pack_value (bp, r.signalling, 1);
 167   bp_pack_value (bp, r.canonical, 1);
 168   bp_pack_value (bp, r.uexp, EXP_BITS);
 169   for (i = 0; i < SIGSZ; i++)
 170     bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
 171 }
 172
 173
 174 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
 175    expression EXPR into bitpack BP.  */
 176
 177 static void
 178 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
 179 {
 180   struct fixed_value fv = TREE_FIXED_CST (expr);
 181   bp_pack_machine_mode (bp, fv.mode);
 182   bp_pack_var_len_int (bp, fv.data.low);
 183   bp_pack_var_len_int (bp, fv.data.high);
 184 }
 185
 186 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
 187    of expression EXPR into bitpack BP.  */
 188
 189 static void
 190 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
 191 {
 192   bp_pack_machine_mode (bp, DECL_MODE (expr));
 193   bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
 194   bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
 195   bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
 196   bp_pack_value (bp, DECL_ABSTRACT_P (expr), 1);
 197   bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
 198   bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
 199   bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
 200   bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
 201   bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
 202   bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
 203
 204   if (TREE_CODE (expr) == LABEL_DECL)
 205     {
 206       /* Note that we do not write LABEL_DECL_UID.  The reader will
 207          always assume an initial value of -1 so that the
 208          label_to_block_map is recreated by gimple_set_bb.  */
 209       bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
 210     }
 211
 212   if (TREE_CODE (expr) == FIELD_DECL)
 213     {
 214       bp_pack_value (bp, DECL_PACKED (expr), 1);
 215       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
 216       bp_pack_value (bp, expr->decl_common.off_align, 8);
 217     }
 218
 219   if (TREE_CODE (expr) == VAR_DECL)
 220     {
 221       bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
 222       bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
 223     }
 224
 225   if (TREE_CODE (expr) == RESULT_DECL
 226       || TREE_CODE (expr) == PARM_DECL
 227       || TREE_CODE (expr) == VAR_DECL)
 228     {
 229       bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
 230       if (TREE_CODE (expr) == VAR_DECL
 231           || TREE_CODE (expr) == PARM_DECL)
 232         bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
 233     }
 234 }
 235
 236
 237 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
 238    of expression EXPR into bitpack BP.  */
 239
 240 static void
 241 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
 242 {
 243   bp_pack_value (bp, DECL_REGISTER (expr), 1);
 244 }
 245
 246
 247 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
 248    of expression EXPR into bitpack BP.  */
 249
 250 static void
 251 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
 252 {
 253   bp_pack_value (bp, DECL_COMMON (expr), 1);
 254   bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
 255   bp_pack_value (bp, DECL_WEAK (expr), 1);
 256   bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr),  1);
 257   bp_pack_value (bp, DECL_COMDAT (expr),  1);
 258   bp_pack_value (bp, DECL_VISIBILITY (expr),  2);
 259   bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr),  1);
 260
 261   if (TREE_CODE (expr) == VAR_DECL)
 262     {
 263       bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
 264       /* DECL_IN_TEXT_SECTION is set during final asm output only. */
 265       bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
 266     }
 267
 268   if (TREE_CODE (expr) == FUNCTION_DECL)
 269     {
 270       bp_pack_value (bp, DECL_FINAL_P (expr), 1);
 271       bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1);
 272       bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1);
 273     }
 274 }
 275
 276
 277 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
 278    of expression EXPR into bitpack BP.  */
 279
 280 static void
 281 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
 282 {
 283   /* For normal/md builtins we only write the class and code, so they
 284      should never be handled here.  */
 285   gcc_assert (!streamer_handle_as_builtin_p (expr));
 286
 287   bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
 288                 DECL_BUILT_IN_CLASS (expr));
 289   bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
 290   bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
 291   bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
 292   bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
 293   bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
 294   bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
 295   bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
 296   bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
 297   bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
 298   bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
 299   bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
 300   bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
 301   bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
 302   bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
 303   bp_pack_value (bp, DECL_PURE_P (expr), 1);
 304   bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
 305   if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
 306     bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 12);
 307 }
 308
 309
 310 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
 311    of expression EXPR into bitpack BP.  */
 312
 313 static void
 314 pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
 315 {
 316   bp_pack_machine_mode (bp, TYPE_MODE (expr));
 317   bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
 318   /* TYPE_NO_FORCE_BLK is private to stor-layout and need
 319      no streaming.  */
 320   bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
 321   if (RECORD_OR_UNION_TYPE_P (expr))
 322     {
 323       bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
 324       bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
 325     }
 326   else if (TREE_CODE (expr) == ARRAY_TYPE)
 327     bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
 328   bp_pack_value (bp, TYPE_PACKED (expr), 1);
 329   bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
 330   bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
 331   bp_pack_value (bp, TYPE_READONLY (expr), 1);
 332   bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
 333   bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
 334   /* Make sure to preserve the fact whether the frontend would assign
 335      alias-set zero to this type.  */
 336   bp_pack_var_len_int (bp, (TYPE_ALIAS_SET (expr) == 0
 337                             || (!in_lto_p
 338                                 && get_alias_set (expr) == 0)) ? 0 : -1);
 339 }
 340
 341
 342 /* Pack all the non-pointer fields of the TS_BLOCK structure
 343    of expression EXPR into bitpack BP.  */
 344
 345 static void
 346 pack_ts_block_value_fields (struct output_block *ob,
 347                             struct bitpack_d *bp, tree expr)
 348 {
 349   bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
 350   /* BLOCK_NUMBER is recomputed.  */
 351   /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
 352      that represent inlined function scopes.
 353      For the rest them on the floor instead of ICEing in dwarf2out.c.  */
 354   if (inlined_function_outer_scope_p (expr))
 355     stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
 356   else
 357     stream_output_location (ob, bp, UNKNOWN_LOCATION);
 358 }
 359
 360 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
 361    of expression EXPR into bitpack BP.  */
 362
 363 static void
 364 pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
 365                                             struct bitpack_d *bp, tree expr)
 366 {
 367   bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
 368 }
 369
 370
 371 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
 372    of expression EXPR into bitpack BP.  */
 373
 374 static void
 375 pack_ts_omp_clause_value_fields (struct output_block *ob,
 376                                  struct bitpack_d *bp, tree expr)
 377 {
 378   stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
 379   switch (OMP_CLAUSE_CODE (expr))
 380     {
 381     case OMP_CLAUSE_DEFAULT:
 382       bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
 383                     OMP_CLAUSE_DEFAULT_KIND (expr));
 384       break;
 385     case OMP_CLAUSE_SCHEDULE:
 386       bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
 387                     OMP_CLAUSE_SCHEDULE_KIND (expr));
 388       break;
 389     case OMP_CLAUSE_DEPEND:
 390       bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
 391                     OMP_CLAUSE_DEPEND_KIND (expr));
 392       break;
 393     case OMP_CLAUSE_MAP:
 394       bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST,
 395                     OMP_CLAUSE_MAP_KIND (expr));
 396       break;
 397     case OMP_CLAUSE_PROC_BIND:
 398       bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
 399                     OMP_CLAUSE_PROC_BIND_KIND (expr));
 400       break;
 401     case OMP_CLAUSE_REDUCTION:
 402       bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
 403                     OMP_CLAUSE_REDUCTION_CODE (expr));
 404       break;
 405     default:
 406       break;
 407     }
 408 }
 409
 410
 411 /* Pack all the bitfields in EXPR into a bit pack.  */
 412
 413 void
 414 streamer_write_tree_bitfields (struct output_block *ob, tree expr)
 415 {
 416   bitpack_d bp = bitpack_create (ob->main_stream);
 417   enum tree_code code;
 418
 419   code = TREE_CODE (expr);
 420
 421   /* Note that all these functions are highly sensitive to changes in
 422      the types and sizes of each of the fields being packed.  */
 423   pack_ts_base_value_fields (&bp, expr);
 424
 425   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
 426     pack_ts_int_cst_value_fields (&bp, expr);
 427
 428   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 429     pack_ts_real_cst_value_fields (&bp, expr);
 430
 431   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 432     pack_ts_fixed_cst_value_fields (&bp, expr);
 433
 434   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 435     stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
 436
 437   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 438     pack_ts_decl_common_value_fields (&bp, expr);
 439
 440   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 441     pack_ts_decl_wrtl_value_fields (&bp, expr);
 442
 443   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 444     pack_ts_decl_with_vis_value_fields (&bp, expr);
 445
 446   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 447     pack_ts_function_decl_value_fields (&bp, expr);
 448
 449   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 450     pack_ts_type_common_value_fields (&bp, expr);
 451
 452   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 453     {
 454       stream_output_location (ob, &bp, EXPR_LOCATION (expr));
 455       if (code == MEM_REF
 456           || code == TARGET_MEM_REF)
 457         {
 458           bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8);
 459           if (MR_DEPENDENCE_CLIQUE (expr) != 0)
 460             bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8);
 461         }
 462     }
 463
 464   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 465     pack_ts_block_value_fields (ob, &bp, expr);
 466
 467   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 468     pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
 469
 470   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
 471     cl_optimization_stream_out (&bp, TREE_OPTIMIZATION (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_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
 480       /* Don't stream these when passing things to a different target.  */
 481       && !lto_stream_offload_p)
 482     cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
 483
 484   if (code == OMP_CLAUSE)
 485     pack_ts_omp_clause_value_fields (ob, &bp, expr);
 486
 487   streamer_write_bitpack (&bp);
 488 }
 489
 490
 491 /* Write the code and class of builtin EXPR to output block OB.  IX is
 492    the index into the streamer cache where EXPR is stored.*/
 493
 494 void
 495 streamer_write_builtin (struct output_block *ob, tree expr)
 496 {
 497   gcc_assert (streamer_handle_as_builtin_p (expr));
 498
 499   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
 500       && !targetm.builtin_decl)
 501     sorry ("tree bytecode streams do not support machine specific builtin "
 502            "functions on this target");
 503
 504   streamer_write_record_start (ob, LTO_builtin_decl);
 505   streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
 506                        DECL_BUILT_IN_CLASS (expr));
 507   streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
 508
 509   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 510     {
 511       /* When the assembler name of a builtin gets a user name,
 512          the new name is always prefixed with '*' by
 513          set_builtin_user_assembler_name.  So, to prevent the
 514          reader side from adding a second '*', we omit it here.  */
 515       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
 516       if (strlen (str) > 1 && str[0] == '*')
 517         streamer_write_string (ob, ob->main_stream, &str[1], true);
 518       else
 519         streamer_write_string (ob, ob->main_stream, NULL, true);
 520     }
 521   else
 522     streamer_write_string (ob, ob->main_stream, NULL, true);
 523 }
 524
 525
 526 /* Emit the chain of tree nodes starting at T.  OB is the output block
 527    to write to.  REF_P is true if chain elements should be emitted
 528    as references.  */
 529
 530 void
 531 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
 532 {
 533   while (t)
 534     {
 535       /* We avoid outputting external vars or functions by reference
 536          to the global decls section as we do not want to have them
 537          enter decl merging.  This is, of course, only for the call
 538          for streaming BLOCK_VARS, but other callers are safe.
 539          See also lto-streamer-out.c:DFS_write_tree_body.  */
 540       if (VAR_OR_FUNCTION_DECL_P (t)
 541           && DECL_EXTERNAL (t))
 542         stream_write_tree_shallow_non_ref (ob, t, ref_p);
 543       else
 544         stream_write_tree (ob, t, ref_p);
 545
 546       t = TREE_CHAIN (t);
 547     }
 548
 549   /* Write a sentinel to terminate the chain.  */
 550   stream_write_tree (ob, NULL_TREE, ref_p);
 551 }
 552
 553
 554 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 555    block OB.  If REF_P is true, write a reference to EXPR's pointer
 556    fields.  */
 557
 558 static void
 559 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 560 {
 561   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 562     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
 563 }
 564
 565
 566 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 567    block OB.  If REF_P is true, write a reference to EXPR's pointer
 568    fields.  */
 569
 570 static void
 571 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 572 {
 573   unsigned i;
 574   /* Note that the number of elements for EXPR has already been emitted
 575      in EXPR's header (see streamer_write_tree_header).  */
 576   for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
 577     stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p);
 578 }
 579
 580
 581 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 582    block OB.  If REF_P is true, write a reference to EXPR's pointer
 583    fields.  */
 584
 585 static void
 586 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 587 {
 588   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 589   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 590 }
 591
 592
 593 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 594    to output block OB.  If REF_P is true, write a reference to EXPR's
 595    pointer fields.  */
 596
 597 static void
 598 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 599                                      bool ref_p)
 600 {
 601   /* Drop names that were created for anonymous entities.  */
 602   if (DECL_NAME (expr)
 603       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
 604       && anon_aggrname_p (DECL_NAME (expr)))
 605     stream_write_tree (ob, NULL_TREE, ref_p);
 606   else
 607     stream_write_tree (ob, DECL_NAME (expr), ref_p);
 608   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 609 }
 610
 611
 612 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 613    output block OB.  If REF_P is true, write a reference to EXPR's
 614    pointer fields.  */
 615
 616 static void
 617 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 618                                     bool ref_p)
 619 {
 620   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 621   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 622
 623   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 624      special handling in LTO, it must be handled by streamer hooks.  */
 625
 626   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 627
 628   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 629      for early inlining so drop it on the floor instead of ICEing in
 630      dwarf2out.c.  */
 631
 632   if ((TREE_CODE (expr) == VAR_DECL
 633        || TREE_CODE (expr) == PARM_DECL)
 634       && DECL_HAS_VALUE_EXPR_P (expr))
 635     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 636
 637   if (TREE_CODE (expr) == VAR_DECL)
 638     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 639 }
 640
 641
 642 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 643    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 644    pointer fields.  */
 645
 646 static void
 647 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 648                                         bool ref_p)
 649 {
 650   if (TREE_CODE (expr) == TYPE_DECL)
 651     stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
 652 }
 653
 654
 655 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 656    to output block OB.  If REF_P is true, write a reference to EXPR's
 657    pointer fields.  */
 658
 659 static void
 660 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 661                                       bool ref_p)
 662 {
 663   /* Make sure we don't inadvertently set the assembler name.  */
 664   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 665     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 666   else
 667     stream_write_tree (ob, NULL_TREE, false);
 668 }
 669
 670
 671 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 672    output block OB.  If REF_P is true, write a reference to EXPR's
 673    pointer fields.  */
 674
 675 static void
 676 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 677                                    bool ref_p)
 678 {
 679   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 680   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 681   stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
 682   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 683   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 684 }
 685
 686
 687 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 688    to output block OB.  If REF_P is true, write a reference to EXPR's
 689    pointer fields.  */
 690
 691 static void
 692 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 693                                       bool ref_p)
 694 {
 695   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 696   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  */
 697   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 698   /* Don't stream these when passing things to a different target.  */
 699   if (!lto_stream_offload_p)
 700     stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
 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 }