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