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