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