gcc/tree-streamer-out.c

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