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