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_EACH_VEC_ELT (tree, BLOCK_NONLOCALIZED_VARS (expr), i, t)
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_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
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_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
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_EACH_VEC_ELT (eh_region, fn->eh->region_array, i, eh)
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_EACH_VEC_ELT (eh_landing_pad, fn->eh->lp_array, i, lp)
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_EACH_VEC_ELT (tree, fn->eh->ttype_data, i, ttype)
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_EACH_VEC_ELT (tree, fn->eh->ehspec_data.arm_eabi, i, t)
1530             lto_output_tree_ref (ob, t);
1531         }
1532       else
1533         {
1534           uchar c;
1535           output_sleb128 (ob, VEC_length (uchar, fn->eh->ehspec_data.other));
1536           FOR_EACH_VEC_ELT (uchar, fn->eh->ehspec_data.other, i, c)
1537             lto_output_1_stream (ob->main_stream, c);
1538         }
1539     }
1540
1541   /* The 0 either terminates the record or indicates that there are no
1542      eh_records at all.  */
1543   output_zero (ob);
1544 }
1545
1546
1547 /* Output all of the active ssa names to the ssa_names stream.  */
1548
1549 static void
1550 output_ssa_names (struct output_block *ob, struct function *fn)
1551 {
1552   unsigned int i, len;
1553
1554   len = VEC_length (tree, SSANAMES (fn));
1555   output_uleb128 (ob, len);
1556
1557   for (i = 1; i < len; i++)
1558     {
1559       tree ptr = VEC_index (tree, SSANAMES (fn), i);
1560
1561       if (ptr == NULL_TREE
1562           || SSA_NAME_IN_FREE_LIST (ptr)
1563           || !is_gimple_reg (ptr))
1564         continue;
1565
1566       output_uleb128 (ob, i);
1567       lto_output_1_stream (ob->main_stream, SSA_NAME_IS_DEFAULT_DEF (ptr));
1568       lto_output_tree_ref (ob, SSA_NAME_VAR (ptr));
1569     }
1570
1571   output_zero (ob);
1572 }
1573
1574
1575 /* Output the cfg.  */
1576
1577 static void
1578 output_cfg (struct output_block *ob, struct function *fn)
1579 {
1580   struct lto_output_stream *tmp_stream = ob->main_stream;
1581   basic_block bb;
1582
1583   ob->main_stream = ob->cfg_stream;
1584
1585   output_uleb128 (ob, profile_status_for_function (fn));
1586
1587   /* Output the number of the highest basic block.  */
1588   output_uleb128 (ob, last_basic_block_for_function (fn));
1589
1590   FOR_ALL_BB_FN (bb, fn)
1591     {
1592       edge_iterator ei;
1593       edge e;
1594
1595       output_sleb128 (ob, bb->index);
1596
1597       /* Output the successors and the edge flags.  */
1598       output_uleb128 (ob, EDGE_COUNT (bb->succs));
1599       FOR_EACH_EDGE (e, ei, bb->succs)
1600         {
1601           output_uleb128 (ob, e->dest->index);
1602           output_sleb128 (ob, e->probability);
1603           output_sleb128 (ob, e->count);
1604           output_uleb128 (ob, e->flags);
1605         }
1606     }
1607
1608   output_sleb128 (ob, -1);
1609
1610   bb = ENTRY_BLOCK_PTR;
1611   while (bb->next_bb)
1612     {
1613       output_sleb128 (ob, bb->next_bb->index);
1614       bb = bb->next_bb;
1615     }
1616
1617   output_sleb128 (ob, -1);
1618
1619   ob->main_stream = tmp_stream;
1620 }
1621
1622
1623 /* Output PHI function PHI to the main stream in OB.  */
1624
1625 static void
1626 output_phi (struct output_block *ob, gimple phi)
1627 {
1628   unsigned i, len = gimple_phi_num_args (phi);
1629
1630   output_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI));
1631   output_uleb128 (ob, SSA_NAME_VERSION (PHI_RESULT (phi)));
1632
1633   for (i = 0; i < len; i++)
1634     {
1635       lto_output_tree_ref (ob, gimple_phi_arg_def (phi, i));
1636       output_uleb128 (ob, gimple_phi_arg_edge (phi, i)->src->index);
1637       lto_output_location (ob, gimple_phi_arg_location (phi, i));
1638     }
1639 }
1640
1641
1642 /* Emit statement STMT on the main stream of output block OB.  */
1643
1644 static void
1645 output_gimple_stmt (struct output_block *ob, gimple stmt)
1646 {
1647   unsigned i;
1648   enum gimple_code code;
1649   enum LTO_tags tag;
1650   struct bitpack_d bp;
1651
1652   /* Emit identifying tag.  */
1653   code = gimple_code (stmt);
1654   tag = lto_gimple_code_to_tag (code);
1655   output_record_start (ob, tag);
1656
1657   /* Emit the tuple header.  */
1658   bp = bitpack_create (ob->main_stream);
1659   bp_pack_value (&bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
1660   bp_pack_value (&bp, gimple_no_warning_p (stmt), 1);
1661   if (is_gimple_assign (stmt))
1662     bp_pack_value (&bp, gimple_assign_nontemporal_move_p (stmt), 1);
1663   bp_pack_value (&bp, gimple_has_volatile_ops (stmt), 1);
1664   bp_pack_value (&bp, stmt->gsbase.subcode, 16);
1665   lto_output_bitpack (&bp);
1666
1667   /* Emit location information for the statement.  */
1668   lto_output_location (ob, gimple_location (stmt));
1669
1670   /* Emit the lexical block holding STMT.  */
1671   lto_output_tree (ob, gimple_block (stmt), true);
1672
1673   /* Emit the operands.  */
1674   switch (gimple_code (stmt))
1675     {
1676     case GIMPLE_RESX:
1677       output_sleb128 (ob, gimple_resx_region (stmt));
1678       break;
1679
1680     case GIMPLE_EH_MUST_NOT_THROW:
1681       lto_output_tree_ref (ob, gimple_eh_must_not_throw_fndecl (stmt));
1682       break;
1683
1684     case GIMPLE_EH_DISPATCH:
1685       output_sleb128 (ob, gimple_eh_dispatch_region (stmt));
1686       break;
1687
1688     case GIMPLE_ASM:
1689       lto_output_uleb128_stream (ob->main_stream, gimple_asm_ninputs (stmt));
1690       lto_output_uleb128_stream (ob->main_stream, gimple_asm_noutputs (stmt));
1691       lto_output_uleb128_stream (ob->main_stream, gimple_asm_nclobbers (stmt));
1692       lto_output_uleb128_stream (ob->main_stream, gimple_asm_nlabels (stmt));
1693       output_string (ob, ob->main_stream, gimple_asm_string (stmt));
1694       /* Fallthru  */
1695
1696     case GIMPLE_ASSIGN:
1697     case GIMPLE_CALL:
1698     case GIMPLE_RETURN:
1699     case GIMPLE_SWITCH:
1700     case GIMPLE_LABEL:
1701     case GIMPLE_COND:
1702     case GIMPLE_GOTO:
1703     case GIMPLE_DEBUG:
1704       for (i = 0; i < gimple_num_ops (stmt); i++)
1705         {
1706           tree op = gimple_op (stmt, i);
1707           /* Wrap all uses of non-automatic variables inside MEM_REFs
1708              so that we do not have to deal with type mismatches on
1709              merged symbols during IL read in.  */
1710           if (op)
1711             {
1712               tree *basep = &op;
1713               if (handled_component_p (*basep))
1714                 basep = &TREE_OPERAND (*basep, 0);
1715               if (TREE_CODE (*basep) == VAR_DECL
1716                   && !auto_var_in_fn_p (*basep, current_function_decl))
1717                 {
1718                   bool volatilep = TREE_THIS_VOLATILE (*basep);
1719                   *basep = build2 (MEM_REF, TREE_TYPE (*basep),
1720                                    build_fold_addr_expr (*basep),
1721                                    build_int_cst (build_pointer_type
1722                                                   (TREE_TYPE (*basep)), 0));
1723                   TREE_THIS_VOLATILE (*basep) = volatilep;
1724                 }
1725             }
1726           lto_output_tree_ref (ob, op);
1727         }
1728       break;
1729
1730     case GIMPLE_NOP:
1731     case GIMPLE_PREDICT:
1732       break;
1733
1734     default:
1735       gcc_unreachable ();
1736     }
1737 }
1738
1739
1740 /* Output a basic block BB to the main stream in OB for this FN.  */
1741
1742 static void
1743 output_bb (struct output_block *ob, basic_block bb, struct function *fn)
1744 {
1745   gimple_stmt_iterator bsi = gsi_start_bb (bb);
1746
1747   output_record_start (ob,
1748                        (!gsi_end_p (bsi)) || phi_nodes (bb)
1749                         ? LTO_bb1
1750                         : LTO_bb0);
1751
1752   output_uleb128 (ob, bb->index);
1753   output_sleb128 (ob, bb->count);
1754   output_sleb128 (ob, bb->loop_depth);
1755   output_sleb128 (ob, bb->frequency);
1756   output_sleb128 (ob, bb->flags);
1757
1758   if (!gsi_end_p (bsi) || phi_nodes (bb))
1759     {
1760       /* Output the statements.  The list of statements is terminated
1761          with a zero.  */
1762       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1763         {
1764           int region;
1765           gimple stmt = gsi_stmt (bsi);
1766
1767           output_gimple_stmt (ob, stmt);
1768
1769           /* Emit the EH region holding STMT.  */
1770           region = lookup_stmt_eh_lp_fn (fn, stmt);
1771           if (region != 0)
1772             {
1773               output_record_start (ob, LTO_eh_region);
1774               output_sleb128 (ob, region);
1775             }
1776           else
1777             output_zero (ob);
1778         }
1779
1780       output_zero (ob);
1781
1782       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1783         {
1784           gimple phi = gsi_stmt (bsi);
1785
1786           /* Only emit PHIs for gimple registers.  PHI nodes for .MEM
1787              will be filled in on reading when the SSA form is
1788              updated.  */
1789           if (is_gimple_reg (gimple_phi_result (phi)))
1790             output_phi (ob, phi);
1791         }
1792
1793       output_zero (ob);
1794     }
1795 }
1796
1797 /* Create the header in the file using OB.  If the section type is for
1798    a function, set FN to the decl for that function.  */
1799
1800 void
1801 produce_asm (struct output_block *ob, tree fn)
1802 {
1803   enum lto_section_type section_type = ob->section_type;
1804   struct lto_function_header header;
1805   char *section_name;
1806   struct lto_output_stream *header_stream;
1807
1808   if (section_type == LTO_section_function_body)
1809     {
1810       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
1811       section_name = lto_get_section_name (section_type, name, NULL);
1812     }
1813   else
1814     section_name = lto_get_section_name (section_type, NULL, NULL);
1815
1816   lto_begin_section (section_name, !flag_wpa);
1817   free (section_name);
1818
1819   /* The entire header is stream computed here.  */
1820   memset (&header, 0, sizeof (struct lto_function_header));
1821
1822   /* Write the header.  */
1823   header.lto_header.major_version = LTO_major_version;
1824   header.lto_header.minor_version = LTO_minor_version;
1825   header.lto_header.section_type = section_type;
1826
1827   header.compressed_size = 0;
1828
1829   if (section_type == LTO_section_function_body)
1830     header.cfg_size = ob->cfg_stream->total_size;
1831   header.main_size = ob->main_stream->total_size;
1832   header.string_size = ob->string_stream->total_size;
1833
1834   header_stream = XCNEW (struct lto_output_stream);
1835   lto_output_data_stream (header_stream, &header, sizeof header);
1836   lto_write_stream (header_stream);
1837   free (header_stream);
1838
1839   /* Put all of the gimple and the string table out the asm file as a
1840      block of text.  */
1841   if (section_type == LTO_section_function_body)
1842     lto_write_stream (ob->cfg_stream);
1843   lto_write_stream (ob->main_stream);
1844   lto_write_stream (ob->string_stream);
1845
1846   lto_end_section ();
1847 }
1848
1849
1850 /* Output the body of function NODE->DECL.  */
1851
1852 static void
1853 output_function (struct cgraph_node *node)
1854 {
1855   struct bitpack_d bp;
1856   tree function;
1857   struct function *fn;
1858   basic_block bb;
1859   struct output_block *ob;
1860   unsigned i;
1861   tree t;
1862
1863   function = node->decl;
1864   fn = DECL_STRUCT_FUNCTION (function);
1865   ob = create_output_block (LTO_section_function_body);
1866
1867   clear_line_info (ob);
1868   ob->cgraph_node = node;
1869
1870   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
1871
1872   /* Set current_function_decl and cfun.  */
1873   current_function_decl = function;
1874   push_cfun (fn);
1875
1876   /* Make string 0 be a NULL string.  */
1877   lto_output_1_stream (ob->string_stream, 0);
1878
1879   output_record_start (ob, LTO_function);
1880
1881   /* Write all the attributes for FN.  */
1882   bp = bitpack_create (ob->main_stream);
1883   bp_pack_value (&bp, fn->is_thunk, 1);
1884   bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1);
1885   bp_pack_value (&bp, fn->after_tree_profile, 1);
1886   bp_pack_value (&bp, fn->returns_pcc_struct, 1);
1887   bp_pack_value (&bp, fn->returns_struct, 1);
1888   bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
1889   bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
1890   bp_pack_value (&bp, fn->after_inlining, 1);
1891   bp_pack_value (&bp, fn->dont_save_pending_sizes_p, 1);
1892   bp_pack_value (&bp, fn->stdarg, 1);
1893   bp_pack_value (&bp, fn->has_nonlocal_label, 1);
1894   bp_pack_value (&bp, fn->calls_alloca, 1);
1895   bp_pack_value (&bp, fn->calls_setjmp, 1);
1896   bp_pack_value (&bp, fn->va_list_fpr_size, 8);
1897   bp_pack_value (&bp, fn->va_list_gpr_size, 8);
1898   lto_output_bitpack (&bp);
1899
1900   /* Output current IL state of the function.  */
1901   output_uleb128 (ob, fn->curr_properties);
1902
1903   /* Output the static chain and non-local goto save area.  */
1904   lto_output_tree_ref (ob, fn->static_chain_decl);
1905   lto_output_tree_ref (ob, fn->nonlocal_goto_save_area);
1906
1907   /* Output all the local variables in the function.  */
1908   output_sleb128 (ob, VEC_length (tree, fn->local_decls));
1909   FOR_EACH_VEC_ELT (tree, fn->local_decls, i, t)
1910     lto_output_tree_ref (ob, t);
1911
1912   /* Output the head of the arguments list.  */
1913   lto_output_tree_ref (ob, DECL_ARGUMENTS (function));
1914
1915   /* Output all the SSA names used in the function.  */
1916   output_ssa_names (ob, fn);
1917
1918   /* Output any exception handling regions.  */
1919   output_eh_regions (ob, fn);
1920
1921   /* Output DECL_INITIAL for the function, which contains the tree of
1922      lexical scopes.  */
1923   lto_output_tree (ob, DECL_INITIAL (function), true);
1924
1925   /* We will renumber the statements.  The code that does this uses
1926      the same ordering that we use for serializing them so we can use
1927      the same code on the other end and not have to write out the
1928      statement numbers.  */
1929   renumber_gimple_stmt_uids ();
1930
1931   /* Output the code for the function.  */
1932   FOR_ALL_BB_FN (bb, fn)
1933     output_bb (ob, bb, fn);
1934
1935   /* The terminator for this function.  */
1936   output_zero (ob);
1937
1938   output_cfg (ob, fn);
1939
1940   /* Create a section to hold the pickled output of this function.   */
1941   produce_asm (ob, function);
1942
1943   destroy_output_block (ob);
1944
1945   current_function_decl = NULL;
1946   pop_cfun ();
1947 }
1948
1949
1950 /* Return true if alias pair P belongs to the set of cgraph nodes in
1951    SET.  If P is a an alias for a VAR_DECL, it can always be emitted.
1952    However, for FUNCTION_DECL aliases, we should only output the pair
1953    if it belongs to a function whose cgraph node is in SET.
1954    Otherwise, the LTRANS phase will get into trouble when finalizing
1955    aliases because the alias will refer to a function not defined in
1956    the file processed by LTRANS.  */
1957
1958 static bool
1959 output_alias_pair_p (alias_pair *p, cgraph_node_set set, varpool_node_set vset)
1960 {
1961   if (TREE_CODE (p->decl) == VAR_DECL)
1962     return varpool_node_in_set_p (varpool_node_for_asm (p->target), vset);
1963
1964   /* Check if the assembler name for P->TARGET has its cgraph node in SET.  */
1965   gcc_assert (TREE_CODE (p->decl) == FUNCTION_DECL);
1966   return cgraph_node_in_set_p (cgraph_node_for_asm (p->target), set);
1967 }
1968
1969
1970 /* Output any unreferenced global symbol defined in SET, alias pairs
1971    and labels.  */
1972
1973 static void
1974 output_unreferenced_globals (cgraph_node_set set, varpool_node_set vset)
1975 {
1976   struct output_block *ob;
1977   alias_pair *p;
1978   unsigned i;
1979   struct varpool_node *vnode;
1980
1981   ob = create_output_block (LTO_section_static_initializer);
1982   ob->cgraph_node = NULL;
1983
1984   clear_line_info (ob);
1985
1986   /* Make string 0 be a NULL string.  */
1987   lto_output_1_stream (ob->string_stream, 0);
1988
1989   /* Emit references for all the global symbols.  If a global symbol
1990      was never referenced in any of the functions of this file, it
1991      would not be emitted otherwise.  This will result in unreferenced
1992      symbols at link time if a file defines a global symbol but
1993      never references it.  */
1994   FOR_EACH_STATIC_VARIABLE (vnode)
1995    if (vnode->needed && varpool_node_in_set_p (vnode, vset))
1996       {
1997         tree var = vnode->decl;
1998
1999         if (TREE_CODE (var) == VAR_DECL)
2000           {
2001             /* Output the object in order to output references used in the
2002                initialization. */
2003             lto_output_tree (ob, var, true);
2004
2005             /* If it is public we also need a reference to the object itself. */
2006             if (TREE_PUBLIC (var))
2007               lto_output_tree_ref (ob, var);
2008           }
2009       }
2010
2011   output_zero (ob);
2012
2013   /* Emit the alias pairs for the nodes in SET.  */
2014   FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
2015     {
2016       if (output_alias_pair_p (p, set, vset))
2017         {
2018           lto_output_tree_ref (ob, p->decl);
2019           lto_output_tree_ref (ob, p->target);
2020         }
2021     }
2022
2023   output_zero (ob);
2024
2025   produce_asm (ob, NULL);
2026   destroy_output_block (ob);
2027 }
2028
2029
2030 /* Copy the function body of NODE without deserializing. */
2031
2032 static void
2033 copy_function (struct cgraph_node *node)
2034 {
2035   tree function = node->decl;
2036   struct lto_file_decl_data *file_data = node->local.lto_file_data;
2037   struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
2038   const char *data;
2039   size_t len;
2040   const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
2041   char *section_name =
2042     lto_get_section_name (LTO_section_function_body, name, NULL);
2043   size_t i, j;
2044   struct lto_in_decl_state *in_state;
2045   struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2046
2047   lto_begin_section (section_name, !flag_wpa);
2048   free (section_name);
2049
2050   /* We may have renamed the declaration, e.g., a static function.  */
2051   name = lto_get_decl_name_mapping (file_data, name);
2052
2053   data = lto_get_section_data (file_data, LTO_section_function_body,
2054                                name, &len);
2055   gcc_assert (data);
2056
2057   /* Do a bit copy of the function body.  */
2058   lto_output_data_stream (output_stream, data, len);
2059   lto_write_stream (output_stream);
2060
2061   /* Copy decls. */
2062   in_state =
2063     lto_get_function_in_decl_state (node->local.lto_file_data, function);
2064   gcc_assert (in_state);
2065
2066   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2067     {
2068       size_t n = in_state->streams[i].size;
2069       tree *trees = in_state->streams[i].trees;
2070       struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2071
2072       /* The out state must have the same indices and the in state.
2073          So just copy the vector.  All the encoders in the in state
2074          must be empty where we reach here. */
2075       gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2076       for (j = 0; j < n; j++)
2077         VEC_safe_push (tree, heap, encoder->trees, trees[j]);
2078       encoder->next_index = n;
2079     }
2080
2081   lto_free_section_data (file_data, LTO_section_function_body, name,
2082                          data, len);
2083   free (output_stream);
2084   lto_end_section ();
2085 }
2086
2087
2088 /* Initialize the LTO writer.  */
2089
2090 static void
2091 lto_writer_init (void)
2092 {
2093   lto_streamer_init ();
2094 }
2095
2096
2097 /* Main entry point from the pass manager.  */
2098
2099 static void
2100 lto_output (cgraph_node_set set, varpool_node_set vset)
2101 {
2102   struct cgraph_node *node;
2103   struct lto_out_decl_state *decl_state;
2104 #ifdef ENABLE_CHECKING
2105   bitmap output = lto_bitmap_alloc ();
2106 #endif
2107   int i, n_nodes;
2108   lto_cgraph_encoder_t encoder = lto_get_out_decl_state ()->cgraph_node_encoder;
2109
2110   lto_writer_init ();
2111
2112   n_nodes = lto_cgraph_encoder_size (encoder);
2113   /* Process only the functions with bodies.  */
2114   for (i = 0; i < n_nodes; i++)
2115     {
2116       node = lto_cgraph_encoder_deref (encoder, i);
2117       if (lto_cgraph_encoder_encode_body_p (encoder, node))
2118         {
2119 #ifdef ENABLE_CHECKING
2120           gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
2121           bitmap_set_bit (output, DECL_UID (node->decl));
2122 #endif
2123           decl_state = lto_new_out_decl_state ();
2124           lto_push_out_decl_state (decl_state);
2125           if (gimple_has_body_p (node->decl))
2126             output_function (node);
2127           else
2128             copy_function (node);
2129           gcc_assert (lto_get_out_decl_state () == decl_state);
2130           lto_pop_out_decl_state ();
2131           lto_record_function_out_decl_state (node->decl, decl_state);
2132         }
2133     }
2134
2135   /* Emit the callgraph after emitting function bodies.  This needs to
2136      be done now to make sure that all the statements in every function
2137      have been renumbered so that edges can be associated with call
2138      statements using the statement UIDs.  */
2139   output_cgraph (set, vset);
2140
2141 #ifdef ENABLE_CHECKING
2142   lto_bitmap_free (output);
2143 #endif
2144 }
2145
2146 struct ipa_opt_pass_d pass_ipa_lto_gimple_out =
2147 {
2148  {
2149   IPA_PASS,
2150   "lto_gimple_out",                     /* name */
2151   gate_lto_out,                         /* gate */
2152   NULL,                                 /* execute */
2153   NULL,                                 /* sub */
2154   NULL,                                 /* next */
2155   0,                                    /* static_pass_number */
2156   TV_IPA_LTO_GIMPLE_OUT,                        /* tv_id */
2157   0,                                    /* properties_required */
2158   0,                                    /* properties_provided */
2159   0,                                    /* properties_destroyed */
2160   0,                                    /* todo_flags_start */
2161   TODO_dump_func                        /* todo_flags_finish */
2162  },
2163  NULL,                                  /* generate_summary */
2164  lto_output,                            /* write_summary */
2165  NULL,                                  /* read_summary */
2166  lto_output,                            /* write_optimization_summary */
2167  NULL,                                  /* read_optimization_summary */
2168  NULL,                                  /* stmt_fixup */
2169  0,                                     /* TODOs */
2170  NULL,                                  /* function_transform */
2171  NULL                                   /* variable_transform */
2172 };
2173
2174
2175 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2176    from it and required for correct representation of its semantics.
2177    Each node in ENCODER must be a global declaration or a type.  A node
2178    is written only once, even if it appears multiple times in the
2179    vector.  Certain transitively-reachable nodes, such as those
2180    representing expressions, may be duplicated, but such nodes
2181    must not appear in ENCODER itself.  */
2182
2183 static void
2184 write_global_stream (struct output_block *ob,
2185                      struct lto_tree_ref_encoder *encoder)
2186 {
2187   tree t;
2188   size_t index;
2189   const size_t size = lto_tree_ref_encoder_size (encoder);
2190
2191   for (index = 0; index < size; index++)
2192     {
2193       t = lto_tree_ref_encoder_get_tree (encoder, index);
2194       if (!lto_streamer_cache_lookup (ob->writer_cache, t, NULL))
2195         lto_output_tree (ob, t, false);
2196     }
2197 }
2198
2199
2200 /* Write a sequence of indices into the globals vector corresponding
2201    to the trees in ENCODER.  These are used by the reader to map the
2202    indices used to refer to global entities within function bodies to
2203    their referents.  */
2204
2205 static void
2206 write_global_references (struct output_block *ob,
2207                          struct lto_output_stream *ref_stream,
2208                          struct lto_tree_ref_encoder *encoder)
2209 {
2210   tree t;
2211   int32_t index;
2212   const int32_t size = lto_tree_ref_encoder_size (encoder);
2213
2214   /* Write size as 32-bit unsigned. */
2215   lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
2216
2217   for (index = 0; index < size; index++)
2218     {
2219       int32_t slot_num;
2220
2221       t = lto_tree_ref_encoder_get_tree (encoder, index);
2222       lto_streamer_cache_lookup (ob->writer_cache, t, &slot_num);
2223       gcc_assert (slot_num >= 0);
2224       lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
2225     }
2226 }
2227
2228
2229 /* Write all the streams in an lto_out_decl_state STATE using
2230    output block OB and output stream OUT_STREAM.  */
2231
2232 static void
2233 lto_output_decl_state_streams (struct output_block *ob,
2234                                struct lto_out_decl_state *state)
2235 {
2236   int i;
2237
2238   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2239     write_global_stream (ob, &state->streams[i]);
2240 }
2241
2242
2243 /* Write all the references in an lto_out_decl_state STATE using
2244    output block OB and output stream OUT_STREAM.  */
2245
2246 static void
2247 lto_output_decl_state_refs (struct output_block *ob,
2248                             struct lto_output_stream *out_stream,
2249                             struct lto_out_decl_state *state)
2250 {
2251   unsigned i;
2252   int32_t ref;
2253   tree decl;
2254
2255   /* Write reference to FUNCTION_DECL.  If there is not function,
2256      write reference to void_type_node. */
2257   decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2258   lto_streamer_cache_lookup (ob->writer_cache, decl, &ref);
2259   gcc_assert (ref >= 0);
2260   lto_output_data_stream (out_stream, &ref, sizeof (int32_t));
2261
2262   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2263     write_global_references (ob, out_stream, &state->streams[i]);
2264 }
2265
2266
2267 /* Return the written size of STATE. */
2268
2269 static size_t
2270 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2271 {
2272   int i;
2273   size_t size;
2274
2275   size = sizeof (int32_t);      /* fn_ref. */
2276   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2277     {
2278       size += sizeof (int32_t); /* vector size. */
2279       size += (lto_tree_ref_encoder_size (&state->streams[i])
2280                * sizeof (int32_t));
2281     }
2282   return size;
2283 }
2284
2285
2286 /* Write symbol T into STREAM in CACHE. SEEN specify symbols we wrote so
2287    far.  */
2288
2289 static void
2290 write_symbol (struct lto_streamer_cache_d *cache,
2291               struct lto_output_stream *stream,
2292               tree t, bitmap seen, bool alias)
2293 {
2294   const char *name;
2295   enum gcc_plugin_symbol_kind kind;
2296   enum gcc_plugin_symbol_visibility visibility;
2297   int slot_num;
2298   uint64_t size;
2299   const char *comdat;
2300
2301   /* None of the following kinds of symbols are needed in the
2302      symbol table.  */
2303   if (!TREE_PUBLIC (t)
2304       || is_builtin_fn (t)
2305       || DECL_ABSTRACT (t)
2306       || TREE_CODE (t) == RESULT_DECL)
2307     return;
2308
2309   gcc_assert (TREE_CODE (t) == VAR_DECL
2310               || TREE_CODE (t) == FUNCTION_DECL);
2311
2312   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2313
2314   /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2315      architectures we might have to do the same name manipulations that
2316      ASM_OUTPUT_LABELREF does. */
2317   if (name[0] == '*')
2318     name = &name[1];
2319
2320   lto_streamer_cache_lookup (cache, t, &slot_num);
2321   gcc_assert (slot_num >= 0);
2322
2323   /* Avoid duplicate symbols. */
2324   if (!bitmap_set_bit (seen, slot_num))
2325     return;
2326
2327   if (DECL_EXTERNAL (t))
2328     {
2329       if (DECL_WEAK (t))
2330         kind = GCCPK_WEAKUNDEF;
2331       else
2332         kind = GCCPK_UNDEF;
2333     }
2334   else
2335     {
2336       if (DECL_WEAK (t))
2337         kind = GCCPK_WEAKDEF;
2338       else if (DECL_COMMON (t))
2339         kind = GCCPK_COMMON;
2340       else
2341         kind = GCCPK_DEF;
2342
2343       /* When something is defined, it should have a node attached.
2344          FIXME: For fortran this is still not the case since wrapup global
2345          decls is done after streaming.  */
2346       gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL
2347                   || (cgraph_get_node (t)
2348                       && cgraph_get_node (t)->analyzed));
2349     }
2350
2351   /* Imitate what default_elf_asm_output_external do.
2352      When symbol is external, we need to output it with DEFAULT visibility
2353      when compiling with -fvisibility=default, while with HIDDEN visibility
2354      when symbol has attribute (visibility("hidden")) specified.
2355      targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2356      right. */
2357
2358   if (DECL_EXTERNAL (t)
2359       && !targetm.binds_local_p (t))
2360     visibility = GCCPV_DEFAULT;
2361   else
2362     switch (DECL_VISIBILITY(t))
2363       {
2364       case VISIBILITY_DEFAULT:
2365         visibility = GCCPV_DEFAULT;
2366         break;
2367       case VISIBILITY_PROTECTED:
2368         visibility = GCCPV_PROTECTED;
2369         break;
2370       case VISIBILITY_HIDDEN:
2371         visibility = GCCPV_HIDDEN;
2372         break;
2373       case VISIBILITY_INTERNAL:
2374         visibility = GCCPV_INTERNAL;
2375         break;
2376       }
2377
2378   if (kind == GCCPK_COMMON
2379       && DECL_SIZE (t)
2380       && TREE_CODE (DECL_SIZE (t)) == INTEGER_CST)
2381     size = (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t))) << 32)
2382       | TREE_INT_CST_LOW (DECL_SIZE (t));
2383   else
2384     size = 0;
2385
2386   if (DECL_ONE_ONLY (t))
2387     comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
2388   else
2389     comdat = "";
2390
2391   lto_output_data_stream (stream, name, strlen (name) + 1);
2392   lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
2393   lto_output_data_stream (stream, &kind, 1);
2394   lto_output_data_stream (stream, &visibility, 1);
2395   lto_output_data_stream (stream, &size, 8);
2396   lto_output_data_stream (stream, &slot_num, 4);
2397 }
2398
2399
2400 /* Write an IL symbol table to OB.
2401    SET and VSET are cgraph/varpool node sets we are outputting.  */
2402
2403 static void
2404 produce_symtab (struct output_block *ob,
2405                 cgraph_node_set set, varpool_node_set vset)
2406 {
2407   struct lto_streamer_cache_d *cache = ob->writer_cache;
2408   char *section_name = lto_get_section_name (LTO_section_symtab, NULL, NULL);
2409   bitmap seen;
2410   struct cgraph_node *node, *alias;
2411   struct varpool_node *vnode, *valias;
2412   struct lto_output_stream stream;
2413   lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
2414   lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
2415   int i;
2416   alias_pair *p;
2417
2418   lto_begin_section (section_name, false);
2419   free (section_name);
2420
2421   seen = lto_bitmap_alloc ();
2422   memset (&stream, 0, sizeof (stream));
2423
2424   /* Write all functions.  */
2425   for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
2426     {
2427       node = lto_cgraph_encoder_deref (encoder, i);
2428       if (node->alias)
2429         continue;
2430       write_symbol (cache, &stream, node->decl, seen, false);
2431       for (alias = node->same_body; alias; alias = alias->next)
2432         write_symbol (cache, &stream, alias->decl, seen, true);
2433     }
2434
2435   /* Write all variables.  */
2436   for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
2437     {
2438       vnode = lto_varpool_encoder_deref (varpool_encoder, i);
2439       if (vnode->alias)
2440         continue;
2441       write_symbol (cache, &stream, vnode->decl, seen, false);
2442       for (valias = vnode->extra_name; valias; valias = valias->next)
2443         write_symbol (cache, &stream, valias->decl, seen, true);
2444     }
2445
2446   /* Write all aliases.  */
2447   FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
2448     if (output_alias_pair_p (p, set, vset))
2449       write_symbol (cache, &stream, p->decl, seen, true);
2450
2451   lto_write_stream (&stream);
2452   lto_bitmap_free (seen);
2453
2454   lto_end_section ();
2455 }
2456
2457
2458 /* This pass is run after all of the functions are serialized and all
2459    of the IPA passes have written their serialized forms.  This pass
2460    causes the vector of all of the global decls and types used from
2461    this file to be written in to a section that can then be read in to
2462    recover these on other side.  */
2463
2464 static void
2465 produce_asm_for_decls (cgraph_node_set set, varpool_node_set vset)
2466 {
2467   struct lto_out_decl_state *out_state;
2468   struct lto_out_decl_state *fn_out_state;
2469   struct lto_decl_header header;
2470   char *section_name;
2471   struct output_block *ob;
2472   struct lto_output_stream *header_stream, *decl_state_stream;
2473   unsigned idx, num_fns;
2474   size_t decl_state_size;
2475   int32_t num_decl_states;
2476
2477   ob = create_output_block (LTO_section_decls);
2478   ob->global = true;
2479
2480   /* Write out unreferenced globals, alias pairs and labels.  We defer
2481      doing this until now so that we can write out only what is
2482      needed.  */
2483   output_unreferenced_globals (set, vset);
2484
2485   memset (&header, 0, sizeof (struct lto_decl_header));
2486
2487   section_name = lto_get_section_name (LTO_section_decls, NULL, NULL);
2488   lto_begin_section (section_name, !flag_wpa);
2489   free (section_name);
2490
2491   /* Make string 0 be a NULL string.  */
2492   lto_output_1_stream (ob->string_stream, 0);
2493
2494   /* Write the global symbols.  */
2495   out_state = lto_get_out_decl_state ();
2496   num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2497   lto_output_decl_state_streams (ob, out_state);
2498   for (idx = 0; idx < num_fns; idx++)
2499     {
2500       fn_out_state =
2501         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2502       lto_output_decl_state_streams (ob, fn_out_state);
2503     }
2504
2505   header.lto_header.major_version = LTO_major_version;
2506   header.lto_header.minor_version = LTO_minor_version;
2507   header.lto_header.section_type = LTO_section_decls;
2508
2509   /* Currently not used.  This field would allow us to preallocate
2510      the globals vector, so that it need not be resized as it is extended.  */
2511   header.num_nodes = -1;
2512
2513   /* Compute the total size of all decl out states. */
2514   decl_state_size = sizeof (int32_t);
2515   decl_state_size += lto_out_decl_state_written_size (out_state);
2516   for (idx = 0; idx < num_fns; idx++)
2517     {
2518       fn_out_state =
2519         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2520       decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2521     }
2522   header.decl_state_size = decl_state_size;
2523
2524   header.main_size = ob->main_stream->total_size;
2525   header.string_size = ob->string_stream->total_size;
2526
2527   header_stream = XCNEW (struct lto_output_stream);
2528   lto_output_data_stream (header_stream, &header, sizeof header);
2529   lto_write_stream (header_stream);
2530   free (header_stream);
2531
2532   /* Write the main out-decl state, followed by out-decl states of
2533      functions. */
2534   decl_state_stream = ((struct lto_output_stream *)
2535                        xcalloc (1, sizeof (struct lto_output_stream)));
2536   num_decl_states = num_fns + 1;
2537   lto_output_data_stream (decl_state_stream, &num_decl_states,
2538                           sizeof (num_decl_states));
2539   lto_output_decl_state_refs (ob, decl_state_stream, out_state);
2540   for (idx = 0; idx < num_fns; idx++)
2541     {
2542       fn_out_state =
2543         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2544       lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
2545     }
2546   lto_write_stream (decl_state_stream);
2547   free(decl_state_stream);
2548
2549   lto_write_stream (ob->main_stream);
2550   lto_write_stream (ob->string_stream);
2551
2552   lto_end_section ();
2553
2554   /* Write the symbol table.  It is used by linker to determine dependencies
2555      and thus we can skip it for WPA.  */
2556   if (!flag_wpa)
2557     produce_symtab (ob, set, vset);
2558
2559   /* Write command line opts.  */
2560   lto_write_options ();
2561
2562   /* Deallocate memory and clean up.  */
2563   for (idx = 0; idx < num_fns; idx++)
2564     {
2565       fn_out_state =
2566         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2567       lto_delete_out_decl_state (fn_out_state);
2568     }
2569   lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
2570   lto_varpool_encoder_delete (ob->decl_state->varpool_node_encoder);
2571   VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
2572   lto_function_decl_states = NULL;
2573   destroy_output_block (ob);
2574 }
2575
2576
2577 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
2578 {
2579  {
2580   IPA_PASS,
2581   "lto_decls_out",                      /* name */
2582   gate_lto_out,                         /* gate */
2583   NULL,                                 /* execute */
2584   NULL,                                 /* sub */
2585   NULL,                                 /* next */
2586   0,                                    /* static_pass_number */
2587   TV_IPA_LTO_DECL_OUT,                  /* tv_id */
2588   0,                                    /* properties_required */
2589   0,                                    /* properties_provided */
2590   0,                                    /* properties_destroyed */
2591   0,                                    /* todo_flags_start */
2592   0                                     /* todo_flags_finish */
2593  },
2594  NULL,                                  /* generate_summary */
2595  produce_asm_for_decls,                 /* write_summary */
2596  NULL,                                  /* read_summary */
2597  produce_asm_for_decls,                 /* write_optimization_summary */
2598  NULL,                                  /* read_optimization_summary */
2599  NULL,                                  /* stmt_fixup */
2600  0,                                     /* TODOs */
2601  NULL,                                  /* function_transform */
2602  NULL                                   /* variable_transform */
2603 };