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