gcc/lto-streamer-out.c

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