gcc/tree-streamer-out.c

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