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