gcc/tree-streamer-out.c

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