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