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