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