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       if (node->callees)
 376         {
 377           /* Output edges in backward direction, so the reconstructed callgraph
 378              match and it is easy to associate call sites in the IPA pass summaries.  */
 379           edge = node->callees;
 380           while (edge->next_callee)
 381             edge = edge->next_callee;
 382           for (; edge; edge = edge->prev_callee)
 383             lto_output_edge (ob, edge, encoder);
 384         }
 385     }
 386
 387   lto_output_uleb128_stream (ob->main_stream, 0);
 388
 389   /* Emit toplevel asms.  */
 390   for (can = cgraph_asm_nodes; can; can = can->next)
 391     {
 392       int len = TREE_STRING_LENGTH (can->asm_str);
 393       lto_output_uleb128_stream (ob->main_stream, len);
 394       for (i = 0; i < len; ++i)
 395         lto_output_1_stream (ob->main_stream,
 396                              TREE_STRING_POINTER (can->asm_str)[i]);
 397     }
 398
 399   lto_output_uleb128_stream (ob->main_stream, 0);
 400
 401   lto_destroy_simple_output_block (ob);
 402 }
 403
 404
 405 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
 406    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
 407    NODE or to replace the values in it, for instance because the first
 408    time we saw it, the function body was not available but now it
 409    is.  BP is a bitpack with all the bitflags for NODE read from the
 410    stream.  */
 411
 412 static void
 413 input_overwrite_node (struct lto_file_decl_data *file_data,
 414                       struct cgraph_node *node,
 415                       enum LTO_cgraph_tags tag,
 416                       struct bitpack_d *bp,
 417                       unsigned int stack_size,
 418                       unsigned int self_time,
 419                       unsigned int time_inlining_benefit,
 420                       unsigned int self_size,
 421                       unsigned int size_inlining_benefit)
 422 {
 423   node->aux = (void *) tag;
 424   node->local.inline_summary.estimated_self_stack_size = stack_size;
 425   node->local.inline_summary.self_time = self_time;
 426   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
 427   node->local.inline_summary.self_size = self_size;
 428   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
 429   node->global.time = self_time;
 430   node->global.size = self_size;
 431   node->local.lto_file_data = file_data;
 432
 433   node->local.local = bp_unpack_value (bp, 1);
 434   node->local.externally_visible = bp_unpack_value (bp, 1);
 435   node->local.finalized = bp_unpack_value (bp, 1);
 436   node->local.inlinable = bp_unpack_value (bp, 1);
 437   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
 438   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
 439   node->local.for_functions_valid = bp_unpack_value (bp, 1);
 440   node->local.vtable_method = bp_unpack_value (bp, 1);
 441   node->needed = bp_unpack_value (bp, 1);
 442   node->address_taken = bp_unpack_value (bp, 1);
 443   node->abstract_and_needed = bp_unpack_value (bp, 1);
 444   node->reachable = bp_unpack_value (bp, 1);
 445   node->lowered = bp_unpack_value (bp, 1);
 446   node->analyzed = bp_unpack_value (bp, 1);
 447   node->process = bp_unpack_value (bp, 1);
 448   node->alias = bp_unpack_value (bp, 1);
 449   node->finalized_by_frontend = bp_unpack_value (bp, 1);
 450 }
 451
 452
 453 /* Read a node from input_block IB.  TAG is the node's tag just read.
 454    Return the node read or overwriten.  */
 455
 456 static struct cgraph_node *
 457 input_node (struct lto_file_decl_data *file_data,
 458             struct lto_input_block *ib,
 459             enum LTO_cgraph_tags tag)
 460 {
 461   tree fn_decl;
 462   struct cgraph_node *node;
 463   struct bitpack_d *bp;
 464   int stack_size = 0;
 465   unsigned decl_index;
 466   bool clone_p;
 467   int estimated_stack_size = 0;
 468   int stack_frame_offset = 0;
 469   int ref = LCC_NOT_FOUND;
 470   int estimated_growth = 0;
 471   int time = 0;
 472   int size = 0;
 473   int self_time = 0;
 474   int self_size = 0;
 475   int time_inlining_benefit = 0;
 476   int size_inlining_benefit = 0;
 477   bool inlined = false;
 478
 479   clone_p = (lto_input_uleb128 (ib) != 0);
 480
 481   decl_index = lto_input_uleb128 (ib);
 482   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 483
 484   if (clone_p)
 485     node = cgraph_clone_node (cgraph_node (fn_decl), 0,
 486                               CGRAPH_FREQ_BASE, 0, false, NULL);
 487
 488   else
 489     node = cgraph_node (fn_decl);
 490
 491   node->count = lto_input_sleb128 (ib);
 492   bp = lto_input_bitpack (ib);
 493
 494   if (tag != LTO_cgraph_unavail_node)
 495     {
 496       stack_size = lto_input_sleb128 (ib);
 497       self_size = lto_input_sleb128 (ib);
 498       size_inlining_benefit = lto_input_sleb128 (ib);
 499       self_time = lto_input_sleb128 (ib);
 500       time_inlining_benefit = lto_input_sleb128 (ib);
 501     }
 502
 503   estimated_stack_size = lto_input_sleb128 (ib);
 504   stack_frame_offset = lto_input_sleb128 (ib);
 505   ref = lto_input_sleb128 (ib);
 506   time = lto_input_sleb128 (ib);
 507   size = lto_input_sleb128 (ib);
 508   estimated_growth = lto_input_sleb128 (ib);
 509   inlined = lto_input_uleb128 (ib);
 510
 511   /* Make sure that we have not read this node before.  Nodes that
 512      have already been read will have their tag stored in the 'aux'
 513      field.  Since built-in functions can be referenced in multiple
 514      functions, they are expected to be read more than once.  */
 515   if (node->aux && !DECL_IS_BUILTIN (node->decl))
 516     internal_error ("bytecode stream: found multiple instances of cgraph "
 517                     "node %d", node->uid);
 518
 519   input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
 520                         time_inlining_benefit, self_size,
 521                         size_inlining_benefit);
 522   bitpack_delete (bp);
 523
 524   node->global.estimated_stack_size = estimated_stack_size;
 525   node->global.stack_frame_offset = stack_frame_offset;
 526   node->global.time = time;
 527   node->global.size = size;
 528
 529   /* Store a reference for now, and fix up later to be a pointer.  */
 530   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
 531
 532   node->global.estimated_growth = estimated_growth;
 533   node->global.inlined = inlined;
 534
 535   return node;
 536 }
 537
 538
 539 /* Read an edge from IB.  NODES points to a vector of previously read
 540    nodes for decoding caller and callee of the edge to be read.  */
 541
 542 static void
 543 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
 544 {
 545   struct cgraph_node *caller, *callee;
 546   struct cgraph_edge *edge;
 547   unsigned int stmt_id;
 548   gcov_type count;
 549   int freq;
 550   unsigned int nest;
 551   cgraph_inline_failed_t inline_failed;
 552   struct bitpack_d *bp;
 553   enum ld_plugin_symbol_resolution caller_resolution;
 554
 555   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 556   if (caller == NULL || caller->decl == NULL_TREE)
 557     internal_error ("bytecode stream: no caller found while reading edge");
 558
 559   callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 560   if (callee == NULL || callee->decl == NULL_TREE)
 561     internal_error ("bytecode stream: no callee found while reading edge");
 562
 563   count = (gcov_type) lto_input_sleb128 (ib);
 564
 565   bp = lto_input_bitpack (ib);
 566   stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 567   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
 568                                                             HOST_BITS_PER_INT);
 569   freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 570   nest = (unsigned) bp_unpack_value (bp, 30);
 571
 572   /* If the caller was preempted, don't create the edge.
 573      ???  Should we ever have edges from a preempted caller?  */
 574   caller_resolution = lto_symtab_get_resolution (caller->decl);
 575   if (caller_resolution == LDPR_PREEMPTED_REG
 576       || caller_resolution == LDPR_PREEMPTED_IR)
 577     return;
 578
 579   edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
 580   edge->lto_stmt_uid = stmt_id;
 581   edge->inline_failed = inline_failed;
 582   edge->indirect_call = bp_unpack_value (bp, 1);
 583   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
 584   edge->can_throw_external = bp_unpack_value (bp, 1);
 585   bitpack_delete (bp);
 586 }
 587
 588
 589 /* Read a cgraph from IB using the info in FILE_DATA.  */
 590
 591 static void
 592 input_cgraph_1 (struct lto_file_decl_data *file_data,
 593                 struct lto_input_block *ib)
 594 {
 595   enum LTO_cgraph_tags tag;
 596   VEC(cgraph_node_ptr, heap) *nodes = NULL;
 597   struct cgraph_node *node;
 598   unsigned i;
 599   unsigned HOST_WIDE_INT len;
 600
 601   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 602   while (tag)
 603     {
 604       if (tag == LTO_cgraph_edge)
 605         input_edge (ib, nodes);
 606       else
 607         {
 608           node = input_node (file_data, ib, tag);
 609           if (node == NULL || node->decl == NULL_TREE)
 610             internal_error ("bytecode stream: found empty cgraph node");
 611           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
 612           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
 613         }
 614
 615       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 616     }
 617
 618   /* Input toplevel asms.  */
 619   len = lto_input_uleb128 (ib);
 620   while (len)
 621     {
 622       char *str = (char *)xmalloc (len + 1);
 623       for (i = 0; i < len; ++i)
 624         str[i] = lto_input_1_unsigned (ib);
 625       cgraph_add_asm_node (build_string (len, str));
 626       free (str);
 627
 628       len = lto_input_uleb128 (ib);
 629     }
 630
 631   for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
 632     {
 633       const int ref = (int) (intptr_t) node->global.inlined_to;
 634
 635       /* Fixup inlined_to from reference to pointer.  */
 636       if (ref != LCC_NOT_FOUND)
 637         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
 638       else
 639         node->global.inlined_to = NULL;
 640     }
 641
 642   VEC_free (cgraph_node_ptr, heap, nodes);
 643 }
 644
 645
 646 /* Input and merge the cgraph from each of the .o files passed to
 647    lto1.  */
 648
 649 void
 650 input_cgraph (void)
 651 {
 652   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
 653   struct lto_file_decl_data *file_data;
 654   unsigned int j = 0;
 655   struct cgraph_node *node;
 656
 657   while ((file_data = file_data_vec[j++]))
 658     {
 659       const char *data;
 660       size_t len;
 661       struct lto_input_block *ib;
 662
 663       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
 664                                           &data, &len);
 665       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
 666       input_cgraph_1 (file_data, ib);
 667       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
 668                                       ib, data, len);
 669
 670       /* Assume that every file read needs to be processed by LTRANS.  */
 671       if (flag_wpa)
 672         lto_mark_file_for_ltrans (file_data);
 673     }
 674
 675   /* Clear out the aux field that was used to store enough state to
 676      tell which nodes should be overwritten.  */
 677   for (node = cgraph_nodes; node; node = node->next)
 678     {
 679       /* Some nodes may have been created by cgraph_node.  This
 680          happens when the callgraph contains nested functions.  If the
 681          node for the parent function was never emitted to the gimple
 682          file, cgraph_node will create a node for it when setting the
 683          context of the nested function.  */
 684       if (node->local.lto_file_data)
 685         node->aux = NULL;
 686     }
 687 }