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