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