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   streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 557 }
 558
 559
 560 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 561    to output block OB.  If REF_P is true, write a reference to EXPR's
 562    pointer fields.  */
 563
 564 static void
 565 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 566                                       bool ref_p)
 567 {
 568   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 569      maybe it should be handled here?  */
 570   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 571   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
 572   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
 573 }
 574
 575
 576 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
 577    output block OB.  If REF_P is true, write a reference to EXPR's
 578    pointer fields.  */
 579
 580 static void
 581 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
 582                                     bool ref_p)
 583 {
 584   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
 585   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
 586   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
 587   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
 588   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
 589      reconstructed during fixup.  */
 590   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 591      during fixup.  */
 592   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 593   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
 594   /* TYPE_CANONICAL is re-computed during type merging, so no need
 595      to stream it here.  */
 596   stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
 597 }
 598
 599 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
 600    to output block OB.  If REF_P is true, write a reference to EXPR's
 601    pointer fields.  */
 602
 603 static void
 604 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
 605                                         bool ref_p)
 606 {
 607   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 608     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
 609   else if (TREE_CODE (expr) == ARRAY_TYPE)
 610     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
 611   else if (RECORD_OR_UNION_TYPE_P (expr))
 612     stream_write_tree (ob, TYPE_FIELDS (expr), ref_p);
 613   else if (TREE_CODE (expr) == FUNCTION_TYPE
 614            || TREE_CODE (expr) == METHOD_TYPE)
 615     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
 616
 617   if (!POINTER_TYPE_P (expr))
 618     stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
 619   stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
 620   if (RECORD_OR_UNION_TYPE_P (expr))
 621     stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
 622 }
 623
 624
 625 /* Write all pointer fields in the TS_LIST structure of EXPR to output
 626    block OB.  If REF_P is true, write a reference to EXPR's pointer
 627    fields.  */
 628
 629 static void
 630 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 631 {
 632   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
 633   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
 634   streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 635 }
 636
 637
 638 /* Write all pointer fields in the TS_VEC structure of EXPR to output
 639    block OB.  If REF_P is true, write a reference to EXPR's pointer
 640    fields.  */
 641
 642 static void
 643 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 644 {
 645   int i;
 646
 647   /* Note that the number of slots for EXPR has already been emitted
 648      in EXPR's header (see streamer_write_tree_header).  */
 649   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
 650     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 651 }
 652
 653
 654 /* Write all pointer fields in the TS_EXP structure of EXPR to output
 655    block OB.  If REF_P is true, write a reference to EXPR's pointer
 656    fields.  */
 657
 658 static void
 659 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 660 {
 661   int i;
 662
 663   streamer_write_hwi (ob, TREE_OPERAND_LENGTH (expr));
 664   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
 665     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
 666   lto_output_location (ob, EXPR_LOCATION (expr));
 667   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
 668 }
 669
 670
 671 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
 672    block OB.  If REF_P is true, write a reference to EXPR's pointer
 673    fields.  */
 674
 675 static void
 676 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 677 {
 678   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
 679      for early inlining so drop it on the floor instead of ICEing in
 680      dwarf2out.c.  */
 681   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 682
 683   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
 684      for early inlining so drop it on the floor instead of ICEing in
 685      dwarf2out.c.  */
 686
 687   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
 688   /* Do not stream BLOCK_ABSTRACT_ORIGIN.  We cannot handle debug information
 689      for early inlining so drop it on the floor instead of ICEing in
 690      dwarf2out.c.  */
 691   stream_write_tree (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
 692   stream_write_tree (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
 693   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
 694      list is re-constructed from BLOCK_SUPERCONTEXT.  */
 695 }
 696
 697
 698 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
 699    block OB.  If REF_P is true, write a reference to EXPR's pointer
 700    fields.  */
 701
 702 static void
 703 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 704 {
 705   unsigned i;
 706   tree t;
 707
 708   /* Note that the number of BINFO slots has already been emitted in
 709      EXPR's header (see streamer_write_tree_header) because this length
 710      is needed to build the empty BINFO node on the reader side.  */
 711   FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
 712     stream_write_tree (ob, t, ref_p);
 713   stream_write_tree (ob, NULL_TREE, false);
 714
 715   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
 716   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
 717   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 718
 719   streamer_write_uhwi (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
 720   FOR_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
 721     stream_write_tree (ob, t, ref_p);
 722
 723   stream_write_tree (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
 724   stream_write_tree (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
 725   stream_write_tree (ob, BINFO_VPTR_INDEX (expr), ref_p);
 726 }
 727
 728
 729 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
 730    output block OB.  If REF_P is true, write a reference to EXPR's
 731    pointer fields.  */
 732
 733 static void
 734 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 735                                     bool ref_p)
 736 {
 737   unsigned i;
 738   tree index, value;
 739
 740   streamer_write_uhwi (ob, CONSTRUCTOR_NELTS (expr));
 741   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
 742     {
 743       stream_write_tree (ob, index, ref_p);
 744       stream_write_tree (ob, value, ref_p);
 745     }
 746 }
 747
 748 /* Write a TS_TARGET_OPTION tree in EXPR to OB.  */
 749
 750 static void
 751 write_ts_target_option (struct output_block *ob, tree expr)
 752 {
 753   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
 754   struct bitpack_d bp;
 755   unsigned i, len;
 756
 757   /* The cl_target_option is target specific and generated by the options
 758      awk script, so we just recreate a byte-by-byte copy here. */
 759
 760   bp = bitpack_create (ob->main_stream);
 761   len = sizeof (struct cl_target_option);
 762   for (i = 0; i < len; i++)
 763     bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
 764   /* Catch struct size mismatches between reader and writer. */
 765   bp_pack_value (&bp, 0x12345678, 32);
 766   streamer_write_bitpack (&bp);
 767 }
 768
 769 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB.  */
 770
 771 static void
 772 write_ts_translation_unit_decl_tree_pointers (struct output_block *ob,
 773                                               tree expr)
 774 {
 775   streamer_write_string (ob, ob->main_stream,
 776                          TRANSLATION_UNIT_LANGUAGE (expr), true);
 777 }
 778
 779 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
 780    the leaves of EXPR are emitted as references.  */
 781
 782 void
 783 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 784 {
 785   enum tree_code code;
 786
 787   code = TREE_CODE (expr);
 788
 789   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 790     write_ts_common_tree_pointers (ob, expr, ref_p);
 791
 792   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 793     write_ts_vector_tree_pointers (ob, expr, ref_p);
 794
 795   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 796     write_ts_complex_tree_pointers (ob, expr, ref_p);
 797
 798   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
 799     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 800
 801   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 802     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 803
 804   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
 805     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 806
 807   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 808     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 809
 810   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
 811     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 812
 813   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 814     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 815
 816   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
 817     write_ts_type_common_tree_pointers (ob, expr, ref_p);
 818
 819   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 820     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 821
 822   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
 823     write_ts_list_tree_pointers (ob, expr, ref_p);
 824
 825   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 826     write_ts_vec_tree_pointers (ob, expr, ref_p);
 827
 828   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
 829     write_ts_exp_tree_pointers (ob, expr, ref_p);
 830
 831   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 832     write_ts_block_tree_pointers (ob, expr, ref_p);
 833
 834   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 835     write_ts_binfo_tree_pointers (ob, expr, ref_p);
 836
 837   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 838     write_ts_constructor_tree_pointers (ob, expr, ref_p);
 839
 840   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
 841     write_ts_target_option (ob, expr);
 842
 843   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 844     write_ts_translation_unit_decl_tree_pointers (ob, expr);
 845 }
 846
 847
 848 /* Emit header information for tree EXPR to output block OB.  The header
 849    contains everything needed to instantiate an empty skeleton for
 850    EXPR on the reading side.  IX is the index into the streamer cache
 851    where EXPR is stored.  */
 852
 853 void
 854 streamer_write_tree_header (struct output_block *ob, tree expr)
 855 {
 856   enum LTO_tags tag;
 857   enum tree_code code;
 858
 859   /* We should not see any tree nodes not handled by the streamer.  */
 860   code = TREE_CODE (expr);
 861
 862   /* The header of a tree node consists of its tag, the size of
 863      the node, and any other information needed to instantiate
 864      EXPR on the reading side (such as the number of slots in
 865      variable sized nodes).  */
 866   tag = lto_tree_code_to_tag (code);
 867   streamer_write_record_start (ob, tag);
 868
 869   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 870 #ifdef LTO_STREAMER_DEBUG
 871   /* This is used mainly for debugging purposes.  When the reader
 872      and the writer do not agree on a streamed node, the pointer
 873      value for EXPR can be used to track down the differences in
 874      the debugger.  */
 875   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
 876   streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
 877 #endif
 878
 879   /* The text in strings and identifiers are completely emitted in
 880      the header.  */
 881   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
 882     streamer_write_string_cst (ob, ob->main_stream, expr);
 883   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
 884     write_identifier (ob, ob->main_stream, expr);
 885   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
 886     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
 887   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
 888     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
 889   else if (TREE_CODE (expr) == CALL_EXPR)
 890     streamer_write_uhwi (ob, call_expr_nargs (expr));
 891 }
 892
 893
 894 /* Emit the integer constant CST to output block OB.  If REF_P is true,
 895    CST's type will be emitted as a reference.  */
 896
 897 void
 898 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
 899 {
 900   streamer_write_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
 901   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
 902   streamer_write_char_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
 903   streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
 904   streamer_write_uhwi (ob, TREE_INT_CST_HIGH (cst));
 905 }