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