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