gcc/lto-streamer-out.c

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