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)
 522     bp_pack_value (bp, TYPE_TRANSPARENT_UNION (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 the static chain and non-local goto save area.  */
1876   lto_output_tree_ref (ob, fn->static_chain_decl);
1877   lto_output_tree_ref (ob, fn->nonlocal_goto_save_area);
1878
1879   /* Output all the local variables in the function.  */
1880   lto_output_tree_ref (ob, fn->local_decls);
1881
1882   /* Output the head of the arguments list.  */
1883   lto_output_tree_ref (ob, DECL_ARGUMENTS (function));
1884
1885   /* Output all the SSA names used in the function.  */
1886   output_ssa_names (ob, fn);
1887
1888   /* Output any exception handling regions.  */
1889   output_eh_regions (ob, fn);
1890
1891   /* Output DECL_INITIAL for the function, which contains the tree of
1892      lexical scopes.  */
1893   lto_output_tree (ob, DECL_INITIAL (function), true);
1894
1895   /* We will renumber the statements.  The code that does this uses
1896      the same ordering that we use for serializing them so we can use
1897      the same code on the other end and not have to write out the
1898      statement numbers.  */
1899   renumber_gimple_stmt_uids ();
1900
1901   /* Output the code for the function.  */
1902   FOR_ALL_BB_FN (bb, fn)
1903     output_bb (ob, bb, fn);
1904
1905   /* The terminator for this function.  */
1906   output_zero (ob);
1907
1908   output_cfg (ob, fn);
1909
1910   /* Create a section to hold the pickled output of this function.   */
1911   produce_asm (ob, function);
1912
1913   destroy_output_block (ob);
1914
1915   current_function_decl = NULL;
1916   pop_cfun ();
1917 }
1918
1919
1920 /* Return true if alias pair P belongs to the set of cgraph nodes in
1921    SET.  If P is a an alias for a VAR_DECL, it can always be emitted.
1922    However, for FUNCTION_DECL aliases, we should only output the pair
1923    if it belongs to a function whose cgraph node is in SET.
1924    Otherwise, the LTRANS phase will get into trouble when finalizing
1925    aliases because the alias will refer to a function not defined in
1926    the file processed by LTRANS.  */
1927
1928 static bool
1929 output_alias_pair_p (alias_pair *p, cgraph_node_set set)
1930 {
1931   cgraph_node_set_iterator csi;
1932   struct cgraph_node *target_node;
1933
1934   /* Always emit VAR_DECLs.  FIXME lto, we should probably only emit
1935      those VAR_DECLs that are instantiated in this file partition, but
1936      we have no easy way of knowing this based on SET.  */
1937   if (TREE_CODE (p->decl) == VAR_DECL)
1938     return true;
1939
1940   /* Check if the assembler name for P->TARGET has its cgraph node in SET.  */
1941   gcc_assert (TREE_CODE (p->decl) == FUNCTION_DECL);
1942   target_node = cgraph_node_for_asm (p->target);
1943   csi = cgraph_node_set_find (set, target_node);
1944   return (!csi_end_p (csi));
1945 }
1946
1947
1948 /* Output any unreferenced global symbol defined in SET, alias pairs
1949    and labels.  */
1950
1951 static void
1952 output_unreferenced_globals (cgraph_node_set set)
1953 {
1954   struct output_block *ob;
1955   alias_pair *p;
1956   unsigned i;
1957   struct varpool_node *vnode;
1958
1959   ob = create_output_block (LTO_section_static_initializer);
1960   ob->cgraph_node = NULL;
1961
1962   clear_line_info (ob);
1963
1964   /* Make string 0 be a NULL string.  */
1965   lto_output_1_stream (ob->string_stream, 0);
1966
1967   /* Emit references for all the global symbols.  If a global symbol
1968      was never referenced in any of the functions of this file, it
1969      would not be emitted otherwise.  This will result in unreferenced
1970      symbols at link time if a file defines a global symbol but
1971      never references it.  */
1972   FOR_EACH_STATIC_VARIABLE (vnode)
1973     {
1974       tree var = vnode->decl;
1975
1976       if (TREE_CODE (var) == VAR_DECL && TREE_PUBLIC (var))
1977         {
1978           /* Outputting just the reference will not output the object itself
1979              or references it might have.*/
1980           lto_output_tree (ob, var, true);
1981           lto_output_tree_ref (ob, var);
1982         }
1983     }
1984
1985   output_zero (ob);
1986
1987   /* Emit the alias pairs for the nodes in SET.  */
1988   for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
1989     {
1990       if (output_alias_pair_p (p, set))
1991         {
1992           lto_output_tree_ref (ob, p->decl);
1993           lto_output_tree_ref (ob, p->target);
1994         }
1995     }
1996
1997   output_zero (ob);
1998
1999   produce_asm (ob, NULL);
2000   destroy_output_block (ob);
2001 }
2002
2003
2004 /* Copy the function body of NODE without deserializing. */
2005
2006 static void
2007 copy_function (struct cgraph_node *node)
2008 {
2009   tree function = node->decl;
2010   struct lto_file_decl_data *file_data = node->local.lto_file_data;
2011   struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
2012   const char *data;
2013   size_t len;
2014   const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
2015   char *section_name =
2016     lto_get_section_name (LTO_section_function_body, name);
2017   size_t i, j;
2018   struct lto_in_decl_state *in_state;
2019   struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2020
2021   lto_begin_section (section_name, !flag_wpa);
2022   free (section_name);
2023
2024   /* We may have renamed the declaration, e.g., a static function.  */
2025   name = lto_get_decl_name_mapping (file_data, name);
2026
2027   data = lto_get_section_data (file_data, LTO_section_function_body,
2028                                name, &len);
2029   gcc_assert (data);
2030
2031   /* Do a bit copy of the function body.  */
2032   lto_output_data_stream (output_stream, data, len);
2033   lto_write_stream (output_stream);
2034
2035   /* Copy decls. */
2036   in_state =
2037     lto_get_function_in_decl_state (node->local.lto_file_data, function);
2038   gcc_assert (in_state);
2039
2040   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2041     {
2042       size_t n = in_state->streams[i].size;
2043       tree *trees = in_state->streams[i].trees;
2044       struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2045
2046       /* The out state must have the same indices and the in state.
2047          So just copy the vector.  All the encoders in the in state
2048          must be empty where we reach here. */
2049       gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2050       for (j = 0; j < n; j++)
2051         VEC_safe_push (tree, heap, encoder->trees, trees[j]);
2052       encoder->next_index = n;
2053     }
2054
2055   lto_free_section_data (file_data, LTO_section_function_body, name,
2056                          data, len);
2057   free (output_stream);
2058   lto_end_section ();
2059 }
2060
2061
2062 /* Initialize the LTO writer.  */
2063
2064 static void
2065 lto_writer_init (void)
2066 {
2067   lto_streamer_init ();
2068 }
2069
2070
2071 /* Main entry point from the pass manager.  */
2072
2073 static void
2074 lto_output (cgraph_node_set set)
2075 {
2076   struct cgraph_node *node;
2077   struct lto_out_decl_state *decl_state;
2078   cgraph_node_set_iterator csi;
2079   bitmap output = lto_bitmap_alloc ();
2080
2081   lto_writer_init ();
2082
2083   /* Process only the functions with bodies.  */
2084   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2085     {
2086       node = csi_node (csi);
2087       if (node->analyzed && !bitmap_bit_p (output, DECL_UID (node->decl)))
2088         {
2089           bitmap_set_bit (output, DECL_UID (node->decl));
2090           decl_state = lto_new_out_decl_state ();
2091           lto_push_out_decl_state (decl_state);
2092           if (!flag_wpa)
2093             output_function (node);
2094           else
2095             copy_function (node);
2096           gcc_assert (lto_get_out_decl_state () == decl_state);
2097           lto_pop_out_decl_state ();
2098           lto_record_function_out_decl_state (node->decl, decl_state);
2099         }
2100     }
2101
2102   /* Emit the callgraph after emitting function bodies.  This needs to
2103      be done now to make sure that all the statements in every function
2104      have been renumbered so that edges can be associated with call
2105      statements using the statement UIDs.  */
2106   output_cgraph (set);
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  NULL,                                  /* function_read_summary */
2132  NULL,                                  /* stmt_fixup */
2133  0,                                     /* TODOs */
2134  NULL,                                  /* function_transform */
2135  NULL                                   /* variable_transform */
2136 };
2137
2138
2139 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2140    from it and required for correct representation of its semantics.
2141    Each node in ENCODER must be a global declaration or a type.  A node
2142    is written only once, even if it appears multiple times in the
2143    vector.  Certain transitively-reachable nodes, such as those
2144    representing expressions, may be duplicated, but such nodes
2145    must not appear in ENCODER itself.  */
2146
2147 static void
2148 write_global_stream (struct output_block *ob,
2149                      struct lto_tree_ref_encoder *encoder)
2150 {
2151   tree t;
2152   size_t index;
2153   const size_t size = lto_tree_ref_encoder_size (encoder);
2154
2155   for (index = 0; index < size; index++)
2156     {
2157       t = lto_tree_ref_encoder_get_tree (encoder, index);
2158       if (!lto_streamer_cache_lookup (ob->writer_cache, t, NULL))
2159         lto_output_tree (ob, t, false);
2160
2161       if (flag_wpa)
2162         {
2163           /* In WPA we should not emit multiple definitions of the
2164              same symbol to all the files in the link set.  If
2165              T had already been emitted as the pervailing definition
2166              in one file, do not emit it in the others.  */
2167           /* FIXME lto.  We should check if T belongs to the
2168              file we are writing to.  */
2169           if (TREE_CODE (t) == VAR_DECL
2170               && TREE_PUBLIC (t)
2171               && !DECL_EXTERNAL (t))
2172             TREE_ASM_WRITTEN (t) = 1;
2173         }
2174     }
2175 }
2176
2177
2178 /* Write a sequence of indices into the globals vector corresponding
2179    to the trees in ENCODER.  These are used by the reader to map the
2180    indices used to refer to global entities within function bodies to
2181    their referents.  */
2182
2183 static void
2184 write_global_references (struct output_block *ob,
2185                          struct lto_output_stream *ref_stream,
2186                          struct lto_tree_ref_encoder *encoder)
2187 {
2188   tree t;
2189   int32_t index;
2190   const int32_t size = lto_tree_ref_encoder_size (encoder);
2191
2192   /* Write size as 32-bit unsigned. */
2193   lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
2194
2195   for (index = 0; index < size; index++)
2196     {
2197       int32_t slot_num;
2198
2199       t = lto_tree_ref_encoder_get_tree (encoder, index);
2200       lto_streamer_cache_lookup (ob->writer_cache, t, &slot_num);
2201       gcc_assert (slot_num >= 0);
2202       lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
2203     }
2204 }
2205
2206
2207 /* Write all the streams in an lto_out_decl_state STATE using
2208    output block OB and output stream OUT_STREAM.  */
2209
2210 static void
2211 lto_output_decl_state_streams (struct output_block *ob,
2212                                struct lto_out_decl_state *state)
2213 {
2214   int i;
2215
2216   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2217     write_global_stream (ob, &state->streams[i]);
2218 }
2219
2220
2221 /* Write all the references in an lto_out_decl_state STATE using
2222    output block OB and output stream OUT_STREAM.  */
2223
2224 static void
2225 lto_output_decl_state_refs (struct output_block *ob,
2226                             struct lto_output_stream *out_stream,
2227                             struct lto_out_decl_state *state)
2228 {
2229   unsigned i;
2230   int32_t ref;
2231   tree decl;
2232
2233   /* Write reference to FUNCTION_DECL.  If there is not function,
2234      write reference to void_type_node. */
2235   decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2236   lto_streamer_cache_lookup (ob->writer_cache, decl, &ref);
2237   gcc_assert (ref >= 0);
2238   lto_output_data_stream (out_stream, &ref, sizeof (int32_t));
2239
2240   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2241     write_global_references (ob, out_stream, &state->streams[i]);
2242 }
2243
2244
2245 /* Return the written size of STATE. */
2246
2247 static size_t
2248 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2249 {
2250   int i;
2251   size_t size;
2252
2253   size = sizeof (int32_t);      /* fn_ref. */
2254   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2255     {
2256       size += sizeof (int32_t); /* vector size. */
2257       size += (lto_tree_ref_encoder_size (&state->streams[i])
2258                * sizeof (int32_t));
2259     }
2260   return size;
2261 }
2262
2263
2264 /* Helper function of write_symbols_of_kind.  CACHE is the streamer
2265    cache with all the pickled nodes.  STREAM is the stream where to
2266    write the table.  V is a vector with the DECLs that should be on
2267    the table.  SEEN is a bitmap of symbols written so far.  */
2268
2269 static void
2270 write_symbol_vec (struct lto_streamer_cache_d *cache,
2271                   struct lto_output_stream *stream,
2272                   VEC(tree,heap) *v, bitmap seen)
2273 {
2274   tree t;
2275   int index;
2276
2277   for (index = 0; VEC_iterate(tree, v, index, t); index++)
2278     {
2279       const char *name;
2280       enum gcc_plugin_symbol_kind kind;
2281       enum gcc_plugin_symbol_visibility visibility;
2282       int slot_num;
2283       uint64_t size;
2284       const char *comdat;
2285
2286       /* None of the following kinds of symbols are needed in the
2287          symbol table.  */
2288       if (!TREE_PUBLIC (t)
2289           || is_builtin_fn (t)
2290           || DECL_ABSTRACT (t)
2291           || TREE_CODE (t) == RESULT_DECL)
2292         continue;
2293
2294       gcc_assert (TREE_CODE (t) == VAR_DECL
2295                   || TREE_CODE (t) == FUNCTION_DECL);
2296
2297       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2298
2299       /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2300          architectures we might have to do the same name manipulations that
2301          ASM_OUTPUT_LABELREF does. */
2302       if (name[0] == '*')
2303         name = &name[1];
2304
2305       lto_streamer_cache_lookup (cache, t, &slot_num);
2306       gcc_assert (slot_num >= 0);
2307
2308       /* Avoid duplicate symbols. */
2309       if (bitmap_bit_p (seen, slot_num))
2310         continue;
2311       else
2312         bitmap_set_bit (seen, slot_num);
2313
2314       if (DECL_EXTERNAL (t))
2315         {
2316           if (DECL_WEAK (t))
2317             kind = GCCPK_WEAKUNDEF;
2318           else
2319             kind = GCCPK_UNDEF;
2320         }
2321       else
2322         {
2323           if (DECL_WEAK (t))
2324             kind = GCCPK_WEAKDEF;
2325           else if (DECL_COMMON (t))
2326             kind = GCCPK_COMMON;
2327           else
2328             kind = GCCPK_DEF;
2329         }
2330
2331       switch (DECL_VISIBILITY(t))
2332         {
2333         case VISIBILITY_DEFAULT:
2334           visibility = GCCPV_DEFAULT;
2335           break;
2336         case VISIBILITY_PROTECTED:
2337           visibility = GCCPV_PROTECTED;
2338           break;
2339         case VISIBILITY_HIDDEN:
2340           visibility = GCCPV_HIDDEN;
2341           break;
2342         case VISIBILITY_INTERNAL:
2343           visibility = GCCPV_INTERNAL;
2344           break;
2345         }
2346
2347       if (kind == GCCPK_COMMON
2348           && DECL_SIZE (t)
2349           && TREE_CODE (DECL_SIZE (t)) == INTEGER_CST)
2350         size = (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t))) << 32)
2351           | TREE_INT_CST_LOW (DECL_SIZE (t));
2352       else
2353         size = 0;
2354
2355       if (DECL_ONE_ONLY (t))
2356         comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
2357       else
2358         comdat = "";
2359
2360       lto_output_data_stream (stream, name, strlen (name) + 1);
2361       lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
2362       lto_output_data_stream (stream, &kind, 1);
2363       lto_output_data_stream (stream, &visibility, 1);
2364       lto_output_data_stream (stream, &size, 8);
2365       lto_output_data_stream (stream, &slot_num, 4);
2366     }
2367 }
2368
2369
2370 /* Write IL symbols of KIND.  CACHE is the streamer cache with all the
2371    pickled nodes.  SEEN is a bitmap of symbols written so far.  */
2372
2373 static void
2374 write_symbols_of_kind (lto_decl_stream_e_t kind,
2375                        struct lto_streamer_cache_d *cache, bitmap seen)
2376 {
2377   struct lto_out_decl_state *out_state;
2378   struct lto_output_stream stream;
2379   unsigned num_fns =
2380     VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2381   unsigned idx;
2382
2383   memset (&stream, 0, sizeof (stream));
2384   out_state = lto_get_out_decl_state ();
2385   write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2386
2387   for (idx = 0; idx < num_fns; idx++)
2388     {
2389       out_state =
2390         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2391       write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2392     }
2393
2394   lto_write_stream (&stream);
2395 }
2396
2397
2398 /* Write an IL symbol table.  CACHE is the streamer cache with all the
2399    pickled nodes.  */
2400
2401 static void
2402 produce_symtab (struct lto_streamer_cache_d *cache)
2403 {
2404   char *section_name = lto_get_section_name (LTO_section_symtab, NULL);
2405   bitmap seen;
2406
2407   lto_begin_section (section_name, false);
2408   free (section_name);
2409
2410   seen = lto_bitmap_alloc ();
2411   write_symbols_of_kind (LTO_DECL_STREAM_FN_DECL, cache, seen);
2412   write_symbols_of_kind (LTO_DECL_STREAM_VAR_DECL, cache, seen);
2413   lto_bitmap_free (seen);
2414
2415   lto_end_section ();
2416 }
2417
2418
2419 /* This pass is run after all of the functions are serialized and all
2420    of the IPA passes have written their serialized forms.  This pass
2421    causes the vector of all of the global decls and types used from
2422    this file to be written in to a section that can then be read in to
2423    recover these on other side.  */
2424
2425 static void
2426 produce_asm_for_decls (cgraph_node_set set)
2427 {
2428   struct lto_out_decl_state *out_state;
2429   struct lto_out_decl_state *fn_out_state;
2430   struct lto_decl_header header;
2431   char *section_name;
2432   struct output_block *ob;
2433   struct lto_output_stream *header_stream, *decl_state_stream;
2434   unsigned idx, num_fns;
2435   size_t decl_state_size;
2436   int32_t num_decl_states;
2437
2438   ob = create_output_block (LTO_section_decls);
2439   ob->global = true;
2440
2441   /* Write out unreferenced globals, alias pairs and labels.  We defer
2442      doing this until now so that we can write out only what is
2443      needed.  */
2444   output_unreferenced_globals (set);
2445
2446   memset (&header, 0, sizeof (struct lto_decl_header));
2447
2448   section_name = lto_get_section_name (LTO_section_decls, NULL);
2449   lto_begin_section (section_name, !flag_wpa);
2450   free (section_name);
2451
2452   /* Make string 0 be a NULL string.  */
2453   lto_output_1_stream (ob->string_stream, 0);
2454
2455   /* Write the global symbols.  */
2456   out_state = lto_get_out_decl_state ();
2457   num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2458   lto_output_decl_state_streams (ob, out_state);
2459   for (idx = 0; idx < num_fns; idx++)
2460     {
2461       fn_out_state =
2462         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2463       lto_output_decl_state_streams (ob, fn_out_state);
2464     }
2465
2466   header.lto_header.major_version = LTO_major_version;
2467   header.lto_header.minor_version = LTO_minor_version;
2468   header.lto_header.section_type = LTO_section_decls;
2469
2470   /* Currently not used.  This field would allow us to preallocate
2471      the globals vector, so that it need not be resized as it is extended.  */
2472   header.num_nodes = -1;
2473
2474   /* Compute the total size of all decl out states. */
2475   decl_state_size = sizeof (int32_t);
2476   decl_state_size += lto_out_decl_state_written_size (out_state);
2477   for (idx = 0; idx < num_fns; idx++)
2478     {
2479       fn_out_state =
2480         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2481       decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2482     }
2483   header.decl_state_size = decl_state_size;
2484
2485   header.main_size = ob->main_stream->total_size;
2486   header.string_size = ob->string_stream->total_size;
2487
2488   header_stream = XCNEW (struct lto_output_stream);
2489   lto_output_data_stream (header_stream, &header, sizeof header);
2490   lto_write_stream (header_stream);
2491   free (header_stream);
2492
2493   /* Write the main out-decl state, followed by out-decl states of
2494      functions. */
2495   decl_state_stream = ((struct lto_output_stream *)
2496                        xcalloc (1, sizeof (struct lto_output_stream)));
2497   num_decl_states = num_fns + 1;
2498   lto_output_data_stream (decl_state_stream, &num_decl_states,
2499                           sizeof (num_decl_states));
2500   lto_output_decl_state_refs (ob, decl_state_stream, out_state);
2501   for (idx = 0; idx < num_fns; idx++)
2502     {
2503       fn_out_state =
2504         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2505       lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
2506     }
2507   lto_write_stream (decl_state_stream);
2508   free(decl_state_stream);
2509
2510   lto_write_stream (ob->main_stream);
2511   lto_write_stream (ob->string_stream);
2512
2513   lto_end_section ();
2514
2515   /* Write the symbol table. */
2516   produce_symtab (ob->writer_cache);
2517
2518   /* Write command line opts.  */
2519   lto_write_options ();
2520
2521   /* Deallocate memory and clean up.  */
2522   lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
2523   VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
2524   lto_function_decl_states = NULL;
2525   destroy_output_block (ob);
2526 }
2527
2528
2529 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
2530 {
2531  {
2532   IPA_PASS,
2533   "lto_decls_out",                      /* name */
2534   gate_lto_out,                         /* gate */
2535   NULL,                                 /* execute */
2536   NULL,                                 /* sub */
2537   NULL,                                 /* next */
2538   0,                                    /* static_pass_number */
2539   TV_IPA_LTO_DECL_IO,                   /* tv_id */
2540   0,                                    /* properties_required */
2541   0,                                    /* properties_provided */
2542   0,                                    /* properties_destroyed */
2543   0,                                    /* todo_flags_start */
2544   0                                     /* todo_flags_finish */
2545  },
2546  NULL,                                  /* generate_summary */
2547  produce_asm_for_decls,                 /* write_summary */
2548  NULL,                                  /* read_summary */
2549  NULL,                                  /* function_read_summary */
2550  NULL,                                  /* stmt_fixup */
2551  0,                                     /* TODOs */
2552  NULL,                                  /* function_transform */
2553  NULL                                   /* variable_transform */
2554 };