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