gcc/tree-streamer-out.c

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