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 /* Return true when node is reachable from other partition.  */
 168
 169 static bool
 170 reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
 171 {
 172   struct cgraph_edge *e;
 173   if (node->needed)
 174     return true;
 175   if (!node->analyzed)
 176     return false;
 177   if (node->global.inlined_to)
 178     return false;
 179   for (e = node->callers; e; e = e->next_caller)
 180     if (!cgraph_node_in_set_p (e->caller, set))
 181       return true;
 182   return false;
 183 }
 184
 185 /* Output the cgraph NODE to OB.  ENCODER is used to find the
 186    reference number of NODE->inlined_to.  SET is the set of nodes we
 187    are writing to the current file.  If NODE is not in SET, then NODE
 188    is a boundary of a cgraph_node_set and we pretend NODE just has a
 189    decl and no callees.  WRITTEN_DECLS is the set of FUNCTION_DECLs
 190    that have had their callgraph node written so far.  This is used to
 191    determine if NODE is a clone of a previously written node.  */
 192
 193 static void
 194 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 195                  lto_cgraph_encoder_t encoder, cgraph_node_set set,
 196                  bitmap written_decls)
 197 {
 198   unsigned int tag;
 199   struct bitpack_d *bp;
 200   unsigned local, externally_visible, inlinable, analyzed;
 201   bool boundary_p, wrote_decl_p;
 202   intptr_t ref;
 203   bool in_other_partition = false;
 204
 205   boundary_p = !cgraph_node_in_set_p (node, set);
 206   wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
 207
 208   switch (cgraph_function_body_availability (node))
 209     {
 210     case AVAIL_NOT_AVAILABLE:
 211       tag = LTO_cgraph_unavail_node;
 212       break;
 213
 214     case AVAIL_AVAILABLE:
 215     case AVAIL_LOCAL:
 216       tag = LTO_cgraph_avail_node;
 217       break;
 218
 219     case AVAIL_OVERWRITABLE:
 220       tag = LTO_cgraph_overwritable_node;
 221       break;
 222
 223     default:
 224       gcc_unreachable ();
 225     }
 226
 227   if (boundary_p)
 228     tag = LTO_cgraph_unavail_node;
 229
 230   lto_output_uleb128_stream (ob->main_stream, tag);
 231
 232   local = node->local.local;
 233   externally_visible = node->local.externally_visible;
 234   inlinable = node->local.inlinable;
 235   analyzed = node->analyzed;
 236
 237   /* In WPA mode, we only output part of the call-graph.  Also, we
 238      fake cgraph node attributes.  There are two cases that we care.
 239
 240      Boundary nodes: There are nodes that are not part of SET but are
 241      called from within SET.  We artificially make them look like
 242      externally visible nodes with no function body.
 243
 244      Cherry-picked nodes:  These are nodes we pulled from other
 245      translation units into SET during IPA-inlining.  We make them as
 246      local static nodes to prevent clashes with other local statics.  */
 247   if (boundary_p)
 248     {
 249       /* Inline clones can not be part of boundary.
 250          gcc_assert (!node->global.inlined_to);
 251
 252          FIXME: At the moment they can be, when partition contains an inline
 253          clone that is clone of inline clone from outside partition.  We can
 254          reshape the clone tree and make other tree to be the root, but it
 255          needs a bit extra work and will be promplty done by cgraph_remove_node
 256          after reading back.  */
 257       in_other_partition = 1;
 258       analyzed = 0;
 259     }
 260
 261   lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
 262
 263   if (!wrote_decl_p)
 264     bitmap_set_bit (written_decls, DECL_UID (node->decl));
 265
 266   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
 267   lto_output_sleb128_stream (ob->main_stream, node->count);
 268
 269   bp = bitpack_create ();
 270   bp_pack_value (bp, local, 1);
 271   bp_pack_value (bp, externally_visible, 1);
 272   bp_pack_value (bp, node->local.finalized, 1);
 273   bp_pack_value (bp, inlinable, 1);
 274   bp_pack_value (bp, node->local.disregard_inline_limits, 1);
 275   bp_pack_value (bp, node->local.redefined_extern_inline, 1);
 276   bp_pack_value (bp, node->local.for_functions_valid, 1);
 277   bp_pack_value (bp, node->local.vtable_method, 1);
 278   bp_pack_value (bp, node->needed, 1);
 279   bp_pack_value (bp, node->address_taken, 1);
 280   bp_pack_value (bp, node->abstract_and_needed, 1);
 281   bp_pack_value (bp, node->reachable, 1);
 282   bp_pack_value (bp, analyzed && reachable_from_other_partition_p (node, set), 1);
 283   bp_pack_value (bp, node->lowered, 1);
 284   bp_pack_value (bp, analyzed, 1);
 285   bp_pack_value (bp, in_other_partition, 1);
 286   bp_pack_value (bp, node->process, 1);
 287   bp_pack_value (bp, node->alias, 1);
 288   bp_pack_value (bp, node->finalized_by_frontend, 1);
 289   lto_output_bitpack (ob->main_stream, bp);
 290   bitpack_delete (bp);
 291
 292   if (tag != LTO_cgraph_unavail_node)
 293     {
 294       lto_output_sleb128_stream (ob->main_stream,
 295                                  node->local.inline_summary.estimated_self_stack_size);
 296       lto_output_sleb128_stream (ob->main_stream,
 297                                  node->local.inline_summary.self_size);
 298       lto_output_sleb128_stream (ob->main_stream,
 299                                  node->local.inline_summary.size_inlining_benefit);
 300       lto_output_sleb128_stream (ob->main_stream,
 301                                  node->local.inline_summary.self_time);
 302       lto_output_sleb128_stream (ob->main_stream,
 303                                  node->local.inline_summary.time_inlining_benefit);
 304     }
 305
 306   /* FIXME lto: Outputting global info is not neccesary until after
 307      inliner was run.  Global structure holds results of propagation
 308      done by inliner.  */
 309   lto_output_sleb128_stream (ob->main_stream,
 310                              node->global.estimated_stack_size);
 311   lto_output_sleb128_stream (ob->main_stream,
 312                              node->global.stack_frame_offset);
 313   if (node->global.inlined_to && !boundary_p)
 314     {
 315       ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
 316       gcc_assert (ref != LCC_NOT_FOUND);
 317     }
 318   else
 319     ref = LCC_NOT_FOUND;
 320   lto_output_sleb128_stream (ob->main_stream, ref);
 321
 322   lto_output_sleb128_stream (ob->main_stream, node->global.time);
 323   lto_output_sleb128_stream (ob->main_stream, node->global.size);
 324   lto_output_sleb128_stream (ob->main_stream,
 325                              node->global.estimated_growth);
 326   lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
 327   if (node->same_comdat_group)
 328     {
 329       ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
 330       gcc_assert (ref != LCC_NOT_FOUND);
 331     }
 332   else
 333     ref = LCC_NOT_FOUND;
 334   lto_output_sleb128_stream (ob->main_stream, ref);
 335
 336   if (node->same_body)
 337     {
 338       struct cgraph_node *alias;
 339       unsigned long alias_count = 1;
 340       for (alias = node->same_body; alias->next; alias = alias->next)
 341         alias_count++;
 342       lto_output_uleb128_stream (ob->main_stream, alias_count);
 343       do
 344         {
 345           lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 346                                     alias->decl);
 347           if (alias->thunk.thunk_p)
 348             {
 349               lto_output_uleb128_stream
 350                  (ob->main_stream,
 351                   1 + (alias->thunk.this_adjusting != 0) * 2
 352                   + (alias->thunk.virtual_offset_p != 0) * 4);
 353               lto_output_uleb128_stream (ob->main_stream,
 354                                          alias->thunk.fixed_offset);
 355               lto_output_uleb128_stream (ob->main_stream,
 356                                          alias->thunk.virtual_value);
 357               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 358                                         alias->thunk.alias);
 359             }
 360           else
 361             {
 362               lto_output_uleb128_stream (ob->main_stream, 0);
 363               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 364                                         alias->thunk.alias);
 365             }
 366           alias = alias->previous;
 367         }
 368       while (alias);
 369     }
 370   else
 371     lto_output_uleb128_stream (ob->main_stream, 0);
 372 }
 373
 374 /* Stream out profile_summary to OB.  */
 375
 376 static void
 377 output_profile_summary (struct lto_simple_output_block *ob)
 378 {
 379   if (profile_info)
 380     {
 381       /* We do not output num, it is not terribly useful.  */
 382       gcc_assert (profile_info->runs);
 383       lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
 384       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
 385       lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
 386       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
 387     }
 388   else
 389     lto_output_uleb128_stream (ob->main_stream, 0);
 390 }
 391
 392 /* Add NODE into encoder as well as nodes it is cloned from.
 393    Do it in a way so clones appear first.  */
 394 static void
 395 add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
 396 {
 397   if (node->clone_of)
 398     add_node_to (encoder, node->clone_of);
 399   lto_cgraph_encoder_encode (encoder, node);
 400 }
 401
 402 /* Output the part of the cgraph in SET.  */
 403
 404 void
 405 output_cgraph (cgraph_node_set set)
 406 {
 407   struct cgraph_node *node;
 408   struct lto_simple_output_block *ob;
 409   cgraph_node_set_iterator csi;
 410   struct cgraph_edge *edge;
 411   int i, n_nodes;
 412   bitmap written_decls;
 413   lto_cgraph_encoder_t encoder;
 414   struct cgraph_asm_node *can;
 415
 416   ob = lto_create_simple_output_block (LTO_section_cgraph);
 417
 418   output_profile_summary (ob);
 419
 420   /* An encoder for cgraph nodes should have been created by
 421      ipa_write_summaries_1.  */
 422   gcc_assert (ob->decl_state->cgraph_node_encoder);
 423   encoder = ob->decl_state->cgraph_node_encoder;
 424
 425   /* The FUNCTION_DECLs for which we have written a node.  The first
 426      node found is written as the "original" node, the remaining nodes
 427      are considered its clones.  */
 428   written_decls = lto_bitmap_alloc ();
 429
 430   /* Go over all the nodes in SET and assign references.  */
 431   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 432     {
 433       node = csi_node (csi);
 434       add_node_to (encoder, node);
 435     }
 436
 437   /* Go over all the nodes again to include callees that are not in
 438      SET.  */
 439   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 440     {
 441       node = csi_node (csi);
 442       for (edge = node->callees; edge; edge = edge->next_callee)
 443         {
 444           struct cgraph_node *callee = edge->callee;
 445           if (!cgraph_node_in_set_p (callee, set))
 446             {
 447               /* We should have moved all the inlines.  */
 448               gcc_assert (!callee->global.inlined_to);
 449               add_node_to (encoder, callee);
 450               /* Also with each included function include all other functions
 451                  in the same comdat group.  */
 452               if (callee->same_comdat_group)
 453                 {
 454                   struct cgraph_node *next;
 455                   for (next = callee->same_comdat_group;
 456                        next != callee;
 457                        next = next->same_comdat_group)
 458                     if (!cgraph_node_in_set_p (next, set))
 459                       add_node_to (encoder, next);
 460                 }
 461             }
 462         }
 463       /* Also with each included function include all other functions
 464          in the same comdat group.  */
 465       if (node->same_comdat_group)
 466         {
 467           struct cgraph_node *next;
 468           for (next = node->same_comdat_group;
 469                next != node;
 470                next = next->same_comdat_group)
 471             if (!cgraph_node_in_set_p (next, set))
 472               add_node_to (encoder, next);
 473         }
 474     }
 475
 476   /* Write out the nodes.  We must first output a node and then its clones,
 477      otherwise at a time reading back the node there would be nothing to clone
 478      from.  */
 479   n_nodes = lto_cgraph_encoder_size (encoder);
 480   for (i = 0; i < n_nodes; i++)
 481     {
 482       node = lto_cgraph_encoder_deref (encoder, i);
 483       lto_output_node (ob, node, encoder, set, written_decls);
 484     }
 485
 486   lto_bitmap_free (written_decls);
 487
 488   /* Go over the nodes in SET again to write edges.  */
 489   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 490     {
 491       node = csi_node (csi);
 492       if (node->callees)
 493         {
 494           /* Output edges in backward direction, so the reconstructed callgraph
 495              match and it is easy to associate call sites in the IPA pass summaries.  */
 496           edge = node->callees;
 497           while (edge->next_callee)
 498             edge = edge->next_callee;
 499           for (; edge; edge = edge->prev_callee)
 500             lto_output_edge (ob, edge, encoder);
 501         }
 502     }
 503
 504   lto_output_uleb128_stream (ob->main_stream, 0);
 505
 506   /* Emit toplevel asms.  */
 507   for (can = cgraph_asm_nodes; can; can = can->next)
 508     {
 509       int len = TREE_STRING_LENGTH (can->asm_str);
 510       lto_output_uleb128_stream (ob->main_stream, len);
 511       for (i = 0; i < len; ++i)
 512         lto_output_1_stream (ob->main_stream,
 513                              TREE_STRING_POINTER (can->asm_str)[i]);
 514     }
 515
 516   lto_output_uleb128_stream (ob->main_stream, 0);
 517
 518   lto_destroy_simple_output_block (ob);
 519 }
 520
 521
 522 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
 523    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
 524    NODE or to replace the values in it, for instance because the first
 525    time we saw it, the function body was not available but now it
 526    is.  BP is a bitpack with all the bitflags for NODE read from the
 527    stream.  */
 528
 529 static void
 530 input_overwrite_node (struct lto_file_decl_data *file_data,
 531                       struct cgraph_node *node,
 532                       enum LTO_cgraph_tags tag,
 533                       struct bitpack_d *bp,
 534                       unsigned int stack_size,
 535                       unsigned int self_time,
 536                       unsigned int time_inlining_benefit,
 537                       unsigned int self_size,
 538                       unsigned int size_inlining_benefit)
 539 {
 540   node->aux = (void *) tag;
 541   node->local.inline_summary.estimated_self_stack_size = stack_size;
 542   node->local.inline_summary.self_time = self_time;
 543   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
 544   node->local.inline_summary.self_size = self_size;
 545   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
 546   node->global.time = self_time;
 547   node->global.size = self_size;
 548   node->local.lto_file_data = file_data;
 549
 550   node->local.local = bp_unpack_value (bp, 1);
 551   node->local.externally_visible = bp_unpack_value (bp, 1);
 552   node->local.finalized = bp_unpack_value (bp, 1);
 553   node->local.inlinable = bp_unpack_value (bp, 1);
 554   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
 555   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
 556   node->local.for_functions_valid = bp_unpack_value (bp, 1);
 557   node->local.vtable_method = bp_unpack_value (bp, 1);
 558   node->needed = bp_unpack_value (bp, 1);
 559   node->address_taken = bp_unpack_value (bp, 1);
 560   node->abstract_and_needed = bp_unpack_value (bp, 1);
 561   node->reachable = bp_unpack_value (bp, 1);
 562   node->reachable_from_other_partition = bp_unpack_value (bp, 1);
 563   node->lowered = bp_unpack_value (bp, 1);
 564   node->analyzed = bp_unpack_value (bp, 1);
 565   node->in_other_partition = bp_unpack_value (bp, 1);
 566   node->process = bp_unpack_value (bp, 1);
 567   node->alias = bp_unpack_value (bp, 1);
 568   node->finalized_by_frontend = bp_unpack_value (bp, 1);
 569 }
 570
 571
 572 /* Read a node from input_block IB.  TAG is the node's tag just read.
 573    Return the node read or overwriten.  */
 574
 575 static struct cgraph_node *
 576 input_node (struct lto_file_decl_data *file_data,
 577             struct lto_input_block *ib,
 578             enum LTO_cgraph_tags tag)
 579 {
 580   tree fn_decl;
 581   struct cgraph_node *node;
 582   struct bitpack_d *bp;
 583   int stack_size = 0;
 584   unsigned decl_index;
 585   bool clone_p;
 586   int estimated_stack_size = 0;
 587   int stack_frame_offset = 0;
 588   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
 589   int estimated_growth = 0;
 590   int time = 0;
 591   int size = 0;
 592   int self_time = 0;
 593   int self_size = 0;
 594   int time_inlining_benefit = 0;
 595   int size_inlining_benefit = 0;
 596   unsigned long same_body_count = 0;
 597   bool inlined = false;
 598
 599   clone_p = (lto_input_uleb128 (ib) != 0);
 600
 601   decl_index = lto_input_uleb128 (ib);
 602   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 603
 604   if (clone_p)
 605     node = cgraph_clone_node (cgraph_node (fn_decl), 0,
 606                               CGRAPH_FREQ_BASE, 0, false, NULL);
 607
 608   else
 609     node = cgraph_node (fn_decl);
 610
 611   node->count = lto_input_sleb128 (ib);
 612   bp = lto_input_bitpack (ib);
 613
 614   if (tag != LTO_cgraph_unavail_node)
 615     {
 616       stack_size = lto_input_sleb128 (ib);
 617       self_size = lto_input_sleb128 (ib);
 618       size_inlining_benefit = lto_input_sleb128 (ib);
 619       self_time = lto_input_sleb128 (ib);
 620       time_inlining_benefit = lto_input_sleb128 (ib);
 621     }
 622
 623   estimated_stack_size = lto_input_sleb128 (ib);
 624   stack_frame_offset = lto_input_sleb128 (ib);
 625   ref = lto_input_sleb128 (ib);
 626   time = lto_input_sleb128 (ib);
 627   size = lto_input_sleb128 (ib);
 628   estimated_growth = lto_input_sleb128 (ib);
 629   inlined = lto_input_uleb128 (ib);
 630   ref2 = lto_input_sleb128 (ib);
 631   same_body_count = lto_input_uleb128 (ib);
 632
 633   /* Make sure that we have not read this node before.  Nodes that
 634      have already been read will have their tag stored in the 'aux'
 635      field.  Since built-in functions can be referenced in multiple
 636      functions, they are expected to be read more than once.  */
 637   if (node->aux && !DECL_IS_BUILTIN (node->decl))
 638     internal_error ("bytecode stream: found multiple instances of cgraph "
 639                     "node %d", node->uid);
 640
 641   input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
 642                         time_inlining_benefit, self_size,
 643                         size_inlining_benefit);
 644   bitpack_delete (bp);
 645
 646   node->global.estimated_stack_size = estimated_stack_size;
 647   node->global.stack_frame_offset = stack_frame_offset;
 648   node->global.time = time;
 649   node->global.size = size;
 650
 651   /* Store a reference for now, and fix up later to be a pointer.  */
 652   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
 653
 654   node->global.estimated_growth = estimated_growth;
 655   node->global.inlined = inlined;
 656
 657   /* Store a reference for now, and fix up later to be a pointer.  */
 658   node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
 659
 660   while (same_body_count-- > 0)
 661     {
 662       tree alias_decl;
 663       int type;
 664       decl_index = lto_input_uleb128 (ib);
 665       alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 666       type = lto_input_uleb128 (ib);
 667       if (!type)
 668         {
 669           tree real_alias;
 670           decl_index = lto_input_uleb128 (ib);
 671           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 672           cgraph_same_body_alias (alias_decl, real_alias);
 673         }
 674       else
 675         {
 676           HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
 677           HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
 678           tree real_alias;
 679           decl_index = lto_input_uleb128 (ib);
 680           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 681           cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
 682                             virtual_value,
 683                             (type & 4) ? size_int (virtual_value) : NULL_TREE,
 684                             real_alias);
 685         }
 686     }
 687   return node;
 688 }
 689
 690
 691 /* Read an edge from IB.  NODES points to a vector of previously read
 692    nodes for decoding caller and callee of the edge to be read.  */
 693
 694 static void
 695 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
 696 {
 697   struct cgraph_node *caller, *callee;
 698   struct cgraph_edge *edge;
 699   unsigned int stmt_id;
 700   gcov_type count;
 701   int freq;
 702   unsigned int nest;
 703   cgraph_inline_failed_t inline_failed;
 704   struct bitpack_d *bp;
 705   enum ld_plugin_symbol_resolution caller_resolution;
 706
 707   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 708   if (caller == NULL || caller->decl == NULL_TREE)
 709     internal_error ("bytecode stream: no caller found while reading edge");
 710
 711   callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
 712   if (callee == NULL || callee->decl == NULL_TREE)
 713     internal_error ("bytecode stream: no callee found while reading edge");
 714
 715   count = (gcov_type) lto_input_sleb128 (ib);
 716
 717   bp = lto_input_bitpack (ib);
 718   stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 719   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
 720                                                             HOST_BITS_PER_INT);
 721   freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
 722   nest = (unsigned) bp_unpack_value (bp, 30);
 723
 724   /* If the caller was preempted, don't create the edge.
 725      ???  Should we ever have edges from a preempted caller?  */
 726   caller_resolution = lto_symtab_get_resolution (caller->decl);
 727   if (caller_resolution == LDPR_PREEMPTED_REG
 728       || caller_resolution == LDPR_PREEMPTED_IR)
 729     return;
 730
 731   edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
 732   edge->lto_stmt_uid = stmt_id;
 733   edge->inline_failed = inline_failed;
 734   edge->indirect_call = bp_unpack_value (bp, 1);
 735   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
 736   edge->can_throw_external = bp_unpack_value (bp, 1);
 737   bitpack_delete (bp);
 738 }
 739
 740
 741 /* Read a cgraph from IB using the info in FILE_DATA.  */
 742
 743 static void
 744 input_cgraph_1 (struct lto_file_decl_data *file_data,
 745                 struct lto_input_block *ib)
 746 {
 747   enum LTO_cgraph_tags tag;
 748   VEC(cgraph_node_ptr, heap) *nodes = NULL;
 749   struct cgraph_node *node;
 750   unsigned i;
 751   unsigned HOST_WIDE_INT len;
 752
 753   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 754   while (tag)
 755     {
 756       if (tag == LTO_cgraph_edge)
 757         input_edge (ib, nodes);
 758       else
 759         {
 760           node = input_node (file_data, ib, tag);
 761           if (node == NULL || node->decl == NULL_TREE)
 762             internal_error ("bytecode stream: found empty cgraph node");
 763           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
 764           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
 765         }
 766
 767       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
 768     }
 769
 770   /* Input toplevel asms.  */
 771   len = lto_input_uleb128 (ib);
 772   while (len)
 773     {
 774       char *str = (char *)xmalloc (len + 1);
 775       for (i = 0; i < len; ++i)
 776         str[i] = lto_input_1_unsigned (ib);
 777       cgraph_add_asm_node (build_string (len, str));
 778       free (str);
 779
 780       len = lto_input_uleb128 (ib);
 781     }
 782
 783   for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
 784     {
 785       int ref = (int) (intptr_t) node->global.inlined_to;
 786
 787       /* Fixup inlined_to from reference to pointer.  */
 788       if (ref != LCC_NOT_FOUND)
 789         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
 790       else
 791         node->global.inlined_to = NULL;
 792
 793       ref = (int) (intptr_t) node->same_comdat_group;
 794
 795       /* Fixup same_comdat_group from reference to pointer.  */
 796       if (ref != LCC_NOT_FOUND)
 797         node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
 798       else
 799         node->same_comdat_group = NULL;
 800     }
 801
 802   VEC_free (cgraph_node_ptr, heap, nodes);
 803 }
 804
 805 static struct gcov_ctr_summary lto_gcov_summary;
 806
 807 /* Input profile_info from IB.  */
 808 static void
 809 input_profile_summary (struct lto_input_block *ib)
 810 {
 811   unsigned int runs = lto_input_uleb128 (ib);
 812   if (runs)
 813     {
 814       if (!profile_info)
 815         {
 816           profile_info = &lto_gcov_summary;
 817           lto_gcov_summary.runs = runs;
 818           lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
 819           lto_gcov_summary.run_max = lto_input_sleb128 (ib);
 820           lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
 821         }
 822       /* We can support this by scaling all counts to nearest common multiple
 823          of all different runs, but it is perhaps not worth the effort.  */
 824       else if (profile_info->runs != runs
 825                || profile_info->sum_all != lto_input_sleb128 (ib)
 826                || profile_info->run_max != lto_input_sleb128 (ib)
 827                || profile_info->sum_max != lto_input_sleb128 (ib))
 828         sorry ("Combining units with different profiles is not supported.");
 829       /* We allow some units to have profile and other to not have one.  This will
 830          just make unprofiled units to be size optimized that is sane.  */
 831     }
 832
 833 }
 834
 835 /* Input and merge the cgraph from each of the .o files passed to
 836    lto1.  */
 837
 838 void
 839 input_cgraph (void)
 840 {
 841   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
 842   struct lto_file_decl_data *file_data;
 843   unsigned int j = 0;
 844   struct cgraph_node *node;
 845
 846   while ((file_data = file_data_vec[j++]))
 847     {
 848       const char *data;
 849       size_t len;
 850       struct lto_input_block *ib;
 851
 852       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
 853                                           &data, &len);
 854       input_profile_summary (ib);
 855       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
 856       input_cgraph_1 (file_data, ib);
 857       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
 858                                       ib, data, len);
 859
 860       /* Assume that every file read needs to be processed by LTRANS.  */
 861       if (flag_wpa)
 862         lto_mark_file_for_ltrans (file_data);
 863     }
 864
 865   /* Clear out the aux field that was used to store enough state to
 866      tell which nodes should be overwritten.  */
 867   for (node = cgraph_nodes; node; node = node->next)
 868     {
 869       /* Some nodes may have been created by cgraph_node.  This
 870          happens when the callgraph contains nested functions.  If the
 871          node for the parent function was never emitted to the gimple
 872          file, cgraph_node will create a node for it when setting the
 873          context of the nested function.  */
 874       if (node->local.lto_file_data)
 875         node->aux = NULL;
 876     }
 877 }