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