gcc/tree-streamer-out.cc

   1 /* Routines for emitting trees to a file stream.
   2
   3    Copyright (C) 2011-2024 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 (!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       if (lto_stream_offload_p)
 121         /* Host and offload targets have no common meaning of address
 122            spaces.  */
 123         ;
 124       else
 125         bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
 126     }
 127   else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF)
 128     {
 129       bp_pack_value (bp, REF_REVERSE_STORAGE_ORDER (expr), 1);
 130       bp_pack_value (bp, 0, 8);
 131     }
 132   else if (TREE_CODE (expr) == SSA_NAME)
 133     {
 134       bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
 135       bp_pack_value (bp, 0, 8);
 136     }
 137   else if (TREE_CODE (expr) == CALL_EXPR)
 138     {
 139       bp_pack_value (bp, CALL_EXPR_BY_DESCRIPTOR (expr), 1);
 140       bp_pack_value (bp, 0, 8);
 141     }
 142   else
 143     bp_pack_value (bp, 0, 9);
 144 }
 145
 146
 147 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
 148    expression EXPR into bitpack BP.  */
 149
 150 static void
 151 pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
 152 {
 153   int i;
 154   /* Note that the number of elements has already been written out in
 155      streamer_write_tree_header.  */
 156   for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
 157     bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i));
 158 }
 159
 160
 161 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
 162    expression EXPR into bitpack BP.  */
 163
 164 static void
 165 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
 166 {
 167   REAL_VALUE_TYPE r = TREE_REAL_CST (expr);
 168   bp_pack_real_value (bp, &r);
 169 }
 170
 171
 172 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
 173    expression EXPR into bitpack BP.  */
 174
 175 static void
 176 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
 177 {
 178   struct fixed_value fv = TREE_FIXED_CST (expr);
 179   bp_pack_machine_mode (bp, fv.mode);
 180   bp_pack_var_len_int (bp, fv.data.low);
 181   bp_pack_var_len_int (bp, fv.data.high);
 182 }
 183
 184 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
 185    of expression EXPR into bitpack BP.  */
 186
 187 static void
 188 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
 189 {
 190   /* Similar to TYPE_MODE, avoid streaming out host-specific DECL_MODE
 191      for aggregate type with offloading enabled, and while streaming-in
 192      recompute appropriate DECL_MODE for accelerator.  */
 193   if (lto_stream_offload_p
 194       && (VAR_P (expr)
 195           || TREE_CODE (expr) == PARM_DECL
 196           || TREE_CODE (expr) == FIELD_DECL)
 197       && (AGGREGATE_TYPE_P (TREE_TYPE (expr))
 198           || VECTOR_TYPE_P (TREE_TYPE (expr))))
 199     bp_pack_machine_mode (bp, VOIDmode);
 200   else
 201     bp_pack_machine_mode (bp, DECL_MODE (expr));
 202   bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
 203   bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
 204   bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
 205   bp_pack_value (bp, DECL_ABSTRACT_P (expr), 1);
 206   bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
 207   bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
 208   bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
 209   bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
 210   bp_pack_value (bp, DECL_NOT_GIMPLE_REG_P (expr), 1);
 211   bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
 212
 213   if (TREE_CODE (expr) == LABEL_DECL)
 214     {
 215       /* Note that we do not write LABEL_DECL_UID.  The reader will
 216          always assume an initial value of -1 so that the
 217          label_to_block_map is recreated by gimple_set_bb.  */
 218       bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
 219     }
 220
 221   else if (TREE_CODE (expr) == FIELD_DECL)
 222     {
 223       bp_pack_value (bp, DECL_PACKED (expr), 1);
 224       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
 225       bp_pack_value (bp, DECL_PADDING_P (expr), 1);
 226       if (DECL_BIT_FIELD (expr))
 227         bp_pack_value (bp, DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD (expr), 1);
 228       else
 229         bp_pack_value (bp, DECL_FIELD_ABI_IGNORED (expr), 1);
 230       bp_pack_value (bp, expr->decl_common.off_align, 8);
 231       bp_pack_value (bp, DECL_NOT_FLEXARRAY (expr), 1);
 232     }
 233
 234   else if (VAR_P (expr))
 235     {
 236       bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
 237       bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
 238     }
 239
 240   else if (TREE_CODE (expr) == PARM_DECL)
 241     bp_pack_value (bp, DECL_HIDDEN_STRING_LENGTH (expr), 1);
 242
 243   if (TREE_CODE (expr) == RESULT_DECL
 244       || TREE_CODE (expr) == PARM_DECL
 245       || VAR_P (expr))
 246     {
 247       bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
 248       if (VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
 249         bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
 250     }
 251 }
 252
 253
 254 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
 255    of expression EXPR into bitpack BP.  */
 256
 257 static void
 258 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
 259 {
 260   bp_pack_value (bp, DECL_REGISTER (expr), 1);
 261 }
 262
 263
 264 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
 265    of expression EXPR into bitpack BP.  */
 266
 267 static void
 268 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
 269 {
 270   bp_pack_value (bp, DECL_COMMON (expr), 1);
 271   bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
 272   bp_pack_value (bp, DECL_WEAK (expr), 1);
 273   bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr),  1);
 274   bp_pack_value (bp, DECL_COMDAT (expr),  1);
 275   bp_pack_value (bp, DECL_VISIBILITY (expr),  2);
 276   bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr),  1);
 277
 278   if (VAR_P (expr))
 279     {
 280       bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
 281       /* DECL_IN_TEXT_SECTION is set during final asm output only. */
 282       bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
 283     }
 284
 285   if (TREE_CODE (expr) == FUNCTION_DECL)
 286     {
 287       bp_pack_value (bp, DECL_FINAL_P (expr), 1);
 288       bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1);
 289       bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1);
 290     }
 291 }
 292
 293
 294 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
 295    of expression EXPR into bitpack BP.  */
 296
 297 static void
 298 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
 299 {
 300   bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
 301                 DECL_BUILT_IN_CLASS (expr));
 302   bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
 303   bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
 304   bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
 305   bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
 306   bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
 307   bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
 308   bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
 309   bp_pack_value (bp, FUNCTION_DECL_DECL_TYPE (expr), 2);
 310   bp_pack_value (bp, DECL_IS_OPERATOR_DELETE_P (expr), 1);
 311   bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
 312   bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
 313   bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
 314   bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
 315   bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
 316   bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
 317   bp_pack_value (bp, DECL_PURE_P (expr), 1);
 318   bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
 319   bp_pack_value (bp, DECL_IS_REPLACEABLE_OPERATOR (expr), 1);
 320   if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
 321     bp_pack_value (bp, DECL_UNCHECKED_FUNCTION_CODE (expr), 32);
 322 }
 323
 324
 325 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
 326    of expression EXPR into bitpack BP.  */
 327
 328 static void
 329 pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
 330 {
 331   /* For offloading, avoid streaming out TYPE_MODE for aggregate type since
 332      it may be host-specific. For eg, aarch64 uses OImode for ARRAY_TYPE
 333      whose size is 256-bits, which is not representable on accelerator.
 334      Instead stream out VOIDmode, and while streaming-in, recompute
 335      appropriate TYPE_MODE for accelerator.  */
 336   if (lto_stream_offload_p
 337       && (AGGREGATE_TYPE_P (expr) || VECTOR_TYPE_P (expr)))
 338     bp_pack_machine_mode (bp, VOIDmode);
 339   /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
 340      not necessary valid in a global context.
 341      Use the raw value previously set by layout_type.  */
 342   else
 343     bp_pack_machine_mode (bp, TYPE_MODE_RAW (expr));
 344   /* TYPE_NO_FORCE_BLK is private to stor-layout and need
 345      no streaming.  */
 346   bp_pack_value (bp, TYPE_PACKED (expr), 1);
 347   bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
 348   bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
 349   bp_pack_value (bp, TYPE_READONLY (expr), 1);
 350   unsigned vla_p;
 351   if (in_lto_p)
 352     vla_p = TYPE_LANG_FLAG_0 (TYPE_MAIN_VARIANT (expr));
 353   else
 354     vla_p = variably_modified_type_p (expr, NULL_TREE);
 355   bp_pack_value (bp, vla_p, 1);
 356   /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
 357      types that are opaque for TBAA.  This however did not work as intended,
 358      because TYPE_ALIAS_SET == 0 was regularly lost in type merging.  */
 359   if (RECORD_OR_UNION_TYPE_P (expr))
 360     {
 361       bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
 362       bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
 363       /* alias_ptr_types_compatible_p relies on fact that during LTO
 364          types do not get refined from WPA time to ltrans.  */
 365       bp_pack_value (bp, flag_wpa && TYPE_CANONICAL (expr)
 366                          ? TYPE_CXX_ODR_P (TYPE_CANONICAL (expr))
 367                          : TYPE_CXX_ODR_P (expr), 1);
 368     }
 369   else if (TREE_CODE (expr) == ARRAY_TYPE)
 370     bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
 371   if (TREE_CODE (expr) == ARRAY_TYPE || TREE_CODE (expr) == INTEGER_TYPE)
 372     bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
 373   if (AGGREGATE_TYPE_P (expr))
 374     bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1);
 375   bp_pack_value (bp, TYPE_EMPTY_P (expr), 1);
 376   if (FUNC_OR_METHOD_TYPE_P (expr))
 377     bp_pack_value (bp, TYPE_NO_NAMED_ARGS_STDARG_P (expr), 1);
 378   if (RECORD_OR_UNION_TYPE_P (expr))
 379     bp_pack_value (bp, TYPE_INCLUDES_FLEXARRAY (expr), 1);
 380   bp_pack_var_len_unsigned (bp, TYPE_PRECISION_RAW (expr));
 381   bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
 382 }
 383
 384
 385 /* Pack all the non-pointer fields of the TS_BLOCK structure
 386    of expression EXPR into bitpack BP.  */
 387
 388 static void
 389 pack_ts_block_value_fields (struct output_block *ob,
 390                             struct bitpack_d *bp, tree expr)
 391 {
 392   /* BLOCK_NUMBER is recomputed.  */
 393   /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
 394      that represent inlined function scopes.
 395      For the rest them on the floor instead of ICEing in dwarf2out.cc.  */
 396   if (inlined_function_outer_scope_p (expr))
 397     stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
 398   else
 399     stream_output_location (ob, bp, UNKNOWN_LOCATION);
 400 }
 401
 402 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
 403    of expression EXPR into bitpack BP.  */
 404
 405 static void
 406 pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
 407                                             struct bitpack_d *bp, tree expr)
 408 {
 409   bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
 410 }
 411
 412
 413 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
 414    of expression EXPR into bitpack BP.  */
 415
 416 static void
 417 pack_ts_omp_clause_value_fields (struct output_block *ob,
 418                                  struct bitpack_d *bp, tree expr)
 419 {
 420   stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
 421   switch (OMP_CLAUSE_CODE (expr))
 422     {
 423     case OMP_CLAUSE_DEFAULT:
 424       bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
 425                     OMP_CLAUSE_DEFAULT_KIND (expr));
 426       break;
 427     case OMP_CLAUSE_SCHEDULE:
 428       bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
 429                     OMP_CLAUSE_SCHEDULE_KIND (expr));
 430       break;
 431     case OMP_CLAUSE_DEPEND:
 432       bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
 433                     OMP_CLAUSE_DEPEND_KIND (expr));
 434       break;
 435     case OMP_CLAUSE_DOACROSS:
 436       bp_pack_enum (bp, omp_clause_doacross_kind, OMP_CLAUSE_DOACROSS_LAST,
 437                     OMP_CLAUSE_DOACROSS_KIND (expr));
 438       break;
 439     case OMP_CLAUSE_MAP:
 440       bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST,
 441                     OMP_CLAUSE_MAP_KIND (expr));
 442       break;
 443     case OMP_CLAUSE_PROC_BIND:
 444       bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
 445                     OMP_CLAUSE_PROC_BIND_KIND (expr));
 446       break;
 447     case OMP_CLAUSE_REDUCTION:
 448     case OMP_CLAUSE_TASK_REDUCTION:
 449     case OMP_CLAUSE_IN_REDUCTION:
 450       bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
 451                     OMP_CLAUSE_REDUCTION_CODE (expr));
 452       break;
 453     default:
 454       break;
 455     }
 456 }
 457
 458
 459 /* Pack all the bitfields in EXPR into a bit pack.  */
 460
 461 void
 462 streamer_write_tree_bitfields (struct output_block *ob, tree expr)
 463 {
 464   bitpack_d bp = bitpack_create (ob->main_stream);
 465   enum tree_code code;
 466
 467   code = TREE_CODE (expr);
 468
 469   /* Note that all these functions are highly sensitive to changes in
 470      the types and sizes of each of the fields being packed.  */
 471   pack_ts_base_value_fields (&bp, expr);
 472
 473   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
 474     pack_ts_int_cst_value_fields (&bp, expr);
 475
 476   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 477     pack_ts_real_cst_value_fields (&bp, expr);
 478
 479   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 480     pack_ts_fixed_cst_value_fields (&bp, expr);
 481
 482   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 483     stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
 484
 485   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 486     pack_ts_decl_common_value_fields (&bp, expr);
 487
 488   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 489     pack_ts_decl_wrtl_value_fields (&bp, expr);
 490
 491   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 492     pack_ts_decl_with_vis_value_fields (&bp, expr);
 493
 494   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 495     pack_ts_function_decl_value_fields (&bp, expr);
 496
 497   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 498     pack_ts_type_common_value_fields (&bp, expr);
 499
 500   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 501     {
 502       stream_output_location (ob, &bp, EXPR_LOCATION (expr));
 503       if (code == MEM_REF
 504           || code == TARGET_MEM_REF)
 505         {
 506           bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8);
 507           if (MR_DEPENDENCE_CLIQUE (expr) != 0)
 508             bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8);
 509         }
 510       else if (code == CALL_EXPR)
 511         bp_pack_enum (&bp, internal_fn, IFN_LAST, CALL_EXPR_IFN (expr));
 512     }
 513
 514   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 515     pack_ts_block_value_fields (ob, &bp, expr);
 516
 517   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 518     pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
 519
 520   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
 521     cl_optimization_stream_out (ob, &bp, TREE_OPTIMIZATION (expr));
 522
 523   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 524     {
 525       bp_pack_enum (&bp, clobber_kind, CLOBBER_LAST, CLOBBER_KIND (expr));
 526       bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
 527     }
 528
 529   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
 530       /* Don't stream these when passing things to a different target.  */
 531       && !lto_stream_offload_p)
 532     cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
 533
 534   if (code == OMP_CLAUSE)
 535     pack_ts_omp_clause_value_fields (ob, &bp, expr);
 536
 537   streamer_write_bitpack (&bp);
 538 }
 539
 540
 541 /* Emit the chain of tree nodes starting at T.  OB is the output block
 542    to write to.  REF_P is true if chain elements should be emitted
 543    as references.  */
 544
 545 static void
 546 streamer_write_chain (struct output_block *ob, tree t)
 547 {
 548   while (t)
 549     {
 550       /* We avoid outputting external vars or functions by reference
 551          to the global decls section as we do not want to have them
 552          enter decl merging.  We should not need to do this anymore because
 553          free_lang_data removes them from block scopes.  */
 554       gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
 555       stream_write_tree_ref (ob, t);
 556
 557       t = TREE_CHAIN (t);
 558     }
 559
 560   /* Write a sentinel to terminate the chain.  */
 561   stream_write_tree_ref (ob, NULL_TREE);
 562 }
 563
 564
 565 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 566    block OB.  If REF_P is true, write a reference to EXPR's pointer
 567    fields.  */
 568
 569 static void
 570 write_ts_common_tree_pointers (struct output_block *ob, tree expr)
 571 {
 572   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 573     stream_write_tree_ref (ob, TREE_TYPE (expr));
 574 }
 575
 576
 577 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 578    block OB.  If REF_P is true, write a reference to EXPR's pointer
 579    fields.  */
 580
 581 static void
 582 write_ts_vector_tree_pointers (struct output_block *ob, tree expr)
 583 {
 584   /* Note that the number of elements for EXPR has already been emitted
 585      in EXPR's header (see streamer_write_tree_header).  */
 586   unsigned int count = vector_cst_encoded_nelts (expr);
 587   for (unsigned int i = 0; i < count; ++i)
 588     stream_write_tree_ref (ob, VECTOR_CST_ENCODED_ELT (expr, i));
 589 }
 590
 591
 592 /* Write all pointer fields in the TS_POLY_INT_CST structure of EXPR to
 593    output block OB.  If REF_P is true, write a reference to EXPR's pointer
 594    fields.  */
 595
 596 static void
 597 write_ts_poly_tree_pointers (struct output_block *ob, tree expr)
 598 {
 599   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
 600     stream_write_tree_ref (ob, POLY_INT_CST_COEFF (expr, i));
 601 }
 602
 603
 604 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 605    block OB.  If REF_P is true, write a reference to EXPR's pointer
 606    fields.  */
 607
 608 static void
 609 write_ts_complex_tree_pointers (struct output_block *ob, tree expr)
 610 {
 611   stream_write_tree_ref (ob, TREE_REALPART (expr));
 612   stream_write_tree_ref (ob, TREE_IMAGPART (expr));
 613 }
 614
 615
 616 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 617    to output block OB.  If REF_P is true, write a reference to EXPR's
 618    pointer fields.  */
 619
 620 static void
 621 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr)
 622 {
 623   /* Drop names that were created for anonymous entities.  */
 624   if (DECL_NAME (expr)
 625       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
 626       && IDENTIFIER_ANON_P (DECL_NAME (expr)))
 627     stream_write_tree_ref (ob, NULL_TREE);
 628   else
 629     stream_write_tree_ref (ob, DECL_NAME (expr));
 630   if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
 631       && ! DECL_CONTEXT (expr))
 632     stream_write_tree_ref (ob, (*all_translation_units)[0]);
 633   else
 634     stream_write_tree_ref (ob, DECL_CONTEXT (expr));
 635 }
 636
 637
 638 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 639    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_common_tree_pointers (struct output_block *ob, tree expr)
 644 {
 645   stream_write_tree_ref (ob, DECL_SIZE (expr));
 646   stream_write_tree_ref (ob, DECL_SIZE_UNIT (expr));
 647
 648   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 649      special handling in LTO, it must be handled by streamer hooks.  */
 650
 651   stream_write_tree_ref (ob, DECL_ATTRIBUTES (expr));
 652
 653   /* On non-early-LTO enabled targets we claim we compiled with -g0
 654      but dwarf2out still did its set_decl_origin_self game fooling
 655      itself late.  Und that here since we won't have access to the
 656      early generated abstract DIEs.  */
 657   tree ao = DECL_ABSTRACT_ORIGIN (expr);
 658   if (debug_info_level == DINFO_LEVEL_NONE
 659       && ao == expr)
 660     ao = NULL_TREE;
 661   stream_write_tree_ref (ob, ao);
 662
 663   if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
 664       && DECL_HAS_VALUE_EXPR_P (expr))
 665     stream_write_tree_ref (ob, DECL_VALUE_EXPR (expr));
 666
 667   if (VAR_P (expr)
 668       && DECL_HAS_DEBUG_EXPR_P (expr))
 669     stream_write_tree_ref (ob, DECL_DEBUG_EXPR (expr));
 670 }
 671
 672
 673 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 674    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 675    pointer fields.  */
 676
 677 static void
 678 write_ts_decl_non_common_tree_pointers (struct output_block *, tree)
 679 {
 680 }
 681
 682
 683 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 684    to output block OB.  If REF_P is true, write a reference to EXPR's
 685    pointer fields.  */
 686
 687 static void
 688 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr)
 689 {
 690   /* Make sure we don't inadvertently set the assembler name.  */
 691   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 692     stream_write_tree_ref (ob, DECL_ASSEMBLER_NAME (expr));
 693   else
 694     stream_write_tree_ref (ob, NULL_TREE);
 695 }
 696
 697
 698 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 699    output block OB.  If REF_P is true, write a reference to EXPR's
 700    pointer fields.  */
 701
 702 static void
 703 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr)
 704 {
 705   stream_write_tree_ref (ob, DECL_FIELD_OFFSET (expr));
 706   stream_write_tree_ref (ob, DECL_BIT_FIELD_TYPE (expr));
 707   stream_write_tree_ref (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr));
 708   stream_write_tree_ref (ob, DECL_FIELD_BIT_OFFSET (expr));
 709 }
 710
 711
 712 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 713    to output block OB.  If REF_P is true, write a reference to EXPR's
 714    pointer fields.  */
 715
 716 static void
 717 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr)
 718 {
 719   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  */
 720   stream_write_tree_ref (ob, DECL_FUNCTION_PERSONALITY (expr));
 721   /* Don't stream these when passing things to a different target.  */
 722   if (!lto_stream_offload_p)
 723     stream_write_tree_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr));
 724   stream_write_tree_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr));
 725 }
 726
 727
 728 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 729    output block OB.  If REF_P is true, write a reference to EXPR's
 730    pointer fields.  */
 731
 732 static void
 733 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr)
 734 {
 735   stream_write_tree_ref (ob, TYPE_SIZE (expr));
 736   stream_write_tree_ref (ob, TYPE_SIZE_UNIT (expr));
 737   stream_write_tree_ref (ob, TYPE_ATTRIBUTES (expr));
 738   stream_write_tree_ref (ob, TYPE_NAME (expr));
 739   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 740      reconstructed during fixup.  */
 741   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 742      during fixup.  */
 743   stream_write_tree_ref (ob, TYPE_MAIN_VARIANT (expr));
 744   stream_write_tree_ref (ob, TYPE_CONTEXT (expr));
 745   /* TYPE_CANONICAL is re-computed during type merging, so no need
 746      to stream it here.  */
 747   /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
 748      it cannot be freed by free_lang_data without triggering ICEs in
 749      langhooks.  */
 750 }
 751
 752 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 753    to output block OB.  If REF_P is true, write a reference to EXPR's
 754    pointer fields.  */
 755
 756 static void
 757 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr)
 758 {
 759   if (TREE_CODE (expr) == ARRAY_TYPE)
 760     stream_write_tree_ref (ob, TYPE_DOMAIN (expr));
 761   else if (RECORD_OR_UNION_TYPE_P (expr))
 762     streamer_write_chain (ob, TYPE_FIELDS (expr));
 763   else if (FUNC_OR_METHOD_TYPE_P (expr))
 764     stream_write_tree_ref (ob, TYPE_ARG_TYPES (expr));
 765
 766   if (!POINTER_TYPE_P (expr))
 767     stream_write_tree_ref (ob, TYPE_MIN_VALUE_RAW (expr));
 768   stream_write_tree_ref (ob, TYPE_MAX_VALUE_RAW (expr));
 769 }
 770
 771
 772 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 773    block OB.  If REF_P is true, write a reference to EXPR's pointer
 774    fields.  */
 775
 776 static void
 777 write_ts_list_tree_pointers (struct output_block *ob, tree expr)
 778 {
 779   stream_write_tree_ref (ob, TREE_PURPOSE (expr));
 780   stream_write_tree_ref (ob, TREE_VALUE (expr));
 781   stream_write_tree_ref (ob, TREE_CHAIN (expr));
 782 }
 783
 784
 785 /* Write all pointer fields in the TS_VEC 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_vec_tree_pointers (struct output_block *ob, tree expr)
 791 {
 792   int i;
 793
 794   /* Note that the number of slots for EXPR has already been emitted
 795      in EXPR's header (see streamer_write_tree_header).  */
 796   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 797     stream_write_tree_ref (ob, TREE_VEC_ELT (expr, i));
 798 }
 799
 800
 801 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 802    block OB.  If REF_P is true, write a reference to EXPR's pointer
 803    fields.  */
 804
 805 static void
 806 write_ts_exp_tree_pointers (struct output_block *ob, tree expr)
 807 {
 808   int i;
 809
 810   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 811     stream_write_tree_ref (ob, TREE_OPERAND (expr, i));
 812   stream_write_tree_ref (ob, TREE_BLOCK (expr));
 813 }
 814
 815
 816 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 817    block OB.  If REF_P is true, write a reference to EXPR's pointer
 818    fields.  */
 819
 820 static void
 821 write_ts_block_tree_pointers (struct output_block *ob, tree expr)
 822 {
 823   streamer_write_chain (ob, BLOCK_VARS (expr));
 824
 825   stream_write_tree_ref (ob, BLOCK_SUPERCONTEXT (expr));
 826   stream_write_tree_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr));
 827
 828   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 829      for early inlined BLOCKs so drop it on the floor instead of ICEing in
 830      dwarf2out.cc.  */
 831
 832   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
 833      streaming time.  */
 834
 835   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 836      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 837 }
 838
 839
 840 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 841    block OB.  If REF_P is true, write a reference to EXPR's pointer
 842    fields.  */
 843
 844 static void
 845 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr)
 846 {
 847   unsigned i;
 848   tree t;
 849
 850   /* Note that the number of BINFO slots has already been emitted in
 851      EXPR's header (see streamer_write_tree_header) because this length
 852      is needed to build the empty BINFO node on the reader side.  */
 853   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
 854     stream_write_tree_ref (ob, t);
 855   stream_write_tree_ref (ob, NULL_TREE);
 856
 857   stream_write_tree_ref (ob, BINFO_OFFSET (expr));
 858   stream_write_tree_ref (ob, BINFO_VTABLE (expr));
 859
 860   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
 861      BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
 862 }
 863
 864
 865 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 866    output block OB.  If REF_P is true, write a reference to EXPR's
 867    pointer fields.  */
 868
 869 static void
 870 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr)
 871 {
 872   unsigned i;
 873   tree index, value;
 874
 875   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 876     {
 877       stream_write_tree_ref (ob, index);
 878       stream_write_tree_ref (ob, value);
 879     }
 880 }
 881
 882
 883 /* Write all pointer fields in the RAW_DATA_CST/TS_RAW_DATA_CST structure of
 884    EXPR to output block OB.  */
 885
 886 static void
 887 write_ts_raw_data_cst_tree_pointers (struct output_block *ob, tree expr)
 888 {
 889   /* Only write this for non-NULL RAW_DATA_OWNER.  RAW_DATA_CST with
 890      NULL RAW_DATA_OWNER is streamed to be read back as STRING_CST.  */
 891   if (RAW_DATA_OWNER (expr) != NULL_TREE)
 892     stream_write_tree_ref (ob, RAW_DATA_OWNER (expr));
 893 }
 894
 895
 896 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
 897    to output block OB.  If REF_P is true, write a reference to EXPR's
 898    pointer fields.  */
 899
 900 static void
 901 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr)
 902 {
 903   int i;
 904   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
 905     stream_write_tree_ref (ob, OMP_CLAUSE_OPERAND (expr, i));
 906   switch (OMP_CLAUSE_CODE (expr))
 907     {
 908     case OMP_CLAUSE_REDUCTION:
 909     case OMP_CLAUSE_TASK_REDUCTION:
 910     case OMP_CLAUSE_IN_REDUCTION:
 911       /* We don't stream these right now, handle it if streaming
 912          of them is needed.  */
 913       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
 914       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
 915       break;
 916     default:
 917       break;
 918     }
 919   stream_write_tree_ref (ob, OMP_CLAUSE_CHAIN (expr));
 920 }
 921
 922
 923 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 924    the leaves of EXPR are emitted as references.  */
 925
 926 void
 927 streamer_write_tree_body (struct output_block *ob, tree expr)
 928 {
 929   enum tree_code code;
 930
 931   lto_stats.num_tree_bodies_output++;
 932
 933   code = TREE_CODE (expr);
 934
 935   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 936     write_ts_common_tree_pointers (ob, expr);
 937
 938   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 939     write_ts_vector_tree_pointers (ob, expr);
 940
 941   if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
 942     write_ts_poly_tree_pointers (ob, expr);
 943
 944   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 945     write_ts_complex_tree_pointers (ob, expr);
 946
 947   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 948     write_ts_decl_minimal_tree_pointers (ob, expr);
 949
 950   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 951     write_ts_decl_common_tree_pointers (ob, expr);
 952
 953   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 954     write_ts_decl_non_common_tree_pointers (ob, expr);
 955
 956   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 957     write_ts_decl_with_vis_tree_pointers (ob, expr);
 958
 959   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 960     write_ts_field_decl_tree_pointers (ob, expr);
 961
 962   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 963     write_ts_function_decl_tree_pointers (ob, expr);
 964
 965   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 966     write_ts_type_common_tree_pointers (ob, expr);
 967
 968   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 969     write_ts_type_non_common_tree_pointers (ob, expr);
 970
 971   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 972     write_ts_list_tree_pointers (ob, expr);
 973
 974   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 975     write_ts_vec_tree_pointers (ob, expr);
 976
 977   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 978     write_ts_exp_tree_pointers (ob, expr);
 979
 980   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 981     write_ts_block_tree_pointers (ob, expr);
 982
 983   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 984     write_ts_binfo_tree_pointers (ob, expr);
 985
 986   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 987     write_ts_constructor_tree_pointers (ob, expr);
 988
 989   if (code == RAW_DATA_CST)
 990     write_ts_raw_data_cst_tree_pointers (ob, expr);
 991
 992   if (code == OMP_CLAUSE)
 993     write_ts_omp_clause_tree_pointers (ob, expr);
 994 }
 995
 996
 997 /* Emit header information for tree EXPR to output block OB.  The header
 998    contains everything needed to instantiate an empty skeleton for
 999    EXPR on the reading side.  IX is the index into the streamer cache
1000    where EXPR is stored.  */
1001
1002 void
1003 streamer_write_tree_header (struct output_block *ob, tree expr)
1004 {
1005   enum LTO_tags tag;
1006   enum tree_code code;
1007
1008   if (streamer_dump_file)
1009     {
1010       print_node_brief (streamer_dump_file, "     Streaming header of ",
1011                         expr, 4);
1012       fprintf (streamer_dump_file, "  to %s\n",
1013                lto_section_name[ob->section_type]);
1014     }
1015
1016   /* We should not see any tree nodes not handled by the streamer.  */
1017   code = TREE_CODE (expr);
1018
1019   /* The header of a tree node consists of its tag, the size of
1020      the node, and any other information needed to instantiate
1021      EXPR on the reading side (such as the number of slots in
1022      variable sized nodes).  */
1023   tag = lto_tree_code_to_tag (code);
1024   streamer_write_record_start (ob, tag);
1025
1026   /* The text in strings and identifiers are completely emitted in
1027      the header.  */
1028   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1029     streamer_write_string_cst (ob, ob->main_stream, expr);
1030   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1031     write_identifier (ob, ob->main_stream, expr);
1032   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1033     {
1034       bitpack_d bp = bitpack_create (ob->main_stream);
1035       bp_pack_value (&bp, VECTOR_CST_LOG2_NPATTERNS (expr), 8);
1036       bp_pack_value (&bp, VECTOR_CST_NELTS_PER_PATTERN (expr), 8);
1037       streamer_write_bitpack (&bp);
1038     }
1039   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1040     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1041   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1042     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1043   else if (TREE_CODE (expr) == CALL_EXPR)
1044     streamer_write_uhwi (ob, call_expr_nargs (expr));
1045   else if (TREE_CODE (expr) == OMP_CLAUSE)
1046     streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
1047   else if (TREE_CODE (expr) == RAW_DATA_CST)
1048     {
1049       if (RAW_DATA_OWNER (expr) == NULL_TREE)
1050         {
1051           /* RAW_DATA_CST with NULL RAW_DATA_OWNER is an owner of other
1052              RAW_DATA_CST's data.  This should be streamed out so that
1053              it can be streamed back in as a STRING_CST instead, but without
1054              the need to duplicate the possibly large data.  */
1055           streamer_write_uhwi (ob, 0);
1056           streamer_write_string_with_length (ob, ob->main_stream,
1057                                              RAW_DATA_POINTER (expr),
1058                                              RAW_DATA_LENGTH (expr), true);
1059         }
1060       else
1061         {
1062           streamer_write_uhwi (ob, RAW_DATA_LENGTH (expr));
1063           tree owner = RAW_DATA_OWNER (expr);
1064           unsigned HOST_WIDE_INT off;
1065           if (TREE_CODE (owner) == STRING_CST)
1066             off = RAW_DATA_POINTER (expr) - TREE_STRING_POINTER (owner);
1067           else
1068             {
1069               gcc_checking_assert (TREE_CODE (owner) == RAW_DATA_CST
1070                                    && RAW_DATA_OWNER (owner) == NULL_TREE);
1071               off = RAW_DATA_POINTER (expr) - RAW_DATA_POINTER (owner);
1072             }
1073           streamer_write_uhwi (ob, off);
1074         }
1075     }
1076   else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1077     {
1078       gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
1079       streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
1080       streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
1081     }
1082 }
1083
1084
1085 /* Emit the integer constant CST to output block OB.  If REF_P is true,
1086    CST's type will be emitted as a reference.  */
1087
1088 void
1089 streamer_write_integer_cst (struct output_block *ob, tree cst)
1090 {
1091   int i;
1092   int len = TREE_INT_CST_NUNITS (cst);
1093   gcc_assert (!TREE_OVERFLOW (cst));
1094   if (streamer_dump_file)
1095     {
1096       print_node_brief (streamer_dump_file, "     Streaming integer ",
1097                         cst, 4);
1098       fprintf (streamer_dump_file, "\n");
1099     }
1100   streamer_write_record_start (ob, LTO_integer_cst);
1101   stream_write_tree_ref (ob, TREE_TYPE (cst));
1102   /* We're effectively streaming a non-sign-extended wide_int here,
1103      so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1104      array members beyond LEN.  We'll recreate the tree from the
1105      wide_int and the type.  */
1106   streamer_write_uhwi (ob, len);
1107   for (i = 0; i < len; i++)
1108     streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
1109 }