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