gcc/lto-cgraph.c

   1 /* Write and read the cgraph to the memory mapped representation of a
   2    .o file.
   3
   4    Copyright 2009, 2010 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 "tree.h"
  28 #include "expr.h"
  29 #include "flags.h"
  30 #include "params.h"
  31 #include "input.h"
  32 #include "hashtab.h"
  33 #include "langhooks.h"
  34 #include "basic-block.h"
  35 #include "tree-flow.h"
  36 #include "cgraph.h"
  37 #include "function.h"
  38 #include "ggc.h"
  39 #include "diagnostic-core.h"
  40 #include "except.h"
  41 #include "vec.h"
  42 #include "timevar.h"
  43 #include "output.h"
  44 #include "pointer-set.h"
  45 #include "lto-streamer.h"
  46 #include "gcov-io.h"
  47
  48 static void output_varpool (cgraph_node_set, varpool_node_set);
  49 static void output_cgraph_opt_summary (cgraph_node_set set);
  50 static void input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes);
  51
  52
  53 /* Cgraph streaming is organized as set of record whose type
  54    is indicated by a tag.  */
  55 enum LTO_cgraph_tags
  56 {
  57   /* Must leave 0 for the stopper.  */
  58
  59   /* Cgraph node without body available.  */
  60   LTO_cgraph_unavail_node = 1,
  61   /* Cgraph node with function body.  */
  62   LTO_cgraph_analyzed_node,
  63   /* Cgraph edges.  */
  64   LTO_cgraph_edge,
  65   LTO_cgraph_indirect_edge
  66 };
  67
  68 /* Create a new cgraph encoder.  */
  69
  70 lto_cgraph_encoder_t
  71 lto_cgraph_encoder_new (void)
  72 {
  73   lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
  74   encoder->map = pointer_map_create ();
  75   encoder->nodes = NULL;
  76   encoder->body = pointer_set_create ();
  77   return encoder;
  78 }
  79
  80
  81 /* Delete ENCODER and its components.  */
  82
  83 void
  84 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
  85 {
  86    VEC_free (cgraph_node_ptr, heap, encoder->nodes);
  87    pointer_map_destroy (encoder->map);
  88    pointer_set_destroy (encoder->body);
  89    free (encoder);
  90 }
  91
  92
  93 /* Return the existing reference number of NODE in the cgraph encoder in
  94    output block OB.  Assign a new reference if this is the first time
  95    NODE is encoded.  */
  96
  97 int
  98 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
  99                            struct cgraph_node *node)
 100 {
 101   int ref;
 102   void **slot;
 103
 104   slot = pointer_map_contains (encoder->map, node);
 105   if (!slot)
 106     {
 107       ref = VEC_length (cgraph_node_ptr, encoder->nodes);
 108       slot = pointer_map_insert (encoder->map, node);
 109       *slot = (void *) (intptr_t) ref;
 110       VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
 111     }
 112   else
 113     ref = (int) (intptr_t) *slot;
 114
 115   return ref;
 116 }
 117
 118 #define LCC_NOT_FOUND   (-1)
 119
 120 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
 121    or LCC_NOT_FOUND if it is not there.  */
 122
 123 int
 124 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
 125                            struct cgraph_node *node)
 126 {
 127   void **slot = pointer_map_contains (encoder->map, node);
 128   return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
 129 }
 130
 131
 132 /* Return the cgraph node corresponding to REF using ENCODER.  */
 133
 134 struct cgraph_node *
 135 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
 136 {
 137   if (ref == LCC_NOT_FOUND)
 138     return NULL;
 139
 140   return VEC_index (cgraph_node_ptr, encoder->nodes, ref);
 141 }
 142
 143
 144 /* Return TRUE if we should encode initializer of NODE (if any).  */
 145
 146 bool
 147 lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t encoder,
 148                                   struct cgraph_node *node)
 149 {
 150   return pointer_set_contains (encoder->body, node);
 151 }
 152
 153 /* Return TRUE if we should encode body of NODE (if any).  */
 154
 155 static void
 156 lto_set_cgraph_encoder_encode_body (lto_cgraph_encoder_t encoder,
 157                                     struct cgraph_node *node)
 158 {
 159   pointer_set_insert (encoder->body, node);
 160 }
 161
 162 /* Create a new varpool encoder.  */
 163
 164 lto_varpool_encoder_t
 165 lto_varpool_encoder_new (void)
 166 {
 167   lto_varpool_encoder_t encoder = XCNEW (struct lto_varpool_encoder_d);
 168   encoder->map = pointer_map_create ();
 169   encoder->initializer = pointer_set_create ();
 170   encoder->nodes = NULL;
 171   return encoder;
 172 }
 173
 174
 175 /* Delete ENCODER and its components.  */
 176
 177 void
 178 lto_varpool_encoder_delete (lto_varpool_encoder_t encoder)
 179 {
 180    VEC_free (varpool_node_ptr, heap, encoder->nodes);
 181    pointer_map_destroy (encoder->map);
 182    pointer_set_destroy (encoder->initializer);
 183    free (encoder);
 184 }
 185
 186
 187 /* Return the existing reference number of NODE in the varpool encoder in
 188    output block OB.  Assign a new reference if this is the first time
 189    NODE is encoded.  */
 190
 191 int
 192 lto_varpool_encoder_encode (lto_varpool_encoder_t encoder,
 193                            struct varpool_node *node)
 194 {
 195   int ref;
 196   void **slot;
 197
 198   slot = pointer_map_contains (encoder->map, node);
 199   if (!slot)
 200     {
 201       ref = VEC_length (varpool_node_ptr, encoder->nodes);
 202       slot = pointer_map_insert (encoder->map, node);
 203       *slot = (void *) (intptr_t) ref;
 204       VEC_safe_push (varpool_node_ptr, heap, encoder->nodes, node);
 205     }
 206   else
 207     ref = (int) (intptr_t) *slot;
 208
 209   return ref;
 210 }
 211
 212 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
 213    or LCC_NOT_FOUND if it is not there.  */
 214
 215 int
 216 lto_varpool_encoder_lookup (lto_varpool_encoder_t encoder,
 217                            struct varpool_node *node)
 218 {
 219   void **slot = pointer_map_contains (encoder->map, node);
 220   return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
 221 }
 222
 223
 224 /* Return the varpool node corresponding to REF using ENCODER.  */
 225
 226 struct varpool_node *
 227 lto_varpool_encoder_deref (lto_varpool_encoder_t encoder, int ref)
 228 {
 229   if (ref == LCC_NOT_FOUND)
 230     return NULL;
 231
 232   return VEC_index (varpool_node_ptr, encoder->nodes, ref);
 233 }
 234
 235
 236 /* Return TRUE if we should encode initializer of NODE (if any).  */
 237
 238 bool
 239 lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t encoder,
 240                                           struct varpool_node *node)
 241 {
 242   return pointer_set_contains (encoder->initializer, node);
 243 }
 244
 245 /* Return TRUE if we should encode initializer of NODE (if any).  */
 246
 247 static void
 248 lto_set_varpool_encoder_encode_initializer (lto_varpool_encoder_t encoder,
 249                                             struct varpool_node *node)
 250 {
 251   pointer_set_insert (encoder->initializer, node);
 252 }
 253
 254 /* Output the cgraph EDGE to OB using ENCODER.  */
 255
 256 static void
 257 lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
 258                  lto_cgraph_encoder_t encoder)
 259 {
 260   unsigned int uid;
 261   intptr_t ref;
 262   struct bitpack_d bp;
 263
 264   if (edge->indirect_unknown_callee)
 265     lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
 266   else
 267     lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
 268
 269   ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
 270   gcc_assert (ref != LCC_NOT_FOUND);
 271   lto_output_sleb128_stream (ob->main_stream, ref);
 272
 273   if (!edge->indirect_unknown_callee)
 274     {
 275       ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
 276       gcc_assert (ref != LCC_NOT_FOUND);
 277       lto_output_sleb128_stream (ob->main_stream, ref);
 278     }
 279
 280   lto_output_sleb128_stream (ob->main_stream, edge->count);
 281
 282   bp = bitpack_create (ob->main_stream);
 283   uid = (!gimple_has_body_p (edge->caller->decl)
 284          ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt));
 285   bp_pack_value (&bp, uid, HOST_BITS_PER_INT);
 286   bp_pack_value (&bp, edge->inline_failed, HOST_BITS_PER_INT);
 287   bp_pack_value (&bp, edge->frequency, HOST_BITS_PER_INT);
 288   bp_pack_value (&bp, edge->loop_nest, 30);
 289   bp_pack_value (&bp, edge->indirect_inlining_edge, 1);
 290   bp_pack_value (&bp, edge->call_stmt_cannot_inline_p, 1);
 291   bp_pack_value (&bp, edge->can_throw_external, 1);
 292   if (edge->indirect_unknown_callee)
 293     {
 294       int flags = edge->indirect_info->ecf_flags;
 295       bp_pack_value (&bp, (flags & ECF_CONST) != 0, 1);
 296       bp_pack_value (&bp, (flags & ECF_PURE) != 0, 1);
 297       bp_pack_value (&bp, (flags & ECF_NORETURN) != 0, 1);
 298       bp_pack_value (&bp, (flags & ECF_MALLOC) != 0, 1);
 299       bp_pack_value (&bp, (flags & ECF_NOTHROW) != 0, 1);
 300       bp_pack_value (&bp, (flags & ECF_RETURNS_TWICE) != 0, 1);
 301       /* Flags that should not appear on indirect calls.  */
 302       gcc_assert (!(flags & (ECF_LOOPING_CONST_OR_PURE
 303                              | ECF_MAY_BE_ALLOCA
 304                              | ECF_SIBCALL
 305                              | ECF_LEAF
 306                              | ECF_NOVOPS)));
 307     }
 308   lto_output_bitpack (&bp);
 309 }
 310
 311 /* Return if LIST contain references from other partitions.  */
 312
 313 bool
 314 referenced_from_other_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
 315                                    varpool_node_set vset)
 316 {
 317   int i;
 318   struct ipa_ref *ref;
 319   for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
 320     {
 321       if (ref->refering_type == IPA_REF_CGRAPH)
 322         {
 323           if (ipa_ref_refering_node (ref)->in_other_partition
 324               || !cgraph_node_in_set_p (ipa_ref_refering_node (ref), set))
 325             return true;
 326         }
 327       else
 328         {
 329           if (ipa_ref_refering_varpool_node (ref)->in_other_partition
 330               || !varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref),
 331                                          vset))
 332             return true;
 333         }
 334     }
 335   return false;
 336 }
 337
 338 /* Return true when node is reachable from other partition.  */
 339
 340 bool
 341 reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
 342 {
 343   struct cgraph_edge *e;
 344   if (!node->analyzed)
 345     return false;
 346   if (node->global.inlined_to)
 347     return false;
 348   for (e = node->callers; e; e = e->next_caller)
 349     if (e->caller->in_other_partition
 350         || !cgraph_node_in_set_p (e->caller, set))
 351       return true;
 352   return false;
 353 }
 354
 355 /* Return if LIST contain references from other partitions.  */
 356
 357 bool
 358 referenced_from_this_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
 359                                   varpool_node_set vset)
 360 {
 361   int i;
 362   struct ipa_ref *ref;
 363   for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
 364     {
 365       if (ref->refering_type == IPA_REF_CGRAPH)
 366         {
 367           if (cgraph_node_in_set_p (ipa_ref_refering_node (ref), set))
 368             return true;
 369         }
 370       else
 371         {
 372           if (varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref),
 373                                      vset))
 374             return true;
 375         }
 376     }
 377   return false;
 378 }
 379
 380 /* Return true when node is reachable from other partition.  */
 381
 382 bool
 383 reachable_from_this_partition_p (struct cgraph_node *node, cgraph_node_set set)
 384 {
 385   struct cgraph_edge *e;
 386   for (e = node->callers; e; e = e->next_caller)
 387     if (cgraph_node_in_set_p (e->caller, set))
 388       return true;
 389   return false;
 390 }
 391
 392 /* Output the cgraph NODE to OB.  ENCODER is used to find the
 393    reference number of NODE->inlined_to.  SET is the set of nodes we
 394    are writing to the current file.  If NODE is not in SET, then NODE
 395    is a boundary of a cgraph_node_set and we pretend NODE just has a
 396    decl and no callees.  WRITTEN_DECLS is the set of FUNCTION_DECLs
 397    that have had their callgraph node written so far.  This is used to
 398    determine if NODE is a clone of a previously written node.  */
 399
 400 static void
 401 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 402                  lto_cgraph_encoder_t encoder, cgraph_node_set set,
 403                  varpool_node_set vset)
 404 {
 405   unsigned int tag;
 406   struct bitpack_d bp;
 407   bool boundary_p;
 408   intptr_t ref;
 409   bool in_other_partition = false;
 410   struct cgraph_node *clone_of;
 411
 412   boundary_p = !cgraph_node_in_set_p (node, set);
 413
 414   if (node->analyzed && !boundary_p)
 415     tag = LTO_cgraph_analyzed_node;
 416   else
 417     tag = LTO_cgraph_unavail_node;
 418
 419   lto_output_uleb128_stream (ob->main_stream, tag);
 420
 421   /* In WPA mode, we only output part of the call-graph.  Also, we
 422      fake cgraph node attributes.  There are two cases that we care.
 423
 424      Boundary nodes: There are nodes that are not part of SET but are
 425      called from within SET.  We artificially make them look like
 426      externally visible nodes with no function body.
 427
 428      Cherry-picked nodes:  These are nodes we pulled from other
 429      translation units into SET during IPA-inlining.  We make them as
 430      local static nodes to prevent clashes with other local statics.  */
 431   if (boundary_p && node->analyzed)
 432     {
 433       /* Inline clones can not be part of boundary.
 434          gcc_assert (!node->global.inlined_to);
 435
 436          FIXME: At the moment they can be, when partition contains an inline
 437          clone that is clone of inline clone from outside partition.  We can
 438          reshape the clone tree and make other tree to be the root, but it
 439          needs a bit extra work and will be promplty done by cgraph_remove_node
 440          after reading back.  */
 441       in_other_partition = 1;
 442     }
 443
 444   clone_of = node->clone_of;
 445   while (clone_of
 446          && (ref = lto_cgraph_encoder_lookup (encoder, clone_of)) == LCC_NOT_FOUND)
 447     if (clone_of->prev_sibling_clone)
 448       clone_of = clone_of->prev_sibling_clone;
 449     else
 450       clone_of = clone_of->clone_of;
 451
 452   if (LTO_cgraph_analyzed_node)
 453     gcc_assert (clone_of || !node->clone_of);
 454   if (!clone_of)
 455     lto_output_sleb128_stream (ob->main_stream, LCC_NOT_FOUND);
 456   else
 457     lto_output_sleb128_stream (ob->main_stream, ref);
 458
 459
 460   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
 461   lto_output_sleb128_stream (ob->main_stream, node->count);
 462   lto_output_sleb128_stream (ob->main_stream, node->count_materialization_scale);
 463
 464   if (tag == LTO_cgraph_analyzed_node)
 465     {
 466       lto_output_sleb128_stream (ob->main_stream,
 467                                  node->local.inline_summary.estimated_self_stack_size);
 468       lto_output_sleb128_stream (ob->main_stream,
 469                                  node->local.inline_summary.self_size);
 470       lto_output_sleb128_stream (ob->main_stream,
 471                                  node->local.inline_summary.size_inlining_benefit);
 472       lto_output_sleb128_stream (ob->main_stream,
 473                                  node->local.inline_summary.self_time);
 474       lto_output_sleb128_stream (ob->main_stream,
 475                                  node->local.inline_summary.time_inlining_benefit);
 476       if (node->global.inlined_to)
 477         {
 478           ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
 479           gcc_assert (ref != LCC_NOT_FOUND);
 480         }
 481       else
 482         ref = LCC_NOT_FOUND;
 483
 484       lto_output_sleb128_stream (ob->main_stream, ref);
 485     }
 486
 487   if (node->same_comdat_group && !boundary_p)
 488     {
 489       ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
 490       gcc_assert (ref != LCC_NOT_FOUND);
 491     }
 492   else
 493     ref = LCC_NOT_FOUND;
 494   lto_output_sleb128_stream (ob->main_stream, ref);
 495
 496   bp = bitpack_create (ob->main_stream);
 497   bp_pack_value (&bp, node->local.local, 1);
 498   bp_pack_value (&bp, node->local.externally_visible, 1);
 499   bp_pack_value (&bp, node->local.finalized, 1);
 500   bp_pack_value (&bp, node->local.inlinable, 1);
 501   bp_pack_value (&bp, node->local.versionable, 1);
 502   bp_pack_value (&bp, node->local.can_change_signature, 1);
 503   bp_pack_value (&bp, node->local.disregard_inline_limits, 1);
 504   bp_pack_value (&bp, node->local.redefined_extern_inline, 1);
 505   bp_pack_value (&bp, node->local.vtable_method, 1);
 506   bp_pack_value (&bp, node->needed, 1);
 507   bp_pack_value (&bp, node->address_taken, 1);
 508   bp_pack_value (&bp, node->abstract_and_needed, 1);
 509   bp_pack_value (&bp, tag == LTO_cgraph_analyzed_node
 510                  && !DECL_EXTERNAL (node->decl)
 511                  && !DECL_COMDAT (node->decl)
 512                  && (reachable_from_other_partition_p (node, set)
 513                      || referenced_from_other_partition_p (&node->ref_list, set, vset)), 1);
 514   bp_pack_value (&bp, node->lowered, 1);
 515   bp_pack_value (&bp, in_other_partition, 1);
 516   bp_pack_value (&bp, node->alias, 1);
 517   bp_pack_value (&bp, node->finalized_by_frontend, 1);
 518   bp_pack_value (&bp, node->frequency, 2);
 519   bp_pack_value (&bp, node->only_called_at_startup, 1);
 520   bp_pack_value (&bp, node->only_called_at_exit, 1);
 521   lto_output_bitpack (&bp);
 522   lto_output_uleb128_stream (ob->main_stream, node->resolution);
 523
 524   if (node->same_body)
 525     {
 526       struct cgraph_node *alias;
 527       unsigned long alias_count = 1;
 528       for (alias = node->same_body; alias->next; alias = alias->next)
 529         alias_count++;
 530       lto_output_uleb128_stream (ob->main_stream, alias_count);
 531       do
 532         {
 533           lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 534                                     alias->decl);
 535           if (alias->thunk.thunk_p)
 536             {
 537               lto_output_uleb128_stream
 538                  (ob->main_stream,
 539                   1 + (alias->thunk.this_adjusting != 0) * 2
 540                   + (alias->thunk.virtual_offset_p != 0) * 4);
 541               lto_output_uleb128_stream (ob->main_stream,
 542                                          alias->thunk.fixed_offset);
 543               lto_output_uleb128_stream (ob->main_stream,
 544                                          alias->thunk.virtual_value);
 545               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 546                                         alias->thunk.alias);
 547             }
 548           else
 549             {
 550               lto_output_uleb128_stream (ob->main_stream, 0);
 551               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
 552                                         alias->thunk.alias);
 553             }
 554           gcc_assert (cgraph_get_node (alias->thunk.alias) == node);
 555           lto_output_uleb128_stream (ob->main_stream, alias->resolution);
 556           alias = alias->previous;
 557         }
 558       while (alias);
 559     }
 560   else
 561     lto_output_uleb128_stream (ob->main_stream, 0);
 562 }
 563
 564 /* Output the varpool NODE to OB.
 565    If NODE is not in SET, then NODE is a boundary.  */
 566
 567 static void
 568 lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
 569                          lto_varpool_encoder_t varpool_encoder,
 570                          cgraph_node_set set, varpool_node_set vset)
 571 {
 572   bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
 573   struct bitpack_d bp;
 574   struct varpool_node *alias;
 575   int count = 0;
 576   int ref;
 577
 578   lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
 579   bp = bitpack_create (ob->main_stream);
 580   bp_pack_value (&bp, node->externally_visible, 1);
 581   bp_pack_value (&bp, node->force_output, 1);
 582   bp_pack_value (&bp, node->finalized, 1);
 583   bp_pack_value (&bp, node->alias, 1);
 584   gcc_assert (!node->alias || !node->extra_name);
 585   gcc_assert (node->finalized || !node->analyzed);
 586   gcc_assert (node->needed);
 587   /* Constant pool initializers can be de-unified into individual ltrans units.
 588      FIXME: Alternatively at -Os we may want to avoid generating for them the local
 589      labels and share them across LTRANS partitions.  */
 590   if (DECL_IN_CONSTANT_POOL (node->decl)
 591       && !DECL_COMDAT (node->decl))
 592     {
 593       bp_pack_value (&bp, 0, 1);  /* used_from_other_parition.  */
 594       bp_pack_value (&bp, 0, 1);  /* in_other_partition.  */
 595     }
 596   else
 597     {
 598       bp_pack_value (&bp, node->analyzed
 599                      && referenced_from_other_partition_p (&node->ref_list,
 600                                                            set, vset), 1);
 601       bp_pack_value (&bp, boundary_p, 1);  /* in_other_partition.  */
 602     }
 603   /* Also emit any extra name aliases.  */
 604   for (alias = node->extra_name; alias; alias = alias->next)
 605     count++;
 606   bp_pack_value (&bp, count != 0, 1);
 607   lto_output_bitpack (&bp);
 608   if (node->same_comdat_group && !boundary_p)
 609     {
 610       ref = lto_varpool_encoder_lookup (varpool_encoder, node->same_comdat_group);
 611       gcc_assert (ref != LCC_NOT_FOUND);
 612     }
 613   else
 614     ref = LCC_NOT_FOUND;
 615   lto_output_sleb128_stream (ob->main_stream, ref);
 616   lto_output_uleb128_stream (ob->main_stream, node->resolution);
 617
 618   if (count)
 619     {
 620       lto_output_uleb128_stream (ob->main_stream, count);
 621       for (alias = node->extra_name; alias; alias = alias->next)
 622         {
 623           lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
 624           lto_output_uleb128_stream (ob->main_stream, alias->resolution);
 625         }
 626     }
 627 }
 628
 629 /* Output the varpool NODE to OB.
 630    If NODE is not in SET, then NODE is a boundary.  */
 631
 632 static void
 633 lto_output_ref (struct lto_simple_output_block *ob, struct ipa_ref *ref,
 634                 lto_cgraph_encoder_t encoder,
 635                 lto_varpool_encoder_t varpool_encoder)
 636 {
 637   struct bitpack_d bp;
 638   bp = bitpack_create (ob->main_stream);
 639   bp_pack_value (&bp, ref->refered_type, 1);
 640   bp_pack_value (&bp, ref->use, 2);
 641   lto_output_bitpack (&bp);
 642   if (ref->refered_type == IPA_REF_CGRAPH)
 643     {
 644       int nref = lto_cgraph_encoder_lookup (encoder, ipa_ref_node (ref));
 645       gcc_assert (nref != LCC_NOT_FOUND);
 646       lto_output_sleb128_stream (ob->main_stream, nref);
 647     }
 648   else
 649     {
 650       int nref = lto_varpool_encoder_lookup (varpool_encoder,
 651                                              ipa_ref_varpool_node (ref));
 652       gcc_assert (nref != LCC_NOT_FOUND);
 653       lto_output_sleb128_stream (ob->main_stream, nref);
 654     }
 655 }
 656
 657 /* Stream out profile_summary to OB.  */
 658
 659 static void
 660 output_profile_summary (struct lto_simple_output_block *ob)
 661 {
 662   if (profile_info)
 663     {
 664       /* We do not output num, sum_all and run_max, they are not used by
 665          GCC profile feedback and they are difficult to merge from multiple
 666          units.  */
 667       gcc_assert (profile_info->runs);
 668       lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
 669       lto_output_uleb128_stream (ob->main_stream, profile_info->sum_max);
 670     }
 671   else
 672     lto_output_uleb128_stream (ob->main_stream, 0);
 673 }
 674
 675 /* Add NODE into encoder as well as nodes it is cloned from.
 676    Do it in a way so clones appear first.  */
 677
 678 static void
 679 add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node,
 680              bool include_body)
 681 {
 682   if (node->clone_of)
 683     add_node_to (encoder, node->clone_of, include_body);
 684   else if (include_body)
 685     lto_set_cgraph_encoder_encode_body (encoder, node);
 686   lto_cgraph_encoder_encode (encoder, node);
 687 }
 688
 689 /* Add all references in LIST to encoders.  */
 690
 691 static void
 692 add_references (lto_cgraph_encoder_t encoder,
 693                 lto_varpool_encoder_t varpool_encoder,
 694                 struct ipa_ref_list *list)
 695 {
 696   int i;
 697   struct ipa_ref *ref;
 698   for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
 699     if (ref->refered_type == IPA_REF_CGRAPH)
 700       add_node_to (encoder, ipa_ref_node (ref), false);
 701     else
 702       {
 703         struct varpool_node *vnode = ipa_ref_varpool_node (ref);
 704         lto_varpool_encoder_encode (varpool_encoder, vnode);
 705       }
 706 }
 707
 708 /* Output all callees or indirect outgoing edges.  EDGE must be the first such
 709    edge.  */
 710
 711 static void
 712 output_outgoing_cgraph_edges (struct cgraph_edge *edge,
 713                               struct lto_simple_output_block *ob,
 714                               lto_cgraph_encoder_t encoder)
 715 {
 716   if (!edge)
 717     return;
 718
 719   /* Output edges in backward direction, so the reconstructed callgraph match
 720      and it is easy to associate call sites in the IPA pass summaries.  */
 721   while (edge->next_callee)
 722     edge = edge->next_callee;
 723   for (; edge; edge = edge->prev_callee)
 724     lto_output_edge (ob, edge, encoder);
 725 }
 726
 727 /* Output the part of the cgraph in SET.  */
 728
 729 static void
 730 output_refs (cgraph_node_set set, varpool_node_set vset,
 731              lto_cgraph_encoder_t encoder,
 732              lto_varpool_encoder_t varpool_encoder)
 733 {
 734   cgraph_node_set_iterator csi;
 735   varpool_node_set_iterator vsi;
 736   struct lto_simple_output_block *ob;
 737   int count;
 738   struct ipa_ref *ref;
 739   int i;
 740
 741   ob = lto_create_simple_output_block (LTO_section_refs);
 742
 743   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 744     {
 745       struct cgraph_node *node = csi_node (csi);
 746
 747       count = ipa_ref_list_nreferences (&node->ref_list);
 748       if (count)
 749         {
 750           lto_output_uleb128_stream (ob->main_stream, count);
 751           lto_output_uleb128_stream (ob->main_stream,
 752                                      lto_cgraph_encoder_lookup (encoder, node));
 753           for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
 754             lto_output_ref (ob, ref, encoder, varpool_encoder);
 755         }
 756     }
 757
 758   lto_output_uleb128_stream (ob->main_stream, 0);
 759
 760   for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
 761     {
 762       struct varpool_node *node = vsi_node (vsi);
 763
 764       count = ipa_ref_list_nreferences (&node->ref_list);
 765       if (count)
 766         {
 767           lto_output_uleb128_stream (ob->main_stream, count);
 768           lto_output_uleb128_stream (ob->main_stream,
 769                                      lto_varpool_encoder_lookup (varpool_encoder,
 770                                                                  node));
 771           for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
 772             lto_output_ref (ob, ref, encoder, varpool_encoder);
 773         }
 774     }
 775
 776   lto_output_uleb128_stream (ob->main_stream, 0);
 777
 778   lto_destroy_simple_output_block (ob);
 779 }
 780
 781 /* Find out all cgraph and varpool nodes we want to encode in current unit
 782    and insert them to encoders.  */
 783 void
 784 compute_ltrans_boundary (struct lto_out_decl_state *state,
 785                          cgraph_node_set set, varpool_node_set vset)
 786 {
 787   struct cgraph_node *node;
 788   cgraph_node_set_iterator csi;
 789   varpool_node_set_iterator vsi;
 790   struct cgraph_edge *edge;
 791   int i;
 792   lto_cgraph_encoder_t encoder;
 793   lto_varpool_encoder_t varpool_encoder;
 794
 795   encoder = state->cgraph_node_encoder = lto_cgraph_encoder_new ();
 796   varpool_encoder = state->varpool_node_encoder = lto_varpool_encoder_new ();
 797
 798   /* Go over all the nodes in SET and assign references.  */
 799   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 800     {
 801       node = csi_node (csi);
 802       add_node_to (encoder, node, true);
 803       add_references (encoder, varpool_encoder, &node->ref_list);
 804     }
 805   for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
 806     {
 807       struct varpool_node *vnode = vsi_node (vsi);
 808       gcc_assert (!vnode->alias);
 809       lto_varpool_encoder_encode (varpool_encoder, vnode);
 810       lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
 811       add_references (encoder, varpool_encoder, &vnode->ref_list);
 812     }
 813   /* Pickle in also the initializer of all referenced readonly variables
 814      to help folding.  Constant pool variables are not shared, so we must
 815      pickle those too.  */
 816   for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
 817     {
 818       struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i);
 819       if (DECL_INITIAL (vnode->decl)
 820           && !lto_varpool_encoder_encode_initializer_p (varpool_encoder,
 821                                                         vnode)
 822           && const_value_known_p (vnode->decl))
 823         {
 824           lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
 825           add_references (encoder, varpool_encoder, &vnode->ref_list);
 826         }
 827     }
 828
 829   /* Go over all the nodes again to include callees that are not in
 830      SET.  */
 831   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 832     {
 833       node = csi_node (csi);
 834       for (edge = node->callees; edge; edge = edge->next_callee)
 835         {
 836           struct cgraph_node *callee = edge->callee;
 837           if (!cgraph_node_in_set_p (callee, set))
 838             {
 839               /* We should have moved all the inlines.  */
 840               gcc_assert (!callee->global.inlined_to);
 841               add_node_to (encoder, callee, false);
 842             }
 843         }
 844     }
 845 }
 846
 847 /* Output the part of the cgraph in SET.  */
 848
 849 void
 850 output_cgraph (cgraph_node_set set, varpool_node_set vset)
 851 {
 852   struct cgraph_node *node;
 853   struct lto_simple_output_block *ob;
 854   cgraph_node_set_iterator csi;
 855   int i, n_nodes;
 856   lto_cgraph_encoder_t encoder;
 857   lto_varpool_encoder_t varpool_encoder;
 858   struct cgraph_asm_node *can;
 859   static bool asm_nodes_output = false;
 860
 861   if (flag_wpa)
 862     output_cgraph_opt_summary (set);
 863
 864   ob = lto_create_simple_output_block (LTO_section_cgraph);
 865
 866   output_profile_summary (ob);
 867
 868   /* An encoder for cgraph nodes should have been created by
 869      ipa_write_summaries_1.  */
 870   gcc_assert (ob->decl_state->cgraph_node_encoder);
 871   gcc_assert (ob->decl_state->varpool_node_encoder);
 872   encoder = ob->decl_state->cgraph_node_encoder;
 873   varpool_encoder = ob->decl_state->varpool_node_encoder;
 874
 875   /* Write out the nodes.  We must first output a node and then its clones,
 876      otherwise at a time reading back the node there would be nothing to clone
 877      from.  */
 878   n_nodes = lto_cgraph_encoder_size (encoder);
 879   for (i = 0; i < n_nodes; i++)
 880     {
 881       node = lto_cgraph_encoder_deref (encoder, i);
 882       lto_output_node (ob, node, encoder, set, vset);
 883     }
 884
 885   /* Go over the nodes in SET again to write edges.  */
 886   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
 887     {
 888       node = csi_node (csi);
 889       output_outgoing_cgraph_edges (node->callees, ob, encoder);
 890       output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
 891     }
 892
 893   lto_output_uleb128_stream (ob->main_stream, 0);
 894
 895   /* Emit toplevel asms.
 896      When doing WPA we must output every asm just once.  Since we do not partition asm
 897      nodes at all, output them to first output.  This is kind of hack, but should work
 898      well.  */
 899   if (!asm_nodes_output)
 900     {
 901       asm_nodes_output = true;
 902       for (can = cgraph_asm_nodes; can; can = can->next)
 903         {
 904           int len = TREE_STRING_LENGTH (can->asm_str);
 905           lto_output_uleb128_stream (ob->main_stream, len);
 906           for (i = 0; i < len; ++i)
 907             lto_output_1_stream (ob->main_stream,
 908                                  TREE_STRING_POINTER (can->asm_str)[i]);
 909         }
 910     }
 911
 912   lto_output_uleb128_stream (ob->main_stream, 0);
 913
 914   lto_destroy_simple_output_block (ob);
 915   output_varpool (set, vset);
 916   output_refs (set, vset, encoder, varpool_encoder);
 917 }
 918
 919 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
 920    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
 921    NODE or to replace the values in it, for instance because the first
 922    time we saw it, the function body was not available but now it
 923    is.  BP is a bitpack with all the bitflags for NODE read from the
 924    stream.  */
 925
 926 static void
 927 input_overwrite_node (struct lto_file_decl_data *file_data,
 928                       struct cgraph_node *node,
 929                       enum LTO_cgraph_tags tag,
 930                       struct bitpack_d *bp,
 931                       unsigned int stack_size,
 932                       unsigned int self_time,
 933                       unsigned int time_inlining_benefit,
 934                       unsigned int self_size,
 935                       unsigned int size_inlining_benefit,
 936                       enum ld_plugin_symbol_resolution resolution)
 937 {
 938   node->aux = (void *) tag;
 939   node->local.inline_summary.estimated_self_stack_size = stack_size;
 940   node->local.inline_summary.self_time = self_time;
 941   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
 942   node->local.inline_summary.self_size = self_size;
 943   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
 944   node->global.time = self_time;
 945   node->global.size = self_size;
 946   node->global.estimated_stack_size = stack_size;
 947   node->global.estimated_growth = INT_MIN;
 948   node->local.lto_file_data = file_data;
 949
 950   node->local.local = bp_unpack_value (bp, 1);
 951   node->local.externally_visible = bp_unpack_value (bp, 1);
 952   node->local.finalized = bp_unpack_value (bp, 1);
 953   node->local.inlinable = bp_unpack_value (bp, 1);
 954   node->local.versionable = bp_unpack_value (bp, 1);
 955   node->local.can_change_signature = bp_unpack_value (bp, 1);
 956   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
 957   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
 958   node->local.vtable_method = bp_unpack_value (bp, 1);
 959   node->needed = bp_unpack_value (bp, 1);
 960   node->address_taken = bp_unpack_value (bp, 1);
 961   node->abstract_and_needed = bp_unpack_value (bp, 1);
 962   node->reachable_from_other_partition = bp_unpack_value (bp, 1);
 963   node->lowered = bp_unpack_value (bp, 1);
 964   node->analyzed = tag == LTO_cgraph_analyzed_node;
 965   node->in_other_partition = bp_unpack_value (bp, 1);
 966   if (node->in_other_partition
 967       /* Avoid updating decl when we are seeing just inline clone.
 968          When inlining function that has functions already inlined into it,
 969          we produce clones of inline clones.
 970
 971          WPA partitioning might put each clone into different unit and
 972          we might end up streaming inline clone from other partition
 973          to support clone we are interested in. */
 974       && (!node->clone_of
 975           || node->clone_of->decl != node->decl))
 976     {
 977       DECL_EXTERNAL (node->decl) = 1;
 978       DECL_ABSTRACT_ORIGIN (node->decl) = NULL_TREE;
 979       TREE_STATIC (node->decl) = 0;
 980     }
 981   node->alias = bp_unpack_value (bp, 1);
 982   node->finalized_by_frontend = bp_unpack_value (bp, 1);
 983   node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
 984   node->only_called_at_startup = bp_unpack_value (bp, 1);
 985   node->only_called_at_exit = bp_unpack_value (bp, 1);
 986   node->resolution = resolution;
 987 }
 988
 989 /* Output the part of the cgraph in SET.  */
 990
 991 static void
 992 output_varpool (cgraph_node_set set, varpool_node_set vset)
 993 {
 994   struct lto_simple_output_block *ob = lto_create_simple_output_block (LTO_section_varpool);
 995   lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
 996   int len = lto_varpool_encoder_size (varpool_encoder), i;
 997
 998   lto_output_uleb128_stream (ob->main_stream, len);
 999
1000   /* Write out the nodes.  We must first output a node and then its clones,
1001      otherwise at a time reading back the node there would be nothing to clone
1002      from.  */
1003   for (i = 0; i < len; i++)
1004     {
1005       lto_output_varpool_node (ob, lto_varpool_encoder_deref (varpool_encoder, i),
1006                                varpool_encoder,
1007                                set, vset);
1008     }
1009
1010   lto_destroy_simple_output_block (ob);
1011 }
1012
1013 /* Read a node from input_block IB.  TAG is the node's tag just read.
1014    Return the node read or overwriten.  */
1015
1016 static struct cgraph_node *
1017 input_node (struct lto_file_decl_data *file_data,
1018             struct lto_input_block *ib,
1019             enum LTO_cgraph_tags tag,
1020             VEC(cgraph_node_ptr, heap) *nodes)
1021 {
1022   tree fn_decl;
1023   struct cgraph_node *node;
1024   struct bitpack_d bp;
1025   int stack_size = 0;
1026   unsigned decl_index;
1027   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
1028   int self_time = 0;
1029   int self_size = 0;
1030   int time_inlining_benefit = 0;
1031   int size_inlining_benefit = 0;
1032   unsigned long same_body_count = 0;
1033   int clone_ref;
1034   enum ld_plugin_symbol_resolution resolution;
1035
1036   clone_ref = lto_input_sleb128 (ib);
1037
1038   decl_index = lto_input_uleb128 (ib);
1039   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
1040
1041   if (clone_ref != LCC_NOT_FOUND)
1042     {
1043       node = cgraph_clone_node (VEC_index (cgraph_node_ptr, nodes, clone_ref), fn_decl,
1044                                 0, CGRAPH_FREQ_BASE, 0, false, NULL);
1045     }
1046   else
1047     node = cgraph_node (fn_decl);
1048
1049   node->count = lto_input_sleb128 (ib);
1050   node->count_materialization_scale = lto_input_sleb128 (ib);
1051
1052   if (tag == LTO_cgraph_analyzed_node)
1053     {
1054       stack_size = lto_input_sleb128 (ib);
1055       self_size = lto_input_sleb128 (ib);
1056       size_inlining_benefit = lto_input_sleb128 (ib);
1057       self_time = lto_input_sleb128 (ib);
1058       time_inlining_benefit = lto_input_sleb128 (ib);
1059
1060       ref = lto_input_sleb128 (ib);
1061     }
1062
1063   ref2 = lto_input_sleb128 (ib);
1064
1065   /* Make sure that we have not read this node before.  Nodes that
1066      have already been read will have their tag stored in the 'aux'
1067      field.  Since built-in functions can be referenced in multiple
1068      functions, they are expected to be read more than once.  */
1069   if (node->aux && !DECL_IS_BUILTIN (node->decl))
1070     internal_error ("bytecode stream: found multiple instances of cgraph "
1071                     "node %d", node->uid);
1072
1073   bp = lto_input_bitpack (ib);
1074   resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
1075   input_overwrite_node (file_data, node, tag, &bp, stack_size, self_time,
1076                         time_inlining_benefit, self_size,
1077                         size_inlining_benefit, resolution);
1078
1079   /* Store a reference for now, and fix up later to be a pointer.  */
1080   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
1081
1082   /* Store a reference for now, and fix up later to be a pointer.  */
1083   node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
1084
1085   same_body_count = lto_input_uleb128 (ib);
1086   while (same_body_count-- > 0)
1087     {
1088       tree alias_decl;
1089       int type;
1090       struct cgraph_node *alias;
1091       decl_index = lto_input_uleb128 (ib);
1092       alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
1093       type = lto_input_uleb128 (ib);
1094       if (!type)
1095         {
1096           tree real_alias;
1097           decl_index = lto_input_uleb128 (ib);
1098           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
1099           alias = cgraph_same_body_alias (node, alias_decl, real_alias);
1100         }
1101       else
1102         {
1103           HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
1104           HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
1105           tree real_alias;
1106           decl_index = lto_input_uleb128 (ib);
1107           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
1108           alias = cgraph_add_thunk (node, alias_decl, fn_decl, type & 2, fixed_offset,
1109                                     virtual_value,
1110                                     (type & 4) ? size_int (virtual_value) : NULL_TREE,
1111                                     real_alias);
1112         }
1113       gcc_assert (alias);
1114       alias->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
1115     }
1116   return node;
1117 }
1118
1119 /* Read a node from input_block IB.  TAG is the node's tag just read.
1120    Return the node read or overwriten.  */
1121
1122 static struct varpool_node *
1123 input_varpool_node (struct lto_file_decl_data *file_data,
1124                     struct lto_input_block *ib)
1125 {
1126   int decl_index;
1127   tree var_decl;
1128   struct varpool_node *node;
1129   struct bitpack_d bp;
1130   bool aliases_p;
1131   int count;
1132   int ref = LCC_NOT_FOUND;
1133
1134   decl_index = lto_input_uleb128 (ib);
1135   var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
1136   node = varpool_node (var_decl);
1137   node->lto_file_data = file_data;
1138
1139   bp = lto_input_bitpack (ib);
1140   node->externally_visible = bp_unpack_value (&bp, 1);
1141   node->force_output = bp_unpack_value (&bp, 1);
1142   node->finalized = bp_unpack_value (&bp, 1);
1143   node->alias = bp_unpack_value (&bp, 1);
1144   node->analyzed = node->finalized;
1145   node->used_from_other_partition = bp_unpack_value (&bp, 1);
1146   node->in_other_partition = bp_unpack_value (&bp, 1);
1147   if (node->in_other_partition)
1148     {
1149       DECL_EXTERNAL (node->decl) = 1;
1150       DECL_ABSTRACT_ORIGIN (node->decl) = NULL_TREE;
1151       TREE_STATIC (node->decl) = 0;
1152     }
1153   aliases_p = bp_unpack_value (&bp, 1);
1154   if (node->finalized)
1155     varpool_mark_needed_node (node);
1156   ref = lto_input_sleb128 (ib);
1157   /* Store a reference for now, and fix up later to be a pointer.  */
1158   node->same_comdat_group = (struct varpool_node *) (intptr_t) ref;
1159   node->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
1160   if (aliases_p)
1161     {
1162       count = lto_input_uleb128 (ib);
1163       for (; count > 0; count --)
1164         {
1165           tree decl = lto_file_decl_data_get_var_decl (file_data,
1166                                                        lto_input_uleb128 (ib));
1167           struct varpool_node *alias;
1168           alias = varpool_extra_name_alias (decl, var_decl);
1169           alias->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
1170         }
1171     }
1172   return node;
1173 }
1174
1175 /* Read a node from input_block IB.  TAG is the node's tag just read.
1176    Return the node read or overwriten.  */
1177
1178 static void
1179 input_ref (struct lto_input_block *ib,
1180            struct cgraph_node *refering_node,
1181            struct varpool_node *refering_varpool_node,
1182            VEC(cgraph_node_ptr, heap) *nodes,
1183            VEC(varpool_node_ptr, heap) *varpool_nodes)
1184 {
1185   struct cgraph_node *node = NULL;
1186   struct varpool_node *varpool_node = NULL;
1187   struct bitpack_d bp;
1188   enum ipa_ref_type type;
1189   enum ipa_ref_use use;
1190
1191   bp = lto_input_bitpack (ib);
1192   type = (enum ipa_ref_type) bp_unpack_value (&bp, 1);
1193   use = (enum ipa_ref_use) bp_unpack_value (&bp, 2);
1194   if (type == IPA_REF_CGRAPH)
1195     node = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
1196   else
1197     varpool_node = VEC_index (varpool_node_ptr, varpool_nodes, lto_input_sleb128 (ib));
1198   ipa_record_reference (refering_node, refering_varpool_node,
1199                         node, varpool_node, use, NULL);
1200 }
1201
1202 /* Read an edge from IB.  NODES points to a vector of previously read nodes for
1203    decoding caller and callee of the edge to be read.  If INDIRECT is true, the
1204    edge being read is indirect (in the sense that it has
1205    indirect_unknown_callee set).  */
1206
1207 static void
1208 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
1209             bool indirect)
1210 {
1211   struct cgraph_node *caller, *callee;
1212   struct cgraph_edge *edge;
1213   unsigned int stmt_id;
1214   gcov_type count;
1215   int freq;
1216   unsigned int nest;
1217   cgraph_inline_failed_t inline_failed;
1218   struct bitpack_d bp;
1219   int ecf_flags = 0;
1220
1221   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
1222   if (caller == NULL || caller->decl == NULL_TREE)
1223     internal_error ("bytecode stream: no caller found while reading edge");
1224
1225   if (!indirect)
1226     {
1227       callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
1228       if (callee == NULL || callee->decl == NULL_TREE)
1229         internal_error ("bytecode stream: no callee found while reading edge");
1230     }
1231   else
1232     callee = NULL;
1233
1234   count = (gcov_type) lto_input_sleb128 (ib);
1235
1236   bp = lto_input_bitpack (ib);
1237   stmt_id = (unsigned int) bp_unpack_value (&bp, HOST_BITS_PER_INT);
1238   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (&bp,
1239                                                             HOST_BITS_PER_INT);
1240   freq = (int) bp_unpack_value (&bp, HOST_BITS_PER_INT);
1241   nest = (unsigned) bp_unpack_value (&bp, 30);
1242
1243   if (indirect)
1244     edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq, nest);
1245   else
1246     edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
1247
1248   edge->indirect_inlining_edge = bp_unpack_value (&bp, 1);
1249   edge->lto_stmt_uid = stmt_id;
1250   edge->inline_failed = inline_failed;
1251   edge->call_stmt_cannot_inline_p = bp_unpack_value (&bp, 1);
1252   edge->can_throw_external = bp_unpack_value (&bp, 1);
1253   if (indirect)
1254     {
1255       if (bp_unpack_value (&bp, 1))
1256         ecf_flags |= ECF_CONST;
1257       if (bp_unpack_value (&bp, 1))
1258         ecf_flags |= ECF_PURE;
1259       if (bp_unpack_value (&bp, 1))
1260         ecf_flags |= ECF_NORETURN;
1261       if (bp_unpack_value (&bp, 1))
1262         ecf_flags |= ECF_MALLOC;
1263       if (bp_unpack_value (&bp, 1))
1264         ecf_flags |= ECF_NOTHROW;
1265       if (bp_unpack_value (&bp, 1))
1266         ecf_flags |= ECF_RETURNS_TWICE;
1267       edge->indirect_info->ecf_flags = ecf_flags;
1268     }
1269 }
1270
1271
1272 /* Read a cgraph from IB using the info in FILE_DATA.  */
1273
1274 static VEC(cgraph_node_ptr, heap) *
1275 input_cgraph_1 (struct lto_file_decl_data *file_data,
1276                 struct lto_input_block *ib)
1277 {
1278   enum LTO_cgraph_tags tag;
1279   VEC(cgraph_node_ptr, heap) *nodes = NULL;
1280   struct cgraph_node *node;
1281   unsigned i;
1282   unsigned HOST_WIDE_INT len;
1283
1284   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
1285   while (tag)
1286     {
1287       if (tag == LTO_cgraph_edge)
1288         input_edge (ib, nodes, false);
1289       else if (tag == LTO_cgraph_indirect_edge)
1290         input_edge (ib, nodes, true);
1291       else
1292         {
1293           node = input_node (file_data, ib, tag,nodes);
1294           if (node == NULL || node->decl == NULL_TREE)
1295             internal_error ("bytecode stream: found empty cgraph node");
1296           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
1297           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
1298         }
1299
1300       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
1301     }
1302
1303   /* Input toplevel asms.  */
1304   len = lto_input_uleb128 (ib);
1305   while (len)
1306     {
1307       char *str = (char *)xmalloc (len + 1);
1308       for (i = 0; i < len; ++i)
1309         str[i] = lto_input_1_unsigned (ib);
1310       cgraph_add_asm_node (build_string (len, str));
1311       free (str);
1312
1313       len = lto_input_uleb128 (ib);
1314     }
1315   /* AUX pointers should be all non-zero for nodes read from the stream.  */
1316 #ifdef ENABLE_CHECKING
1317   FOR_EACH_VEC_ELT (cgraph_node_ptr, nodes, i, node)
1318     gcc_assert (node->aux);
1319 #endif
1320   FOR_EACH_VEC_ELT (cgraph_node_ptr, nodes, i, node)
1321     {
1322       int ref = (int) (intptr_t) node->global.inlined_to;
1323
1324       /* We share declaration of builtins, so we may read same node twice.  */
1325       if (!node->aux)
1326         continue;
1327       node->aux = NULL;
1328
1329       /* Fixup inlined_to from reference to pointer.  */
1330       if (ref != LCC_NOT_FOUND)
1331         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
1332       else
1333         node->global.inlined_to = NULL;
1334
1335       ref = (int) (intptr_t) node->same_comdat_group;
1336
1337       /* Fixup same_comdat_group from reference to pointer.  */
1338       if (ref != LCC_NOT_FOUND)
1339         node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
1340       else
1341         node->same_comdat_group = NULL;
1342     }
1343   FOR_EACH_VEC_ELT (cgraph_node_ptr, nodes, i, node)
1344     node->aux = (void *)1;
1345   return nodes;
1346 }
1347
1348 /* Read a varpool from IB using the info in FILE_DATA.  */
1349
1350 static VEC(varpool_node_ptr, heap) *
1351 input_varpool_1 (struct lto_file_decl_data *file_data,
1352                 struct lto_input_block *ib)
1353 {
1354   unsigned HOST_WIDE_INT len;
1355   VEC(varpool_node_ptr, heap) *varpool = NULL;
1356   int i;
1357   struct varpool_node *node;
1358
1359   len = lto_input_uleb128 (ib);
1360   while (len)
1361     {
1362       VEC_safe_push (varpool_node_ptr, heap, varpool,
1363                      input_varpool_node (file_data, ib));
1364       len--;
1365     }
1366 #ifdef ENABLE_CHECKING
1367   FOR_EACH_VEC_ELT (varpool_node_ptr, varpool, i, node)
1368     gcc_assert (!node->aux);
1369 #endif
1370   FOR_EACH_VEC_ELT (varpool_node_ptr, varpool, i, node)
1371     {
1372       int ref = (int) (intptr_t) node->same_comdat_group;
1373       /* We share declaration of builtins, so we may read same node twice.  */
1374       if (node->aux)
1375         continue;
1376       node->aux = (void *)1;
1377
1378       /* Fixup same_comdat_group from reference to pointer.  */
1379       if (ref != LCC_NOT_FOUND)
1380         node->same_comdat_group = VEC_index (varpool_node_ptr, varpool, ref);
1381       else
1382         node->same_comdat_group = NULL;
1383     }
1384   FOR_EACH_VEC_ELT (varpool_node_ptr, varpool, i, node)
1385     node->aux = NULL;
1386   return varpool;
1387 }
1388
1389 /* Input ipa_refs.  */
1390
1391 static void
1392 input_refs (struct lto_input_block *ib,
1393             VEC(cgraph_node_ptr, heap) *nodes,
1394             VEC(varpool_node_ptr, heap) *varpool)
1395 {
1396   int count;
1397   int idx;
1398   while (true)
1399     {
1400       struct cgraph_node *node;
1401       count = lto_input_uleb128 (ib);
1402       if (!count)
1403         break;
1404       idx = lto_input_uleb128 (ib);
1405       node = VEC_index (cgraph_node_ptr, nodes, idx);
1406       while (count)
1407         {
1408           input_ref (ib, node, NULL, nodes, varpool);
1409           count--;
1410         }
1411     }
1412   while (true)
1413     {
1414       struct varpool_node *node;
1415       count = lto_input_uleb128 (ib);
1416       if (!count)
1417         break;
1418       node = VEC_index (varpool_node_ptr, varpool, lto_input_uleb128 (ib));
1419       while (count)
1420         {
1421           input_ref (ib, NULL, node, nodes, varpool);
1422           count--;
1423         }
1424     }
1425 }
1426
1427
1428 static struct gcov_ctr_summary lto_gcov_summary;
1429
1430 /* Input profile_info from IB.  */
1431 static void
1432 input_profile_summary (struct lto_input_block *ib,
1433                        struct lto_file_decl_data *file_data)
1434 {
1435   unsigned int runs = lto_input_uleb128 (ib);
1436   if (runs)
1437     {
1438       file_data->profile_info.runs = runs;
1439       file_data->profile_info.sum_max = lto_input_uleb128 (ib);
1440     }
1441
1442 }
1443
1444 /* Rescale profile summaries to the same number of runs in the whole unit.  */
1445
1446 static void
1447 merge_profile_summaries (struct lto_file_decl_data **file_data_vec)
1448 {
1449   struct lto_file_decl_data *file_data;
1450   unsigned int j;
1451   gcov_unsigned_t max_runs = 0;
1452   struct cgraph_node *node;
1453   struct cgraph_edge *edge;
1454
1455   /* Find unit with maximal number of runs.  If we ever get serious about
1456      roundoff errors, we might also consider computing smallest common
1457      multiply.  */
1458   for (j = 0; (file_data = file_data_vec[j]) != NULL; j++)
1459     if (max_runs < file_data->profile_info.runs)
1460       max_runs = file_data->profile_info.runs;
1461
1462   if (!max_runs)
1463     return;
1464
1465   /* Simple overflow check.  We probably don't need to support that many train
1466      runs. Such a large value probably imply data corruption anyway.  */
1467   if (max_runs > INT_MAX / REG_BR_PROB_BASE)
1468     {
1469       sorry ("At most %i profile runs is supported. Perhaps corrupted profile?",
1470              INT_MAX / REG_BR_PROB_BASE);
1471       return;
1472     }
1473
1474   profile_info = &lto_gcov_summary;
1475   lto_gcov_summary.runs = max_runs;
1476   lto_gcov_summary.sum_max = 0;
1477
1478   /* Rescale all units to the maximal number of runs.
1479      sum_max can not be easily merged, as we have no idea what files come from
1480      the same run.  We do not use the info anyway, so leave it 0.  */
1481   for (j = 0; (file_data = file_data_vec[j]) != NULL; j++)
1482     if (file_data->profile_info.runs)
1483       {
1484         int scale = ((REG_BR_PROB_BASE * max_runs
1485                       + file_data->profile_info.runs / 2)
1486                      / file_data->profile_info.runs);
1487         lto_gcov_summary.sum_max = MAX (lto_gcov_summary.sum_max,
1488                                         (file_data->profile_info.sum_max
1489                                          * scale
1490                                          + REG_BR_PROB_BASE / 2)
1491                                         / REG_BR_PROB_BASE);
1492       }
1493
1494   /* Watch roundoff errors.  */
1495   if (lto_gcov_summary.sum_max < max_runs)
1496     lto_gcov_summary.sum_max = max_runs;
1497
1498   /* If merging already happent at WPA time, we are done.  */
1499   if (flag_ltrans)
1500     return;
1501
1502   /* Now compute count_materialization_scale of each node.
1503      During LTRANS we already have values of count_materialization_scale
1504      computed, so just update them.  */
1505   for (node = cgraph_nodes; node; node = node->next)
1506     if (node->local.lto_file_data->profile_info.runs)
1507       {
1508         int scale;
1509
1510         scale =
1511            ((node->count_materialization_scale * max_runs
1512              + node->local.lto_file_data->profile_info.runs / 2)
1513             / node->local.lto_file_data->profile_info.runs);
1514         node->count_materialization_scale = scale;
1515         if (scale < 0)
1516           fatal_error ("Profile information in %s corrupted",
1517                        file_data->file_name);
1518
1519         if (scale == REG_BR_PROB_BASE)
1520           continue;
1521         for (edge = node->callees; edge; edge = edge->next_callee)
1522           edge->count = ((edge->count * scale + REG_BR_PROB_BASE / 2)
1523                          / REG_BR_PROB_BASE);
1524         node->count = ((node->count * scale + REG_BR_PROB_BASE / 2)
1525                        / REG_BR_PROB_BASE);
1526       }
1527 }
1528
1529 /* Input and merge the cgraph from each of the .o files passed to
1530    lto1.  */
1531
1532 void
1533 input_cgraph (void)
1534 {
1535   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
1536   struct lto_file_decl_data *file_data;
1537   unsigned int j = 0;
1538   struct cgraph_node *node;
1539
1540   while ((file_data = file_data_vec[j++]))
1541     {
1542       const char *data;
1543       size_t len;
1544       struct lto_input_block *ib;
1545       VEC(cgraph_node_ptr, heap) *nodes;
1546       VEC(varpool_node_ptr, heap) *varpool;
1547
1548       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
1549                                           &data, &len);
1550       if (!ib)
1551         fatal_error ("cannot find LTO cgraph in %s", file_data->file_name);
1552       input_profile_summary (ib, file_data);
1553       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
1554       nodes = input_cgraph_1 (file_data, ib);
1555       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
1556                                       ib, data, len);
1557
1558       ib = lto_create_simple_input_block (file_data, LTO_section_varpool,
1559                                           &data, &len);
1560       if (!ib)
1561         fatal_error ("cannot find LTO varpool in %s", file_data->file_name);
1562       varpool = input_varpool_1 (file_data, ib);
1563       lto_destroy_simple_input_block (file_data, LTO_section_varpool,
1564                                       ib, data, len);
1565
1566       ib = lto_create_simple_input_block (file_data, LTO_section_refs,
1567                                           &data, &len);
1568       if (!ib)
1569         fatal_error("cannot find LTO section refs in %s", file_data->file_name);
1570       input_refs (ib, nodes, varpool);
1571       lto_destroy_simple_input_block (file_data, LTO_section_refs,
1572                                       ib, data, len);
1573       if (flag_ltrans)
1574         input_cgraph_opt_summary (nodes);
1575       VEC_free (cgraph_node_ptr, heap, nodes);
1576       VEC_free (varpool_node_ptr, heap, varpool);
1577     }
1578   merge_profile_summaries (file_data_vec);
1579
1580
1581   /* Clear out the aux field that was used to store enough state to
1582      tell which nodes should be overwritten.  */
1583   for (node = cgraph_nodes; node; node = node->next)
1584     {
1585       /* Some nodes may have been created by cgraph_node.  This
1586          happens when the callgraph contains nested functions.  If the
1587          node for the parent function was never emitted to the gimple
1588          file, cgraph_node will create a node for it when setting the
1589          context of the nested function.  */
1590       if (node->local.lto_file_data)
1591         node->aux = NULL;
1592     }
1593 }
1594
1595 /* True when we need optimization summary for NODE.  */
1596
1597 static int
1598 output_cgraph_opt_summary_p (struct cgraph_node *node, cgraph_node_set set)
1599 {
1600   struct cgraph_edge *e;
1601
1602   if (cgraph_node_in_set_p (node, set))
1603     {
1604       for (e = node->callees; e; e = e->next_callee)
1605         if (e->indirect_info
1606             && e->indirect_info->thunk_delta != 0)
1607           return true;
1608
1609       for (e = node->indirect_calls; e; e = e->next_callee)
1610         if (e->indirect_info->thunk_delta != 0)
1611           return true;
1612     }
1613
1614   return (node->clone_of
1615           && (node->clone.tree_map
1616               || node->clone.args_to_skip
1617               || node->clone.combined_args_to_skip));
1618 }
1619
1620 /* Output optimization summary for EDGE to OB.  */
1621 static void
1622 output_edge_opt_summary (struct output_block *ob,
1623                          struct cgraph_edge *edge)
1624 {
1625   if (edge->indirect_info)
1626     lto_output_sleb128_stream (ob->main_stream,
1627                                edge->indirect_info->thunk_delta);
1628   else
1629     lto_output_sleb128_stream (ob->main_stream, 0);
1630 }
1631
1632 /* Output optimization summary for NODE to OB.  */
1633
1634 static void
1635 output_node_opt_summary (struct output_block *ob,
1636                          struct cgraph_node *node,
1637                          cgraph_node_set set)
1638 {
1639   unsigned int index;
1640   bitmap_iterator bi;
1641   struct ipa_replace_map *map;
1642   struct bitpack_d bp;
1643   int i;
1644   struct cgraph_edge *e;
1645
1646   lto_output_uleb128_stream (ob->main_stream,
1647                              bitmap_count_bits (node->clone.args_to_skip));
1648   EXECUTE_IF_SET_IN_BITMAP (node->clone.args_to_skip, 0, index, bi)
1649     lto_output_uleb128_stream (ob->main_stream, index);
1650   lto_output_uleb128_stream (ob->main_stream,
1651                              bitmap_count_bits (node->clone.combined_args_to_skip));
1652   EXECUTE_IF_SET_IN_BITMAP (node->clone.combined_args_to_skip, 0, index, bi)
1653     lto_output_uleb128_stream (ob->main_stream, index);
1654   lto_output_uleb128_stream (ob->main_stream,
1655                              VEC_length (ipa_replace_map_p, node->clone.tree_map));
1656   FOR_EACH_VEC_ELT (ipa_replace_map_p, node->clone.tree_map, i, map)
1657     {
1658       int parm_num;
1659       tree parm;
1660
1661       for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm;
1662            parm = DECL_CHAIN (parm), parm_num++)
1663         if (map->old_tree == parm)
1664           break;
1665       /* At the moment we assume all old trees to be PARM_DECLs, because we have no
1666          mechanism to store function local declarations into summaries.  */
1667       gcc_assert (parm);
1668       lto_output_uleb128_stream (ob->main_stream, parm_num);
1669       lto_output_tree (ob, map->new_tree, true);
1670       bp = bitpack_create (ob->main_stream);
1671       bp_pack_value (&bp, map->replace_p, 1);
1672       bp_pack_value (&bp, map->ref_p, 1);
1673       lto_output_bitpack (&bp);
1674     }
1675
1676   if (cgraph_node_in_set_p (node, set))
1677     {
1678       for (e = node->callees; e; e = e->next_callee)
1679         output_edge_opt_summary (ob, e);
1680       for (e = node->indirect_calls; e; e = e->next_callee)
1681         output_edge_opt_summary (ob, e);
1682     }
1683 }
1684
1685 /* Output optimization summaries stored in callgraph.
1686    At the moment it is the clone info structure.  */
1687
1688 static void
1689 output_cgraph_opt_summary (cgraph_node_set set)
1690 {
1691   struct cgraph_node *node;
1692   int i, n_nodes;
1693   lto_cgraph_encoder_t encoder;
1694   struct output_block *ob = create_output_block (LTO_section_cgraph_opt_sum);
1695   unsigned count = 0;
1696
1697   ob->cgraph_node = NULL;
1698   encoder = ob->decl_state->cgraph_node_encoder;
1699   n_nodes = lto_cgraph_encoder_size (encoder);
1700   for (i = 0; i < n_nodes; i++)
1701     if (output_cgraph_opt_summary_p (lto_cgraph_encoder_deref (encoder, i),
1702                                      set))
1703       count++;
1704   lto_output_uleb128_stream (ob->main_stream, count);
1705   for (i = 0; i < n_nodes; i++)
1706     {
1707       node = lto_cgraph_encoder_deref (encoder, i);
1708       if (output_cgraph_opt_summary_p (node, set))
1709         {
1710           lto_output_uleb128_stream (ob->main_stream, i);
1711           output_node_opt_summary (ob, node, set);
1712         }
1713     }
1714   produce_asm (ob, NULL);
1715   destroy_output_block (ob);
1716 }
1717
1718 /* Input optimisation summary of EDGE.  */
1719
1720 static void
1721 input_edge_opt_summary (struct cgraph_edge *edge,
1722                         struct lto_input_block *ib_main)
1723 {
1724   HOST_WIDE_INT thunk_delta;
1725   thunk_delta = lto_input_sleb128 (ib_main);
1726   if (thunk_delta != 0)
1727     {
1728       gcc_assert (!edge->indirect_info);
1729       edge->indirect_info = cgraph_allocate_init_indirect_info ();
1730       edge->indirect_info->thunk_delta = thunk_delta;
1731     }
1732 }
1733
1734 /* Input optimisation summary of NODE.  */
1735
1736 static void
1737 input_node_opt_summary (struct cgraph_node *node,
1738                         struct lto_input_block *ib_main,
1739                         struct data_in *data_in)
1740 {
1741   int i;
1742   int count;
1743   int bit;
1744   struct bitpack_d bp;
1745   struct cgraph_edge *e;
1746
1747   count = lto_input_uleb128 (ib_main);
1748   if (count)
1749     node->clone.args_to_skip = BITMAP_GGC_ALLOC ();
1750   for (i = 0; i < count; i++)
1751     {
1752       bit = lto_input_uleb128 (ib_main);
1753       bitmap_set_bit (node->clone.args_to_skip, bit);
1754     }
1755   count = lto_input_uleb128 (ib_main);
1756   if (count)
1757     node->clone.combined_args_to_skip = BITMAP_GGC_ALLOC ();
1758   for (i = 0; i < count; i++)
1759     {
1760       bit = lto_input_uleb128 (ib_main);
1761       bitmap_set_bit (node->clone.combined_args_to_skip, bit);
1762     }
1763   count = lto_input_uleb128 (ib_main);
1764   for (i = 0; i < count; i++)
1765     {
1766       int parm_num;
1767       tree parm;
1768       struct ipa_replace_map *map = ggc_alloc_ipa_replace_map ();
1769
1770       VEC_safe_push (ipa_replace_map_p, gc, node->clone.tree_map, map);
1771       for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm_num;
1772            parm = DECL_CHAIN (parm))
1773         parm_num --;
1774       map->parm_num = lto_input_uleb128 (ib_main);
1775       map->old_tree = NULL;
1776       map->new_tree = lto_input_tree (ib_main, data_in);
1777       bp = lto_input_bitpack (ib_main);
1778       map->replace_p = bp_unpack_value (&bp, 1);
1779       map->ref_p = bp_unpack_value (&bp, 1);
1780     }
1781   for (e = node->callees; e; e = e->next_callee)
1782     input_edge_opt_summary (e, ib_main);
1783   for (e = node->indirect_calls; e; e = e->next_callee)
1784     input_edge_opt_summary (e, ib_main);
1785 }
1786
1787 /* Read section in file FILE_DATA of length LEN with data DATA.  */
1788
1789 static void
1790 input_cgraph_opt_section (struct lto_file_decl_data *file_data,
1791                           const char *data, size_t len, VEC (cgraph_node_ptr,
1792                                                              heap) * nodes)
1793 {
1794   const struct lto_function_header *header =
1795     (const struct lto_function_header *) data;
1796   const int32_t cfg_offset = sizeof (struct lto_function_header);
1797   const int32_t main_offset = cfg_offset + header->cfg_size;
1798   const int32_t string_offset = main_offset + header->main_size;
1799   struct data_in *data_in;
1800   struct lto_input_block ib_main;
1801   unsigned int i;
1802   unsigned int count;
1803
1804   LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
1805                         header->main_size);
1806
1807   data_in =
1808     lto_data_in_create (file_data, (const char *) data + string_offset,
1809                         header->string_size, NULL);
1810   count = lto_input_uleb128 (&ib_main);
1811
1812   for (i = 0; i < count; i++)
1813     {
1814       int ref = lto_input_uleb128 (&ib_main);
1815       input_node_opt_summary (VEC_index (cgraph_node_ptr, nodes, ref),
1816                               &ib_main, data_in);
1817     }
1818   lto_free_section_data (file_data, LTO_section_cgraph_opt_sum, NULL, data,
1819                          len);
1820   lto_data_in_delete (data_in);
1821 }
1822
1823 /* Input optimization summary of cgraph.  */
1824
1825 static void
1826 input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes)
1827 {
1828   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
1829   struct lto_file_decl_data *file_data;
1830   unsigned int j = 0;
1831
1832   while ((file_data = file_data_vec[j++]))
1833     {
1834       size_t len;
1835       const char *data =
1836         lto_get_section_data (file_data, LTO_section_cgraph_opt_sum, NULL,
1837                               &len);
1838
1839       if (data)
1840         input_cgraph_opt_section (file_data, data, len, nodes);
1841     }
1842 }