gcc/tree-streamer-out.c

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