gcc/lto-streamer-out.c

   1 /* Write the GIMPLE representation to a file stream.
   2
   3    Copyright 2009, 2010 Free Software Foundation, Inc.
   4    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
   5    Re-implemented by Diego Novillo <dnovillo@google.com>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "tree.h"
  28 #include "expr.h"
  29 #include "flags.h"
  30 #include "params.h"
  31 #include "input.h"
  32 #include "hashtab.h"
  33 #include "basic-block.h"
  34 #include "tree-flow.h"
  35 #include "tree-pass.h"
  36 #include "cgraph.h"
  37 #include "function.h"
  38 #include "ggc.h"
  39 #include "diagnostic-core.h"
  40 #include "except.h"
  41 #include "vec.h"
  42 #include "lto-symtab.h"
  43 #include "lto-streamer.h"
  44
  45
  46 struct string_slot
  47 {
  48   const char *s;
  49   int len;
  50   unsigned int slot_num;
  51 };
  52
  53
  54 /* Returns a hash code for P.  */
  55
  56 static hashval_t
  57 hash_string_slot_node (const void *p)
  58 {
  59   const struct string_slot *ds = (const struct string_slot *) p;
  60   return (hashval_t) htab_hash_string (ds->s);
  61 }
  62
  63
  64 /* Returns nonzero if P1 and P2 are equal.  */
  65
  66 static int
  67 eq_string_slot_node (const void *p1, const void *p2)
  68 {
  69   const struct string_slot *ds1 = (const struct string_slot *) p1;
  70   const struct string_slot *ds2 = (const struct string_slot *) p2;
  71
  72   if (ds1->len == ds2->len)
  73     {
  74       int i;
  75       for (i = 0; i < ds1->len; i++)
  76         if (ds1->s[i] != ds2->s[i])
  77           return 0;
  78       return 1;
  79     }
  80
  81   return 0;
  82 }
  83
  84
  85 /* Free the string slot pointed-to by P.  */
  86
  87 static void
  88 string_slot_free (void *p)
  89 {
  90   struct string_slot *slot = (struct string_slot *) p;
  91   free (CONST_CAST (void *, (const void *) slot->s));
  92   free (slot);
  93 }
  94
  95
  96 /* Clear the line info stored in DATA_IN.  */
  97
  98 static void
  99 clear_line_info (struct output_block *ob)
 100 {
 101   ob->current_file = NULL;
 102   ob->current_line = 0;
 103   ob->current_col = 0;
 104 }
 105
 106
 107 /* Create the output block and return it.  SECTION_TYPE is
 108    LTO_section_function_body or LTO_static_initializer.  */
 109
 110 struct output_block *
 111 create_output_block (enum lto_section_type section_type)
 112 {
 113   struct output_block *ob = XCNEW (struct output_block);
 114
 115   ob->section_type = section_type;
 116   ob->decl_state = lto_get_out_decl_state ();
 117   ob->main_stream = XCNEW (struct lto_output_stream);
 118   ob->string_stream = XCNEW (struct lto_output_stream);
 119   ob->writer_cache = lto_streamer_cache_create ();
 120
 121   if (section_type == LTO_section_function_body)
 122     ob->cfg_stream = XCNEW (struct lto_output_stream);
 123
 124   clear_line_info (ob);
 125
 126   ob->string_hash_table = htab_create (37, hash_string_slot_node,
 127                                        eq_string_slot_node, string_slot_free);
 128
 129   return ob;
 130 }
 131
 132
 133 /* Destroy the output block OB.  */
 134
 135 void
 136 destroy_output_block (struct output_block *ob)
 137 {
 138   enum lto_section_type section_type = ob->section_type;
 139
 140   htab_delete (ob->string_hash_table);
 141
 142   free (ob->main_stream);
 143   free (ob->string_stream);
 144   if (section_type == LTO_section_function_body)
 145     free (ob->cfg_stream);
 146
 147   lto_streamer_cache_delete (ob->writer_cache);
 148
 149   free (ob);
 150 }
 151
 152
 153 /* Output STRING of LEN characters to the string
 154    table in OB. The string might or might not include a trailing '\0'.
 155    Then put the index onto the INDEX_STREAM.  */
 156
 157 static void
 158 output_string_with_length (struct output_block *ob,
 159                            struct lto_output_stream *index_stream,
 160                            const char *s,
 161                            unsigned int len)
 162 {
 163   struct string_slot **slot;
 164   struct string_slot s_slot;
 165   char *string = (char *) xmalloc (len + 1);
 166   memcpy (string, s, len);
 167   string[len] = '\0';
 168
 169   s_slot.s = string;
 170   s_slot.len = len;
 171   s_slot.slot_num = 0;
 172
 173   slot = (struct string_slot **) htab_find_slot (ob->string_hash_table,
 174                                                  &s_slot, INSERT);
 175   if (*slot == NULL)
 176     {
 177       struct lto_output_stream *string_stream = ob->string_stream;
 178       unsigned int start = string_stream->total_size;
 179       struct string_slot *new_slot
 180         = (struct string_slot *) xmalloc (sizeof (struct string_slot));
 181       unsigned int i;
 182
 183       new_slot->s = string;
 184       new_slot->len = len;
 185       new_slot->slot_num = start;
 186       *slot = new_slot;
 187       lto_output_uleb128_stream (index_stream, start);
 188       lto_output_uleb128_stream (string_stream, len);
 189       for (i = 0; i < len; i++)
 190         lto_output_1_stream (string_stream, string[i]);
 191     }
 192   else
 193     {
 194       struct string_slot *old_slot = (struct string_slot *)*slot;
 195       lto_output_uleb128_stream (index_stream, old_slot->slot_num);
 196       free (string);
 197     }
 198 }
 199
 200 /* Output the '\0' terminated STRING to the string
 201    table in OB.  Then put the index onto the INDEX_STREAM.  */
 202
 203 static void
 204 output_string (struct output_block *ob,
 205                struct lto_output_stream *index_stream,
 206                const char *string)
 207 {
 208   if (string)
 209     {
 210       lto_output_uleb128_stream (index_stream, 0);
 211       output_string_with_length (ob, index_stream, string, strlen (string) + 1);
 212     }
 213   else
 214     lto_output_uleb128_stream (index_stream, 1);
 215 }
 216
 217
 218 /* Output the STRING constant to the string
 219    table in OB.  Then put the index onto the INDEX_STREAM.  */
 220
 221 static void
 222 output_string_cst (struct output_block *ob,
 223                    struct lto_output_stream *index_stream,
 224                    tree string)
 225 {
 226   if (string)
 227     {
 228       lto_output_uleb128_stream (index_stream, 0);
 229       output_string_with_length (ob, index_stream,
 230                                  TREE_STRING_POINTER (string),
 231                                  TREE_STRING_LENGTH (string));
 232     }
 233   else
 234     lto_output_uleb128_stream (index_stream, 1);
 235 }
 236
 237
 238 /* Output the identifier ID to the string
 239    table in OB.  Then put the index onto the INDEX_STREAM.  */
 240
 241 static void
 242 output_identifier (struct output_block *ob,
 243                    struct lto_output_stream *index_stream,
 244                    tree id)
 245 {
 246   if (id)
 247     {
 248       lto_output_uleb128_stream (index_stream, 0);
 249       output_string_with_length (ob, index_stream,
 250                                  IDENTIFIER_POINTER (id),
 251                                  IDENTIFIER_LENGTH (id));
 252     }
 253   else
 254     lto_output_uleb128_stream (index_stream, 1);
 255 }
 256
 257 /* Write a zero to the output stream.  */
 258
 259 static void
 260 output_zero (struct output_block *ob)
 261 {
 262   lto_output_1_stream (ob->main_stream, 0);
 263 }
 264
 265
 266 /* Output an unsigned LEB128 quantity to OB->main_stream.  */
 267
 268 static void
 269 output_uleb128 (struct output_block *ob, unsigned HOST_WIDE_INT work)
 270 {
 271   lto_output_uleb128_stream (ob->main_stream, work);
 272 }
 273
 274
 275 /* Output a signed LEB128 quantity to OB->main_stream.  */
 276
 277 static void
 278 output_sleb128 (struct output_block *ob, HOST_WIDE_INT work)
 279 {
 280   lto_output_sleb128_stream (ob->main_stream, work);
 281 }
 282
 283
 284 /* Output the start of a record with TAG to output block OB.  */
 285
 286 static void
 287 output_record_start (struct output_block *ob, enum LTO_tags tag)
 288 {
 289   /* Make sure TAG fits inside an unsigned int.  */
 290   gcc_assert (tag == (enum LTO_tags) (unsigned) tag);
 291   output_uleb128 (ob, tag);
 292 }
 293
 294
 295 /* Look up NODE in the type table and write the index for it to OB.  */
 296
 297 static void
 298 output_type_ref (struct output_block *ob, tree node)
 299 {
 300   output_record_start (ob, LTO_type_ref);
 301   lto_output_type_ref_index (ob->decl_state, ob->main_stream, node);
 302 }
 303
 304
 305 /* Pack all the non-pointer fields of the TS_BASE structure of
 306    expression EXPR into bitpack BP.  */
 307
 308 static void
 309 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
 310 {
 311   bp_pack_value (bp, TREE_CODE (expr), 16);
 312   if (!TYPE_P (expr))
 313     {
 314       bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
 315       bp_pack_value (bp, TREE_CONSTANT (expr), 1);
 316       bp_pack_value (bp, TREE_READONLY (expr), 1);
 317
 318       /* TREE_PUBLIC is used on types to indicate that the type
 319          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
 320          so we skip it here.  */
 321       bp_pack_value (bp, TREE_PUBLIC (expr), 1);
 322     }
 323   else
 324     bp_pack_value (bp, 0, 4);
 325   bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
 326   bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
 327   if (DECL_P (expr))
 328     bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
 329   else if (TYPE_P (expr))
 330     bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
 331   else
 332     bp_pack_value (bp, 0, 1);
 333   /* We write debug info two times, do not confuse the second one.  */
 334   bp_pack_value (bp, TYPE_P (expr) ? 0 : TREE_ASM_WRITTEN (expr), 1);
 335   bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
 336   bp_pack_value (bp, TREE_USED (expr), 1);
 337   bp_pack_value (bp, TREE_NOTHROW (expr), 1);
 338   bp_pack_value (bp, TREE_STATIC (expr), 1);
 339   bp_pack_value (bp, TREE_PRIVATE (expr), 1);
 340   bp_pack_value (bp, TREE_PROTECTED (expr), 1);
 341   bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
 342   if (TYPE_P (expr))
 343     bp_pack_value (bp, TYPE_SATURATING (expr), 1);
 344   else if (TREE_CODE (expr) == SSA_NAME)
 345     bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
 346   else
 347     bp_pack_value (bp, 0, 1);
 348 }
 349
 350
 351 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
 352    expression EXPR into bitpack BP.  */
 353
 354 static void
 355 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
 356 {
 357   unsigned i;
 358   REAL_VALUE_TYPE r;
 359
 360   r = TREE_REAL_CST (expr);
 361   bp_pack_value (bp, r.cl, 2);
 362   bp_pack_value (bp, r.decimal, 1);
 363   bp_pack_value (bp, r.sign, 1);
 364   bp_pack_value (bp, r.signalling, 1);
 365   bp_pack_value (bp, r.canonical, 1);
 366   bp_pack_value (bp, r.uexp, EXP_BITS);
 367   for (i = 0; i < SIGSZ; i++)
 368     bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
 369 }
 370
 371
 372 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
 373    expression EXPR into bitpack BP.  */
 374
 375 static void
 376 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
 377 {
 378   struct fixed_value fv = TREE_FIXED_CST (expr);
 379   bp_pack_value (bp, fv.data.low, HOST_BITS_PER_WIDE_INT);
 380   bp_pack_value (bp, fv.data.high, HOST_BITS_PER_WIDE_INT);
 381   bp_pack_value (bp, fv.mode, HOST_BITS_PER_INT);
 382 }
 383
 384
 385 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
 386    of expression EXPR into bitpack BP.  */
 387
 388 static void
 389 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
 390 {
 391   bp_pack_value (bp, DECL_MODE (expr), 8);
 392   bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
 393   bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
 394   bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
 395   bp_pack_value (bp, DECL_ABSTRACT (expr), 1);
 396   bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
 397   bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
 398   bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
 399   bp_pack_value (bp, DECL_DEBUG_EXPR_IS_FROM (expr), 1);
 400   bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
 401   bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
 402   bp_pack_value (bp, DECL_ALIGN (expr), HOST_BITS_PER_INT);
 403
 404   if (TREE_CODE (expr) == LABEL_DECL)
 405     {
 406       /* Note that we do not write LABEL_DECL_UID.  The reader will
 407          always assume an initial value of -1 so that the
 408          label_to_block_map is recreated by gimple_set_bb.  */
 409       bp_pack_value (bp, DECL_ERROR_ISSUED (expr), 1);
 410       bp_pack_value (bp, EH_LANDING_PAD_NR (expr), HOST_BITS_PER_INT);
 411     }
 412
 413   if (TREE_CODE (expr) == FIELD_DECL)
 414     {
 415       bp_pack_value (bp, DECL_PACKED (expr), 1);
 416       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
 417       bp_pack_value (bp, DECL_OFFSET_ALIGN (expr), 8);
 418     }
 419
 420   if (TREE_CODE (expr) == RESULT_DECL
 421       || TREE_CODE (expr) == PARM_DECL
 422       || TREE_CODE (expr) == VAR_DECL)
 423     {
 424       bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
 425       if (TREE_CODE (expr) == VAR_DECL
 426           || TREE_CODE (expr) == PARM_DECL)
 427         bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
 428       bp_pack_value (bp, DECL_RESTRICTED_P (expr), 1);
 429     }
 430 }
 431
 432
 433 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
 434    of expression EXPR into bitpack BP.  */
 435
 436 static void
 437 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
 438 {
 439   bp_pack_value (bp, DECL_REGISTER (expr), 1);
 440 }
 441
 442
 443 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
 444    of expression EXPR into bitpack BP.  */
 445
 446 static void
 447 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
 448 {
 449   bp_pack_value (bp, DECL_DEFER_OUTPUT (expr), 1);
 450   bp_pack_value (bp, DECL_COMMON (expr), 1);
 451   bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
 452   bp_pack_value (bp, DECL_WEAK (expr), 1);
 453   bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr),  1);
 454   bp_pack_value (bp, DECL_COMDAT (expr),  1);
 455   bp_pack_value (bp, DECL_VISIBILITY (expr),  2);
 456   bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr),  1);
 457
 458   if (TREE_CODE (expr) == VAR_DECL)
 459     {
 460       bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
 461       bp_pack_value (bp, DECL_IN_TEXT_SECTION (expr), 1);
 462       bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
 463       bp_pack_value (bp, DECL_TLS_MODEL (expr),  3);
 464     }
 465
 466   if (VAR_OR_FUNCTION_DECL_P (expr))
 467     bp_pack_value (bp, DECL_INIT_PRIORITY (expr), HOST_BITS_PER_SHORT);
 468 }
 469
 470
 471 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
 472    of expression EXPR into bitpack BP.  */
 473
 474 static void
 475 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
 476 {
 477   /* For normal/md builtins we only write the class and code, so they
 478      should never be handled here.  */
 479   gcc_assert (!lto_stream_as_builtin_p (expr));
 480
 481   bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
 482   bp_pack_value (bp, DECL_BUILT_IN_CLASS (expr), 2);
 483   bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
 484   bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
 485   bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
 486   bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
 487   bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
 488   bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
 489   bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
 490   bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
 491   bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
 492   bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
 493   bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
 494   bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
 495   bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
 496   bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
 497   bp_pack_value (bp, DECL_PURE_P (expr), 1);
 498   bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
 499 }
 500
 501
 502 /* Pack all the non-pointer fields of the TS_TYPE structure
 503    of expression EXPR into bitpack BP.  */
 504
 505 static void
 506 pack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
 507 {
 508   bp_pack_value (bp, TYPE_PRECISION (expr), 10);
 509   bp_pack_value (bp, TYPE_MODE (expr), 8);
 510   bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
 511   bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
 512   bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
 513   if (RECORD_OR_UNION_TYPE_P (expr))
 514     bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
 515   bp_pack_value (bp, TYPE_PACKED (expr), 1);
 516   bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
 517   bp_pack_value (bp, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr), 2);
 518   bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
 519   bp_pack_value (bp, TYPE_READONLY (expr), 1);
 520   bp_pack_value (bp, TYPE_ALIGN (expr), HOST_BITS_PER_INT);
 521   bp_pack_value (bp, TYPE_ALIAS_SET (expr) == 0 ? 0 : -1, HOST_BITS_PER_INT);
 522 }
 523
 524
 525 /* Pack all the non-pointer fields of the TS_BLOCK structure
 526    of expression EXPR into bitpack BP.  */
 527
 528 static void
 529 pack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
 530 {
 531   bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
 532   bp_pack_value (bp, BLOCK_NUMBER (expr), 31);
 533 }
 534
 535 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
 536    of expression EXPR into bitpack BP.  */
 537
 538 static void
 539 pack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
 540 {
 541 }
 542
 543 /* Pack all the non-pointer fields in EXPR into a bit pack.  */
 544
 545 static void
 546 pack_value_fields (struct bitpack_d *bp, tree expr)
 547 {
 548   enum tree_code code;
 549
 550   code = TREE_CODE (expr);
 551
 552   /* Note that all these functions are highly sensitive to changes in
 553      the types and sizes of each of the fields being packed.  */
 554   pack_ts_base_value_fields (bp, expr);
 555
 556   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
 557     pack_ts_real_cst_value_fields (bp, expr);
 558
 559   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
 560     pack_ts_fixed_cst_value_fields (bp, expr);
 561
 562   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 563     pack_ts_decl_common_value_fields (bp, expr);
 564
 565   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
 566     pack_ts_decl_wrtl_value_fields (bp, expr);
 567
 568   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 569     pack_ts_decl_with_vis_value_fields (bp, expr);
 570
 571   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 572     pack_ts_function_decl_value_fields (bp, expr);
 573
 574   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
 575     pack_ts_type_value_fields (bp, expr);
 576
 577   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 578     pack_ts_block_value_fields (bp, expr);
 579
 580   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
 581     {
 582       /* We only stream the version number of SSA names.  */
 583       gcc_unreachable ();
 584     }
 585
 586   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
 587     {
 588       /* This is only used by GENERIC.  */
 589       gcc_unreachable ();
 590     }
 591
 592   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
 593     {
 594       /* This is only used by High GIMPLE.  */
 595       gcc_unreachable ();
 596     }
 597
 598   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 599     pack_ts_translation_unit_decl_value_fields (bp, expr);
 600 }
 601
 602
 603 /* Emit location LOC to output block OB.  */
 604
 605 static void
 606 lto_output_location (struct output_block *ob, location_t loc)
 607 {
 608   expanded_location xloc;
 609
 610   if (loc == UNKNOWN_LOCATION)
 611     {
 612       output_string (ob, ob->main_stream, NULL);
 613       return;
 614     }
 615
 616   xloc = expand_location (loc);
 617
 618   output_string (ob, ob->main_stream, xloc.file);
 619   output_sleb128 (ob, xloc.line);
 620   output_sleb128 (ob, xloc.column);
 621   output_sleb128 (ob, xloc.sysp);
 622
 623   ob->current_file = xloc.file;
 624   ob->current_line = xloc.line;
 625   ob->current_col = xloc.column;
 626 }
 627
 628
 629 /* Return true if tree node T is written to various tables.  For these
 630    nodes, we sometimes want to write their phyiscal representation
 631    (via lto_output_tree), and sometimes we need to emit an index
 632    reference into a table (via lto_output_tree_ref).  */
 633
 634 static bool
 635 tree_is_indexable (tree t)
 636 {
 637   if (TREE_CODE (t) == PARM_DECL)
 638     return false;
 639   else if (TREE_CODE (t) == VAR_DECL && decl_function_context (t)
 640            && !TREE_STATIC (t))
 641     return false;
 642   else
 643     return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME);
 644 }
 645
 646
 647 /* If EXPR is an indexable tree node, output a reference to it to
 648    output block OB.  Otherwise, output the physical representation of
 649    EXPR to OB.  */
 650
 651 static void
 652 lto_output_tree_ref (struct output_block *ob, tree expr)
 653 {
 654   enum tree_code code;
 655
 656   if (expr == NULL_TREE)
 657     {
 658       output_zero (ob);
 659       return;
 660     }
 661
 662   if (!tree_is_indexable (expr))
 663     {
 664       /* Even though we are emitting the physical representation of
 665          EXPR, its leaves must be emitted as references.  */
 666       lto_output_tree (ob, expr, true);
 667       return;
 668     }
 669
 670   if (TYPE_P (expr))
 671     {
 672       output_type_ref (ob, expr);
 673       return;
 674     }
 675
 676   code = TREE_CODE (expr);
 677   switch (code)
 678     {
 679     case SSA_NAME:
 680       output_record_start (ob, LTO_ssa_name_ref);
 681       output_uleb128 (ob, SSA_NAME_VERSION (expr));
 682       break;
 683
 684     case FIELD_DECL:
 685       output_record_start (ob, LTO_field_decl_ref);
 686       lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr);
 687       break;
 688
 689     case FUNCTION_DECL:
 690       output_record_start (ob, LTO_function_decl_ref);
 691       lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr);
 692       break;
 693
 694     case VAR_DECL:
 695     case DEBUG_EXPR_DECL:
 696       gcc_assert (decl_function_context (expr) == NULL
 697                   || TREE_STATIC (expr));
 698       output_record_start (ob, LTO_global_decl_ref);
 699       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
 700       break;
 701
 702     case CONST_DECL:
 703       output_record_start (ob, LTO_const_decl_ref);
 704       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
 705       break;
 706
 707     case IMPORTED_DECL:
 708       gcc_assert (decl_function_context (expr) == NULL);
 709       output_record_start (ob, LTO_imported_decl_ref);
 710       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
 711       break;
 712
 713     case TYPE_DECL:
 714       output_record_start (ob, LTO_type_decl_ref);
 715       lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
 716       break;
 717
 718     case NAMESPACE_DECL:
 719       output_record_start (ob, LTO_namespace_decl_ref);
 720       lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
 721       break;
 722
 723     case LABEL_DECL:
 724       output_record_start (ob, LTO_label_decl_ref);
 725       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
 726       break;
 727
 728     case RESULT_DECL:
 729       output_record_start (ob, LTO_result_decl_ref);
 730       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
 731       break;
 732
 733     case TRANSLATION_UNIT_DECL:
 734       output_record_start (ob, LTO_translation_unit_decl_ref);
 735       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
 736       break;
 737
 738     default:
 739       /* No other node is indexable, so it should have been handled
 740          by lto_output_tree.  */
 741       gcc_unreachable ();
 742     }
 743 }
 744
 745
 746 /* If REF_P is true, emit a reference to EXPR in output block OB,
 747    otherwise emit the physical representation of EXPR in OB.  */
 748
 749 static inline void
 750 lto_output_tree_or_ref (struct output_block *ob, tree expr, bool ref_p)
 751 {
 752   if (ref_p)
 753     lto_output_tree_ref (ob, expr);
 754   else
 755     lto_output_tree (ob, expr, false);
 756 }
 757
 758
 759 /* Emit the chain of tree nodes starting at T.  OB is the output block
 760    to write to.  REF_P is true if chain elements should be emitted
 761    as references.  */
 762
 763 static void
 764 lto_output_chain (struct output_block *ob, tree t, bool ref_p)
 765 {
 766   int i, count;
 767
 768   count = list_length (t);
 769   output_sleb128 (ob, count);
 770   for (i = 0; i < count; i++)
 771     {
 772       tree saved_chain;
 773
 774       /* Clear TREE_CHAIN to avoid blindly recursing into the rest
 775          of the list.  */
 776       saved_chain = TREE_CHAIN (t);
 777       TREE_CHAIN (t) = NULL_TREE;
 778
 779       lto_output_tree_or_ref (ob, t, ref_p);
 780
 781       TREE_CHAIN (t) = saved_chain;
 782       t = TREE_CHAIN (t);
 783     }
 784 }
 785
 786
 787 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
 788    block OB.  If REF_P is true, write a reference to EXPR's pointer
 789    fields.  */
 790
 791 static void
 792 lto_output_ts_common_tree_pointers (struct output_block *ob, tree expr,
 793                                     bool ref_p)
 794 {
 795   if (TREE_CODE (expr) != IDENTIFIER_NODE)
 796     lto_output_tree_or_ref (ob, TREE_TYPE (expr), ref_p);
 797 }
 798
 799
 800 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
 801    block OB.  If REF_P is true, write a reference to EXPR's pointer
 802    fields.  */
 803
 804 static void
 805 lto_output_ts_vector_tree_pointers (struct output_block *ob, tree expr,
 806                                     bool ref_p)
 807 {
 808   lto_output_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
 809 }
 810
 811
 812 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
 813    block OB.  If REF_P is true, write a reference to EXPR's pointer
 814    fields.  */
 815
 816 static void
 817 lto_output_ts_complex_tree_pointers (struct output_block *ob, tree expr,
 818                                      bool ref_p)
 819 {
 820   lto_output_tree_or_ref (ob, TREE_REALPART (expr), ref_p);
 821   lto_output_tree_or_ref (ob, TREE_IMAGPART (expr), ref_p);
 822 }
 823
 824
 825 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
 826    to output block OB.  If REF_P is true, write a reference to EXPR's
 827    pointer fields.  */
 828
 829 static void
 830 lto_output_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
 831                                           bool ref_p)
 832 {
 833   lto_output_tree_or_ref (ob, DECL_NAME (expr), ref_p);
 834   lto_output_tree_or_ref (ob, DECL_CONTEXT (expr), ref_p);
 835   lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
 836 }
 837
 838
 839 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
 840    output block OB.  If REF_P is true, write a reference to EXPR's
 841    pointer fields.  */
 842
 843 static void
 844 lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
 845                                          bool ref_p)
 846 {
 847   lto_output_tree_or_ref (ob, DECL_SIZE (expr), ref_p);
 848   lto_output_tree_or_ref (ob, DECL_SIZE_UNIT (expr), ref_p);
 849
 850   if (TREE_CODE (expr) != FUNCTION_DECL)
 851     {
 852       tree initial = DECL_INITIAL (expr);
 853       if (TREE_CODE (expr) == VAR_DECL
 854           && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
 855           && initial)
 856         {
 857           lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
 858           struct varpool_node *vnode = varpool_get_node (expr);
 859           if (!vnode)
 860             initial = error_mark_node;
 861           else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder,
 862                                                               vnode))
 863             initial = NULL;
 864         }
 865
 866       lto_output_tree_or_ref (ob, initial, ref_p);
 867     }
 868
 869   lto_output_tree_or_ref (ob, DECL_ATTRIBUTES (expr), ref_p);
 870   lto_output_tree_or_ref (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
 871
 872   if (TREE_CODE (expr) == PARM_DECL)
 873     lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
 874
 875   if ((TREE_CODE (expr) == VAR_DECL
 876        || TREE_CODE (expr) == PARM_DECL)
 877       && DECL_HAS_VALUE_EXPR_P (expr))
 878     lto_output_tree_or_ref (ob, DECL_VALUE_EXPR (expr), ref_p);
 879
 880   if (TREE_CODE (expr) == VAR_DECL)
 881     lto_output_tree_or_ref (ob, DECL_DEBUG_EXPR (expr), ref_p);
 882 }
 883
 884
 885 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
 886    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
 887    pointer fields.  */
 888
 889 static void
 890 lto_output_ts_decl_non_common_tree_pointers (struct output_block *ob,
 891                                              tree expr, bool ref_p)
 892 {
 893   if (TREE_CODE (expr) == FUNCTION_DECL)
 894     {
 895       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
 896          At this point, it should not exist.  Either because it was
 897          converted to gimple or because DECL didn't have a GENERIC
 898          representation in this TU.  */
 899       gcc_assert (DECL_SAVED_TREE (expr) == NULL_TREE);
 900       lto_output_tree_or_ref (ob, DECL_ARGUMENTS (expr), ref_p);
 901       lto_output_tree_or_ref (ob, DECL_RESULT (expr), ref_p);
 902     }
 903   lto_output_tree_or_ref (ob, DECL_VINDEX (expr), ref_p);
 904 }
 905
 906
 907 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
 908    to output block OB.  If REF_P is true, write a reference to EXPR's
 909    pointer fields.  */
 910
 911 static void
 912 lto_output_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
 913                                            bool ref_p)
 914 {
 915   /* Make sure we don't inadvertently set the assembler name.  */
 916   if (DECL_ASSEMBLER_NAME_SET_P (expr))
 917     lto_output_tree_or_ref (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
 918   else
 919     output_zero (ob);
 920
 921   lto_output_tree_or_ref (ob, DECL_SECTION_NAME (expr), ref_p);
 922   lto_output_tree_or_ref (ob, DECL_COMDAT_GROUP (expr), ref_p);
 923 }
 924
 925
 926 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
 927    output block OB.  If REF_P is true, write a reference to EXPR's
 928    pointer fields.  */
 929
 930 static void
 931 lto_output_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
 932                                         bool ref_p)
 933 {
 934   lto_output_tree_or_ref (ob, DECL_FIELD_OFFSET (expr), ref_p);
 935   lto_output_tree_or_ref (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
 936   lto_output_tree_or_ref (ob, DECL_QUALIFIER (expr), ref_p);
 937   lto_output_tree_or_ref (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
 938   lto_output_tree_or_ref (ob, DECL_FCONTEXT (expr), ref_p);
 939   lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
 940 }
 941
 942
 943 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
 944    to output block OB.  If REF_P is true, write a reference to EXPR's
 945    pointer fields.  */
 946
 947 static void
 948 lto_output_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
 949                                            bool ref_p)
 950 {
 951   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
 952      maybe it should be handled here?  */
 953   lto_output_tree_or_ref (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
 954   lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
 955   lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr),
 956                           ref_p);
 957 }
 958
 959
 960 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
 961    block OB.  If REF_P is true, write a reference to EXPR's pointer
 962    fields.  */
 963
 964 static void
 965 lto_output_ts_type_tree_pointers (struct output_block *ob, tree expr,
 966                                   bool ref_p)
 967 {
 968   if (TREE_CODE (expr) == ENUMERAL_TYPE)
 969     lto_output_tree_or_ref (ob, TYPE_VALUES (expr), ref_p);
 970   else if (TREE_CODE (expr) == ARRAY_TYPE)
 971     lto_output_tree_or_ref (ob, TYPE_DOMAIN (expr), ref_p);
 972   else if (RECORD_OR_UNION_TYPE_P (expr))
 973     lto_output_tree_or_ref (ob, TYPE_FIELDS (expr), ref_p);
 974   else if (TREE_CODE (expr) == FUNCTION_TYPE
 975            || TREE_CODE (expr) == METHOD_TYPE)
 976     lto_output_tree_or_ref (ob, TYPE_ARG_TYPES (expr), ref_p);
 977
 978   lto_output_tree_or_ref (ob, TYPE_SIZE (expr), ref_p);
 979   lto_output_tree_or_ref (ob, TYPE_SIZE_UNIT (expr), ref_p);
 980   lto_output_tree_or_ref (ob, TYPE_ATTRIBUTES (expr), ref_p);
 981   lto_output_tree_or_ref (ob, TYPE_NAME (expr), ref_p);
 982   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
 983      TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  */
 984   if (!POINTER_TYPE_P (expr))
 985     lto_output_tree_or_ref (ob, TYPE_MINVAL (expr), ref_p);
 986   lto_output_tree_or_ref (ob, TYPE_MAXVAL (expr), ref_p);
 987   lto_output_tree_or_ref (ob, TYPE_MAIN_VARIANT (expr), ref_p);
 988   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
 989      during fixup.  */
 990   if (RECORD_OR_UNION_TYPE_P (expr))
 991     lto_output_tree_or_ref (ob, TYPE_BINFO (expr), ref_p);
 992   lto_output_tree_or_ref (ob, TYPE_CONTEXT (expr), ref_p);
 993   /* TYPE_CANONICAL is re-computed during type merging, so no need
 994      to stream it here.  */
 995   lto_output_tree_or_ref (ob, TYPE_STUB_DECL (expr), ref_p);
 996 }
 997
 998
 999 /* Write all pointer fields in the TS_LIST structure of EXPR to output
1000    block OB.  If REF_P is true, write a reference to EXPR's pointer
1001    fields.  */
1002
1003 static void
1004 lto_output_ts_list_tree_pointers (struct output_block *ob, tree expr,
1005                                   bool ref_p)
1006 {
1007   lto_output_tree_or_ref (ob, TREE_PURPOSE (expr), ref_p);
1008   lto_output_tree_or_ref (ob, TREE_VALUE (expr), ref_p);
1009   lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
1010 }
1011
1012
1013 /* Write all pointer fields in the TS_VEC structure of EXPR to output
1014    block OB.  If REF_P is true, write a reference to EXPR's pointer
1015    fields.  */
1016
1017 static void
1018 lto_output_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1019 {
1020   int i;
1021
1022   /* Note that the number of slots for EXPR has already been emitted
1023      in EXPR's header (see lto_output_tree_header).  */
1024   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
1025     lto_output_tree_or_ref (ob, TREE_VEC_ELT (expr, i), ref_p);
1026 }
1027
1028
1029 /* Write all pointer fields in the TS_EXP structure of EXPR to output
1030    block OB.  If REF_P is true, write a reference to EXPR's pointer
1031    fields.  */
1032
1033 static void
1034 lto_output_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1035 {
1036   int i;
1037
1038   output_sleb128 (ob, TREE_OPERAND_LENGTH (expr));
1039   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
1040     lto_output_tree_or_ref (ob, TREE_OPERAND (expr, i), ref_p);
1041   lto_output_location (ob, EXPR_LOCATION (expr));
1042   lto_output_tree_or_ref (ob, TREE_BLOCK (expr), ref_p);
1043 }
1044
1045
1046 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1047    block OB.  If REF_P is true, write a reference to EXPR's pointer
1048    fields.  */
1049
1050 static void
1051 lto_output_ts_block_tree_pointers (struct output_block *ob, tree expr,
1052                                    bool ref_p)
1053 {
1054   unsigned i;
1055   tree t;
1056
1057   lto_output_location (ob, BLOCK_SOURCE_LOCATION (expr));
1058   /* We do not stream BLOCK_VARS but lazily construct it when reading
1059      in decls.  */
1060
1061   output_uleb128 (ob, VEC_length (tree, BLOCK_NONLOCALIZED_VARS (expr)));
1062   FOR_EACH_VEC_ELT (tree, BLOCK_NONLOCALIZED_VARS (expr), i, t)
1063     {
1064       gcc_assert (DECL_CONTEXT (t) != expr);
1065       lto_output_tree_or_ref (ob, t, ref_p);
1066     }
1067
1068   lto_output_tree_or_ref (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
1069   lto_output_tree_or_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr), ref_p);
1070   lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
1071   lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
1072   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
1073      list is re-constructed from BLOCK_SUPERCONTEXT.  */
1074 }
1075
1076
1077 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1078    block OB.  If REF_P is true, write a reference to EXPR's pointer
1079    fields.  */
1080
1081 static void
1082 lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
1083                                    bool ref_p)
1084 {
1085   unsigned i;
1086   tree t;
1087
1088   /* Note that the number of BINFO slots has already been emitted in
1089      EXPR's header (see lto_output_tree_header) because this length
1090      is needed to build the empty BINFO node on the reader side.  */
1091   FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
1092     lto_output_tree_or_ref (ob, t, ref_p);
1093   output_zero (ob);
1094
1095   lto_output_tree_or_ref (ob, BINFO_OFFSET (expr), ref_p);
1096   lto_output_tree_or_ref (ob, BINFO_VTABLE (expr), ref_p);
1097   lto_output_tree_or_ref (ob, BINFO_VIRTUALS (expr), ref_p);
1098   lto_output_tree_or_ref (ob, BINFO_VPTR_FIELD (expr), ref_p);
1099
1100   output_uleb128 (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
1101   FOR_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
1102     lto_output_tree_or_ref (ob, t, ref_p);
1103
1104   lto_output_tree_or_ref (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
1105   lto_output_tree_or_ref (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
1106   lto_output_tree_or_ref (ob, BINFO_VPTR_INDEX (expr), ref_p);
1107 }
1108
1109
1110 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1111    output block OB.  If REF_P is true, write a reference to EXPR's
1112    pointer fields.  */
1113
1114 static void
1115 lto_output_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
1116                                          bool ref_p)
1117 {
1118   unsigned i;
1119   tree index, value;
1120
1121   output_uleb128 (ob, CONSTRUCTOR_NELTS (expr));
1122   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
1123     {
1124       lto_output_tree_or_ref (ob, index, ref_p);
1125       lto_output_tree_or_ref (ob, value, ref_p);
1126     }
1127 }
1128
1129 /* Write a TS_TARGET_OPTION tree in EXPR to OB.  */
1130
1131 static void
1132 lto_output_ts_target_option (struct output_block *ob, tree expr)
1133 {
1134   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
1135   struct bitpack_d bp;
1136   unsigned i, len;
1137
1138   /* The cl_target_option is target specific and generated by the options
1139      awk script, so we just recreate a byte-by-byte copy here. */
1140
1141   bp = bitpack_create (ob->main_stream);
1142   len = sizeof (struct cl_target_option);
1143   for (i = 0; i < len; i++)
1144     bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
1145   /* Catch struct size mismatches between reader and writer. */
1146   bp_pack_value (&bp, 0x12345678, 32);
1147   lto_output_bitpack (&bp);
1148 }
1149
1150 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB.  */
1151
1152 static void
1153 lto_output_ts_translation_unit_decl_tree_pointers (struct output_block *ob,
1154                                                    tree expr)
1155 {
1156   output_string (ob, ob->main_stream, TRANSLATION_UNIT_LANGUAGE (expr));
1157 }
1158
1159 /* Helper for lto_output_tree.  Write all pointer fields in EXPR to output
1160    block OB.  If REF_P is true, the leaves of EXPR are emitted as
1161    references.  */
1162
1163 static void
1164 lto_output_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1165 {
1166   enum tree_code code;
1167
1168   code = TREE_CODE (expr);
1169
1170   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1171     lto_output_ts_common_tree_pointers (ob, expr, ref_p);
1172
1173   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1174     lto_output_ts_vector_tree_pointers (ob, expr, ref_p);
1175
1176   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1177     lto_output_ts_complex_tree_pointers (ob, expr, ref_p);
1178
1179   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1180     lto_output_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
1181
1182   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1183     lto_output_ts_decl_common_tree_pointers (ob, expr, ref_p);
1184
1185   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
1186     lto_output_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
1187
1188   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1189     lto_output_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
1190
1191   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1192     lto_output_ts_field_decl_tree_pointers (ob, expr, ref_p);
1193
1194   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1195     lto_output_ts_function_decl_tree_pointers (ob, expr, ref_p);
1196
1197   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1198     lto_output_ts_type_tree_pointers (ob, expr, ref_p);
1199
1200   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1201     lto_output_ts_list_tree_pointers (ob, expr, ref_p);
1202
1203   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1204     lto_output_ts_vec_tree_pointers (ob, expr, ref_p);
1205
1206   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1207     lto_output_ts_exp_tree_pointers (ob, expr, ref_p);
1208
1209   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1210     {
1211       /* We only stream the version number of SSA names.  */
1212       gcc_unreachable ();
1213     }
1214
1215   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1216     lto_output_ts_block_tree_pointers (ob, expr, ref_p);
1217
1218   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1219     lto_output_ts_binfo_tree_pointers (ob, expr, ref_p);
1220
1221   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1222     lto_output_ts_constructor_tree_pointers (ob, expr, ref_p);
1223
1224   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1225     {
1226       /* This should only appear in GENERIC.  */
1227       gcc_unreachable ();
1228     }
1229
1230   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1231     {
1232       /* This should only appear in High GIMPLE.  */
1233       gcc_unreachable ();
1234     }
1235
1236   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1237     sorry ("gimple bytecode streams do not support the optimization attribute");
1238
1239   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
1240     lto_output_ts_target_option (ob, expr);
1241
1242   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1243     lto_output_ts_translation_unit_decl_tree_pointers (ob, expr);
1244 }
1245
1246
1247 /* Emit header information for tree EXPR to output block OB.  The header
1248    contains everything needed to instantiate an empty skeleton for
1249    EXPR on the reading side.  IX is the index into the streamer cache
1250    where EXPR is stored.  REF_P is as in lto_output_tree.  */
1251
1252 static void
1253 lto_output_tree_header (struct output_block *ob, tree expr, int ix)
1254 {
1255   enum LTO_tags tag;
1256   enum tree_code code;
1257
1258   /* We should not see any non-GIMPLE tree nodes here.  */
1259   code = TREE_CODE (expr);
1260   if (!lto_is_streamable (expr))
1261     internal_error ("tree code %qs is not supported in gimple streams",
1262                     tree_code_name[code]);
1263
1264   /* The header of a tree node consists of its tag, the size of
1265      the node, and any other information needed to instantiate
1266      EXPR on the reading side (such as the number of slots in
1267      variable sized nodes).  */
1268   tag = lto_tree_code_to_tag (code);
1269   output_record_start (ob, tag);
1270   output_sleb128 (ob, ix);
1271
1272   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
1273 #ifdef LTO_STREAMER_DEBUG
1274   /* This is used mainly for debugging purposes.  When the reader
1275      and the writer do not agree on a streamed node, the pointer
1276      value for EXPR can be used to track down the differences in
1277      the debugger.  */
1278   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
1279   output_sleb128 (ob, (HOST_WIDEST_INT) (intptr_t) expr);
1280 #endif
1281
1282   /* The text in strings and identifiers are completely emitted in
1283      the header.  */
1284   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1285     output_string_cst (ob, ob->main_stream, expr);
1286   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1287     output_identifier (ob, ob->main_stream, expr);
1288   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1289     output_sleb128 (ob, TREE_VEC_LENGTH (expr));
1290   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1291     output_uleb128 (ob, BINFO_N_BASE_BINFOS (expr));
1292 }
1293
1294
1295 /* Write the code and class of builtin EXPR to output block OB.  IX is
1296    the index into the streamer cache where EXPR is stored.*/
1297
1298 static void
1299 lto_output_builtin_tree (struct output_block *ob, tree expr, int ix)
1300 {
1301   gcc_assert (lto_stream_as_builtin_p (expr));
1302
1303   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
1304       && !targetm.builtin_decl)
1305     sorry ("gimple bytecode streams do not support machine specific builtin "
1306            "functions on this target");
1307
1308   output_record_start (ob, LTO_builtin_decl);
1309   output_uleb128 (ob, DECL_BUILT_IN_CLASS (expr));
1310   output_uleb128 (ob, DECL_FUNCTION_CODE (expr));
1311   output_sleb128 (ob, ix);
1312
1313   if (DECL_ASSEMBLER_NAME_SET_P (expr))
1314     {
1315       /* When the assembler name of a builtin gets a user name,
1316          the new name is always prefixed with '*' by
1317          set_builtin_user_assembler_name.  So, to prevent the
1318          reader side from adding a second '*', we omit it here.  */
1319       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
1320       if (strlen (str) > 1 && str[0] == '*')
1321         output_string (ob, ob->main_stream, &str[1]);
1322       else
1323         output_string (ob, ob->main_stream, NULL);
1324     }
1325   else
1326     output_string (ob, ob->main_stream, NULL);
1327 }
1328
1329
1330 /* Write a physical representation of tree node EXPR to output block
1331    OB.  If REF_P is true, the leaves of EXPR are emitted as references
1332    via lto_output_tree_ref.  IX is the index into the streamer cache
1333    where EXPR is stored.  */
1334
1335 static void
1336 lto_write_tree (struct output_block *ob, tree expr, bool ref_p, int ix)
1337 {
1338   struct bitpack_d bp;
1339
1340   /* Write the header, containing everything needed to materialize
1341      EXPR on the reading side.  */
1342   lto_output_tree_header (ob, expr, ix);
1343
1344   /* Pack all the non-pointer fields in EXPR into a bitpack and write
1345      the resulting bitpack.  */
1346   bp = bitpack_create (ob->main_stream);
1347   pack_value_fields (&bp, expr);
1348   lto_output_bitpack (&bp);
1349
1350   /* Write all the pointer fields in EXPR.  */
1351   lto_output_tree_pointers (ob, expr, ref_p);
1352
1353   /* Mark the end of EXPR.  */
1354   output_zero (ob);
1355 }
1356
1357
1358 /* Emit the integer constant CST to output block OB.  If REF_P is true,
1359    CST's type will be emitted as a reference.  */
1360
1361 static void
1362 lto_output_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1363 {
1364   output_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
1365   lto_output_tree_or_ref (ob, TREE_TYPE (cst), ref_p);
1366   lto_output_1_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
1367   output_uleb128 (ob, TREE_INT_CST_LOW (cst));
1368   output_uleb128 (ob, TREE_INT_CST_HIGH (cst));
1369 }
1370
1371
1372 /* Emit the physical representation of tree node EXPR to output block
1373    OB.  If REF_P is true, the leaves of EXPR are emitted as references
1374    via lto_output_tree_ref.  */
1375
1376 void
1377 lto_output_tree (struct output_block *ob, tree expr, bool ref_p)
1378 {
1379   int ix;
1380   bool existed_p;
1381   unsigned offset;
1382
1383   if (expr == NULL_TREE)
1384     {
1385       output_zero (ob);
1386       return;
1387     }
1388
1389   /* INTEGER_CST nodes are special because they need their original type
1390      to be materialized by the reader (to implement TYPE_CACHED_VALUES).  */
1391   if (TREE_CODE (expr) == INTEGER_CST)
1392     {
1393       lto_output_integer_cst (ob, expr, ref_p);
1394       return;
1395     }
1396
1397   /* Determine the offset in the stream where EXPR will be written.
1398      This is used when emitting pickle references so the reader knows
1399      where to reconstruct the pickled object from.  This allows
1400      circular and forward references within the same stream.  */
1401   offset = ob->main_stream->total_size;
1402
1403   existed_p = lto_streamer_cache_insert (ob->writer_cache, expr, &ix, &offset);
1404   if (existed_p)
1405     {
1406       /* If a node has already been streamed out, make sure that
1407          we don't write it more than once.  Otherwise, the reader
1408          will instantiate two different nodes for the same object.  */
1409       output_record_start (ob, LTO_tree_pickle_reference);
1410       output_sleb128 (ob, ix);
1411       output_uleb128 (ob, lto_tree_code_to_tag (TREE_CODE (expr)));
1412       output_uleb128 (ob, offset);
1413     }
1414   else if (lto_stream_as_builtin_p (expr))
1415     {
1416       /* MD and NORMAL builtins do not need to be written out
1417          completely as they are always instantiated by the
1418          compiler on startup.  The only builtins that need to
1419          be written out are BUILT_IN_FRONTEND.  For all other
1420          builtins, we simply write the class and code.  */
1421       lto_output_builtin_tree (ob, expr, ix);
1422     }
1423   else
1424     {
1425       /* This is the first time we see EXPR, write its fields
1426          to OB.  */
1427       lto_write_tree (ob, expr, ref_p, ix);
1428     }
1429 }
1430
1431
1432 /* Output to OB a list of try/catch handlers starting with FIRST.  */
1433
1434 static void
1435 output_eh_try_list (struct output_block *ob, eh_catch first)
1436 {
1437   eh_catch n;
1438
1439   for (n = first; n; n = n->next_catch)
1440     {
1441       output_record_start (ob, LTO_eh_catch);
1442       lto_output_tree_ref (ob, n->type_list);
1443       lto_output_tree_ref (ob, n->filter_list);
1444       lto_output_tree_ref (ob, n->label);
1445     }
1446
1447   output_zero (ob);
1448 }
1449
1450
1451 /* Output EH region R in function FN to OB.  CURR_RN is the slot index
1452    that is being emitted in FN->EH->REGION_ARRAY.  This is used to
1453    detect EH region sharing.  */
1454
1455 static void
1456 output_eh_region (struct output_block *ob, eh_region r)
1457 {
1458   enum LTO_tags tag;
1459
1460   if (r == NULL)
1461     {
1462       output_zero (ob);
1463       return;
1464     }
1465
1466   if (r->type == ERT_CLEANUP)
1467     tag = LTO_ert_cleanup;
1468   else if (r->type == ERT_TRY)
1469     tag = LTO_ert_try;
1470   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1471     tag = LTO_ert_allowed_exceptions;
1472   else if (r->type == ERT_MUST_NOT_THROW)
1473     tag = LTO_ert_must_not_throw;
1474   else
1475     gcc_unreachable ();
1476
1477   output_record_start (ob, tag);
1478   output_sleb128 (ob, r->index);
1479
1480   if (r->outer)
1481     output_sleb128 (ob, r->outer->index);
1482   else
1483     output_zero (ob);
1484
1485   if (r->inner)
1486     output_sleb128 (ob, r->inner->index);
1487   else
1488     output_zero (ob);
1489
1490   if (r->next_peer)
1491     output_sleb128 (ob, r->next_peer->index);
1492   else
1493     output_zero (ob);
1494
1495   if (r->type == ERT_TRY)
1496     {
1497       output_eh_try_list (ob, r->u.eh_try.first_catch);
1498     }
1499   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1500     {
1501       lto_output_tree_ref (ob, r->u.allowed.type_list);
1502       lto_output_tree_ref (ob, r->u.allowed.label);
1503       output_uleb128 (ob, r->u.allowed.filter);
1504     }
1505   else if (r->type == ERT_MUST_NOT_THROW)
1506     {
1507       lto_output_tree_ref (ob, r->u.must_not_throw.failure_decl);
1508       lto_output_location (ob, r->u.must_not_throw.failure_loc);
1509     }
1510
1511   if (r->landing_pads)
1512     output_sleb128 (ob, r->landing_pads->index);
1513   else
1514     output_zero (ob);
1515 }
1516
1517
1518 /* Output landing pad LP to OB.  */
1519
1520 static void
1521 output_eh_lp (struct output_block *ob, eh_landing_pad lp)
1522 {
1523   if (lp == NULL)
1524     {
1525       output_zero (ob);
1526       return;
1527     }
1528
1529   output_record_start (ob, LTO_eh_landing_pad);
1530   output_sleb128 (ob, lp->index);
1531   if (lp->next_lp)
1532     output_sleb128 (ob, lp->next_lp->index);
1533   else
1534     output_zero (ob);
1535
1536   if (lp->region)
1537     output_sleb128 (ob, lp->region->index);
1538   else
1539     output_zero (ob);
1540
1541   lto_output_tree_ref (ob, lp->post_landing_pad);
1542 }
1543
1544
1545 /* Output the existing eh_table to OB.  */
1546
1547 static void
1548 output_eh_regions (struct output_block *ob, struct function *fn)
1549 {
1550   if (fn->eh && fn->eh->region_tree)
1551     {
1552       unsigned i;
1553       eh_region eh;
1554       eh_landing_pad lp;
1555       tree ttype;
1556
1557       output_record_start (ob, LTO_eh_table);
1558
1559       /* Emit the index of the root of the EH region tree.  */
1560       output_sleb128 (ob, fn->eh->region_tree->index);
1561
1562       /* Emit all the EH regions in the region array.  */
1563       output_sleb128 (ob, VEC_length (eh_region, fn->eh->region_array));
1564       FOR_EACH_VEC_ELT (eh_region, fn->eh->region_array, i, eh)
1565         output_eh_region (ob, eh);
1566
1567       /* Emit all landing pads.  */
1568       output_sleb128 (ob, VEC_length (eh_landing_pad, fn->eh->lp_array));
1569       FOR_EACH_VEC_ELT (eh_landing_pad, fn->eh->lp_array, i, lp)
1570         output_eh_lp (ob, lp);
1571
1572       /* Emit all the runtime type data.  */
1573       output_sleb128 (ob, VEC_length (tree, fn->eh->ttype_data));
1574       FOR_EACH_VEC_ELT (tree, fn->eh->ttype_data, i, ttype)
1575         lto_output_tree_ref (ob, ttype);
1576
1577       /* Emit the table of action chains.  */
1578       if (targetm.arm_eabi_unwinder)
1579         {
1580           tree t;
1581           output_sleb128 (ob, VEC_length (tree, fn->eh->ehspec_data.arm_eabi));
1582           FOR_EACH_VEC_ELT (tree, fn->eh->ehspec_data.arm_eabi, i, t)
1583             lto_output_tree_ref (ob, t);
1584         }
1585       else
1586         {
1587           uchar c;
1588           output_sleb128 (ob, VEC_length (uchar, fn->eh->ehspec_data.other));
1589           FOR_EACH_VEC_ELT (uchar, fn->eh->ehspec_data.other, i, c)
1590             lto_output_1_stream (ob->main_stream, c);
1591         }
1592     }
1593
1594   /* The 0 either terminates the record or indicates that there are no
1595      eh_records at all.  */
1596   output_zero (ob);
1597 }
1598
1599
1600 /* Output all of the active ssa names to the ssa_names stream.  */
1601
1602 static void
1603 output_ssa_names (struct output_block *ob, struct function *fn)
1604 {
1605   unsigned int i, len;
1606
1607   len = VEC_length (tree, SSANAMES (fn));
1608   output_uleb128 (ob, len);
1609
1610   for (i = 1; i < len; i++)
1611     {
1612       tree ptr = VEC_index (tree, SSANAMES (fn), i);
1613
1614       if (ptr == NULL_TREE
1615           || SSA_NAME_IN_FREE_LIST (ptr)
1616           || !is_gimple_reg (ptr))
1617         continue;
1618
1619       output_uleb128 (ob, i);
1620       lto_output_1_stream (ob->main_stream, SSA_NAME_IS_DEFAULT_DEF (ptr));
1621       lto_output_tree_ref (ob, SSA_NAME_VAR (ptr));
1622     }
1623
1624   output_zero (ob);
1625 }
1626
1627
1628 /* Output the cfg.  */
1629
1630 static void
1631 output_cfg (struct output_block *ob, struct function *fn)
1632 {
1633   struct lto_output_stream *tmp_stream = ob->main_stream;
1634   basic_block bb;
1635
1636   ob->main_stream = ob->cfg_stream;
1637
1638   output_uleb128 (ob, profile_status_for_function (fn));
1639
1640   /* Output the number of the highest basic block.  */
1641   output_uleb128 (ob, last_basic_block_for_function (fn));
1642
1643   FOR_ALL_BB_FN (bb, fn)
1644     {
1645       edge_iterator ei;
1646       edge e;
1647
1648       output_sleb128 (ob, bb->index);
1649
1650       /* Output the successors and the edge flags.  */
1651       output_uleb128 (ob, EDGE_COUNT (bb->succs));
1652       FOR_EACH_EDGE (e, ei, bb->succs)
1653         {
1654           output_uleb128 (ob, e->dest->index);
1655           output_sleb128 (ob, e->probability);
1656           output_sleb128 (ob, e->count);
1657           output_uleb128 (ob, e->flags);
1658         }
1659     }
1660
1661   output_sleb128 (ob, -1);
1662
1663   bb = ENTRY_BLOCK_PTR;
1664   while (bb->next_bb)
1665     {
1666       output_sleb128 (ob, bb->next_bb->index);
1667       bb = bb->next_bb;
1668     }
1669
1670   output_sleb128 (ob, -1);
1671
1672   ob->main_stream = tmp_stream;
1673 }
1674
1675
1676 /* Output PHI function PHI to the main stream in OB.  */
1677
1678 static void
1679 output_phi (struct output_block *ob, gimple phi)
1680 {
1681   unsigned i, len = gimple_phi_num_args (phi);
1682
1683   output_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI));
1684   output_uleb128 (ob, SSA_NAME_VERSION (PHI_RESULT (phi)));
1685
1686   for (i = 0; i < len; i++)
1687     {
1688       lto_output_tree_ref (ob, gimple_phi_arg_def (phi, i));
1689       output_uleb128 (ob, gimple_phi_arg_edge (phi, i)->src->index);
1690       lto_output_location (ob, gimple_phi_arg_location (phi, i));
1691     }
1692 }
1693
1694
1695 /* Emit statement STMT on the main stream of output block OB.  */
1696
1697 static void
1698 output_gimple_stmt (struct output_block *ob, gimple stmt)
1699 {
1700   unsigned i;
1701   enum gimple_code code;
1702   enum LTO_tags tag;
1703   struct bitpack_d bp;
1704
1705   /* Emit identifying tag.  */
1706   code = gimple_code (stmt);
1707   tag = lto_gimple_code_to_tag (code);
1708   output_record_start (ob, tag);
1709
1710   /* Emit the tuple header.  */
1711   bp = bitpack_create (ob->main_stream);
1712   bp_pack_value (&bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
1713   bp_pack_value (&bp, gimple_no_warning_p (stmt), 1);
1714   if (is_gimple_assign (stmt))
1715     bp_pack_value (&bp, gimple_assign_nontemporal_move_p (stmt), 1);
1716   bp_pack_value (&bp, gimple_has_volatile_ops (stmt), 1);
1717   bp_pack_value (&bp, stmt->gsbase.subcode, 16);
1718   lto_output_bitpack (&bp);
1719
1720   /* Emit location information for the statement.  */
1721   lto_output_location (ob, gimple_location (stmt));
1722
1723   /* Emit the lexical block holding STMT.  */
1724   lto_output_tree (ob, gimple_block (stmt), true);
1725
1726   /* Emit the operands.  */
1727   switch (gimple_code (stmt))
1728     {
1729     case GIMPLE_RESX:
1730       output_sleb128 (ob, gimple_resx_region (stmt));
1731       break;
1732
1733     case GIMPLE_EH_MUST_NOT_THROW:
1734       lto_output_tree_ref (ob, gimple_eh_must_not_throw_fndecl (stmt));
1735       break;
1736
1737     case GIMPLE_EH_DISPATCH:
1738       output_sleb128 (ob, gimple_eh_dispatch_region (stmt));
1739       break;
1740
1741     case GIMPLE_ASM:
1742       lto_output_uleb128_stream (ob->main_stream, gimple_asm_ninputs (stmt));
1743       lto_output_uleb128_stream (ob->main_stream, gimple_asm_noutputs (stmt));
1744       lto_output_uleb128_stream (ob->main_stream, gimple_asm_nclobbers (stmt));
1745       lto_output_uleb128_stream (ob->main_stream, gimple_asm_nlabels (stmt));
1746       output_string (ob, ob->main_stream, gimple_asm_string (stmt));
1747       /* Fallthru  */
1748
1749     case GIMPLE_ASSIGN:
1750     case GIMPLE_CALL:
1751     case GIMPLE_RETURN:
1752     case GIMPLE_SWITCH:
1753     case GIMPLE_LABEL:
1754     case GIMPLE_COND:
1755     case GIMPLE_GOTO:
1756     case GIMPLE_DEBUG:
1757       for (i = 0; i < gimple_num_ops (stmt); i++)
1758         {
1759           tree op = gimple_op (stmt, i);
1760           /* Wrap all uses of non-automatic variables inside MEM_REFs
1761              so that we do not have to deal with type mismatches on
1762              merged symbols during IL read in.  The first operand
1763              of GIMPLE_DEBUG must be a decl, not MEM_REF, though.  */
1764           if (op && (i || !is_gimple_debug (stmt)))
1765             {
1766               tree *basep = &op;
1767               while (handled_component_p (*basep))
1768                 basep = &TREE_OPERAND (*basep, 0);
1769               if (TREE_CODE (*basep) == VAR_DECL
1770                   && !auto_var_in_fn_p (*basep, current_function_decl))
1771                 {
1772                   bool volatilep = TREE_THIS_VOLATILE (*basep);
1773                   *basep = build2 (MEM_REF, TREE_TYPE (*basep),
1774                                    build_fold_addr_expr (*basep),
1775                                    build_int_cst (build_pointer_type
1776                                                   (TREE_TYPE (*basep)), 0));
1777                   TREE_THIS_VOLATILE (*basep) = volatilep;
1778                 }
1779             }
1780           lto_output_tree_ref (ob, op);
1781         }
1782       break;
1783
1784     case GIMPLE_NOP:
1785     case GIMPLE_PREDICT:
1786       break;
1787
1788     default:
1789       gcc_unreachable ();
1790     }
1791 }
1792
1793
1794 /* Output a basic block BB to the main stream in OB for this FN.  */
1795
1796 static void
1797 output_bb (struct output_block *ob, basic_block bb, struct function *fn)
1798 {
1799   gimple_stmt_iterator bsi = gsi_start_bb (bb);
1800
1801   output_record_start (ob,
1802                        (!gsi_end_p (bsi)) || phi_nodes (bb)
1803                         ? LTO_bb1
1804                         : LTO_bb0);
1805
1806   output_uleb128 (ob, bb->index);
1807   output_sleb128 (ob, bb->count);
1808   output_sleb128 (ob, bb->loop_depth);
1809   output_sleb128 (ob, bb->frequency);
1810   output_sleb128 (ob, bb->flags);
1811
1812   if (!gsi_end_p (bsi) || phi_nodes (bb))
1813     {
1814       /* Output the statements.  The list of statements is terminated
1815          with a zero.  */
1816       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1817         {
1818           int region;
1819           gimple stmt = gsi_stmt (bsi);
1820
1821           output_gimple_stmt (ob, stmt);
1822
1823           /* Emit the EH region holding STMT.  */
1824           region = lookup_stmt_eh_lp_fn (fn, stmt);
1825           if (region != 0)
1826             {
1827               output_record_start (ob, LTO_eh_region);
1828               output_sleb128 (ob, region);
1829             }
1830           else
1831             output_zero (ob);
1832         }
1833
1834       output_zero (ob);
1835
1836       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1837         {
1838           gimple phi = gsi_stmt (bsi);
1839
1840           /* Only emit PHIs for gimple registers.  PHI nodes for .MEM
1841              will be filled in on reading when the SSA form is
1842              updated.  */
1843           if (is_gimple_reg (gimple_phi_result (phi)))
1844             output_phi (ob, phi);
1845         }
1846
1847       output_zero (ob);
1848     }
1849 }
1850
1851 /* Create the header in the file using OB.  If the section type is for
1852    a function, set FN to the decl for that function.  */
1853
1854 void
1855 produce_asm (struct output_block *ob, tree fn)
1856 {
1857   enum lto_section_type section_type = ob->section_type;
1858   struct lto_function_header header;
1859   char *section_name;
1860   struct lto_output_stream *header_stream;
1861
1862   if (section_type == LTO_section_function_body)
1863     {
1864       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
1865       section_name = lto_get_section_name (section_type, name, NULL);
1866     }
1867   else
1868     section_name = lto_get_section_name (section_type, NULL, NULL);
1869
1870   lto_begin_section (section_name, !flag_wpa);
1871   free (section_name);
1872
1873   /* The entire header is stream computed here.  */
1874   memset (&header, 0, sizeof (struct lto_function_header));
1875
1876   /* Write the header.  */
1877   header.lto_header.major_version = LTO_major_version;
1878   header.lto_header.minor_version = LTO_minor_version;
1879   header.lto_header.section_type = section_type;
1880
1881   header.compressed_size = 0;
1882
1883   if (section_type == LTO_section_function_body)
1884     header.cfg_size = ob->cfg_stream->total_size;
1885   header.main_size = ob->main_stream->total_size;
1886   header.string_size = ob->string_stream->total_size;
1887
1888   header_stream = XCNEW (struct lto_output_stream);
1889   lto_output_data_stream (header_stream, &header, sizeof header);
1890   lto_write_stream (header_stream);
1891   free (header_stream);
1892
1893   /* Put all of the gimple and the string table out the asm file as a
1894      block of text.  */
1895   if (section_type == LTO_section_function_body)
1896     lto_write_stream (ob->cfg_stream);
1897   lto_write_stream (ob->main_stream);
1898   lto_write_stream (ob->string_stream);
1899
1900   lto_end_section ();
1901 }
1902
1903
1904 /* Output the body of function NODE->DECL.  */
1905
1906 static void
1907 output_function (struct cgraph_node *node)
1908 {
1909   struct bitpack_d bp;
1910   tree function;
1911   struct function *fn;
1912   basic_block bb;
1913   struct output_block *ob;
1914   unsigned i;
1915   tree t;
1916
1917   function = node->decl;
1918   fn = DECL_STRUCT_FUNCTION (function);
1919   ob = create_output_block (LTO_section_function_body);
1920
1921   clear_line_info (ob);
1922   ob->cgraph_node = node;
1923
1924   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
1925
1926   /* Set current_function_decl and cfun.  */
1927   current_function_decl = function;
1928   push_cfun (fn);
1929
1930   /* Make string 0 be a NULL string.  */
1931   lto_output_1_stream (ob->string_stream, 0);
1932
1933   output_record_start (ob, LTO_function);
1934
1935   /* Write all the attributes for FN.  */
1936   bp = bitpack_create (ob->main_stream);
1937   bp_pack_value (&bp, fn->is_thunk, 1);
1938   bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1);
1939   bp_pack_value (&bp, fn->after_tree_profile, 1);
1940   bp_pack_value (&bp, fn->returns_pcc_struct, 1);
1941   bp_pack_value (&bp, fn->returns_struct, 1);
1942   bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
1943   bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
1944   bp_pack_value (&bp, fn->after_inlining, 1);
1945   bp_pack_value (&bp, fn->dont_save_pending_sizes_p, 1);
1946   bp_pack_value (&bp, fn->stdarg, 1);
1947   bp_pack_value (&bp, fn->has_nonlocal_label, 1);
1948   bp_pack_value (&bp, fn->calls_alloca, 1);
1949   bp_pack_value (&bp, fn->calls_setjmp, 1);
1950   bp_pack_value (&bp, fn->va_list_fpr_size, 8);
1951   bp_pack_value (&bp, fn->va_list_gpr_size, 8);
1952   lto_output_bitpack (&bp);
1953
1954   /* Output the function start and end loci.  */
1955   lto_output_location (ob, fn->function_start_locus);
1956   lto_output_location (ob, fn->function_end_locus);
1957
1958   /* Output current IL state of the function.  */
1959   output_uleb128 (ob, fn->curr_properties);
1960
1961   /* Output the static chain and non-local goto save area.  */
1962   lto_output_tree_ref (ob, fn->static_chain_decl);
1963   lto_output_tree_ref (ob, fn->nonlocal_goto_save_area);
1964
1965   /* Output all the local variables in the function.  */
1966   output_sleb128 (ob, VEC_length (tree, fn->local_decls));
1967   FOR_EACH_VEC_ELT (tree, fn->local_decls, i, t)
1968     lto_output_tree_ref (ob, t);
1969
1970   /* Output the head of the arguments list.  */
1971   lto_output_tree_ref (ob, DECL_ARGUMENTS (function));
1972
1973   /* Output all the SSA names used in the function.  */
1974   output_ssa_names (ob, fn);
1975
1976   /* Output any exception handling regions.  */
1977   output_eh_regions (ob, fn);
1978
1979   /* Output DECL_INITIAL for the function, which contains the tree of
1980      lexical scopes.  */
1981   lto_output_tree (ob, DECL_INITIAL (function), true);
1982
1983   /* We will renumber the statements.  The code that does this uses
1984      the same ordering that we use for serializing them so we can use
1985      the same code on the other end and not have to write out the
1986      statement numbers.  */
1987   renumber_gimple_stmt_uids ();
1988
1989   /* Output the code for the function.  */
1990   FOR_ALL_BB_FN (bb, fn)
1991     output_bb (ob, bb, fn);
1992
1993   /* The terminator for this function.  */
1994   output_zero (ob);
1995
1996   output_cfg (ob, fn);
1997
1998   /* Create a section to hold the pickled output of this function.   */
1999   produce_asm (ob, function);
2000
2001   destroy_output_block (ob);
2002
2003   current_function_decl = NULL;
2004   pop_cfun ();
2005 }
2006
2007
2008 /* Return true if alias pair P belongs to the set of cgraph nodes in
2009    SET.  If P is a an alias for a VAR_DECL, it can always be emitted.
2010    However, for FUNCTION_DECL aliases, we should only output the pair
2011    if it belongs to a function whose cgraph node is in SET.
2012    Otherwise, the LTRANS phase will get into trouble when finalizing
2013    aliases because the alias will refer to a function not defined in
2014    the file processed by LTRANS.  */
2015
2016 static bool
2017 output_alias_pair_p (alias_pair *p, cgraph_node_set set, varpool_node_set vset)
2018 {
2019   if (TREE_CODE (p->decl) == VAR_DECL)
2020     return varpool_node_in_set_p (varpool_node_for_asm (p->target), vset);
2021
2022   /* Check if the assembler name for P->TARGET has its cgraph node in SET.  */
2023   gcc_assert (TREE_CODE (p->decl) == FUNCTION_DECL);
2024   return cgraph_node_in_set_p (cgraph_node_for_asm (p->target), set);
2025 }
2026
2027
2028 /* Output any unreferenced global symbol defined in SET, alias pairs
2029    and labels.  */
2030
2031 static void
2032 output_unreferenced_globals (cgraph_node_set set, varpool_node_set vset)
2033 {
2034   struct output_block *ob;
2035   alias_pair *p;
2036   unsigned i;
2037   struct varpool_node *vnode;
2038
2039   ob = create_output_block (LTO_section_static_initializer);
2040   ob->cgraph_node = NULL;
2041
2042   clear_line_info (ob);
2043
2044   /* Make string 0 be a NULL string.  */
2045   lto_output_1_stream (ob->string_stream, 0);
2046
2047   /* Emit references for all the global symbols.  If a global symbol
2048      was never referenced in any of the functions of this file, it
2049      would not be emitted otherwise.  This will result in unreferenced
2050      symbols at link time if a file defines a global symbol but
2051      never references it.  */
2052   FOR_EACH_STATIC_VARIABLE (vnode)
2053    if (vnode->needed && varpool_node_in_set_p (vnode, vset))
2054       {
2055         tree var = vnode->decl;
2056
2057         if (TREE_CODE (var) == VAR_DECL)
2058           {
2059             /* Output the object in order to output references used in the
2060                initialization. */
2061             lto_output_tree (ob, var, true);
2062
2063             /* If it is public we also need a reference to the object itself. */
2064             if (TREE_PUBLIC (var))
2065               lto_output_tree_ref (ob, var);
2066           }
2067       }
2068
2069   output_zero (ob);
2070
2071   /* Emit the alias pairs for the nodes in SET.  */
2072   FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
2073     {
2074       if (output_alias_pair_p (p, set, vset))
2075         {
2076           lto_output_tree_ref (ob, p->decl);
2077           lto_output_tree_ref (ob, p->target);
2078         }
2079     }
2080
2081   output_zero (ob);
2082
2083   produce_asm (ob, NULL);
2084   destroy_output_block (ob);
2085 }
2086
2087
2088 /* Copy the function body of NODE without deserializing. */
2089
2090 static void
2091 copy_function (struct cgraph_node *node)
2092 {
2093   tree function = node->decl;
2094   struct lto_file_decl_data *file_data = node->local.lto_file_data;
2095   struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
2096   const char *data;
2097   size_t len;
2098   const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
2099   char *section_name =
2100     lto_get_section_name (LTO_section_function_body, name, NULL);
2101   size_t i, j;
2102   struct lto_in_decl_state *in_state;
2103   struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2104
2105   lto_begin_section (section_name, !flag_wpa);
2106   free (section_name);
2107
2108   /* We may have renamed the declaration, e.g., a static function.  */
2109   name = lto_get_decl_name_mapping (file_data, name);
2110
2111   data = lto_get_section_data (file_data, LTO_section_function_body,
2112                                name, &len);
2113   gcc_assert (data);
2114
2115   /* Do a bit copy of the function body.  */
2116   lto_output_data_stream (output_stream, data, len);
2117   lto_write_stream (output_stream);
2118
2119   /* Copy decls. */
2120   in_state =
2121     lto_get_function_in_decl_state (node->local.lto_file_data, function);
2122   gcc_assert (in_state);
2123
2124   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2125     {
2126       size_t n = in_state->streams[i].size;
2127       tree *trees = in_state->streams[i].trees;
2128       struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2129
2130       /* The out state must have the same indices and the in state.
2131          So just copy the vector.  All the encoders in the in state
2132          must be empty where we reach here. */
2133       gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2134       for (j = 0; j < n; j++)
2135         VEC_safe_push (tree, heap, encoder->trees, trees[j]);
2136       encoder->next_index = n;
2137     }
2138
2139   lto_free_section_data (file_data, LTO_section_function_body, name,
2140                          data, len);
2141   free (output_stream);
2142   lto_end_section ();
2143 }
2144
2145
2146 /* Initialize the LTO writer.  */
2147
2148 static void
2149 lto_writer_init (void)
2150 {
2151   lto_streamer_init ();
2152 }
2153
2154
2155 /* Main entry point from the pass manager.  */
2156
2157 static void
2158 lto_output (cgraph_node_set set, varpool_node_set vset)
2159 {
2160   struct cgraph_node *node;
2161   struct lto_out_decl_state *decl_state;
2162 #ifdef ENABLE_CHECKING
2163   bitmap output = lto_bitmap_alloc ();
2164 #endif
2165   int i, n_nodes;
2166   lto_cgraph_encoder_t encoder = lto_get_out_decl_state ()->cgraph_node_encoder;
2167
2168   lto_writer_init ();
2169
2170   n_nodes = lto_cgraph_encoder_size (encoder);
2171   /* Process only the functions with bodies.  */
2172   for (i = 0; i < n_nodes; i++)
2173     {
2174       node = lto_cgraph_encoder_deref (encoder, i);
2175       if (lto_cgraph_encoder_encode_body_p (encoder, node))
2176         {
2177 #ifdef ENABLE_CHECKING
2178           gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
2179           bitmap_set_bit (output, DECL_UID (node->decl));
2180 #endif
2181           decl_state = lto_new_out_decl_state ();
2182           lto_push_out_decl_state (decl_state);
2183           if (gimple_has_body_p (node->decl))
2184             output_function (node);
2185           else
2186             copy_function (node);
2187           gcc_assert (lto_get_out_decl_state () == decl_state);
2188           lto_pop_out_decl_state ();
2189           lto_record_function_out_decl_state (node->decl, decl_state);
2190         }
2191     }
2192
2193   /* Emit the callgraph after emitting function bodies.  This needs to
2194      be done now to make sure that all the statements in every function
2195      have been renumbered so that edges can be associated with call
2196      statements using the statement UIDs.  */
2197   output_cgraph (set, vset);
2198
2199 #ifdef ENABLE_CHECKING
2200   lto_bitmap_free (output);
2201 #endif
2202 }
2203
2204 struct ipa_opt_pass_d pass_ipa_lto_gimple_out =
2205 {
2206  {
2207   IPA_PASS,
2208   "lto_gimple_out",                     /* name */
2209   gate_lto_out,                         /* gate */
2210   NULL,                                 /* execute */
2211   NULL,                                 /* sub */
2212   NULL,                                 /* next */
2213   0,                                    /* static_pass_number */
2214   TV_IPA_LTO_GIMPLE_OUT,                        /* tv_id */
2215   0,                                    /* properties_required */
2216   0,                                    /* properties_provided */
2217   0,                                    /* properties_destroyed */
2218   0,                                    /* todo_flags_start */
2219   TODO_dump_func                        /* todo_flags_finish */
2220  },
2221  NULL,                                  /* generate_summary */
2222  lto_output,                            /* write_summary */
2223  NULL,                                  /* read_summary */
2224  lto_output,                            /* write_optimization_summary */
2225  NULL,                                  /* read_optimization_summary */
2226  NULL,                                  /* stmt_fixup */
2227  0,                                     /* TODOs */
2228  NULL,                                  /* function_transform */
2229  NULL                                   /* variable_transform */
2230 };
2231
2232
2233 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2234    from it and required for correct representation of its semantics.
2235    Each node in ENCODER must be a global declaration or a type.  A node
2236    is written only once, even if it appears multiple times in the
2237    vector.  Certain transitively-reachable nodes, such as those
2238    representing expressions, may be duplicated, but such nodes
2239    must not appear in ENCODER itself.  */
2240
2241 static void
2242 write_global_stream (struct output_block *ob,
2243                      struct lto_tree_ref_encoder *encoder)
2244 {
2245   tree t;
2246   size_t index;
2247   const size_t size = lto_tree_ref_encoder_size (encoder);
2248
2249   for (index = 0; index < size; index++)
2250     {
2251       t = lto_tree_ref_encoder_get_tree (encoder, index);
2252       if (!lto_streamer_cache_lookup (ob->writer_cache, t, NULL))
2253         lto_output_tree (ob, t, false);
2254     }
2255 }
2256
2257
2258 /* Write a sequence of indices into the globals vector corresponding
2259    to the trees in ENCODER.  These are used by the reader to map the
2260    indices used to refer to global entities within function bodies to
2261    their referents.  */
2262
2263 static void
2264 write_global_references (struct output_block *ob,
2265                          struct lto_output_stream *ref_stream,
2266                          struct lto_tree_ref_encoder *encoder)
2267 {
2268   tree t;
2269   int32_t index;
2270   const int32_t size = lto_tree_ref_encoder_size (encoder);
2271
2272   /* Write size as 32-bit unsigned. */
2273   lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
2274
2275   for (index = 0; index < size; index++)
2276     {
2277       int32_t slot_num;
2278
2279       t = lto_tree_ref_encoder_get_tree (encoder, index);
2280       lto_streamer_cache_lookup (ob->writer_cache, t, &slot_num);
2281       gcc_assert (slot_num >= 0);
2282       lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
2283     }
2284 }
2285
2286
2287 /* Write all the streams in an lto_out_decl_state STATE using
2288    output block OB and output stream OUT_STREAM.  */
2289
2290 static void
2291 lto_output_decl_state_streams (struct output_block *ob,
2292                                struct lto_out_decl_state *state)
2293 {
2294   int i;
2295
2296   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2297     write_global_stream (ob, &state->streams[i]);
2298 }
2299
2300
2301 /* Write all the references in an lto_out_decl_state STATE using
2302    output block OB and output stream OUT_STREAM.  */
2303
2304 static void
2305 lto_output_decl_state_refs (struct output_block *ob,
2306                             struct lto_output_stream *out_stream,
2307                             struct lto_out_decl_state *state)
2308 {
2309   unsigned i;
2310   int32_t ref;
2311   tree decl;
2312
2313   /* Write reference to FUNCTION_DECL.  If there is not function,
2314      write reference to void_type_node. */
2315   decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2316   lto_streamer_cache_lookup (ob->writer_cache, decl, &ref);
2317   gcc_assert (ref >= 0);
2318   lto_output_data_stream (out_stream, &ref, sizeof (int32_t));
2319
2320   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2321     write_global_references (ob, out_stream, &state->streams[i]);
2322 }
2323
2324
2325 /* Return the written size of STATE. */
2326
2327 static size_t
2328 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2329 {
2330   int i;
2331   size_t size;
2332
2333   size = sizeof (int32_t);      /* fn_ref. */
2334   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2335     {
2336       size += sizeof (int32_t); /* vector size. */
2337       size += (lto_tree_ref_encoder_size (&state->streams[i])
2338                * sizeof (int32_t));
2339     }
2340   return size;
2341 }
2342
2343
2344 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2345    so far.  */
2346
2347 static void
2348 write_symbol (struct lto_streamer_cache_d *cache,
2349               struct lto_output_stream *stream,
2350               tree t, struct pointer_set_t *seen, bool alias)
2351 {
2352   const char *name;
2353   enum gcc_plugin_symbol_kind kind;
2354   enum gcc_plugin_symbol_visibility visibility;
2355   int slot_num;
2356   uint64_t size;
2357   const char *comdat;
2358
2359   /* None of the following kinds of symbols are needed in the
2360      symbol table.  */
2361   if (!TREE_PUBLIC (t)
2362       || is_builtin_fn (t)
2363       || DECL_ABSTRACT (t)
2364       || TREE_CODE (t) == RESULT_DECL)
2365     return;
2366
2367   gcc_assert (TREE_CODE (t) == VAR_DECL
2368               || TREE_CODE (t) == FUNCTION_DECL);
2369
2370   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2371
2372   /* This behaves like assemble_name_raw in varasm.c, performing the
2373      same name manipulations that ASM_OUTPUT_LABELREF does. */
2374   name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name));
2375
2376   if (pointer_set_contains (seen, name))
2377     return;
2378   pointer_set_insert (seen, name);
2379
2380   lto_streamer_cache_lookup (cache, t, &slot_num);
2381   gcc_assert (slot_num >= 0);
2382
2383   if (DECL_EXTERNAL (t))
2384     {
2385       if (DECL_WEAK (t))
2386         kind = GCCPK_WEAKUNDEF;
2387       else
2388         kind = GCCPK_UNDEF;
2389     }
2390   else
2391     {
2392       if (DECL_WEAK (t))
2393         kind = GCCPK_WEAKDEF;
2394       else if (DECL_COMMON (t))
2395         kind = GCCPK_COMMON;
2396       else
2397         kind = GCCPK_DEF;
2398
2399       /* When something is defined, it should have node attached.  */
2400       gcc_assert (alias || TREE_CODE (t) != VAR_DECL
2401                   || varpool_get_node (t)->finalized);
2402       gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL
2403                   || (cgraph_get_node (t)
2404                       && cgraph_get_node (t)->analyzed));
2405     }
2406
2407   /* Imitate what default_elf_asm_output_external do.
2408      When symbol is external, we need to output it with DEFAULT visibility
2409      when compiling with -fvisibility=default, while with HIDDEN visibility
2410      when symbol has attribute (visibility("hidden")) specified.
2411      targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2412      right. */
2413
2414   if (DECL_EXTERNAL (t)
2415       && !targetm.binds_local_p (t))
2416     visibility = GCCPV_DEFAULT;
2417   else
2418     switch (DECL_VISIBILITY(t))
2419       {
2420       case VISIBILITY_DEFAULT:
2421         visibility = GCCPV_DEFAULT;
2422         break;
2423       case VISIBILITY_PROTECTED:
2424         visibility = GCCPV_PROTECTED;
2425         break;
2426       case VISIBILITY_HIDDEN:
2427         visibility = GCCPV_HIDDEN;
2428         break;
2429       case VISIBILITY_INTERNAL:
2430         visibility = GCCPV_INTERNAL;
2431         break;
2432       }
2433
2434   if (kind == GCCPK_COMMON
2435       && DECL_SIZE (t)
2436       && TREE_CODE (DECL_SIZE (t)) == INTEGER_CST)
2437     {
2438       size = (HOST_BITS_PER_WIDE_INT >= 64)
2439         ? (uint64_t) int_size_in_bytes (TREE_TYPE (t))
2440         : (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t))) << 32)
2441                 | TREE_INT_CST_LOW (DECL_SIZE_UNIT (t));
2442     }
2443   else
2444     size = 0;
2445
2446   if (DECL_ONE_ONLY (t))
2447     comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
2448   else
2449     comdat = "";
2450
2451   lto_output_data_stream (stream, name, strlen (name) + 1);
2452   lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
2453   lto_output_data_stream (stream, &kind, 1);
2454   lto_output_data_stream (stream, &visibility, 1);
2455   lto_output_data_stream (stream, &size, 8);
2456   lto_output_data_stream (stream, &slot_num, 4);
2457 }
2458
2459
2460 /* Write an IL symbol table to OB.
2461    SET and VSET are cgraph/varpool node sets we are outputting.  */
2462
2463 static void
2464 produce_symtab (struct output_block *ob,
2465                 cgraph_node_set set, varpool_node_set vset)
2466 {
2467   struct lto_streamer_cache_d *cache = ob->writer_cache;
2468   char *section_name = lto_get_section_name (LTO_section_symtab, NULL, NULL);
2469   struct pointer_set_t *seen;
2470   struct cgraph_node *node, *alias;
2471   struct varpool_node *vnode, *valias;
2472   struct lto_output_stream stream;
2473   lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
2474   lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
2475   int i;
2476   alias_pair *p;
2477
2478   lto_begin_section (section_name, false);
2479   free (section_name);
2480
2481   seen = pointer_set_create ();
2482   memset (&stream, 0, sizeof (stream));
2483
2484   /* Write all functions.
2485      First write all defined functions and the write all used functions.
2486      This is done so only to handle duplicated symbols in cgraph.  */
2487   for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
2488     {
2489       node = lto_cgraph_encoder_deref (encoder, i);
2490       if (DECL_EXTERNAL (node->decl))
2491         continue;
2492       if (DECL_COMDAT (node->decl)
2493           && cgraph_comdat_can_be_unshared_p (node))
2494         continue;
2495       if (node->alias || node->global.inlined_to)
2496         continue;
2497       write_symbol (cache, &stream, node->decl, seen, false);
2498       for (alias = node->same_body; alias; alias = alias->next)
2499         write_symbol (cache, &stream, alias->decl, seen, true);
2500     }
2501   for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
2502     {
2503       node = lto_cgraph_encoder_deref (encoder, i);
2504       if (!DECL_EXTERNAL (node->decl))
2505         continue;
2506       if (DECL_COMDAT (node->decl)
2507           && cgraph_comdat_can_be_unshared_p (node))
2508         continue;
2509       if (node->alias || node->global.inlined_to)
2510         continue;
2511       write_symbol (cache, &stream, node->decl, seen, false);
2512       for (alias = node->same_body; alias; alias = alias->next)
2513         write_symbol (cache, &stream, alias->decl, seen, true);
2514     }
2515
2516   /* Write all variables.  */
2517   for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
2518     {
2519       vnode = lto_varpool_encoder_deref (varpool_encoder, i);
2520       if (DECL_EXTERNAL (vnode->decl))
2521         continue;
2522       /* COMDAT virtual tables can be unshared.  Do not declare them
2523          in the LTO symbol table to prevent linker from forcing them
2524          into the output. */
2525       if (DECL_COMDAT (vnode->decl)
2526           && !vnode->force_output
2527           && vnode->finalized
2528           && DECL_VIRTUAL_P (vnode->decl))
2529         continue;
2530       if (vnode->alias)
2531         continue;
2532       write_symbol (cache, &stream, vnode->decl, seen, false);
2533       for (valias = vnode->extra_name; valias; valias = valias->next)
2534         write_symbol (cache, &stream, valias->decl, seen, true);
2535     }
2536   for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
2537     {
2538       vnode = lto_varpool_encoder_deref (varpool_encoder, i);
2539       if (!DECL_EXTERNAL (vnode->decl))
2540         continue;
2541       if (DECL_COMDAT (vnode->decl)
2542           && !vnode->force_output
2543           && vnode->finalized
2544           && DECL_VIRTUAL_P (vnode->decl))
2545         continue;
2546       if (vnode->alias)
2547         continue;
2548       write_symbol (cache, &stream, vnode->decl, seen, false);
2549       for (valias = vnode->extra_name; valias; valias = valias->next)
2550         write_symbol (cache, &stream, valias->decl, seen, true);
2551     }
2552
2553   /* Write all aliases.  */
2554   FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
2555     if (output_alias_pair_p (p, set, vset))
2556       write_symbol (cache, &stream, p->decl, seen, true);
2557
2558   lto_write_stream (&stream);
2559   pointer_set_destroy (seen);
2560
2561   lto_end_section ();
2562 }
2563
2564
2565 /* This pass is run after all of the functions are serialized and all
2566    of the IPA passes have written their serialized forms.  This pass
2567    causes the vector of all of the global decls and types used from
2568    this file to be written in to a section that can then be read in to
2569    recover these on other side.  */
2570
2571 static void
2572 produce_asm_for_decls (cgraph_node_set set, varpool_node_set vset)
2573 {
2574   struct lto_out_decl_state *out_state;
2575   struct lto_out_decl_state *fn_out_state;
2576   struct lto_decl_header header;
2577   char *section_name;
2578   struct output_block *ob;
2579   struct lto_output_stream *header_stream, *decl_state_stream;
2580   unsigned idx, num_fns;
2581   size_t decl_state_size;
2582   int32_t num_decl_states;
2583
2584   ob = create_output_block (LTO_section_decls);
2585   ob->global = true;
2586
2587   /* Write out unreferenced globals, alias pairs and labels.  We defer
2588      doing this until now so that we can write out only what is
2589      needed.  */
2590   output_unreferenced_globals (set, vset);
2591
2592   memset (&header, 0, sizeof (struct lto_decl_header));
2593
2594   section_name = lto_get_section_name (LTO_section_decls, NULL, NULL);
2595   lto_begin_section (section_name, !flag_wpa);
2596   free (section_name);
2597
2598   /* Make string 0 be a NULL string.  */
2599   lto_output_1_stream (ob->string_stream, 0);
2600
2601   /* Write the global symbols.  */
2602   out_state = lto_get_out_decl_state ();
2603   num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2604   lto_output_decl_state_streams (ob, out_state);
2605   for (idx = 0; idx < num_fns; idx++)
2606     {
2607       fn_out_state =
2608         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2609       lto_output_decl_state_streams (ob, fn_out_state);
2610     }
2611
2612   header.lto_header.major_version = LTO_major_version;
2613   header.lto_header.minor_version = LTO_minor_version;
2614   header.lto_header.section_type = LTO_section_decls;
2615
2616   /* Currently not used.  This field would allow us to preallocate
2617      the globals vector, so that it need not be resized as it is extended.  */
2618   header.num_nodes = -1;
2619
2620   /* Compute the total size of all decl out states. */
2621   decl_state_size = sizeof (int32_t);
2622   decl_state_size += lto_out_decl_state_written_size (out_state);
2623   for (idx = 0; idx < num_fns; idx++)
2624     {
2625       fn_out_state =
2626         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2627       decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2628     }
2629   header.decl_state_size = decl_state_size;
2630
2631   header.main_size = ob->main_stream->total_size;
2632   header.string_size = ob->string_stream->total_size;
2633
2634   header_stream = XCNEW (struct lto_output_stream);
2635   lto_output_data_stream (header_stream, &header, sizeof header);
2636   lto_write_stream (header_stream);
2637   free (header_stream);
2638
2639   /* Write the main out-decl state, followed by out-decl states of
2640      functions. */
2641   decl_state_stream = ((struct lto_output_stream *)
2642                        xcalloc (1, sizeof (struct lto_output_stream)));
2643   num_decl_states = num_fns + 1;
2644   lto_output_data_stream (decl_state_stream, &num_decl_states,
2645                           sizeof (num_decl_states));
2646   lto_output_decl_state_refs (ob, decl_state_stream, out_state);
2647   for (idx = 0; idx < num_fns; idx++)
2648     {
2649       fn_out_state =
2650         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2651       lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
2652     }
2653   lto_write_stream (decl_state_stream);
2654   free(decl_state_stream);
2655
2656   lto_write_stream (ob->main_stream);
2657   lto_write_stream (ob->string_stream);
2658
2659   lto_end_section ();
2660
2661   /* Write the symbol table.  It is used by linker to determine dependencies
2662      and thus we can skip it for WPA.  */
2663   if (!flag_wpa)
2664     produce_symtab (ob, set, vset);
2665
2666   /* Write command line opts.  */
2667   lto_write_options ();
2668
2669   /* Deallocate memory and clean up.  */
2670   for (idx = 0; idx < num_fns; idx++)
2671     {
2672       fn_out_state =
2673         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2674       lto_delete_out_decl_state (fn_out_state);
2675     }
2676   lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
2677   lto_varpool_encoder_delete (ob->decl_state->varpool_node_encoder);
2678   VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
2679   lto_function_decl_states = NULL;
2680   destroy_output_block (ob);
2681 }
2682
2683
2684 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
2685 {
2686  {
2687   IPA_PASS,
2688   "lto_decls_out",                      /* name */
2689   gate_lto_out,                         /* gate */
2690   NULL,                                 /* execute */
2691   NULL,                                 /* sub */
2692   NULL,                                 /* next */
2693   0,                                    /* static_pass_number */
2694   TV_IPA_LTO_DECL_OUT,                  /* tv_id */
2695   0,                                    /* properties_required */
2696   0,                                    /* properties_provided */
2697   0,                                    /* properties_destroyed */
2698   0,                                    /* todo_flags_start */
2699   0                                     /* todo_flags_finish */
2700  },
2701  NULL,                                  /* generate_summary */
2702  produce_asm_for_decls,                 /* write_summary */
2703  NULL,                                  /* read_summary */
2704  produce_asm_for_decls,                 /* write_optimization_summary */
2705  NULL,                                  /* read_optimization_summary */
2706  NULL,                                  /* stmt_fixup */
2707  0,                                     /* TODOs */
2708  NULL,                                  /* function_transform */
2709  NULL                                   /* variable_transform */
2710 };