gcc/tree-streamer-out.c

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