gcc/tree-streamer-out.c

   1 /* Routines for emitting trees to a file stream.
   2
   3    Copyright 2011 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 "diagnostic.h"
  26 #include "tree.h"
  27 #include "tree-streamer.h"
  28 #include "data-streamer.h"
  29 #include "streamer-hooks.h"
  30
  31 /* Output the STRING constant to the string
  32    table in OB.  Then put the index onto the INDEX_STREAM.  */
  33
  34 void
  35 streamer_write_string_cst (struct output_block *ob,
  36                            struct lto_output_stream *index_stream,
  37                            tree string)
  38 {
  39   streamer_write_string_with_length (ob, index_stream,
  40                                      string ? TREE_STRING_POINTER (string)
  41                                             : NULL,
  42                                      string ? TREE_STRING_LENGTH (string) : 0,
  43                                      true);
  44 }
  45
  46
  47 /* Output the identifier ID to the string
  48    table in OB.  Then put the index onto the INDEX_STREAM.  */
  49
  50 static void
  51 write_identifier (struct output_block *ob,
  52                    struct lto_output_stream *index_stream,
  53                    tree id)
  54 {
  55   streamer_write_string_with_length (ob, index_stream,
  56                                      IDENTIFIER_POINTER (id),
  57                                      IDENTIFIER_LENGTH (id),
  58                                      true);
  59 }
  60
  61
  62 /* Pack all the non-pointer fields of the TS_BASE structure of
  63    expression EXPR into bitpack BP.  */
  64
  65 static void
  66 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
  67 {
  68   bp_pack_value (bp, TREE_CODE (expr), 16);
  69   if (!TYPE_P (expr))
  70     {
  71       bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
  72       bp_pack_value (bp, TREE_CONSTANT (expr), 1);
  73       bp_pack_value (bp, TREE_READONLY (expr), 1);
  74
  75       /* TREE_PUBLIC is used on types to indicate that the type
  76          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
  77          so we skip it here.  */
  78       bp_pack_value (bp, TREE_PUBLIC (expr), 1);
  79     }
  80   else
  81     bp_pack_value (bp, 0, 4);
  82   bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
  83   bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
  84   if (DECL_P (expr))
  85     bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
  86   else if (TYPE_P (expr))
  87     bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
  88   else
  89     bp_pack_value (bp, 0, 1);
  90   /* We write debug info two times, do not confuse the second one.  */
  91   bp_pack_value (bp, TYPE_P (expr) ? 0 : TREE_ASM_WRITTEN (expr), 1);
  92   if (TYPE_P (expr))
  93     bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
  94   else
  95     bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
  96   bp_pack_value (bp, TREE_USED (expr), 1);
  97   bp_pack_value (bp, TREE_NOTHROW (expr), 1);
  98   bp_pack_value (bp, TREE_STATIC (expr), 1);
  99   bp_pack_value (bp, TREE_PRIVATE (expr), 1);
 100   bp_pack_value (bp, TREE_PROTECTED (expr), 1);
 101   bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
 102   if (TYPE_P (expr))
 103     {
 104       bp_pack_value (bp, TYPE_SATURATING (expr), 1);
 105       bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
 106     }
 107   else if (TREE_CODE (expr) == SSA_NAME)
 108     bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
 109   else
 110     bp_pack_value (bp, 0, 1);
 111 }
 112
 113
 114 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
 115    expression EXPR into bitpack BP.  */
 116
 117 static void
 118 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
 119 {
 120   unsigned i;
 121   REAL_VALUE_TYPE r;
 122
 123   r = TREE_REAL_CST (expr);
 124   bp_pack_value (bp, r.cl, 2);
 125   bp_pack_value (bp, r.decimal, 1);
 126   bp_pack_value (bp, r.sign, 1);
 127   bp_pack_value (bp, r.signalling, 1);
 128   bp_pack_value (bp, r.canonical, 1);
 129   bp_pack_value (bp, r.uexp, EXP_BITS);
 130   for (i = 0; i < SIGSZ; i++)
 131     bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
 132 }
 133
 134
 135 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
 136    expression EXPR into bitpack BP.  */
 137
 138 static void
 139 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
 140 {
 141   struct fixed_value fv = TREE_FIXED_CST (expr);
 142   bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, fv.mode);
 143   bp_pack_var_len_int (bp, fv.data.low);
 144   bp_pack_var_len_int (bp, fv.data.high);
 145 }
 146
 147
 148 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
 149    of expression EXPR into bitpack BP.  */
 150
 151 static void
 152 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
 153 {
 154   bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, DECL_MODE (expr));
 155   bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
 156   bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
 157   bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
 158   bp_pack_value (bp, DECL_ABSTRACT (expr), 1);
 159   bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
 160   bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
 161   bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
 162   bp_pack_value (bp, DECL_DEBUG_EXPR_IS_FROM (expr), 1);
 163   bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
 164   bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
 165   bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
 166
 167   if (TREE_CODE (expr) == LABEL_DECL)
 168     {
 169       /* Note that we do not write LABEL_DECL_UID.  The reader will
 170          always assume an initial value of -1 so that the
 171          label_to_block_map is recreated by gimple_set_bb.  */
 172       bp_pack_value (bp, DECL_ERROR_ISSUED (expr), 1);
 173       bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
 174     }
 175
 176   if (TREE_CODE (expr) == FIELD_DECL)
 177     {
 178       bp_pack_value (bp, DECL_PACKED (expr), 1);
 179       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
 180       bp_pack_value (bp, expr->decl_common.off_align, 8);
 181     }
 182
 183   if (TREE_CODE (expr) == RESULT_DECL
 184       || TREE_CODE (expr) == PARM_DECL
 185       || TREE_CODE (expr) == VAR_DECL)
 186     {
 187       bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
 188       if (TREE_CODE (expr) == VAR_DECL
 189           || TREE_CODE (expr) == PARM_DECL)
 190         bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
 191       bp_pack_value (bp, DECL_RESTRICTED_P (expr), 1);
 192     }
 193 }
 194
 195
 196 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
 197    of expression EXPR into bitpack BP.  */
 198
 199 static void
 200 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
 201 {
 202   bp_pack_value (bp, DECL_REGISTER (expr), 1);
 203 }
 204
 205
 206 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
 207    of expression EXPR into bitpack BP.  */
 208
 209 static void
 210 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
 211 {
 212   bp_pack_value (bp, DECL_DEFER_OUTPUT (expr), 1);
 213   bp_pack_value (bp, DECL_COMMON (expr), 1);
 214   bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
 215   bp_pack_value (bp, DECL_WEAK (expr), 1);
 216   bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr),  1);
 217   bp_pack_value (bp, DECL_COMDAT (expr),  1);
 218   bp_pack_value (bp, DECL_VISIBILITY (expr),  2);
 219   bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr),  1);
 220
 221   if (TREE_CODE (expr) == VAR_DECL)
 222     {
 223       bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
 224       bp_pack_value (bp, DECL_IN_TEXT_SECTION (expr), 1);
 225       bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
 226       bp_pack_value (bp, DECL_TLS_MODEL (expr),  3);
 227     }
 228
 229   if (VAR_OR_FUNCTION_DECL_P (expr))
 230     bp_pack_var_len_unsigned (bp, DECL_INIT_PRIORITY (expr));
 231 }
 232
 233
 234 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
 235    of expression EXPR into bitpack BP.  */
 236
 237 static void
 238 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
 239 {
 240   /* For normal/md builtins we only write the class and code, so they
 241      should never be handled here.  */
 242   gcc_assert (!streamer_handle_as_builtin_p (expr));
 243
 244   bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
 245                 DECL_BUILT_IN_CLASS (expr));
 246   bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
 247   bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
 248   bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
 249   bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
 250   bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
 251   bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
 252   bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
 253   bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
 254   bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
 255   bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
 256   bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
 257   bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
 258   bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
 259   bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
 260   bp_pack_value (bp, DECL_PURE_P (expr), 1);
 261   bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
 262   if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
 263     bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
 264   if (DECL_STATIC_DESTRUCTOR (expr))
 265     bp_pack_var_len_unsigned (bp, DECL_FINI_PRIORITY (expr));
 266 }
 267
 268
 269 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
 270    of expression EXPR into bitpack BP.  */
 271
 272 static void
 273 pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
 274 {
 275   bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, TYPE_MODE (expr));
 276   bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
 277   bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
 278   bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
 279   if (RECORD_OR_UNION_TYPE_P (expr))
 280     bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
 281   bp_pack_value (bp, TYPE_PACKED (expr), 1);
 282   bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
 283   bp_pack_value (bp, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr), 2);
 284   bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
 285   bp_pack_value (bp, TYPE_READONLY (expr), 1);
 286   bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
 287   bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
 288   bp_pack_var_len_int (bp, TYPE_ALIAS_SET (expr) == 0 ? 0 : -1);
 289 }
 290
 291
 292 /* Pack all the non-pointer fields of the TS_BLOCK structure
 293    of expression EXPR into bitpack BP.  */
 294
 295 static void
 296 pack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
 297 {
 298   bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
 299   /* BLOCK_NUMBER is recomputed.  */
 300 }
 301
 302 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
 303    of expression EXPR into bitpack BP.  */
 304
 305 static void
 306 pack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
 307 {
 308 }
 309
 310
 311 /* Pack all the bitfields in EXPR into a bit pack.  */
 312
 313 void
 314 streamer_pack_tree_bitfields (struct bitpack_d *bp, tree expr)
 315 {
 316   enum tree_code code;
 317
 318   code = TREE_CODE (expr);
 319
 320   /* Note that all these functions are highly sensitive to changes in
 321      the types and sizes of each of the fields being packed.  */
 322   pack_ts_base_value_fields (bp, expr);
 323
 324   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 325     pack_ts_real_cst_value_fields (bp, expr);
 326
 327   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 328     pack_ts_fixed_cst_value_fields (bp, expr);
 329
 330   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 331     pack_ts_decl_common_value_fields (bp, expr);
 332
 333   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 334     pack_ts_decl_wrtl_value_fields (bp, expr);
 335
 336   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 337     pack_ts_decl_with_vis_value_fields (bp, expr);
 338
 339   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 340     pack_ts_function_decl_value_fields (bp, expr);
 341
 342   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 343     pack_ts_type_common_value_fields (bp, expr);
 344
 345   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 346     pack_ts_block_value_fields (bp, expr);
 347
 348   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 349     pack_ts_translation_unit_decl_value_fields (bp, expr);
 350 }
 351
 352
 353 /* Write the code and class of builtin EXPR to output block OB.  IX is
 354    the index into the streamer cache where EXPR is stored.*/
 355
 356 void
 357 streamer_write_builtin (struct output_block *ob, tree expr)
 358 {
 359   gcc_assert (streamer_handle_as_builtin_p (expr));
 360
 361   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
 362       && !targetm.builtin_decl)
 363     sorry ("tree bytecode streams do not support machine specific builtin "
 364            "functions on this target");
 365
 366   streamer_write_record_start (ob, LTO_builtin_decl);
 367   streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
 368                        DECL_BUILT_IN_CLASS (expr));
 369   streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
 370
 371   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 372     {
 373       /* When the assembler name of a builtin gets a user name,
 374          the new name is always prefixed with '*' by
 375          set_builtin_user_assembler_name.  So, to prevent the
 376          reader side from adding a second '*', we omit it here.  */
 377       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
 378       if (strlen (str) > 1 && str[0] == '*')
 379         streamer_write_string (ob, ob->main_stream, &str[1], true);
 380       else
 381         streamer_write_string (ob, ob->main_stream, NULL, true);
 382     }
 383   else
 384     streamer_write_string (ob, ob->main_stream, NULL, true);
 385 }
 386
 387
 388 /* Emit the chain of tree nodes starting at T.  OB is the output block
 389    to write to.  REF_P is true if chain elements should be emitted
 390    as references.  */
 391
 392 void
 393 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
 394 {
 395   int i, count;
 396
 397   count = list_length (t);
 398   streamer_write_hwi (ob, count);
 399   for (i = 0; i < count; i++)
 400     {
 401       tree saved_chain;
 402
 403       /* Clear TREE_CHAIN to avoid blindly recursing into the rest
 404          of the list.  */
 405       saved_chain = TREE_CHAIN (t);
 406       TREE_CHAIN (t) = NULL_TREE;
 407
 408       stream_write_tree (ob, t, ref_p);
 409
 410       TREE_CHAIN (t) = saved_chain;
 411       t = TREE_CHAIN (t);
 412     }
 413 }
 414
 415
 416 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 417    block OB.  If REF_P is true, write a reference to EXPR's pointer
 418    fields.  */
 419
 420 static void
 421 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 422 {
 423   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 424     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
 425 }
 426
 427
 428 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 429    block OB.  If REF_P is true, write a reference to EXPR's pointer
 430    fields.  */
 431
 432 static void
 433 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 434 {
 435   streamer_write_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
 436 }
 437
 438
 439 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 440    block OB.  If REF_P is true, write a reference to EXPR's pointer
 441    fields.  */
 442
 443 static void
 444 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 445 {
 446   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 447   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 448 }
 449
 450
 451 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 452    to output block OB.  If REF_P is true, write a reference to EXPR's
 453    pointer fields.  */
 454
 455 static void
 456 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 457                                      bool ref_p)
 458 {
 459   stream_write_tree (ob, DECL_NAME (expr), ref_p);
 460   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 461   lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
 462 }
 463
 464
 465 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 466    output block OB.  If REF_P is true, write a reference to EXPR's
 467    pointer fields.  */
 468
 469 static void
 470 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 471                                     bool ref_p)
 472 {
 473   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 474   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 475
 476   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 477      special handling in LTO, it must be handled by streamer hooks.  */
 478
 479   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 480
 481   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 482      for early inlining so drop it on the floor instead of ICEing in
 483      dwarf2out.c.  */
 484
 485   if (TREE_CODE (expr) == PARM_DECL)
 486     streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 487
 488   if ((TREE_CODE (expr) == VAR_DECL
 489        || TREE_CODE (expr) == PARM_DECL)
 490       && DECL_HAS_VALUE_EXPR_P (expr))
 491     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 492
 493   if (TREE_CODE (expr) == VAR_DECL)
 494     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 495 }
 496
 497
 498 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 499    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 500    pointer fields.  */
 501
 502 static void
 503 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 504                                         bool ref_p)
 505 {
 506   if (TREE_CODE (expr) == FUNCTION_DECL)
 507     {
 508       stream_write_tree (ob, DECL_ARGUMENTS (expr), ref_p);
 509       stream_write_tree (ob, DECL_RESULT (expr), ref_p);
 510     }
 511   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 512 }
 513
 514
 515 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 516    to output block OB.  If REF_P is true, write a reference to EXPR's
 517    pointer fields.  */
 518
 519 static void
 520 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 521                                       bool ref_p)
 522 {
 523   /* Make sure we don't inadvertently set the assembler name.  */
 524   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 525     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 526   else
 527     stream_write_tree (ob, NULL_TREE, false);
 528
 529   stream_write_tree (ob, DECL_SECTION_NAME (expr), ref_p);
 530   stream_write_tree (ob, DECL_COMDAT_GROUP (expr), ref_p);
 531 }
 532
 533
 534 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 535    output block OB.  If REF_P is true, write a reference to EXPR's
 536    pointer fields.  */
 537
 538 static void
 539 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 540                                    bool ref_p)
 541 {
 542   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 543   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 544   stream_write_tree (ob, DECL_QUALIFIER (expr), ref_p);
 545   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 546   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 547   streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 548 }
 549
 550
 551 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 552    to output block OB.  If REF_P is true, write a reference to EXPR's
 553    pointer fields.  */
 554
 555 static void
 556 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 557                                       bool ref_p)
 558 {
 559   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 560      maybe it should be handled here?  */
 561   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 562   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
 563   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 564 }
 565
 566
 567 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 568    output block OB.  If REF_P is true, write a reference to EXPR's
 569    pointer fields.  */
 570
 571 static void
 572 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 573                                     bool ref_p)
 574 {
 575   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 576   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 577   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 578   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 579   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 580      reconstructed during fixup.  */
 581   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 582      during fixup.  */
 583   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 584   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 585   /* TYPE_CANONICAL is re-computed during type merging, so no need
 586      to stream it here.  */
 587   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 588 }
 589
 590 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 591    to output block OB.  If REF_P is true, write a reference to EXPR's
 592    pointer fields.  */
 593
 594 static void
 595 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 596                                         bool ref_p)
 597 {
 598   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 599     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 600   else if (TREE_CODE (expr) == ARRAY_TYPE)
 601     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 602   else if (RECORD_OR_UNION_TYPE_P (expr))
 603     stream_write_tree (ob, TYPE_FIELDS (expr), ref_p);
 604   else if (TREE_CODE (expr) == FUNCTION_TYPE
 605            || TREE_CODE (expr) == METHOD_TYPE)
 606     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 607
 608   if (!POINTER_TYPE_P (expr))
 609     stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
 610   stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
 611   if (RECORD_OR_UNION_TYPE_P (expr))
 612     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 613 }
 614
 615
 616 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 617    block OB.  If REF_P is true, write a reference to EXPR's pointer
 618    fields.  */
 619
 620 static void
 621 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 622 {
 623   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 624   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 625   streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 626 }
 627
 628
 629 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 630    block OB.  If REF_P is true, write a reference to EXPR's pointer
 631    fields.  */
 632
 633 static void
 634 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 635 {
 636   int i;
 637
 638   /* Note that the number of slots for EXPR has already been emitted
 639      in EXPR's header (see streamer_write_tree_header).  */
 640   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 641     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 642 }
 643
 644
 645 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 646    block OB.  If REF_P is true, write a reference to EXPR's pointer
 647    fields.  */
 648
 649 static void
 650 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 651 {
 652   int i;
 653
 654   streamer_write_hwi (ob, TREE_OPERAND_LENGTH (expr));
 655   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 656     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 657   lto_output_location (ob, EXPR_LOCATION (expr));
 658   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 659 }
 660
 661
 662 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 663    block OB.  If REF_P is true, write a reference to EXPR's pointer
 664    fields.  */
 665
 666 static void
 667 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 668 {
 669   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
 670      for early inlining so drop it on the floor instead of ICEing in
 671      dwarf2out.c.  */
 672   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 673
 674   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 675      for early inlining so drop it on the floor instead of ICEing in
 676      dwarf2out.c.  */
 677
 678   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 679   /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information
 680      for early inlining so drop it on the floor instead of ICEing in
 681      dwarf2out.c.  */
 682   stream_write_tree (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
 683   stream_write_tree (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
 684   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 685      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 686 }
 687
 688
 689 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 690    block OB.  If REF_P is true, write a reference to EXPR's pointer
 691    fields.  */
 692
 693 static void
 694 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 695 {
 696   unsigned i;
 697   tree t;
 698
 699   /* Note that the number of BINFO slots has already been emitted in
 700      EXPR's header (see streamer_write_tree_header) because this length
 701      is needed to build the empty BINFO node on the reader side.  */
 702   FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
 703     stream_write_tree (ob, t, ref_p);
 704   stream_write_tree (ob, NULL_TREE, false);
 705
 706   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 707   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 708   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 709
 710   streamer_write_uhwi (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
 711   FOR_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
 712     stream_write_tree (ob, t, ref_p);
 713
 714   stream_write_tree (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
 715   stream_write_tree (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
 716   stream_write_tree (ob, BINFO_VPTR_INDEX (expr), ref_p);
 717 }
 718
 719
 720 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 721    output block OB.  If REF_P is true, write a reference to EXPR's
 722    pointer fields.  */
 723
 724 static void
 725 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 726                                     bool ref_p)
 727 {
 728   unsigned i;
 729   tree index, value;
 730
 731   streamer_write_uhwi (ob, CONSTRUCTOR_NELTS (expr));
 732   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 733     {
 734       stream_write_tree (ob, index, ref_p);
 735       stream_write_tree (ob, value, ref_p);
 736     }
 737 }
 738
 739 /* Write a TS_TARGET_OPTION tree in EXPR to OB.  */
 740
 741 static void
 742 write_ts_target_option (struct output_block *ob, tree expr)
 743 {
 744   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
 745   struct bitpack_d bp;
 746   unsigned i, len;
 747
 748   /* The cl_target_option is target specific and generated by the options
 749      awk script, so we just recreate a byte-by-byte copy here. */
 750
 751   bp = bitpack_create (ob->main_stream);
 752   len = sizeof (struct cl_target_option);
 753   for (i = 0; i < len; i++)
 754     bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
 755   /* Catch struct size mismatches between reader and writer. */
 756   bp_pack_value (&bp, 0x12345678, 32);
 757   streamer_write_bitpack (&bp);
 758 }
 759
 760 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB.  */
 761
 762 static void
 763 write_ts_translation_unit_decl_tree_pointers (struct output_block *ob,
 764                                               tree expr)
 765 {
 766   streamer_write_string (ob, ob->main_stream,
 767                          TRANSLATION_UNIT_LANGUAGE (expr), true);
 768 }
 769
 770 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 771    the leaves of EXPR are emitted as references.  */
 772
 773 void
 774 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 775 {
 776   enum tree_code code;
 777
 778   code = TREE_CODE (expr);
 779
 780   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 781     write_ts_common_tree_pointers (ob, expr, ref_p);
 782
 783   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 784     write_ts_vector_tree_pointers (ob, expr, ref_p);
 785
 786   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 787     write_ts_complex_tree_pointers (ob, expr, ref_p);
 788
 789   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 790     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 791
 792   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 793     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 794
 795   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 796     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 797
 798   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 799     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 800
 801   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 802     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 803
 804   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 805     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 806
 807   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 808     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 809
 810   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 811     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 812
 813   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 814     write_ts_list_tree_pointers (ob, expr, ref_p);
 815
 816   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 817     write_ts_vec_tree_pointers (ob, expr, ref_p);
 818
 819   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 820     write_ts_exp_tree_pointers (ob, expr, ref_p);
 821
 822   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 823     write_ts_block_tree_pointers (ob, expr, ref_p);
 824
 825   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 826     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 827
 828   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 829     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 830
 831   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
 832     write_ts_target_option (ob, expr);
 833
 834   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 835     write_ts_translation_unit_decl_tree_pointers (ob, expr);
 836 }
 837
 838
 839 /* Emit header information for tree EXPR to output block OB.  The header
 840    contains everything needed to instantiate an empty skeleton for
 841    EXPR on the reading side.  IX is the index into the streamer cache
 842    where EXPR is stored.  */
 843
 844 void
 845 streamer_write_tree_header (struct output_block *ob, tree expr)
 846 {
 847   enum LTO_tags tag;
 848   enum tree_code code;
 849
 850   /* We should not see any tree nodes not handled by the streamer.  */
 851   code = TREE_CODE (expr);
 852
 853   /* The header of a tree node consists of its tag, the size of
 854      the node, and any other information needed to instantiate
 855      EXPR on the reading side (such as the number of slots in
 856      variable sized nodes).  */
 857   tag = lto_tree_code_to_tag (code);
 858   streamer_write_record_start (ob, tag);
 859
 860   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 861 #ifdef LTO_STREAMER_DEBUG
 862   /* This is used mainly for debugging purposes.  When the reader
 863      and the writer do not agree on a streamed node, the pointer
 864      value for EXPR can be used to track down the differences in
 865      the debugger.  */
 866   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
 867   streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
 868 #endif
 869
 870   /* The text in strings and identifiers are completely emitted in
 871      the header.  */
 872   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
 873     streamer_write_string_cst (ob, ob->main_stream, expr);
 874   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
 875     write_identifier (ob, ob->main_stream, expr);
 876   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 877     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
 878   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 879     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
 880   else if (TREE_CODE (expr) == CALL_EXPR)
 881     streamer_write_uhwi (ob, call_expr_nargs (expr));
 882 }
 883
 884
 885 /* Emit the integer constant CST to output block OB.  If REF_P is true,
 886    CST's type will be emitted as a reference.  */
 887
 888 void
 889 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
 890 {
 891   streamer_write_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
 892   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
 893   streamer_write_char_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
 894   streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
 895   streamer_write_uhwi (ob, TREE_INT_CST_HIGH (cst));
 896 }