gcc/tree-streamer-out.c

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