gcc/tree-streamer-out.c

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