gcc/tree-streamer-out.c

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