gcc/tree-streamer-out.c

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