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   if (AGGREGATE_TYPE_P (expr))
 332     bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1);
 333   bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
 334   bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
 335 }
 336
 337
 338 /* Pack all the non-pointer fields of the TS_BLOCK structure
 339    of expression EXPR into bitpack BP.  */
 340
 341 static void
 342 pack_ts_block_value_fields (struct output_block *ob,
 343                             struct bitpack_d *bp, tree expr)
 344 {
 345   bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
 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       bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
 399                     OMP_CLAUSE_REDUCTION_CODE (expr));
 400       break;
 401     default:
 402       break;
 403     }
 404 }
 405
 406
 407 /* Pack all the bitfields in EXPR into a bit pack.  */
 408
 409 void
 410 streamer_write_tree_bitfields (struct output_block *ob, tree expr)
 411 {
 412   bitpack_d bp = bitpack_create (ob->main_stream);
 413   enum tree_code code;
 414
 415   code = TREE_CODE (expr);
 416
 417   /* Note that all these functions are highly sensitive to changes in
 418      the types and sizes of each of the fields being packed.  */
 419   pack_ts_base_value_fields (&bp, expr);
 420
 421   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
 422     pack_ts_int_cst_value_fields (&bp, expr);
 423
 424   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 425     pack_ts_real_cst_value_fields (&bp, expr);
 426
 427   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 428     pack_ts_fixed_cst_value_fields (&bp, expr);
 429
 430   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 431     stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
 432
 433   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 434     pack_ts_decl_common_value_fields (&bp, expr);
 435
 436   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 437     pack_ts_decl_wrtl_value_fields (&bp, expr);
 438
 439   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 440     pack_ts_decl_with_vis_value_fields (&bp, expr);
 441
 442   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 443     pack_ts_function_decl_value_fields (&bp, expr);
 444
 445   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 446     pack_ts_type_common_value_fields (&bp, expr);
 447
 448   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 449     {
 450       stream_output_location (ob, &bp, EXPR_LOCATION (expr));
 451       if (code == MEM_REF
 452           || code == TARGET_MEM_REF)
 453         {
 454           bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8);
 455           if (MR_DEPENDENCE_CLIQUE (expr) != 0)
 456             bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8);
 457         }
 458     }
 459
 460   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 461     pack_ts_block_value_fields (ob, &bp, expr);
 462
 463   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 464     pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
 465
 466   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
 467     cl_optimization_stream_out (&bp, TREE_OPTIMIZATION (expr));
 468
 469   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 470     bp_pack_var_len_unsigned (&bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
 471
 472   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 473     bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
 474
 475   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
 476       /* Don't stream these when passing things to a different target.  */
 477       && !lto_stream_offload_p)
 478     cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
 479
 480   if (code == OMP_CLAUSE)
 481     pack_ts_omp_clause_value_fields (ob, &bp, expr);
 482
 483   streamer_write_bitpack (&bp);
 484 }
 485
 486
 487 /* Emit the chain of tree nodes starting at T.  OB is the output block
 488    to write to.  REF_P is true if chain elements should be emitted
 489    as references.  */
 490
 491 void
 492 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
 493 {
 494   while (t)
 495     {
 496       /* We avoid outputting external vars or functions by reference
 497          to the global decls section as we do not want to have them
 498          enter decl merging.  This is, of course, only for the call
 499          for streaming BLOCK_VARS, but other callers are safe.
 500          See also lto-streamer-out.c:DFS_write_tree_body.  */
 501       if (VAR_OR_FUNCTION_DECL_P (t)
 502           && DECL_EXTERNAL (t))
 503         stream_write_tree_shallow_non_ref (ob, t, ref_p);
 504       else
 505         stream_write_tree (ob, t, ref_p);
 506
 507       t = TREE_CHAIN (t);
 508     }
 509
 510   /* Write a sentinel to terminate the chain.  */
 511   stream_write_tree (ob, NULL_TREE, ref_p);
 512 }
 513
 514
 515 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 516    block OB.  If REF_P is true, write a reference to EXPR's pointer
 517    fields.  */
 518
 519 static void
 520 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 521 {
 522   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 523     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
 524 }
 525
 526
 527 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 528    block OB.  If REF_P is true, write a reference to EXPR's pointer
 529    fields.  */
 530
 531 static void
 532 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 533 {
 534   unsigned i;
 535   /* Note that the number of elements for EXPR has already been emitted
 536      in EXPR's header (see streamer_write_tree_header).  */
 537   for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
 538     stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p);
 539 }
 540
 541
 542 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 543    block OB.  If REF_P is true, write a reference to EXPR's pointer
 544    fields.  */
 545
 546 static void
 547 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 548 {
 549   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 550   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 551 }
 552
 553
 554 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 555    to output block OB.  If REF_P is true, write a reference to EXPR's
 556    pointer fields.  */
 557
 558 static void
 559 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 560                                      bool ref_p)
 561 {
 562   /* Drop names that were created for anonymous entities.  */
 563   if (DECL_NAME (expr)
 564       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
 565       && anon_aggrname_p (DECL_NAME (expr)))
 566     stream_write_tree (ob, NULL_TREE, ref_p);
 567   else
 568     stream_write_tree (ob, DECL_NAME (expr), ref_p);
 569   if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
 570       && ! DECL_CONTEXT (expr))
 571     stream_write_tree (ob, (*all_translation_units)[0], ref_p);
 572   else
 573     stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 574 }
 575
 576
 577 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 578    output block OB.  If REF_P is true, write a reference to EXPR's
 579    pointer fields.  */
 580
 581 static void
 582 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 583                                     bool ref_p)
 584 {
 585   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 586   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 587
 588   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 589      special handling in LTO, it must be handled by streamer hooks.  */
 590
 591   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 592   stream_write_tree (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
 593
 594   if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
 595       && DECL_HAS_VALUE_EXPR_P (expr))
 596     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 597
 598   if (VAR_P (expr))
 599     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 600 }
 601
 602
 603 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 604    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 605    pointer fields.  */
 606
 607 static void
 608 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 609                                         bool ref_p)
 610 {
 611   if (TREE_CODE (expr) == TYPE_DECL)
 612     stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
 613 }
 614
 615
 616 /* Write all pointer fields in the TS_DECL_WITH_VIS 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_with_vis_tree_pointers (struct output_block *ob, tree expr,
 622                                       bool ref_p)
 623 {
 624   /* Make sure we don't inadvertently set the assembler name.  */
 625   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 626     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 627   else
 628     stream_write_tree (ob, NULL_TREE, false);
 629 }
 630
 631
 632 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 633    output block OB.  If REF_P is true, write a reference to EXPR's
 634    pointer fields.  */
 635
 636 static void
 637 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 638                                    bool ref_p)
 639 {
 640   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 641   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 642   stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
 643   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 644   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 645 }
 646
 647
 648 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 649    to output block OB.  If REF_P is true, write a reference to EXPR's
 650    pointer fields.  */
 651
 652 static void
 653 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 654                                       bool ref_p)
 655 {
 656   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 657   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  */
 658   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 659   /* Don't stream these when passing things to a different target.  */
 660   if (!lto_stream_offload_p)
 661     stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
 662   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 663 }
 664
 665
 666 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 667    output block OB.  If REF_P is true, write a reference to EXPR's
 668    pointer fields.  */
 669
 670 static void
 671 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 672                                     bool ref_p)
 673 {
 674   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 675   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 676   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 677   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 678   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 679      reconstructed during fixup.  */
 680   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 681      during fixup.  */
 682   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 683   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 684   /* TYPE_CANONICAL is re-computed during type merging, so no need
 685      to stream it here.  */
 686   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 687 }
 688
 689 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 690    to output block OB.  If REF_P is true, write a reference to EXPR's
 691    pointer fields.  */
 692
 693 static void
 694 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 695                                         bool ref_p)
 696 {
 697   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 698     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 699   else if (TREE_CODE (expr) == ARRAY_TYPE)
 700     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 701   else if (RECORD_OR_UNION_TYPE_P (expr))
 702     streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
 703   else if (TREE_CODE (expr) == FUNCTION_TYPE
 704            || TREE_CODE (expr) == METHOD_TYPE)
 705     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 706
 707   if (!POINTER_TYPE_P (expr))
 708     stream_write_tree (ob, TYPE_MIN_VALUE_RAW (expr), ref_p);
 709   stream_write_tree (ob, TYPE_MAX_VALUE_RAW (expr), ref_p);
 710 }
 711
 712
 713 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 714    block OB.  If REF_P is true, write a reference to EXPR's pointer
 715    fields.  */
 716
 717 static void
 718 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 719 {
 720   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 721   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 722   stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
 723 }
 724
 725
 726 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 727    block OB.  If REF_P is true, write a reference to EXPR's pointer
 728    fields.  */
 729
 730 static void
 731 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 732 {
 733   int i;
 734
 735   /* Note that the number of slots for EXPR has already been emitted
 736      in EXPR's header (see streamer_write_tree_header).  */
 737   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 738     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 739 }
 740
 741
 742 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 743    block OB.  If REF_P is true, write a reference to EXPR's pointer
 744    fields.  */
 745
 746 static void
 747 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 748 {
 749   int i;
 750
 751   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 752     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 753   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 754 }
 755
 756
 757 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 758    block OB.  If REF_P is true, write a reference to EXPR's pointer
 759    fields.  */
 760
 761 static void
 762 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 763 {
 764   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 765
 766   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 767
 768   /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
 769      that represent inlined function scopes.
 770      For the rest them on the floor instead of ICEing in dwarf2out.c, but
 771      keep the notion of whether the block is an inlined block by refering
 772      to itself for the sake of tree_nonartificial_location.  */
 773   if (inlined_function_outer_scope_p (expr))
 774     {
 775       tree ultimate_origin = block_ultimate_origin (expr);
 776       stream_write_tree (ob, ultimate_origin, ref_p);
 777     }
 778   else
 779     stream_write_tree (ob, (BLOCK_ABSTRACT_ORIGIN (expr)
 780                             ? expr : NULL_TREE), ref_p);
 781   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 782      for early inlined BLOCKs so drop it on the floor instead of ICEing in
 783      dwarf2out.c.  */
 784
 785   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
 786      streaming time.  */
 787
 788   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 789      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 790 }
 791
 792
 793 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 794    block OB.  If REF_P is true, write a reference to EXPR's pointer
 795    fields.  */
 796
 797 static void
 798 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 799 {
 800   unsigned i;
 801   tree t;
 802
 803   /* Note that the number of BINFO slots has already been emitted in
 804      EXPR's header (see streamer_write_tree_header) because this length
 805      is needed to build the empty BINFO node on the reader side.  */
 806   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
 807     stream_write_tree (ob, t, ref_p);
 808   stream_write_tree (ob, NULL_TREE, false);
 809
 810   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 811   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 812   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 813
 814   /* The number of BINFO_BASE_ACCESSES has already been emitted in
 815      EXPR's bitfield section.  */
 816   FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
 817     stream_write_tree (ob, t, ref_p);
 818
 819   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
 820      and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
 821 }
 822
 823
 824 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 825    output block OB.  If REF_P is true, write a reference to EXPR's
 826    pointer fields.  */
 827
 828 static void
 829 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 830                                     bool ref_p)
 831 {
 832   unsigned i;
 833   tree index, value;
 834
 835   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 836     {
 837       stream_write_tree (ob, index, ref_p);
 838       stream_write_tree (ob, value, ref_p);
 839     }
 840 }
 841
 842
 843 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
 844    to output block OB.  If REF_P is true, write a reference to EXPR's
 845    pointer fields.  */
 846
 847 static void
 848 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
 849                                    bool ref_p)
 850 {
 851   int i;
 852   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
 853     stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
 854   if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION)
 855     {
 856       /* We don't stream these right now, handle it if streaming
 857          of them is needed.  */
 858       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
 859       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
 860     }
 861   stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
 862 }
 863
 864
 865 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 866    the leaves of EXPR are emitted as references.  */
 867
 868 void
 869 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 870 {
 871   enum tree_code code;
 872
 873   lto_stats.num_tree_bodies_output++;
 874
 875   code = TREE_CODE (expr);
 876
 877   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 878     write_ts_common_tree_pointers (ob, expr, ref_p);
 879
 880   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 881     write_ts_vector_tree_pointers (ob, expr, ref_p);
 882
 883   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 884     write_ts_complex_tree_pointers (ob, expr, ref_p);
 885
 886   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 887     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 888
 889   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 890     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 891
 892   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 893     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 894
 895   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 896     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 897
 898   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 899     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 900
 901   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 902     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 903
 904   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 905     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 906
 907   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 908     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 909
 910   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 911     write_ts_list_tree_pointers (ob, expr, ref_p);
 912
 913   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 914     write_ts_vec_tree_pointers (ob, expr, ref_p);
 915
 916   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 917     write_ts_exp_tree_pointers (ob, expr, ref_p);
 918
 919   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 920     write_ts_block_tree_pointers (ob, expr, ref_p);
 921
 922   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 923     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 924
 925   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 926     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 927
 928   if (code == OMP_CLAUSE)
 929     write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
 930 }
 931
 932
 933 /* Emit header information for tree EXPR to output block OB.  The header
 934    contains everything needed to instantiate an empty skeleton for
 935    EXPR on the reading side.  IX is the index into the streamer cache
 936    where EXPR is stored.  */
 937
 938 void
 939 streamer_write_tree_header (struct output_block *ob, tree expr)
 940 {
 941   enum LTO_tags tag;
 942   enum tree_code code;
 943
 944   /* We should not see any tree nodes not handled by the streamer.  */
 945   code = TREE_CODE (expr);
 946
 947   /* The header of a tree node consists of its tag, the size of
 948      the node, and any other information needed to instantiate
 949      EXPR on the reading side (such as the number of slots in
 950      variable sized nodes).  */
 951   tag = lto_tree_code_to_tag (code);
 952   streamer_write_record_start (ob, tag);
 953
 954   /* The text in strings and identifiers are completely emitted in
 955      the header.  */
 956   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
 957     streamer_write_string_cst (ob, ob->main_stream, expr);
 958   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
 959     write_identifier (ob, ob->main_stream, expr);
 960   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 961     streamer_write_hwi (ob, VECTOR_CST_NELTS (expr));
 962   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 963     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
 964   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 965     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
 966   else if (TREE_CODE (expr) == CALL_EXPR)
 967     streamer_write_uhwi (ob, call_expr_nargs (expr));
 968   else if (TREE_CODE (expr) == OMP_CLAUSE)
 969     streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
 970   else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
 971     {
 972       gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
 973       streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
 974       streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
 975     }
 976 }
 977
 978
 979 /* Emit the integer constant CST to output block OB.  If REF_P is true,
 980    CST's type will be emitted as a reference.  */
 981
 982 void
 983 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
 984 {
 985   int i;
 986   int len = TREE_INT_CST_NUNITS (cst);
 987   gcc_assert (!TREE_OVERFLOW (cst));
 988   streamer_write_record_start (ob, LTO_integer_cst);
 989   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
 990   /* We're effectively streaming a non-sign-extended wide_int here,
 991      so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
 992      array members beyond LEN.  We'll recreate the tree from the
 993      wide_int and the type.  */
 994   streamer_write_uhwi (ob, len);
 995   for (i = 0; i < len; i++)
 996     streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
 997 }