gcc/tree-streamer-out.c

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