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