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