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 "varray.h"
  34 #include "hashtab.h"
  35 #include "langhooks.h"
  36 #include "basic-block.h"
  37 #include "tree-flow.h"
  38 #include "cgraph.h"
  39 #include "function.h"
  40 #include "ggc.h"
  41 #include "diagnostic.h"
  42 #include "except.h"
  43 #include "vec.h"
  44 #include "timevar.h"
  45 #include "output.h"
  46 #include "pointer-set.h"
  47 #include "lto-streamer.h"
  48 #include "gcov-io.h"
  49
  50 /* Create a new cgraph encoder.  */
  51
  52 lto_cgraph_encoder_t
  53 lto_cgraph_encoder_new (void)
  54 {
  55   lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
  56   encoder->map = pointer_map_create ();
  57   encoder->nodes = NULL;
  58   return encoder;
  59 }
  60
  61
  62 /* Delete ENCODER and its components.  */
  63
  64 void
  65 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
  66 {
  67    VEC_free (cgraph_node_ptr, heap, encoder->nodes);
  68    pointer_map_destroy (encoder->map);
  69    free (encoder);
  70 }
  71
  72
  73 /* Return the existing reference number of NODE in the cgraph encoder in
  74    output block OB.  Assign a new reference if this is the first time
  75    NODE is encoded.  */
  76
  77 int
  78 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
  79                            struct cgraph_node *node)
  80 {
  81   int ref;
  82   void **slot;
  83
  84   slot = pointer_map_contains (encoder->map, node);
  85   if (!slot)
  86     {
  87       ref = VEC_length (cgraph_node_ptr, encoder->nodes);
  88       slot = pointer_map_insert (encoder->map, node);
  89       *slot = (void *) (intptr_t) ref;
  90       VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
  91     }
  92   else
  93     ref = (int) (intptr_t) *slot;
  94
  95   return ref;
  96 }
  97
  98
  99 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
 100    or LCC_NOT_FOUND if it is not there.  */
 101
 102 int
 103 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
 104                            struct cgraph_node *node)
 105 {
 106   void **slot = pointer_map_contains (encoder->map, node);
 107   return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
 108 }
 109
 110
 111 /* Return the cgraph node corresponding to REF using ENCODER.  */
 112
 113 struct cgraph_node *
 114 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
 115 {
 116   if (ref == LCC_NOT_FOUND)
 117     return NULL;
 118
 119   return VEC_index (cgraph_node_ptr, encoder->nodes, ref);
 120 }
 121
 122
 123 /* Return number of encoded nodes in ENCODER.  */
 124
 125 static int
 126 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
 127 {
 128   return VEC_length (cgraph_node_ptr, encoder->nodes);
 129 }
 130
 131
 132 /* Output the cgraph EDGE to OB using ENCODER.  */
 133
 134 static void
 135 lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
 136                  lto_cgraph_encoder_t encoder)
 137 {
 138   unsigned int uid;
 139   intptr_t ref;
 140   struct bitpack_d *bp;
 141
 142   lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
 143
 144   ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
 145   gcc_assert (ref != LCC_NOT_FOUND);
 146   lto_output_sleb128_stream (ob->main_stream, ref);
 147
 148   ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
 149   gcc_assert (ref != LCC_NOT_FOUND);
 150   lto_output_sleb128_stream (ob->main_stream, ref);
 151
 152   lto_output_sleb128_stream (ob->main_stream, edge->count);
 153
 154   bp = bitpack_create ();
 155   uid = flag_wpa ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt);
 156   bp_pack_value (bp, uid, HOST_BITS_PER_INT);
 157   bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
 158   bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
 159   bp_pack_value (bp, edge->loop_nest, 30);
 160   bp_pack_value (bp, edge->indirect_call, 1);
 161   bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
 162   bp_pack_value (bp, edge->can_throw_external, 1);
 163   lto_output_bitpack (ob->main_stream, bp);
 164   bitpack_delete (bp);
 165 }
 166
 167
 168 /* Output the cgraph NODE to OB.  ENCODER is used to find the
 169    reference number of NODE->inlined_to.  SET is the set of nodes we
 170    are writing to the current file.  If NODE is not in SET, then NODE
 171    is a boundary of a cgraph_node_set and we pretend NODE just has a
 172    decl and no callees.  WRITTEN_DECLS is the set of FUNCTION_DECLs
 173    that have had their callgraph node written so far.  This is used to
 174    determine if NODE is a clone of a previously written node.  */
 175
 176 static void
 177 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 178                  lto_cgraph_encoder_t encoder, cgraph_node_set set,
 179                  bitmap written_decls)
 180 {
 181   unsigned int tag;
 182   struct bitpack_d *bp;
 183   unsigned local, externally_visible, inlinable, analyzed;
 184   bool boundary_p, wrote_decl_p;
 185   intptr_t ref;
 186
 187   boundary_p = !cgraph_node_in_set_p (node, set);
 188   wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
 189
 190   switch (cgraph_function_body_availability (node))
 191     {
 192     case AVAIL_NOT_AVAILABLE:
 193       tag = LTO_cgraph_unavail_node;
 194       break;
 195
 196     case AVAIL_AVAILABLE:
 197     case AVAIL_LOCAL:
 198       tag = LTO_cgraph_avail_node;
 199       break;
 200
 201     case AVAIL_OVERWRITABLE:
 202       tag = LTO_cgraph_overwritable_node;
 203       break;
 204
 205     default:
 206       gcc_unreachable ();
 207     }
 208
 209   if (boundary_p)
 210     tag = LTO_cgraph_unavail_node;
 211
 212   lto_output_uleb128_stream (ob->main_stream, tag);
 213
 214   local = node->local.local;
 215   externally_visible = node->local.externally_visible;
 216   inlinable = node->local.inlinable;
 217   analyzed = node->analyzed;
 218
 219   /* In WPA mode, we only output part of the call-graph.  Also, we
 220      fake cgraph node attributes.  There are two cases that we care.
 221
 222      Boundary nodes: There are nodes that are not part of SET but are
 223      called from within SET.  We artificially make them look like
 224      externally visible nodes with no function body.
 225
 226      Cherry-picked nodes:  These are nodes we pulled from other
 227      translation units into SET during IPA-inlining.  We make them as
 228      local static nodes to prevent clashes with other local statics.  */
 229   if (boundary_p)
 230     {
 231       /* Inline clones can not be part of boundary.  */
 232       gcc_assert (!node->global.inlined_to);
 233       local = 0;
 234       externally_visible = 1;
 235       inlinable = 0;
 236       analyzed = 0;
 237     }
 238   else if (lto_forced_extern_inline_p (node->decl))
 239     {
 240       local = 1;
 241       externally_visible = 0;
 242       inlinable = 1;
 243     }
 244
 245   lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
 246
 247   if (!wrote_decl_p)
 248     bitmap_set_bit (written_decls, DECL_UID (node->decl));
 249
 250   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
 251   lto_output_sleb128_stream (ob->main_stream, node->count);
 252
 253   bp = bitpack_create ();
 254   bp_pack_value (bp, local, 1);
 255   bp_pack_value (bp, externally_visible, 1);
 256   bp_pack_value (bp, node->local.finalized, 1);
 257   bp_pack_value (bp, inlinable, 1);
 258   bp_pack_value (bp, node->local.disregard_inline_limits, 1);
 259   bp_pack_value (bp, node->local.redefined_extern_inline, 1);
 260   bp_pack_value (bp, node->local.for_functions_valid, 1);
 261   bp_pack_value (bp, node->local.vtable_method, 1);
 262   bp_pack_value (bp, node->needed, 1);
 263   bp_pack_value (bp, node->address_taken, 1);
 264   bp_pack_value (bp, node->abstract_and_needed, 1);
 265   bp_pack_value (bp, node->reachable, 1);
 266   bp_pack_value (bp, node->lowered, 1);
 267   bp_pack_value (bp, analyzed, 1);
 268   bp_pack_value (bp, node->process, 1);
 269   bp_pack_value (bp, node->alias, 1);
 270   bp_pack_value (bp, node->finalized_by_frontend, 1);
 271   lto_output_bitpack (ob->main_stream, bp);
 272   bitpack_delete (bp);
 273
 274   if (tag != LTO_cgraph_unavail_node)
 275     {
 276       lto_output_sleb128_stream (ob->main_stream,
 277                                  node->local.inline_summary.estimated_self_stack_size);
 278       lto_output_sleb128_stream (ob->main_stream,
 279                                  node->local.inline_summary.self_size);
 280       lto_output_sleb128_stream (ob->main_stream,
 281                                  node->local.inline_summary.size_inlining_benefit);
 282       lto_output_sleb128_stream (ob->main_stream,
 283                                  node->local.inline_summary.self_time);
 284       lto_output_sleb128_stream (ob->main_stream,
 285                                  node->local.inline_summary.time_inlining_benefit);
 286     }
 287
 288   /* FIXME lto: Outputting global info is not neccesary until after
 289      inliner was run.  Global structure holds results of propagation
 290      done by inliner.  */
 291   lto_output_sleb128_stream (ob->main_stream,
 292                              node->global.estimated_stack_size);
 293   lto_output_sleb128_stream (ob->main_stream,
 294                              node->global.stack_frame_offset);
 295   if (node->global.inlined_to && !boundary_p)
 296     {
 297       ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
 298       gcc_assert (ref != LCC_NOT_FOUND);
 299     }
 300   else
 301     ref = LCC_NOT_FOUND;
 302   lto_output_sleb128_stream (ob->main_stream, ref);
 303
 304   lto_output_sleb128_stream (ob->main_stream, node->global.time);
 305   lto_output_sleb128_stream (ob->main_stream, node->global.size);
 306   lto_output_sleb128_stream (ob->main_stream,
 307                              node->global.estimated_growth);
 308   lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
 309   if (node->same_body)
 310     {
 311       struct cgraph_node *alias;
 312       unsigned long alias_count = 1;
 313       for (alias = node->same_body; alias->next; alias = alias->next)
 314         alias_count++;
 315       lto_output_uleb128_stream (ob->main_stream, alias_count);
 316       do
 317         {
 318           lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 319                                     alias->decl);
 320           alias = alias->previous;
 321         }
 322       while (alias);
 323     }
 324   else
 325     lto_output_uleb128_stream (ob->main_stream, 0);
 326 }
 327
 328 /* Stream out profile_summary to OB.  */
 329
 330 static void
 331 output_profile_summary (struct lto_simple_output_block *ob)
 332 {
 333   if (profile_info)
 334     {
 335       /* We do not output num, it is not terribly useful.  */
 336       gcc_assert (profile_info->runs);
 337       lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
 338       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
 339       lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
 340       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
 341     }
 342   else
 343     lto_output_uleb128_stream (ob->main_stream, 0);
 344 }
 345
 346
 347 /* Output the part of the cgraph in SET.  */
 348
 349 void
 350 output_cgraph (cgraph_node_set set)
 351 {
 352   struct cgraph_node *node;
 353   struct lto_simple_output_block *ob;
 354   cgraph_node_set_iterator csi;
 355   struct cgraph_edge *edge;
 356   int i, n_nodes;
 357   bitmap written_decls;
 358   lto_cgraph_encoder_t encoder;
 359   struct cgraph_asm_node *can;
 360
 361   ob = lto_create_simple_output_block (LTO_section_cgraph);
 362
 363   output_profile_summary (ob);
 364
 365   /* An encoder for cgraph nodes should have been created by
 366      ipa_write_summaries_1.  */
 367   gcc_assert (ob->decl_state->cgraph_node_encoder);
 368   encoder = ob->decl_state->cgraph_node_encoder;
 369
 370   /* The FUNCTION_DECLs for which we have written a node.  The first
 371      node found is written as the "original" node, the remaining nodes
 372      are considered its clones.  */
 373   written_decls = lto_bitmap_alloc ();
 374
 375   /* Go over all the nodes in SET and assign references.  */
 376   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 377     {
 378       node = csi_node (csi);
 379       lto_cgraph_encoder_encode (encoder, node);
 380     }
 381
 382   /* Go over all the nodes again to include callees that are not in
 383      SET.  */
 384   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 385     {
 386       node = csi_node (csi);
 387       for (edge = node->callees; edge; edge = edge->next_callee)
 388         {
 389           struct cgraph_node *callee = edge->callee;
 390           if (!cgraph_node_in_set_p (callee, set))
 391             {
 392               /* We should have moved all the inlines.  */
 393               gcc_assert (!callee->global.inlined_to);
 394               lto_cgraph_encoder_encode (encoder, callee);
 395             }
 396         }
 397     }
 398
 399   /* Write out the nodes.  */
 400   n_nodes = lto_cgraph_encoder_size (encoder);
 401   for (i = 0; i < n_nodes; i++)
 402     {
 403       node = lto_cgraph_encoder_deref (encoder, i);
 404       lto_output_node (ob, node, encoder, set, written_decls);
 405     }
 406
 407   lto_bitmap_free (written_decls);
 408
 409   /* Go over the nodes in SET again to write edges.  */
 410   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 411     {
 412       node = csi_node (csi);
 413       if (node->callees)
 414         {
 415           /* Output edges in backward direction, so the reconstructed callgraph
 416              match and it is easy to associate call sites in the IPA pass summaries.  */
 417           edge = node->callees;
 418           while (edge->next_callee)
 419             edge = edge->next_callee;
 420           for (; edge; edge = edge->prev_callee)
 421             lto_output_edge (ob, edge, encoder);
 422         }
 423     }
 424
 425   lto_output_uleb128_stream (ob->main_stream, 0);
 426
 427   /* Emit toplevel asms.  */
 428   for (can = cgraph_asm_nodes; can; can = can->next)
 429     {
 430       int len = TREE_STRING_LENGTH (can->asm_str);
 431       lto_output_uleb128_stream (ob->main_stream, len);
 432       for (i = 0; i < len; ++i)
 433         lto_output_1_stream (ob->main_stream,
 434                              TREE_STRING_POINTER (can->asm_str)[i]);
 435     }
 436
 437   lto_output_uleb128_stream (ob->main_stream, 0);
 438
 439   lto_destroy_simple_output_block (ob);
 440 }
 441
 442
 443 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
 444    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
 445    NODE or to replace the values in it, for instance because the first
 446    time we saw it, the function body was not available but now it
 447    is.  BP is a bitpack with all the bitflags for NODE read from the
 448    stream.  */
 449
 450 static void
 451 input_overwrite_node (struct lto_file_decl_data *file_data,
 452                       struct cgraph_node *node,
 453                       enum LTO_cgraph_tags tag,
 454                       struct bitpack_d *bp,
 455                       unsigned int stack_size,
 456                       unsigned int self_time,
 457                       unsigned int time_inlining_benefit,
 458                       unsigned int self_size,
 459                       unsigned int size_inlining_benefit)
 460 {
 461   node->aux = (void *) tag;
 462   node->local.inline_summary.estimated_self_stack_size = stack_size;
 463   node->local.inline_summary.self_time = self_time;
 464   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
 465   node->local.inline_summary.self_size = self_size;
 466   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
 467   node->global.time = self_time;
 468   node->global.size = self_size;
 469   node->local.lto_file_data = file_data;
 470
 471   node->local.local = bp_unpack_value (bp, 1);
 472   node->local.externally_visible = bp_unpack_value (bp, 1);
 473   node->local.finalized = bp_unpack_value (bp, 1);
 474   node->local.inlinable = bp_unpack_value (bp, 1);
 475   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
 476   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
 477   node->local.for_functions_valid = bp_unpack_value (bp, 1);
 478   node->local.vtable_method = bp_unpack_value (bp, 1);
 479   node->needed = bp_unpack_value (bp, 1);
 480   node->address_taken = bp_unpack_value (bp, 1);
 481   node->abstract_and_needed = bp_unpack_value (bp, 1);
 482   node->reachable = bp_unpack_value (bp, 1);
 483   node->lowered = bp_unpack_value (bp, 1);
 484   node->analyzed = bp_unpack_value (bp, 1);
 485   node->process = bp_unpack_value (bp, 1);
 486   node->alias = bp_unpack_value (bp, 1);
 487   node->finalized_by_frontend = bp_unpack_value (bp, 1);
 488 }
 489
 490
 491 /* Read a node from input_block IB.  TAG is the node's tag just read.
 492    Return the node read or overwriten.  */
 493
 494 static struct cgraph_node *
 495 input_node (struct lto_file_decl_data *file_data,
 496             struct lto_input_block *ib,
 497             enum LTO_cgraph_tags tag)
 498 {
 499   tree fn_decl;
 500   struct cgraph_node *node;
 501   struct bitpack_d *bp;
 502   int stack_size = 0;
 503   unsigned decl_index;
 504   bool clone_p;
 505   int estimated_stack_size = 0;
 506   int stack_frame_offset = 0;
 507   int ref = LCC_NOT_FOUND;
 508   int estimated_growth = 0;
 509   int time = 0;
 510   int size = 0;
 511   int self_time = 0;
 512   int self_size = 0;
 513   int time_inlining_benefit = 0;
 514   int size_inlining_benefit = 0;
 515   unsigned long same_body_count = 0;
 516   bool inlined = false;
 517
 518   clone_p = (lto_input_uleb128 (ib) != 0);
 519
 520   decl_index = lto_input_uleb128 (ib);
 521   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 522
 523   if (clone_p)
 524     node = cgraph_clone_node (cgraph_node (fn_decl), 0,
 525                               CGRAPH_FREQ_BASE, 0, false, NULL);
 526
 527   else
 528     node = cgraph_node (fn_decl);
 529
 530   node->count = lto_input_sleb128 (ib);
 531   bp = lto_input_bitpack (ib);
 532
 533   if (tag != LTO_cgraph_unavail_node)
 534     {
 535       stack_size = lto_input_sleb128 (ib);
 536       self_size = lto_input_sleb128 (ib);
 537       size_inlining_benefit = lto_input_sleb128 (ib);
 538       self_time = lto_input_sleb128 (ib);
 539       time_inlining_benefit = lto_input_sleb128 (ib);
 540     }
 541
 542   estimated_stack_size = lto_input_sleb128 (ib);
 543   stack_frame_offset = lto_input_sleb128 (ib);
 544   ref = lto_input_sleb128 (ib);
 545   time = lto_input_sleb128 (ib);
 546   size = lto_input_sleb128 (ib);
 547   estimated_growth = lto_input_sleb128 (ib);
 548   inlined = lto_input_uleb128 (ib);
 549   same_body_count = lto_input_uleb128 (ib);
 550
 551   /* Make sure that we have not read this node before.  Nodes that
 552      have already been read will have their tag stored in the 'aux'
 553      field.  Since built-in functions can be referenced in multiple
 554      functions, they are expected to be read more than once.  */
 555   if (node->aux && !DECL_IS_BUILTIN (node->decl))
 556     internal_error ("bytecode stream: found multiple instances of cgraph "
 557                     "node %d", node->uid);
 558
 559   input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
 560                         time_inlining_benefit, self_size,
 561                         size_inlining_benefit);
 562   bitpack_delete (bp);
 563
 564   node->global.estimated_stack_size = estimated_stack_size;
 565   node->global.stack_frame_offset = stack_frame_offset;
 566   node->global.time = time;
 567   node->global.size = size;
 568
 569   /* Store a reference for now, and fix up later to be a pointer.  */
 570   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
 571
 572   node->global.estimated_growth = estimated_growth;
 573   node->global.inlined = inlined;
 574
 575   while (same_body_count-- > 0)
 576     {
 577       tree alias_decl;
 578       decl_index = lto_input_uleb128 (ib);
 579       alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 580       cgraph_same_body_alias (alias_decl, fn_decl);
 581     }
 582   return node;
 583 }
 584
 585
 586 /* Read an edge from IB.  NODES points to a vector of previously read
 587    nodes for decoding caller and callee of the edge to be read.  */
 588
 589 static void
 590 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
 591 {
 592   struct cgraph_node *caller, *callee;
 593   struct cgraph_edge *edge;
 594   unsigned int stmt_id;
 595   gcov_type count;
 596   int freq;
 597   unsigned int nest;
 598   cgraph_inline_failed_t inline_failed;
 599   struct bitpack_d *bp;
 600   enum ld_plugin_symbol_resolution caller_resolution;
 601
 602   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 603   if (caller == NULL || caller->decl == NULL_TREE)
 604     internal_error ("bytecode stream: no caller found while reading edge");
 605
 606   callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 607   if (callee == NULL || callee->decl == NULL_TREE)
 608     internal_error ("bytecode stream: no callee found while reading edge");
 609
 610   count = (gcov_type) lto_input_sleb128 (ib);
 611
 612   bp = lto_input_bitpack (ib);
 613   stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 614   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
 615                                                             HOST_BITS_PER_INT);
 616   freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 617   nest = (unsigned) bp_unpack_value (bp, 30);
 618
 619   /* If the caller was preempted, don't create the edge.
 620      ???  Should we ever have edges from a preempted caller?  */
 621   caller_resolution = lto_symtab_get_resolution (caller->decl);
 622   if (caller_resolution == LDPR_PREEMPTED_REG
 623       || caller_resolution == LDPR_PREEMPTED_IR)
 624     return;
 625
 626   edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
 627   edge->lto_stmt_uid = stmt_id;
 628   edge->inline_failed = inline_failed;
 629   edge->indirect_call = bp_unpack_value (bp, 1);
 630   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
 631   edge->can_throw_external = bp_unpack_value (bp, 1);
 632   bitpack_delete (bp);
 633 }
 634
 635
 636 /* Read a cgraph from IB using the info in FILE_DATA.  */
 637
 638 static void
 639 input_cgraph_1 (struct lto_file_decl_data *file_data,
 640                 struct lto_input_block *ib)
 641 {
 642   enum LTO_cgraph_tags tag;
 643   VEC(cgraph_node_ptr, heap) *nodes = NULL;
 644   struct cgraph_node *node;
 645   unsigned i;
 646   unsigned HOST_WIDE_INT len;
 647
 648   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 649   while (tag)
 650     {
 651       if (tag == LTO_cgraph_edge)
 652         input_edge (ib, nodes);
 653       else
 654         {
 655           node = input_node (file_data, ib, tag);
 656           if (node == NULL || node->decl == NULL_TREE)
 657             internal_error ("bytecode stream: found empty cgraph node");
 658           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
 659           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
 660         }
 661
 662       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 663     }
 664
 665   /* Input toplevel asms.  */
 666   len = lto_input_uleb128 (ib);
 667   while (len)
 668     {
 669       char *str = (char *)xmalloc (len + 1);
 670       for (i = 0; i < len; ++i)
 671         str[i] = lto_input_1_unsigned (ib);
 672       cgraph_add_asm_node (build_string (len, str));
 673       free (str);
 674
 675       len = lto_input_uleb128 (ib);
 676     }
 677
 678   for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
 679     {
 680       const int ref = (int) (intptr_t) node->global.inlined_to;
 681
 682       /* Fixup inlined_to from reference to pointer.  */
 683       if (ref != LCC_NOT_FOUND)
 684         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
 685       else
 686         node->global.inlined_to = NULL;
 687     }
 688
 689   VEC_free (cgraph_node_ptr, heap, nodes);
 690 }
 691
 692 static struct gcov_ctr_summary lto_gcov_summary;
 693
 694 /* Input profile_info from IB.  */
 695 static void
 696 input_profile_summary (struct lto_input_block *ib)
 697 {
 698   unsigned int runs = lto_input_uleb128 (ib);
 699   if (runs)
 700     {
 701       if (!profile_info)
 702         {
 703           profile_info = &lto_gcov_summary;
 704           lto_gcov_summary.runs = runs;
 705           lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
 706           lto_gcov_summary.run_max = lto_input_sleb128 (ib);
 707           lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
 708         }
 709       /* We can support this by scaling all counts to nearest common multiple
 710          of all different runs, but it is perhaps not worth the effort.  */
 711       else if (profile_info->runs != runs
 712                || profile_info->sum_all != lto_input_sleb128 (ib)
 713                || profile_info->run_max != lto_input_sleb128 (ib)
 714                || profile_info->sum_max != lto_input_sleb128 (ib))
 715         sorry ("Combining units with different profiles is not supported.");
 716       /* We allow some units to have profile and other to not have one.  This will
 717          just make unprofiled units to be size optimized that is sane.  */
 718     }
 719
 720 }
 721
 722 /* Input and merge the cgraph from each of the .o files passed to
 723    lto1.  */
 724
 725 void
 726 input_cgraph (void)
 727 {
 728   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
 729   struct lto_file_decl_data *file_data;
 730   unsigned int j = 0;
 731   struct cgraph_node *node;
 732
 733   while ((file_data = file_data_vec[j++]))
 734     {
 735       const char *data;
 736       size_t len;
 737       struct lto_input_block *ib;
 738
 739       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
 740                                           &data, &len);
 741       input_profile_summary (ib);
 742       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
 743       input_cgraph_1 (file_data, ib);
 744       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
 745                                       ib, data, len);
 746
 747       /* Assume that every file read needs to be processed by LTRANS.  */
 748       if (flag_wpa)
 749         lto_mark_file_for_ltrans (file_data);
 750     }
 751
 752   /* Clear out the aux field that was used to store enough state to
 753      tell which nodes should be overwritten.  */
 754   for (node = cgraph_nodes; node; node = node->next)
 755     {
 756       /* Some nodes may have been created by cgraph_node.  This
 757          happens when the callgraph contains nested functions.  If the
 758          node for the parent function was never emitted to the gimple
 759          file, cgraph_node will create a node for it when setting the
 760          context of the nested function.  */
 761       if (node->local.lto_file_data)
 762         node->aux = NULL;
 763     }
 764 }