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