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