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