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