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