gcc/lto-cgraph.c

   1 /* Write and read the cgraph to the memory mapped representation of a
   2    .o file.
   3
   4    Copyright 2009 Free Software Foundation, Inc.
   5    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "toplev.h"
  28 #include "tree.h"
  29 #include "expr.h"
  30 #include "flags.h"
  31 #include "params.h"
  32 #include "input.h"
  33 #include "hashtab.h"
  34 #include "langhooks.h"
  35 #include "basic-block.h"
  36 #include "tree-flow.h"
  37 #include "cgraph.h"
  38 #include "function.h"
  39 #include "ggc.h"
  40 #include "diagnostic.h"
  41 #include "except.h"
  42 #include "vec.h"
  43 #include "timevar.h"
  44 #include "output.h"
  45 #include "pointer-set.h"
  46 #include "lto-streamer.h"
  47 #include "gcov-io.h"
  48
  49 /* Cgraph streaming is organized as set of record whose type
  50    is indicated by a tag.  */
  51 enum LTO_cgraph_tags
  52 {
  53   /* Must leave 0 for the stopper.  */
  54
  55   /* Cgraph node without body available.  */
  56   LTO_cgraph_unavail_node = 1,
  57   /* Cgraph node with function body.  */
  58   LTO_cgraph_analyzed_node,
  59   /* Cgraph edges.  */
  60   LTO_cgraph_edge,
  61   LTO_cgraph_indirect_edge
  62 };
  63
  64 /* Create a new cgraph encoder.  */
  65
  66 lto_cgraph_encoder_t
  67 lto_cgraph_encoder_new (void)
  68 {
  69   lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
  70   encoder->map = pointer_map_create ();
  71   encoder->nodes = NULL;
  72   return encoder;
  73 }
  74
  75
  76 /* Delete ENCODER and its components.  */
  77
  78 void
  79 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
  80 {
  81    VEC_free (cgraph_node_ptr, heap, encoder->nodes);
  82    pointer_map_destroy (encoder->map);
  83    free (encoder);
  84 }
  85
  86
  87 /* Return the existing reference number of NODE in the cgraph encoder in
  88    output block OB.  Assign a new reference if this is the first time
  89    NODE is encoded.  */
  90
  91 int
  92 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
  93                            struct cgraph_node *node)
  94 {
  95   int ref;
  96   void **slot;
  97
  98   slot = pointer_map_contains (encoder->map, node);
  99   if (!slot)
 100     {
 101       ref = VEC_length (cgraph_node_ptr, encoder->nodes);
 102       slot = pointer_map_insert (encoder->map, node);
 103       *slot = (void *) (intptr_t) ref;
 104       VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
 105     }
 106   else
 107     ref = (int) (intptr_t) *slot;
 108
 109   return ref;
 110 }
 111
 112 #define LCC_NOT_FOUND   (-1)
 113
 114 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
 115    or LCC_NOT_FOUND if it is not there.  */
 116
 117 int
 118 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
 119                            struct cgraph_node *node)
 120 {
 121   void **slot = pointer_map_contains (encoder->map, node);
 122   return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
 123 }
 124
 125
 126 /* Return the cgraph node corresponding to REF using ENCODER.  */
 127
 128 struct cgraph_node *
 129 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
 130 {
 131   if (ref == LCC_NOT_FOUND)
 132     return NULL;
 133
 134   return VEC_index (cgraph_node_ptr, encoder->nodes, ref);
 135 }
 136
 137
 138 /* Return number of encoded nodes in ENCODER.  */
 139
 140 static int
 141 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
 142 {
 143   return VEC_length (cgraph_node_ptr, encoder->nodes);
 144 }
 145
 146
 147 /* Output the cgraph EDGE to OB using ENCODER.  */
 148
 149 static void
 150 lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
 151                  lto_cgraph_encoder_t encoder)
 152 {
 153   unsigned int uid;
 154   intptr_t ref;
 155   struct bitpack_d *bp;
 156
 157   if (edge->indirect_unknown_callee)
 158     lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
 159   else
 160     lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
 161
 162   ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
 163   gcc_assert (ref != LCC_NOT_FOUND);
 164   lto_output_sleb128_stream (ob->main_stream, ref);
 165
 166   if (!edge->indirect_unknown_callee)
 167     {
 168       ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
 169       gcc_assert (ref != LCC_NOT_FOUND);
 170       lto_output_sleb128_stream (ob->main_stream, ref);
 171     }
 172
 173   lto_output_sleb128_stream (ob->main_stream, edge->count);
 174
 175   bp = bitpack_create ();
 176   uid = flag_wpa ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt);
 177   bp_pack_value (bp, uid, HOST_BITS_PER_INT);
 178   bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
 179   bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
 180   bp_pack_value (bp, edge->loop_nest, 30);
 181   bp_pack_value (bp, edge->indirect_inlining_edge, 1);
 182   bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
 183   bp_pack_value (bp, edge->can_throw_external, 1);
 184   lto_output_bitpack (ob->main_stream, bp);
 185   bitpack_delete (bp);
 186 }
 187
 188 /* Return true when node is reachable from other partition.  */
 189
 190 static bool
 191 reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
 192 {
 193   struct cgraph_edge *e;
 194   if (node->needed)
 195     return true;
 196   if (!node->analyzed)
 197     return false;
 198   if (node->global.inlined_to)
 199     return false;
 200   for (e = node->callers; e; e = e->next_caller)
 201     if (!cgraph_node_in_set_p (e->caller, set))
 202       return true;
 203   return false;
 204 }
 205
 206 /* Output the cgraph NODE to OB.  ENCODER is used to find the
 207    reference number of NODE->inlined_to.  SET is the set of nodes we
 208    are writing to the current file.  If NODE is not in SET, then NODE
 209    is a boundary of a cgraph_node_set and we pretend NODE just has a
 210    decl and no callees.  WRITTEN_DECLS is the set of FUNCTION_DECLs
 211    that have had their callgraph node written so far.  This is used to
 212    determine if NODE is a clone of a previously written node.  */
 213
 214 static void
 215 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 216                  lto_cgraph_encoder_t encoder, cgraph_node_set set,
 217                  bitmap written_decls)
 218 {
 219   unsigned int tag;
 220   struct bitpack_d *bp;
 221   bool boundary_p, wrote_decl_p;
 222   intptr_t ref;
 223   bool in_other_partition = false;
 224
 225   boundary_p = !cgraph_node_in_set_p (node, set);
 226   wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
 227
 228   if (node->analyzed && !boundary_p)
 229     tag = LTO_cgraph_analyzed_node;
 230   else
 231     tag = LTO_cgraph_unavail_node;
 232
 233   lto_output_uleb128_stream (ob->main_stream, tag);
 234
 235   /* In WPA mode, we only output part of the call-graph.  Also, we
 236      fake cgraph node attributes.  There are two cases that we care.
 237
 238      Boundary nodes: There are nodes that are not part of SET but are
 239      called from within SET.  We artificially make them look like
 240      externally visible nodes with no function body.
 241
 242      Cherry-picked nodes:  These are nodes we pulled from other
 243      translation units into SET during IPA-inlining.  We make them as
 244      local static nodes to prevent clashes with other local statics.  */
 245   if (boundary_p && node->analyzed)
 246     {
 247       /* Inline clones can not be part of boundary.
 248          gcc_assert (!node->global.inlined_to);
 249
 250          FIXME: At the moment they can be, when partition contains an inline
 251          clone that is clone of inline clone from outside partition.  We can
 252          reshape the clone tree and make other tree to be the root, but it
 253          needs a bit extra work and will be promplty done by cgraph_remove_node
 254          after reading back.  */
 255       in_other_partition = 1;
 256     }
 257
 258   lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
 259
 260   if (!wrote_decl_p)
 261     bitmap_set_bit (written_decls, DECL_UID (node->decl));
 262
 263   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
 264   lto_output_sleb128_stream (ob->main_stream, node->count);
 265
 266   bp = bitpack_create ();
 267   bp_pack_value (bp, node->local.local, 1);
 268   bp_pack_value (bp, node->local.externally_visible, 1);
 269   bp_pack_value (bp, node->local.finalized, 1);
 270   bp_pack_value (bp, node->local.inlinable, 1);
 271   bp_pack_value (bp, node->local.disregard_inline_limits, 1);
 272   bp_pack_value (bp, node->local.redefined_extern_inline, 1);
 273   bp_pack_value (bp, node->local.vtable_method, 1);
 274   bp_pack_value (bp, node->needed, 1);
 275   bp_pack_value (bp, node->address_taken, 1);
 276   bp_pack_value (bp, node->abstract_and_needed, 1);
 277   bp_pack_value (bp, tag == LTO_cgraph_analyzed_node
 278                  && reachable_from_other_partition_p (node, set), 1);
 279   bp_pack_value (bp, node->lowered, 1);
 280   bp_pack_value (bp, in_other_partition, 1);
 281   bp_pack_value (bp, node->alias, 1);
 282   bp_pack_value (bp, node->finalized_by_frontend, 1);
 283   bp_pack_value (bp, node->frequency, 2);
 284   lto_output_bitpack (ob->main_stream, bp);
 285   bitpack_delete (bp);
 286
 287   if (tag == LTO_cgraph_analyzed_node)
 288     {
 289       lto_output_sleb128_stream (ob->main_stream,
 290                                  node->local.inline_summary.estimated_self_stack_size);
 291       lto_output_sleb128_stream (ob->main_stream,
 292                                  node->local.inline_summary.self_size);
 293       lto_output_sleb128_stream (ob->main_stream,
 294                                  node->local.inline_summary.size_inlining_benefit);
 295       lto_output_sleb128_stream (ob->main_stream,
 296                                  node->local.inline_summary.self_time);
 297       lto_output_sleb128_stream (ob->main_stream,
 298                                  node->local.inline_summary.time_inlining_benefit);
 299       if (node->global.inlined_to)
 300         {
 301           ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
 302           gcc_assert (ref != LCC_NOT_FOUND);
 303         }
 304       else
 305         ref = LCC_NOT_FOUND;
 306
 307       lto_output_sleb128_stream (ob->main_stream, ref);
 308     }
 309
 310   if (node->same_comdat_group && !boundary_p)
 311     {
 312       ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
 313       gcc_assert (ref != LCC_NOT_FOUND);
 314     }
 315   else
 316     ref = LCC_NOT_FOUND;
 317   lto_output_sleb128_stream (ob->main_stream, ref);
 318
 319   if (node->same_body)
 320     {
 321       struct cgraph_node *alias;
 322       unsigned long alias_count = 1;
 323       for (alias = node->same_body; alias->next; alias = alias->next)
 324         alias_count++;
 325       lto_output_uleb128_stream (ob->main_stream, alias_count);
 326       do
 327         {
 328           lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 329                                     alias->decl);
 330           if (alias->thunk.thunk_p)
 331             {
 332               lto_output_uleb128_stream
 333                  (ob->main_stream,
 334                   1 + (alias->thunk.this_adjusting != 0) * 2
 335                   + (alias->thunk.virtual_offset_p != 0) * 4);
 336               lto_output_uleb128_stream (ob->main_stream,
 337                                          alias->thunk.fixed_offset);
 338               lto_output_uleb128_stream (ob->main_stream,
 339                                          alias->thunk.virtual_value);
 340               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 341                                         alias->thunk.alias);
 342             }
 343           else
 344             {
 345               lto_output_uleb128_stream (ob->main_stream, 0);
 346               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 347                                         alias->thunk.alias);
 348             }
 349           alias = alias->previous;
 350         }
 351       while (alias);
 352     }
 353   else
 354     lto_output_uleb128_stream (ob->main_stream, 0);
 355 }
 356
 357 /* Output the varpool NODE to OB.
 358    If NODE is not in SET, then NODE is a boundary.  */
 359
 360 static void
 361 lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
 362                          varpool_node_set set)
 363 {
 364   bool boundary_p = !varpool_node_in_set_p (node, set) && node->analyzed;
 365   struct bitpack_d *bp;
 366   struct varpool_node *alias;
 367   int count = 0;
 368
 369   lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
 370   bp = bitpack_create ();
 371   bp_pack_value (bp, node->externally_visible, 1);
 372   bp_pack_value (bp, node->force_output, 1);
 373   bp_pack_value (bp, node->finalized, 1);
 374   gcc_assert (node->finalized || !node->analyzed);
 375   gcc_assert (node->needed);
 376   gcc_assert (!node->alias);
 377   /* FIXME: We have no idea how we move references around.  For moment assume that
 378      everything is used externally.  */
 379   bp_pack_value (bp, flag_wpa, 1);  /* used_from_other_parition.  */
 380   bp_pack_value (bp, boundary_p, 1);  /* in_other_partition.  */
 381   /* Also emit any extra name aliases.  */
 382   for (alias = node->extra_name; alias; alias = alias->next)
 383     count++;
 384   bp_pack_value (bp, count != 0, 1);
 385   lto_output_bitpack (ob->main_stream, bp);
 386   bitpack_delete (bp);
 387
 388   if (count)
 389     {
 390       lto_output_uleb128_stream (ob->main_stream, count);
 391       for (alias = node->extra_name; alias; alias = alias->next)
 392         lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
 393     }
 394 }
 395
 396 /* Stream out profile_summary to OB.  */
 397
 398 static void
 399 output_profile_summary (struct lto_simple_output_block *ob)
 400 {
 401   if (profile_info)
 402     {
 403       /* We do not output num, it is not terribly useful.  */
 404       gcc_assert (profile_info->runs);
 405       lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
 406       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
 407       lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
 408       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
 409     }
 410   else
 411     lto_output_uleb128_stream (ob->main_stream, 0);
 412 }
 413
 414 /* Add NODE into encoder as well as nodes it is cloned from.
 415    Do it in a way so clones appear first.  */
 416 static void
 417 add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
 418 {
 419   if (node->clone_of)
 420     add_node_to (encoder, node->clone_of);
 421   lto_cgraph_encoder_encode (encoder, node);
 422 }
 423
 424 /* Output all callees or indirect outgoing edges.  EDGE must be the first such
 425    edge.  */
 426
 427 static void
 428 output_outgoing_cgraph_edges (struct cgraph_edge *edge,
 429                               struct lto_simple_output_block *ob,
 430                               lto_cgraph_encoder_t encoder)
 431 {
 432   if (!edge)
 433     return;
 434
 435   /* Output edges in backward direction, so the reconstructed callgraph match
 436      and it is easy to associate call sites in the IPA pass summaries.  */
 437   while (edge->next_callee)
 438     edge = edge->next_callee;
 439   for (; edge; edge = edge->prev_callee)
 440     lto_output_edge (ob, edge, encoder);
 441 }
 442
 443 /* Output the part of the cgraph in SET.  */
 444
 445 void
 446 output_cgraph (cgraph_node_set set)
 447 {
 448   struct cgraph_node *node;
 449   struct lto_simple_output_block *ob;
 450   cgraph_node_set_iterator csi;
 451   struct cgraph_edge *edge;
 452   int i, n_nodes;
 453   bitmap written_decls;
 454   lto_cgraph_encoder_t encoder;
 455   struct cgraph_asm_node *can;
 456
 457   ob = lto_create_simple_output_block (LTO_section_cgraph);
 458
 459   output_profile_summary (ob);
 460
 461   /* An encoder for cgraph nodes should have been created by
 462      ipa_write_summaries_1.  */
 463   gcc_assert (ob->decl_state->cgraph_node_encoder);
 464   encoder = ob->decl_state->cgraph_node_encoder;
 465
 466   /* The FUNCTION_DECLs for which we have written a node.  The first
 467      node found is written as the "original" node, the remaining nodes
 468      are considered its clones.  */
 469   written_decls = lto_bitmap_alloc ();
 470
 471   /* Go over all the nodes in SET and assign references.  */
 472   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 473     {
 474       node = csi_node (csi);
 475       add_node_to (encoder, node);
 476     }
 477
 478   /* Go over all the nodes again to include callees that are not in
 479      SET.  */
 480   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 481     {
 482       node = csi_node (csi);
 483       for (edge = node->callees; edge; edge = edge->next_callee)
 484         {
 485           struct cgraph_node *callee = edge->callee;
 486           if (!cgraph_node_in_set_p (callee, set))
 487             {
 488               /* We should have moved all the inlines.  */
 489               gcc_assert (!callee->global.inlined_to);
 490               add_node_to (encoder, callee);
 491             }
 492         }
 493     }
 494
 495   /* Write out the nodes.  We must first output a node and then its clones,
 496      otherwise at a time reading back the node there would be nothing to clone
 497      from.  */
 498   n_nodes = lto_cgraph_encoder_size (encoder);
 499   for (i = 0; i < n_nodes; i++)
 500     {
 501       node = lto_cgraph_encoder_deref (encoder, i);
 502       lto_output_node (ob, node, encoder, set, written_decls);
 503     }
 504
 505   lto_bitmap_free (written_decls);
 506
 507   /* Go over the nodes in SET again to write edges.  */
 508   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 509     {
 510       node = csi_node (csi);
 511       output_outgoing_cgraph_edges (node->callees, ob, encoder);
 512       output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
 513     }
 514
 515   lto_output_uleb128_stream (ob->main_stream, 0);
 516
 517   /* Emit toplevel asms.  */
 518   for (can = cgraph_asm_nodes; can; can = can->next)
 519     {
 520       int len = TREE_STRING_LENGTH (can->asm_str);
 521       lto_output_uleb128_stream (ob->main_stream, len);
 522       for (i = 0; i < len; ++i)
 523         lto_output_1_stream (ob->main_stream,
 524                              TREE_STRING_POINTER (can->asm_str)[i]);
 525     }
 526
 527   lto_output_uleb128_stream (ob->main_stream, 0);
 528
 529   lto_destroy_simple_output_block (ob);
 530 }
 531
 532 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
 533    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
 534    NODE or to replace the values in it, for instance because the first
 535    time we saw it, the function body was not available but now it
 536    is.  BP is a bitpack with all the bitflags for NODE read from the
 537    stream.  */
 538
 539 static void
 540 input_overwrite_node (struct lto_file_decl_data *file_data,
 541                       struct cgraph_node *node,
 542                       enum LTO_cgraph_tags tag,
 543                       struct bitpack_d *bp,
 544                       unsigned int stack_size,
 545                       unsigned int self_time,
 546                       unsigned int time_inlining_benefit,
 547                       unsigned int self_size,
 548                       unsigned int size_inlining_benefit)
 549 {
 550   node->aux = (void *) tag;
 551   node->local.inline_summary.estimated_self_stack_size = stack_size;
 552   node->local.inline_summary.self_time = self_time;
 553   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
 554   node->local.inline_summary.self_size = self_size;
 555   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
 556   node->global.time = self_time;
 557   node->global.size = self_size;
 558   node->global.estimated_stack_size = stack_size;
 559   node->global.estimated_growth = INT_MIN;
 560   node->local.lto_file_data = file_data;
 561
 562   node->local.local = bp_unpack_value (bp, 1);
 563   node->local.externally_visible = bp_unpack_value (bp, 1);
 564   node->local.finalized = bp_unpack_value (bp, 1);
 565   node->local.inlinable = bp_unpack_value (bp, 1);
 566   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
 567   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
 568   node->local.vtable_method = bp_unpack_value (bp, 1);
 569   node->needed = bp_unpack_value (bp, 1);
 570   node->address_taken = bp_unpack_value (bp, 1);
 571   node->abstract_and_needed = bp_unpack_value (bp, 1);
 572   node->reachable_from_other_partition = bp_unpack_value (bp, 1);
 573   node->lowered = bp_unpack_value (bp, 1);
 574   node->analyzed = tag == LTO_cgraph_analyzed_node;
 575   node->in_other_partition = bp_unpack_value (bp, 1);
 576   node->alias = bp_unpack_value (bp, 1);
 577   node->finalized_by_frontend = bp_unpack_value (bp, 1);
 578   node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
 579 }
 580
 581 /* Output the part of the cgraph in SET.  */
 582
 583 void
 584 output_varpool (varpool_node_set set)
 585 {
 586   struct varpool_node *node;
 587   struct lto_simple_output_block *ob;
 588   int len = 0;
 589
 590   ob = lto_create_simple_output_block (LTO_section_varpool);
 591
 592   for (node = varpool_nodes; node; node = node->next)
 593     if (node->needed && node->analyzed)
 594       len++;
 595
 596   lto_output_uleb128_stream (ob->main_stream, len);
 597
 598   /* Write out the nodes.  We must first output a node and then its clones,
 599      otherwise at a time reading back the node there would be nothing to clone
 600      from.  */
 601   for (node = varpool_nodes; node; node = node->next)
 602     if (node->needed && node->analyzed)
 603       lto_output_varpool_node (ob, node, set);
 604
 605   lto_destroy_simple_output_block (ob);
 606 }
 607
 608 /* Read a node from input_block IB.  TAG is the node's tag just read.
 609    Return the node read or overwriten.  */
 610
 611 static struct cgraph_node *
 612 input_node (struct lto_file_decl_data *file_data,
 613             struct lto_input_block *ib,
 614             enum LTO_cgraph_tags tag)
 615 {
 616   tree fn_decl;
 617   struct cgraph_node *node;
 618   struct bitpack_d *bp;
 619   int stack_size = 0;
 620   unsigned decl_index;
 621   bool clone_p;
 622   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
 623   int self_time = 0;
 624   int self_size = 0;
 625   int time_inlining_benefit = 0;
 626   int size_inlining_benefit = 0;
 627   unsigned long same_body_count = 0;
 628
 629   clone_p = (lto_input_uleb128 (ib) != 0);
 630
 631   decl_index = lto_input_uleb128 (ib);
 632   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 633
 634   if (clone_p)
 635     node = cgraph_clone_node (cgraph_node (fn_decl), 0,
 636                               CGRAPH_FREQ_BASE, 0, false, NULL);
 637
 638   else
 639     node = cgraph_node (fn_decl);
 640
 641   node->count = lto_input_sleb128 (ib);
 642   bp = lto_input_bitpack (ib);
 643
 644   if (tag == LTO_cgraph_analyzed_node)
 645     {
 646       stack_size = lto_input_sleb128 (ib);
 647       self_size = lto_input_sleb128 (ib);
 648       size_inlining_benefit = lto_input_sleb128 (ib);
 649       self_time = lto_input_sleb128 (ib);
 650       time_inlining_benefit = lto_input_sleb128 (ib);
 651
 652       ref = lto_input_sleb128 (ib);
 653     }
 654
 655   ref2 = lto_input_sleb128 (ib);
 656   same_body_count = lto_input_uleb128 (ib);
 657
 658   /* Make sure that we have not read this node before.  Nodes that
 659      have already been read will have their tag stored in the 'aux'
 660      field.  Since built-in functions can be referenced in multiple
 661      functions, they are expected to be read more than once.  */
 662   if (node->aux && !DECL_IS_BUILTIN (node->decl))
 663     internal_error ("bytecode stream: found multiple instances of cgraph "
 664                     "node %d", node->uid);
 665
 666   input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
 667                         time_inlining_benefit, self_size,
 668                         size_inlining_benefit);
 669   bitpack_delete (bp);
 670
 671   /* Store a reference for now, and fix up later to be a pointer.  */
 672   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
 673
 674   /* Store a reference for now, and fix up later to be a pointer.  */
 675   node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
 676
 677   while (same_body_count-- > 0)
 678     {
 679       tree alias_decl;
 680       int type;
 681       decl_index = lto_input_uleb128 (ib);
 682       alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 683       type = lto_input_uleb128 (ib);
 684       if (!type)
 685         {
 686           tree real_alias;
 687           decl_index = lto_input_uleb128 (ib);
 688           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 689           cgraph_same_body_alias (alias_decl, real_alias);
 690         }
 691       else
 692         {
 693           HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
 694           HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
 695           tree real_alias;
 696           decl_index = lto_input_uleb128 (ib);
 697           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 698           cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
 699                             virtual_value,
 700                             (type & 4) ? size_int (virtual_value) : NULL_TREE,
 701                             real_alias);
 702         }
 703     }
 704   return node;
 705 }
 706
 707 /* Read a node from input_block IB.  TAG is the node's tag just read.
 708    Return the node read or overwriten.  */
 709
 710 static struct varpool_node *
 711 input_varpool_node (struct lto_file_decl_data *file_data,
 712                     struct lto_input_block *ib)
 713 {
 714   int decl_index;
 715   tree var_decl;
 716   struct varpool_node *node;
 717   struct bitpack_d *bp;
 718   bool aliases_p;
 719   int count;
 720
 721   decl_index = lto_input_uleb128 (ib);
 722   var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
 723   node = varpool_node (var_decl);
 724
 725   bp = lto_input_bitpack (ib);
 726   node->externally_visible = bp_unpack_value (bp, 1);
 727   node->force_output = bp_unpack_value (bp, 1);
 728   node->finalized = bp_unpack_value (bp, 1);
 729   node->analyzed = 1;
 730   node->used_from_other_partition = bp_unpack_value (bp, 1);
 731   node->in_other_partition = bp_unpack_value (bp, 1);
 732   aliases_p = bp_unpack_value (bp, 1);
 733   if (node->finalized)
 734     varpool_mark_needed_node (node);
 735   bitpack_delete (bp);
 736   if (aliases_p)
 737     {
 738       count = lto_input_uleb128 (ib);
 739       for (; count > 0; count --)
 740         {
 741           tree decl = lto_file_decl_data_get_var_decl (file_data,
 742                                                        lto_input_uleb128 (ib));
 743           varpool_extra_name_alias (decl, var_decl);
 744         }
 745     }
 746   return node;
 747 }
 748
 749
 750 /* Read an edge from IB.  NODES points to a vector of previously read nodes for
 751    decoding caller and callee of the edge to be read.  If INDIRECT is true, the
 752    edge being read is indirect (in the sense that it has
 753    indirect_unknown_callee set).  */
 754
 755 static void
 756 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
 757             bool indirect)
 758 {
 759   struct cgraph_node *caller, *callee;
 760   struct cgraph_edge *edge;
 761   unsigned int stmt_id;
 762   gcov_type count;
 763   int freq;
 764   unsigned int nest;
 765   cgraph_inline_failed_t inline_failed;
 766   struct bitpack_d *bp;
 767   enum ld_plugin_symbol_resolution caller_resolution;
 768
 769   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 770   if (caller == NULL || caller->decl == NULL_TREE)
 771     internal_error ("bytecode stream: no caller found while reading edge");
 772
 773   if (!indirect)
 774     {
 775       callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 776       if (callee == NULL || callee->decl == NULL_TREE)
 777         internal_error ("bytecode stream: no callee found while reading edge");
 778     }
 779   else
 780     callee = NULL;
 781
 782   count = (gcov_type) lto_input_sleb128 (ib);
 783
 784   bp = lto_input_bitpack (ib);
 785   stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 786   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
 787                                                             HOST_BITS_PER_INT);
 788   freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 789   nest = (unsigned) bp_unpack_value (bp, 30);
 790
 791   /* If the caller was preempted, don't create the edge.
 792      ???  Should we ever have edges from a preempted caller?  */
 793   caller_resolution = lto_symtab_get_resolution (caller->decl);
 794   if (caller_resolution == LDPR_PREEMPTED_REG
 795       || caller_resolution == LDPR_PREEMPTED_IR)
 796     return;
 797
 798   if (indirect)
 799     edge = cgraph_create_indirect_edge (caller, NULL, count, freq, nest);
 800   else
 801     edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
 802
 803   edge->indirect_inlining_edge = bp_unpack_value (bp, 1);
 804   edge->lto_stmt_uid = stmt_id;
 805   edge->inline_failed = inline_failed;
 806   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
 807   edge->can_throw_external = bp_unpack_value (bp, 1);
 808   bitpack_delete (bp);
 809 }
 810
 811
 812 /* Read a cgraph from IB using the info in FILE_DATA.  */
 813
 814 static void
 815 input_cgraph_1 (struct lto_file_decl_data *file_data,
 816                 struct lto_input_block *ib)
 817 {
 818   enum LTO_cgraph_tags tag;
 819   VEC(cgraph_node_ptr, heap) *nodes = NULL;
 820   struct cgraph_node *node;
 821   unsigned i;
 822   unsigned HOST_WIDE_INT len;
 823
 824   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 825   while (tag)
 826     {
 827       if (tag == LTO_cgraph_edge)
 828         input_edge (ib, nodes, false);
 829       else if (tag == LTO_cgraph_indirect_edge)
 830         input_edge (ib, nodes, true);
 831       else
 832         {
 833           node = input_node (file_data, ib, tag);
 834           if (node == NULL || node->decl == NULL_TREE)
 835             internal_error ("bytecode stream: found empty cgraph node");
 836           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
 837           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
 838         }
 839
 840       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 841     }
 842
 843   /* Input toplevel asms.  */
 844   len = lto_input_uleb128 (ib);
 845   while (len)
 846     {
 847       char *str = (char *)xmalloc (len + 1);
 848       for (i = 0; i < len; ++i)
 849         str[i] = lto_input_1_unsigned (ib);
 850       cgraph_add_asm_node (build_string (len, str));
 851       free (str);
 852
 853       len = lto_input_uleb128 (ib);
 854     }
 855
 856   for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
 857     {
 858       int ref = (int) (intptr_t) node->global.inlined_to;
 859
 860       /* Fixup inlined_to from reference to pointer.  */
 861       if (ref != LCC_NOT_FOUND)
 862         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
 863       else
 864         node->global.inlined_to = NULL;
 865
 866       ref = (int) (intptr_t) node->same_comdat_group;
 867
 868       /* Fixup same_comdat_group from reference to pointer.  */
 869       if (ref != LCC_NOT_FOUND)
 870         node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
 871       else
 872         node->same_comdat_group = NULL;
 873     }
 874
 875   VEC_free (cgraph_node_ptr, heap, nodes);
 876 }
 877
 878 /* Read a varpool from IB using the info in FILE_DATA.  */
 879
 880 static void
 881 input_varpool_1 (struct lto_file_decl_data *file_data,
 882                 struct lto_input_block *ib)
 883 {
 884   unsigned HOST_WIDE_INT len;
 885
 886   len = lto_input_uleb128 (ib);
 887   while (len)
 888     {
 889       input_varpool_node (file_data, ib);
 890       len--;
 891     }
 892 }
 893
 894 static struct gcov_ctr_summary lto_gcov_summary;
 895
 896 /* Input profile_info from IB.  */
 897 static void
 898 input_profile_summary (struct lto_input_block *ib)
 899 {
 900   unsigned int runs = lto_input_uleb128 (ib);
 901   if (runs)
 902     {
 903       if (!profile_info)
 904         {
 905           profile_info = &lto_gcov_summary;
 906           lto_gcov_summary.runs = runs;
 907           lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
 908           lto_gcov_summary.run_max = lto_input_sleb128 (ib);
 909           lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
 910         }
 911       /* We can support this by scaling all counts to nearest common multiple
 912          of all different runs, but it is perhaps not worth the effort.  */
 913       else if (profile_info->runs != runs
 914                || profile_info->sum_all != lto_input_sleb128 (ib)
 915                || profile_info->run_max != lto_input_sleb128 (ib)
 916                || profile_info->sum_max != lto_input_sleb128 (ib))
 917         sorry ("Combining units with different profiles is not supported.");
 918       /* We allow some units to have profile and other to not have one.  This will
 919          just make unprofiled units to be size optimized that is sane.  */
 920     }
 921
 922 }
 923
 924 /* Input and merge the cgraph from each of the .o files passed to
 925    lto1.  */
 926
 927 void
 928 input_cgraph (void)
 929 {
 930   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
 931   struct lto_file_decl_data *file_data;
 932   unsigned int j = 0;
 933   struct cgraph_node *node;
 934
 935   while ((file_data = file_data_vec[j++]))
 936     {
 937       const char *data;
 938       size_t len;
 939       struct lto_input_block *ib;
 940
 941       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
 942                                           &data, &len);
 943       input_profile_summary (ib);
 944       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
 945       input_cgraph_1 (file_data, ib);
 946       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
 947                                       ib, data, len);
 948
 949       ib = lto_create_simple_input_block (file_data, LTO_section_varpool,
 950                                           &data, &len);
 951       input_varpool_1 (file_data, ib);
 952       lto_destroy_simple_input_block (file_data, LTO_section_varpool,
 953                                       ib, data, len);
 954
 955       /* Assume that every file read needs to be processed by LTRANS.  */
 956       if (flag_wpa)
 957         lto_mark_file_for_ltrans (file_data);
 958     }
 959
 960   /* Clear out the aux field that was used to store enough state to
 961      tell which nodes should be overwritten.  */
 962   for (node = cgraph_nodes; node; node = node->next)
 963     {
 964       /* Some nodes may have been created by cgraph_node.  This
 965          happens when the callgraph contains nested functions.  If the
 966          node for the parent function was never emitted to the gimple
 967          file, cgraph_node will create a node for it when setting the
 968          context of the nested function.  */
 969       if (node->local.lto_file_data)
 970         node->aux = NULL;
 971     }
 972 }