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