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