gcc/tree-streamer-out.c

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