gcc/lto-streamer-out.c

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