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