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   streamer_write_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
 445 }
 446
 447
 448 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 449    block OB.  If REF_P is true, write a reference to EXPR's pointer
 450    fields.  */
 451
 452 static void
 453 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 454 {
 455   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
 456   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
 457 }
 458
 459
 460 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 461    to output block OB.  If REF_P is true, write a reference to EXPR's
 462    pointer fields.  */
 463
 464 static void
 465 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 466                                      bool ref_p)
 467 {
 468   stream_write_tree (ob, DECL_NAME (expr), ref_p);
 469   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
 470   lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
 471 }
 472
 473
 474 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 475    output block OB.  If REF_P is true, write a reference to EXPR's
 476    pointer fields.  */
 477
 478 static void
 479 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 480                                     bool ref_p)
 481 {
 482   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
 483   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
 484
 485   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 486      special handling in LTO, it must be handled by streamer hooks.  */
 487
 488   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
 489
 490   /* Do not stream DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
 491      for early inlining so drop it on the floor instead of ICEing in
 492      dwarf2out.c.  */
 493
 494   if (TREE_CODE (expr) == PARM_DECL)
 495     streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 496
 497   if ((TREE_CODE (expr) == VAR_DECL
 498        || TREE_CODE (expr) == PARM_DECL)
 499       && DECL_HAS_VALUE_EXPR_P (expr))
 500     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
 501
 502   if (TREE_CODE (expr) == VAR_DECL)
 503     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
 504 }
 505
 506
 507 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 508    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 509    pointer fields.  */
 510
 511 static void
 512 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
 513                                         bool ref_p)
 514 {
 515   if (TREE_CODE (expr) == FUNCTION_DECL)
 516     {
 517       stream_write_tree (ob, DECL_ARGUMENTS (expr), ref_p);
 518       stream_write_tree (ob, DECL_RESULT (expr), ref_p);
 519     }
 520   else if (TREE_CODE (expr) == TYPE_DECL)
 521     stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
 522   stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
 523 }
 524
 525
 526 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 527    to output block OB.  If REF_P is true, write a reference to EXPR's
 528    pointer fields.  */
 529
 530 static void
 531 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 532                                       bool ref_p)
 533 {
 534   /* Make sure we don't inadvertently set the assembler name.  */
 535   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 536     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 537   else
 538     stream_write_tree (ob, NULL_TREE, false);
 539
 540   stream_write_tree (ob, DECL_SECTION_NAME (expr), ref_p);
 541   stream_write_tree (ob, DECL_COMDAT_GROUP (expr), ref_p);
 542 }
 543
 544
 545 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 546    output block OB.  If REF_P is true, write a reference to EXPR's
 547    pointer fields.  */
 548
 549 static void
 550 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 551                                    bool ref_p)
 552 {
 553   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
 554   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 555   /* Do not stream DECL_QUALIFIER, it is useless after gimplification.  */
 556   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 557   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
 558 }
 559
 560
 561 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 562    to output block OB.  If REF_P is true, write a reference to EXPR's
 563    pointer fields.  */
 564
 565 static void
 566 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 567                                       bool ref_p)
 568 {
 569   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 570      maybe it should be handled here?  */
 571   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 572   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
 573   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 574 }
 575
 576
 577 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 578    output block OB.  If REF_P is true, write a reference to EXPR's
 579    pointer fields.  */
 580
 581 static void
 582 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 583                                     bool ref_p)
 584 {
 585   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 586   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 587   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 588   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 589   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 590      reconstructed during fixup.  */
 591   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 592      during fixup.  */
 593   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 594   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 595   /* TYPE_CANONICAL is re-computed during type merging, so no need
 596      to stream it here.  */
 597   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 598 }
 599
 600 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 601    to output block OB.  If REF_P is true, write a reference to EXPR's
 602    pointer fields.  */
 603
 604 static void
 605 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 606                                         bool ref_p)
 607 {
 608   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 609     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 610   else if (TREE_CODE (expr) == ARRAY_TYPE)
 611     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 612   else if (RECORD_OR_UNION_TYPE_P (expr))
 613     streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
 614   else if (TREE_CODE (expr) == FUNCTION_TYPE
 615            || TREE_CODE (expr) == METHOD_TYPE)
 616     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 617
 618   if (!POINTER_TYPE_P (expr))
 619     stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
 620   stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
 621   if (RECORD_OR_UNION_TYPE_P (expr))
 622     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 623 }
 624
 625
 626 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 627    block OB.  If REF_P is true, write a reference to EXPR's pointer
 628    fields.  */
 629
 630 static void
 631 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 632 {
 633   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 634   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 635   streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 636 }
 637
 638
 639 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 640    block OB.  If REF_P is true, write a reference to EXPR's pointer
 641    fields.  */
 642
 643 static void
 644 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 645 {
 646   int i;
 647
 648   /* Note that the number of slots for EXPR has already been emitted
 649      in EXPR's header (see streamer_write_tree_header).  */
 650   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 651     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 652 }
 653
 654
 655 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 656    block OB.  If REF_P is true, write a reference to EXPR's pointer
 657    fields.  */
 658
 659 static void
 660 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 661 {
 662   int i;
 663
 664   streamer_write_hwi (ob, TREE_OPERAND_LENGTH (expr));
 665   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 666     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 667   lto_output_location (ob, EXPR_LOCATION (expr));
 668   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 669 }
 670
 671
 672 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 673    block OB.  If REF_P is true, write a reference to EXPR's pointer
 674    fields.  */
 675
 676 static void
 677 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 678 {
 679   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
 680      for early inlining so drop it on the floor instead of ICEing in
 681      dwarf2out.c.  */
 682   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 683
 684   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 685      for early inlining so drop it on the floor instead of ICEing in
 686      dwarf2out.c.  */
 687
 688   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 689   /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information
 690      for early inlining so drop it on the floor instead of ICEing in
 691      dwarf2out.c.  */
 692   stream_write_tree (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
 693   stream_write_tree (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
 694   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 695      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 696 }
 697
 698
 699 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 700    block OB.  If REF_P is true, write a reference to EXPR's pointer
 701    fields.  */
 702
 703 static void
 704 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 705 {
 706   unsigned i;
 707   tree t;
 708
 709   /* Note that the number of BINFO slots has already been emitted in
 710      EXPR's header (see streamer_write_tree_header) because this length
 711      is needed to build the empty BINFO node on the reader side.  */
 712   FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
 713     stream_write_tree (ob, t, ref_p);
 714   stream_write_tree (ob, NULL_TREE, false);
 715
 716   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 717   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 718   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 719
 720   streamer_write_uhwi (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
 721   FOR_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
 722     stream_write_tree (ob, t, ref_p);
 723
 724   stream_write_tree (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
 725   stream_write_tree (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
 726   stream_write_tree (ob, BINFO_VPTR_INDEX (expr), ref_p);
 727 }
 728
 729
 730 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 731    output block OB.  If REF_P is true, write a reference to EXPR's
 732    pointer fields.  */
 733
 734 static void
 735 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 736                                     bool ref_p)
 737 {
 738   unsigned i;
 739   tree index, value;
 740
 741   streamer_write_uhwi (ob, CONSTRUCTOR_NELTS (expr));
 742   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 743     {
 744       stream_write_tree (ob, index, ref_p);
 745       stream_write_tree (ob, value, ref_p);
 746     }
 747 }
 748
 749 /* Write a TS_TARGET_OPTION tree in EXPR to OB.  */
 750
 751 static void
 752 write_ts_target_option (struct output_block *ob, tree expr)
 753 {
 754   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
 755   struct bitpack_d bp;
 756   unsigned i, len;
 757
 758   /* The cl_target_option is target specific and generated by the options
 759      awk script, so we just recreate a byte-by-byte copy here. */
 760
 761   bp = bitpack_create (ob->main_stream);
 762   len = sizeof (struct cl_target_option);
 763   for (i = 0; i < len; i++)
 764     bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
 765   /* Catch struct size mismatches between reader and writer. */
 766   bp_pack_value (&bp, 0x12345678, 32);
 767   streamer_write_bitpack (&bp);
 768 }
 769
 770 /* Write a TS_OPTIMIZATION tree in EXPR to OB.  */
 771
 772 static void
 773 write_ts_optimization (struct output_block *ob, tree expr)
 774 {
 775   struct cl_optimization *t = TREE_OPTIMIZATION (expr);
 776   struct bitpack_d bp;
 777   unsigned i, len;
 778
 779   /* The cl_optimization is generated by the options
 780      awk script, so we just recreate a byte-by-byte copy here. */
 781
 782   bp = bitpack_create (ob->main_stream);
 783   len = sizeof (struct cl_optimization);
 784   for (i = 0; i < len; i++)
 785     bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
 786   /* Catch struct size mismatches between reader and writer. */
 787   bp_pack_value (&bp, 0x12345678, 32);
 788   streamer_write_bitpack (&bp);
 789 }
 790
 791 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB.  */
 792
 793 static void
 794 write_ts_translation_unit_decl_tree_pointers (struct output_block *ob,
 795                                               tree expr)
 796 {
 797   streamer_write_string (ob, ob->main_stream,
 798                          TRANSLATION_UNIT_LANGUAGE (expr), true);
 799 }
 800
 801 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 802    the leaves of EXPR are emitted as references.  */
 803
 804 void
 805 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 806 {
 807   enum tree_code code;
 808
 809   code = TREE_CODE (expr);
 810
 811   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 812     write_ts_common_tree_pointers (ob, expr, ref_p);
 813
 814   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 815     write_ts_vector_tree_pointers (ob, expr, ref_p);
 816
 817   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 818     write_ts_complex_tree_pointers (ob, expr, ref_p);
 819
 820   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 821     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 822
 823   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 824     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 825
 826   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 827     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 828
 829   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 830     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 831
 832   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 833     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 834
 835   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 836     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 837
 838   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 839     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 840
 841   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 842     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 843
 844   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 845     write_ts_list_tree_pointers (ob, expr, ref_p);
 846
 847   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 848     write_ts_vec_tree_pointers (ob, expr, ref_p);
 849
 850   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 851     write_ts_exp_tree_pointers (ob, expr, ref_p);
 852
 853   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 854     write_ts_block_tree_pointers (ob, expr, ref_p);
 855
 856   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 857     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 858
 859   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 860     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 861
 862   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
 863     write_ts_target_option (ob, expr);
 864
 865   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
 866     write_ts_optimization (ob, expr);
 867
 868   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 869     write_ts_translation_unit_decl_tree_pointers (ob, expr);
 870 }
 871
 872
 873 /* Emit header information for tree EXPR to output block OB.  The header
 874    contains everything needed to instantiate an empty skeleton for
 875    EXPR on the reading side.  IX is the index into the streamer cache
 876    where EXPR is stored.  */
 877
 878 void
 879 streamer_write_tree_header (struct output_block *ob, tree expr)
 880 {
 881   enum LTO_tags tag;
 882   enum tree_code code;
 883
 884   /* We should not see any tree nodes not handled by the streamer.  */
 885   code = TREE_CODE (expr);
 886
 887   /* The header of a tree node consists of its tag, the size of
 888      the node, and any other information needed to instantiate
 889      EXPR on the reading side (such as the number of slots in
 890      variable sized nodes).  */
 891   tag = lto_tree_code_to_tag (code);
 892   streamer_write_record_start (ob, tag);
 893
 894   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 895 #ifdef LTO_STREAMER_DEBUG
 896   /* This is used mainly for debugging purposes.  When the reader
 897      and the writer do not agree on a streamed node, the pointer
 898      value for EXPR can be used to track down the differences in
 899      the debugger.  */
 900   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
 901   streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
 902 #endif
 903
 904   /* The text in strings and identifiers are completely emitted in
 905      the header.  */
 906   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
 907     streamer_write_string_cst (ob, ob->main_stream, expr);
 908   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
 909     write_identifier (ob, ob->main_stream, expr);
 910   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 911     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
 912   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 913     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
 914   else if (TREE_CODE (expr) == CALL_EXPR)
 915     streamer_write_uhwi (ob, call_expr_nargs (expr));
 916 }
 917
 918
 919 /* Emit the integer constant CST to output block OB.  If REF_P is true,
 920    CST's type will be emitted as a reference.  */
 921
 922 void
 923 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
 924 {
 925   streamer_write_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
 926   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
 927   streamer_write_char_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
 928   streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
 929   streamer_write_uhwi (ob, TREE_INT_CST_HIGH (cst));
 930 }