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