gcc/tree-streamer-out.c

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