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