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