OSDN Git Service

* lto-cgraph.c (lto_output_varpool_node): Always output constant pool
[pf3gnuchains/gcc-fork.git] / gcc / lto-cgraph.c
1 /* Write and read the cgraph to the memory mapped representation of a
2    .o file.
3
4    Copyright 2009 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 "toplev.h"
28 #include "tree.h"
29 #include "expr.h"
30 #include "flags.h"
31 #include "params.h"
32 #include "input.h"
33 #include "hashtab.h"
34 #include "langhooks.h"
35 #include "basic-block.h"
36 #include "tree-flow.h"
37 #include "cgraph.h"
38 #include "function.h"
39 #include "ggc.h"
40 #include "diagnostic.h"
41 #include "except.h"
42 #include "vec.h"
43 #include "timevar.h"
44 #include "output.h"
45 #include "pointer-set.h"
46 #include "lto-streamer.h"
47 #include "gcov-io.h"
48
49 /* Cgraph streaming is organized as set of record whose type
50    is indicated by a tag.  */
51 enum LTO_cgraph_tags
52 {
53   /* Must leave 0 for the stopper.  */
54
55   /* Cgraph node without body available.  */
56   LTO_cgraph_unavail_node = 1,
57   /* Cgraph node with function body.  */
58   LTO_cgraph_analyzed_node,
59   /* Cgraph edges.  */
60   LTO_cgraph_edge,
61   LTO_cgraph_indirect_edge
62 };
63
64 /* Create a new cgraph encoder.  */
65
66 lto_cgraph_encoder_t
67 lto_cgraph_encoder_new (void)
68 {
69   lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
70   encoder->map = pointer_map_create ();
71   encoder->nodes = NULL;
72   return encoder;
73 }
74
75
76 /* Delete ENCODER and its components.  */
77
78 void
79 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
80 {
81    VEC_free (cgraph_node_ptr, heap, encoder->nodes);
82    pointer_map_destroy (encoder->map);
83    free (encoder);
84 }
85
86
87 /* Return the existing reference number of NODE in the cgraph encoder in
88    output block OB.  Assign a new reference if this is the first time
89    NODE is encoded.  */
90
91 int
92 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
93                            struct cgraph_node *node)
94 {
95   int ref;
96   void **slot;
97
98   slot = pointer_map_contains (encoder->map, node);
99   if (!slot)
100     {
101       ref = VEC_length (cgraph_node_ptr, encoder->nodes);
102       slot = pointer_map_insert (encoder->map, node);
103       *slot = (void *) (intptr_t) ref;
104       VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
105     }
106   else
107     ref = (int) (intptr_t) *slot;
108
109   return ref;
110 }
111
112 #define LCC_NOT_FOUND   (-1)
113
114 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
115    or LCC_NOT_FOUND if it is not there.  */
116
117 int
118 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
119                            struct cgraph_node *node)
120 {
121   void **slot = pointer_map_contains (encoder->map, node);
122   return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
123 }
124
125
126 /* Return the cgraph node corresponding to REF using ENCODER.  */
127
128 struct cgraph_node *
129 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
130 {
131   if (ref == LCC_NOT_FOUND)
132     return NULL;
133
134   return VEC_index (cgraph_node_ptr, encoder->nodes, ref);
135 }
136
137
138 /* Return number of encoded nodes in ENCODER.  */
139
140 static int
141 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
142 {
143   return VEC_length (cgraph_node_ptr, encoder->nodes);
144 }
145
146
147 /* Output the cgraph EDGE to OB using ENCODER.  */
148
149 static void
150 lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
151                  lto_cgraph_encoder_t encoder)
152 {
153   unsigned int uid;
154   intptr_t ref;
155   struct bitpack_d *bp;
156
157   if (edge->indirect_unknown_callee)
158     lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
159   else
160     lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
161
162   ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
163   gcc_assert (ref != LCC_NOT_FOUND);
164   lto_output_sleb128_stream (ob->main_stream, ref);
165
166   if (!edge->indirect_unknown_callee)
167     {
168       ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
169       gcc_assert (ref != LCC_NOT_FOUND);
170       lto_output_sleb128_stream (ob->main_stream, ref);
171     }
172
173   lto_output_sleb128_stream (ob->main_stream, edge->count);
174
175   bp = bitpack_create ();
176   uid = flag_wpa ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt);
177   bp_pack_value (bp, uid, HOST_BITS_PER_INT);
178   bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
179   bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
180   bp_pack_value (bp, edge->loop_nest, 30);
181   bp_pack_value (bp, edge->indirect_inlining_edge, 1);
182   bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
183   bp_pack_value (bp, edge->can_throw_external, 1);
184   lto_output_bitpack (ob->main_stream, bp);
185   bitpack_delete (bp);
186 }
187
188 /* Return true when node is reachable from other partition.  */
189
190 static bool
191 reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
192 {
193   struct cgraph_edge *e;
194   if (node->needed)
195     return true;
196   if (!node->analyzed)
197     return false;
198   if (node->global.inlined_to)
199     return false;
200   for (e = node->callers; e; e = e->next_caller)
201     if (!cgraph_node_in_set_p (e->caller, set))
202       return true;
203   return false;
204 }
205
206 /* Output the cgraph NODE to OB.  ENCODER is used to find the
207    reference number of NODE->inlined_to.  SET is the set of nodes we
208    are writing to the current file.  If NODE is not in SET, then NODE
209    is a boundary of a cgraph_node_set and we pretend NODE just has a
210    decl and no callees.  WRITTEN_DECLS is the set of FUNCTION_DECLs
211    that have had their callgraph node written so far.  This is used to
212    determine if NODE is a clone of a previously written node.  */
213
214 static void
215 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
216                  lto_cgraph_encoder_t encoder, cgraph_node_set set,
217                  bitmap written_decls)
218 {
219   unsigned int tag;
220   struct bitpack_d *bp;
221   bool boundary_p, wrote_decl_p;
222   intptr_t ref;
223   bool in_other_partition = false;
224
225   boundary_p = !cgraph_node_in_set_p (node, set);
226   wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
227
228   if (node->analyzed && !boundary_p)
229     tag = LTO_cgraph_analyzed_node;
230   else
231     tag = LTO_cgraph_unavail_node;
232
233   lto_output_uleb128_stream (ob->main_stream, tag);
234
235   /* In WPA mode, we only output part of the call-graph.  Also, we
236      fake cgraph node attributes.  There are two cases that we care.
237
238      Boundary nodes: There are nodes that are not part of SET but are
239      called from within SET.  We artificially make them look like
240      externally visible nodes with no function body.
241
242      Cherry-picked nodes:  These are nodes we pulled from other
243      translation units into SET during IPA-inlining.  We make them as
244      local static nodes to prevent clashes with other local statics.  */
245   if (boundary_p && node->analyzed)
246     {
247       /* Inline clones can not be part of boundary.  
248          gcc_assert (!node->global.inlined_to);  
249
250          FIXME: At the moment they can be, when partition contains an inline
251          clone that is clone of inline clone from outside partition.  We can
252          reshape the clone tree and make other tree to be the root, but it
253          needs a bit extra work and will be promplty done by cgraph_remove_node
254          after reading back.  */
255       in_other_partition = 1;
256     }
257
258   lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
259
260   if (!wrote_decl_p)
261     bitmap_set_bit (written_decls, DECL_UID (node->decl));
262
263   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
264   lto_output_sleb128_stream (ob->main_stream, node->count);
265
266   bp = bitpack_create ();
267   bp_pack_value (bp, node->local.local, 1);
268   bp_pack_value (bp, node->local.externally_visible, 1);
269   bp_pack_value (bp, node->local.finalized, 1);
270   bp_pack_value (bp, node->local.inlinable, 1);
271   bp_pack_value (bp, node->local.disregard_inline_limits, 1);
272   bp_pack_value (bp, node->local.redefined_extern_inline, 1);
273   bp_pack_value (bp, node->local.vtable_method, 1);
274   bp_pack_value (bp, node->needed, 1);
275   bp_pack_value (bp, node->address_taken, 1);
276   bp_pack_value (bp, node->abstract_and_needed, 1);
277   bp_pack_value (bp, tag == LTO_cgraph_analyzed_node
278                  && reachable_from_other_partition_p (node, set), 1);
279   bp_pack_value (bp, node->lowered, 1);
280   bp_pack_value (bp, in_other_partition, 1);
281   bp_pack_value (bp, node->alias, 1);
282   bp_pack_value (bp, node->finalized_by_frontend, 1);
283   bp_pack_value (bp, node->frequency, 2);
284   lto_output_bitpack (ob->main_stream, bp);
285   bitpack_delete (bp);
286
287   if (tag == LTO_cgraph_analyzed_node)
288     {
289       lto_output_sleb128_stream (ob->main_stream,
290                                  node->local.inline_summary.estimated_self_stack_size);
291       lto_output_sleb128_stream (ob->main_stream,
292                                  node->local.inline_summary.self_size);
293       lto_output_sleb128_stream (ob->main_stream,
294                                  node->local.inline_summary.size_inlining_benefit);
295       lto_output_sleb128_stream (ob->main_stream,
296                                  node->local.inline_summary.self_time);
297       lto_output_sleb128_stream (ob->main_stream,
298                                  node->local.inline_summary.time_inlining_benefit);
299       if (node->global.inlined_to)
300         {
301           ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
302           gcc_assert (ref != LCC_NOT_FOUND);
303         }
304       else
305         ref = LCC_NOT_FOUND;
306
307       lto_output_sleb128_stream (ob->main_stream, ref);
308     }
309
310   if (node->same_comdat_group && !boundary_p)
311     {
312       ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
313       gcc_assert (ref != LCC_NOT_FOUND);
314     }
315   else
316     ref = LCC_NOT_FOUND;
317   lto_output_sleb128_stream (ob->main_stream, ref);
318
319   if (node->same_body)
320     {
321       struct cgraph_node *alias;
322       unsigned long alias_count = 1;
323       for (alias = node->same_body; alias->next; alias = alias->next)
324         alias_count++;
325       lto_output_uleb128_stream (ob->main_stream, alias_count);
326       do
327         {
328           lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
329                                     alias->decl);
330           if (alias->thunk.thunk_p)
331             {
332               lto_output_uleb128_stream
333                  (ob->main_stream,
334                   1 + (alias->thunk.this_adjusting != 0) * 2
335                   + (alias->thunk.virtual_offset_p != 0) * 4);
336               lto_output_uleb128_stream (ob->main_stream,
337                                          alias->thunk.fixed_offset);
338               lto_output_uleb128_stream (ob->main_stream,
339                                          alias->thunk.virtual_value);
340               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
341                                         alias->thunk.alias);
342             }
343           else
344             {
345               lto_output_uleb128_stream (ob->main_stream, 0);
346               lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
347                                         alias->thunk.alias);
348             }
349           alias = alias->previous;
350         }
351       while (alias);
352     }
353   else
354     lto_output_uleb128_stream (ob->main_stream, 0);
355 }
356
357 /* Output the varpool NODE to OB. 
358    If NODE is not in SET, then NODE is a boundary.  */
359
360 static void
361 lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
362                          varpool_node_set set)
363 {
364   bool boundary_p = !varpool_node_in_set_p (node, set) && node->analyzed;
365   struct bitpack_d *bp;
366   struct varpool_node *alias;
367   int count = 0;
368
369   lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
370   bp = bitpack_create ();
371   bp_pack_value (bp, node->externally_visible, 1);
372   bp_pack_value (bp, node->force_output, 1);
373   bp_pack_value (bp, node->finalized, 1);
374   gcc_assert (node->finalized || !node->analyzed);
375   gcc_assert (node->needed);
376   gcc_assert (!node->alias);
377   /* Constant pool initializers can be de-unified into individual ltrans units.
378      FIXME: Alternatively at -Os we may want to avoid generating for them the local
379      labels and share them across LTRANS partitions.  */
380   if (DECL_IN_CONSTANT_POOL (node->decl))
381     {
382       bp_pack_value (bp, 0, 1);  /* used_from_other_parition.  */
383       bp_pack_value (bp, 0, 1);  /* in_other_partition.  */
384     }
385   else
386     {
387       /* FIXME: We have no idea how we move references around.  For moment assume that
388          everything is used externally.  */
389       bp_pack_value (bp, flag_wpa, 1);  /* used_from_other_parition.  */
390       bp_pack_value (bp, boundary_p, 1);  /* in_other_partition.  */
391     }
392   /* Also emit any extra name aliases.  */
393   for (alias = node->extra_name; alias; alias = alias->next)
394     count++;
395   bp_pack_value (bp, count != 0, 1);
396   lto_output_bitpack (ob->main_stream, bp);
397   bitpack_delete (bp);
398
399   if (count)
400     {
401       lto_output_uleb128_stream (ob->main_stream, count);
402       for (alias = node->extra_name; alias; alias = alias->next)
403         lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
404     }
405 }
406
407 /* Stream out profile_summary to OB.  */
408
409 static void
410 output_profile_summary (struct lto_simple_output_block *ob)
411 {
412   if (profile_info)
413     {
414       /* We do not output num, it is not terribly useful.  */
415       gcc_assert (profile_info->runs);
416       lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
417       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
418       lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
419       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
420     }
421   else
422     lto_output_uleb128_stream (ob->main_stream, 0);
423 }
424
425 /* Add NODE into encoder as well as nodes it is cloned from.
426    Do it in a way so clones appear first.  */
427 static void
428 add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
429 {
430   if (node->clone_of)
431     add_node_to (encoder, node->clone_of);
432   lto_cgraph_encoder_encode (encoder, node);
433 }
434
435 /* Output all callees or indirect outgoing edges.  EDGE must be the first such
436    edge.  */
437
438 static void
439 output_outgoing_cgraph_edges (struct cgraph_edge *edge,
440                               struct lto_simple_output_block *ob,
441                               lto_cgraph_encoder_t encoder)
442 {
443   if (!edge)
444     return;
445
446   /* Output edges in backward direction, so the reconstructed callgraph match
447      and it is easy to associate call sites in the IPA pass summaries.  */
448   while (edge->next_callee)
449     edge = edge->next_callee;
450   for (; edge; edge = edge->prev_callee)
451     lto_output_edge (ob, edge, encoder);
452 }
453
454 /* Output the part of the cgraph in SET.  */
455
456 void
457 output_cgraph (cgraph_node_set set)
458 {
459   struct cgraph_node *node;
460   struct lto_simple_output_block *ob;
461   cgraph_node_set_iterator csi;
462   struct cgraph_edge *edge;
463   int i, n_nodes;
464   bitmap written_decls;
465   lto_cgraph_encoder_t encoder;
466   struct cgraph_asm_node *can;
467
468   ob = lto_create_simple_output_block (LTO_section_cgraph);
469
470   output_profile_summary (ob);
471
472   /* An encoder for cgraph nodes should have been created by
473      ipa_write_summaries_1.  */
474   gcc_assert (ob->decl_state->cgraph_node_encoder);
475   encoder = ob->decl_state->cgraph_node_encoder;
476
477   /* The FUNCTION_DECLs for which we have written a node.  The first
478      node found is written as the "original" node, the remaining nodes
479      are considered its clones.  */
480   written_decls = lto_bitmap_alloc ();
481
482   /* Go over all the nodes in SET and assign references.  */
483   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
484     {
485       node = csi_node (csi);
486       add_node_to (encoder, node);
487     }
488
489   /* Go over all the nodes again to include callees that are not in
490      SET.  */
491   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
492     {
493       node = csi_node (csi);
494       for (edge = node->callees; edge; edge = edge->next_callee)
495         {
496           struct cgraph_node *callee = edge->callee;
497           if (!cgraph_node_in_set_p (callee, set))
498             {
499               /* We should have moved all the inlines.  */
500               gcc_assert (!callee->global.inlined_to);
501               add_node_to (encoder, callee);
502             }
503         }
504     }
505
506   /* Write out the nodes.  We must first output a node and then its clones,
507      otherwise at a time reading back the node there would be nothing to clone
508      from.  */
509   n_nodes = lto_cgraph_encoder_size (encoder);
510   for (i = 0; i < n_nodes; i++)
511     {
512       node = lto_cgraph_encoder_deref (encoder, i);
513       lto_output_node (ob, node, encoder, set, written_decls);
514     }
515
516   lto_bitmap_free (written_decls);
517
518   /* Go over the nodes in SET again to write edges.  */
519   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
520     {
521       node = csi_node (csi);
522       output_outgoing_cgraph_edges (node->callees, ob, encoder);
523       output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
524     }
525
526   lto_output_uleb128_stream (ob->main_stream, 0);
527
528   /* Emit toplevel asms.  */
529   for (can = cgraph_asm_nodes; can; can = can->next)
530     {
531       int len = TREE_STRING_LENGTH (can->asm_str);
532       lto_output_uleb128_stream (ob->main_stream, len);
533       for (i = 0; i < len; ++i)
534         lto_output_1_stream (ob->main_stream,
535                              TREE_STRING_POINTER (can->asm_str)[i]);
536     }
537
538   lto_output_uleb128_stream (ob->main_stream, 0);
539
540   lto_destroy_simple_output_block (ob);
541 }
542
543 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
544    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
545    NODE or to replace the values in it, for instance because the first
546    time we saw it, the function body was not available but now it
547    is.  BP is a bitpack with all the bitflags for NODE read from the
548    stream.  */
549
550 static void
551 input_overwrite_node (struct lto_file_decl_data *file_data,
552                       struct cgraph_node *node,
553                       enum LTO_cgraph_tags tag,
554                       struct bitpack_d *bp,
555                       unsigned int stack_size,
556                       unsigned int self_time,
557                       unsigned int time_inlining_benefit,
558                       unsigned int self_size,
559                       unsigned int size_inlining_benefit)
560 {
561   node->aux = (void *) tag;
562   node->local.inline_summary.estimated_self_stack_size = stack_size;
563   node->local.inline_summary.self_time = self_time;
564   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
565   node->local.inline_summary.self_size = self_size;
566   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
567   node->global.time = self_time;
568   node->global.size = self_size;
569   node->global.estimated_stack_size = stack_size;
570   node->global.estimated_growth = INT_MIN;
571   node->local.lto_file_data = file_data;
572
573   node->local.local = bp_unpack_value (bp, 1);
574   node->local.externally_visible = bp_unpack_value (bp, 1);
575   node->local.finalized = bp_unpack_value (bp, 1);
576   node->local.inlinable = bp_unpack_value (bp, 1);
577   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
578   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
579   node->local.vtable_method = bp_unpack_value (bp, 1);
580   node->needed = bp_unpack_value (bp, 1);
581   node->address_taken = bp_unpack_value (bp, 1);
582   node->abstract_and_needed = bp_unpack_value (bp, 1);
583   node->reachable_from_other_partition = bp_unpack_value (bp, 1);
584   node->lowered = bp_unpack_value (bp, 1);
585   node->analyzed = tag == LTO_cgraph_analyzed_node;
586   node->in_other_partition = bp_unpack_value (bp, 1);
587   node->alias = bp_unpack_value (bp, 1);
588   node->finalized_by_frontend = bp_unpack_value (bp, 1);
589   node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
590 }
591
592 /* Output the part of the cgraph in SET.  */
593
594 void
595 output_varpool (varpool_node_set set)
596 {
597   struct varpool_node *node;
598   struct lto_simple_output_block *ob;
599   int len = 0;
600
601   ob = lto_create_simple_output_block (LTO_section_varpool);
602
603   for (node = varpool_nodes; node; node = node->next)
604     if (node->needed && node->analyzed)
605       len++;
606
607   lto_output_uleb128_stream (ob->main_stream, len);
608
609   /* Write out the nodes.  We must first output a node and then its clones,
610      otherwise at a time reading back the node there would be nothing to clone
611      from.  */
612   for (node = varpool_nodes; node; node = node->next)
613     if (node->needed && node->analyzed)
614       lto_output_varpool_node (ob, node, set);
615
616   lto_destroy_simple_output_block (ob);
617 }
618
619 /* Read a node from input_block IB.  TAG is the node's tag just read.
620    Return the node read or overwriten.  */
621
622 static struct cgraph_node *
623 input_node (struct lto_file_decl_data *file_data,
624             struct lto_input_block *ib,
625             enum LTO_cgraph_tags tag)
626 {
627   tree fn_decl;
628   struct cgraph_node *node;
629   struct bitpack_d *bp;
630   int stack_size = 0;
631   unsigned decl_index;
632   bool clone_p;
633   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
634   int self_time = 0;
635   int self_size = 0;
636   int time_inlining_benefit = 0;
637   int size_inlining_benefit = 0;
638   unsigned long same_body_count = 0;
639
640   clone_p = (lto_input_uleb128 (ib) != 0);
641
642   decl_index = lto_input_uleb128 (ib);
643   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
644
645   if (clone_p)
646     node = cgraph_clone_node (cgraph_node (fn_decl), 0,
647                               CGRAPH_FREQ_BASE, 0, false, NULL);
648
649   else
650     node = cgraph_node (fn_decl);
651
652   node->count = lto_input_sleb128 (ib);
653   bp = lto_input_bitpack (ib);
654
655   if (tag == LTO_cgraph_analyzed_node)
656     {
657       stack_size = lto_input_sleb128 (ib);
658       self_size = lto_input_sleb128 (ib);
659       size_inlining_benefit = lto_input_sleb128 (ib);
660       self_time = lto_input_sleb128 (ib);
661       time_inlining_benefit = lto_input_sleb128 (ib);
662
663       ref = lto_input_sleb128 (ib);
664     }
665
666   ref2 = lto_input_sleb128 (ib);
667   same_body_count = lto_input_uleb128 (ib);
668
669   /* Make sure that we have not read this node before.  Nodes that
670      have already been read will have their tag stored in the 'aux'
671      field.  Since built-in functions can be referenced in multiple
672      functions, they are expected to be read more than once.  */
673   if (node->aux && !DECL_IS_BUILTIN (node->decl))
674     internal_error ("bytecode stream: found multiple instances of cgraph "
675                     "node %d", node->uid);
676
677   input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
678                         time_inlining_benefit, self_size,
679                         size_inlining_benefit);
680   bitpack_delete (bp);
681
682   /* Store a reference for now, and fix up later to be a pointer.  */
683   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
684
685   /* Store a reference for now, and fix up later to be a pointer.  */
686   node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
687
688   while (same_body_count-- > 0)
689     {
690       tree alias_decl;
691       int type;
692       decl_index = lto_input_uleb128 (ib);
693       alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
694       type = lto_input_uleb128 (ib);
695       if (!type)
696         {
697           tree real_alias;
698           decl_index = lto_input_uleb128 (ib);
699           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
700           cgraph_same_body_alias (alias_decl, real_alias);
701         }
702       else
703         {
704           HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
705           HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
706           tree real_alias;
707           decl_index = lto_input_uleb128 (ib);
708           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
709           cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
710                             virtual_value,
711                             (type & 4) ? size_int (virtual_value) : NULL_TREE,
712                             real_alias);
713         }
714     }
715   return node;
716 }
717
718 /* Read a node from input_block IB.  TAG is the node's tag just read.
719    Return the node read or overwriten.  */
720
721 static struct varpool_node *
722 input_varpool_node (struct lto_file_decl_data *file_data,
723                     struct lto_input_block *ib)
724 {
725   int decl_index;
726   tree var_decl;
727   struct varpool_node *node;
728   struct bitpack_d *bp;
729   bool aliases_p;
730   int count;
731
732   decl_index = lto_input_uleb128 (ib);
733   var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
734   node = varpool_node (var_decl);
735
736   bp = lto_input_bitpack (ib);
737   node->externally_visible = bp_unpack_value (bp, 1);
738   node->force_output = bp_unpack_value (bp, 1);
739   node->finalized = bp_unpack_value (bp, 1);
740   node->analyzed = 1; 
741   node->used_from_other_partition = bp_unpack_value (bp, 1);
742   node->in_other_partition = bp_unpack_value (bp, 1);
743   aliases_p = bp_unpack_value (bp, 1);
744   if (node->finalized)
745     varpool_mark_needed_node (node);
746   bitpack_delete (bp);
747   if (aliases_p)
748     {
749       count = lto_input_uleb128 (ib);
750       for (; count > 0; count --)
751         {
752           tree decl = lto_file_decl_data_get_var_decl (file_data,
753                                                        lto_input_uleb128 (ib));
754           varpool_extra_name_alias (decl, var_decl);
755         }
756     }
757   return node;
758 }
759
760
761 /* Read an edge from IB.  NODES points to a vector of previously read nodes for
762    decoding caller and callee of the edge to be read.  If INDIRECT is true, the
763    edge being read is indirect (in the sense that it has
764    indirect_unknown_callee set).  */
765
766 static void
767 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
768             bool indirect)
769 {
770   struct cgraph_node *caller, *callee;
771   struct cgraph_edge *edge;
772   unsigned int stmt_id;
773   gcov_type count;
774   int freq;
775   unsigned int nest;
776   cgraph_inline_failed_t inline_failed;
777   struct bitpack_d *bp;
778   enum ld_plugin_symbol_resolution caller_resolution;
779
780   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
781   if (caller == NULL || caller->decl == NULL_TREE)
782     internal_error ("bytecode stream: no caller found while reading edge");
783
784   if (!indirect)
785     {
786       callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
787       if (callee == NULL || callee->decl == NULL_TREE)
788         internal_error ("bytecode stream: no callee found while reading edge");
789     }
790   else
791     callee = NULL;
792
793   count = (gcov_type) lto_input_sleb128 (ib);
794
795   bp = lto_input_bitpack (ib);
796   stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
797   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
798                                                             HOST_BITS_PER_INT);
799   freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
800   nest = (unsigned) bp_unpack_value (bp, 30);
801
802   /* If the caller was preempted, don't create the edge.
803      ???  Should we ever have edges from a preempted caller?  */
804   caller_resolution = lto_symtab_get_resolution (caller->decl);
805   if (caller_resolution == LDPR_PREEMPTED_REG
806       || caller_resolution == LDPR_PREEMPTED_IR)
807     return;
808
809   if (indirect)
810     edge = cgraph_create_indirect_edge (caller, NULL, count, freq, nest);
811   else
812     edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
813
814   edge->indirect_inlining_edge = bp_unpack_value (bp, 1);
815   edge->lto_stmt_uid = stmt_id;
816   edge->inline_failed = inline_failed;
817   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
818   edge->can_throw_external = bp_unpack_value (bp, 1);
819   bitpack_delete (bp);
820 }
821
822
823 /* Read a cgraph from IB using the info in FILE_DATA.  */
824
825 static void
826 input_cgraph_1 (struct lto_file_decl_data *file_data,
827                 struct lto_input_block *ib)
828 {
829   enum LTO_cgraph_tags tag;
830   VEC(cgraph_node_ptr, heap) *nodes = NULL;
831   struct cgraph_node *node;
832   unsigned i;
833   unsigned HOST_WIDE_INT len;
834
835   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
836   while (tag)
837     {
838       if (tag == LTO_cgraph_edge)
839         input_edge (ib, nodes, false);
840       else if (tag == LTO_cgraph_indirect_edge)
841         input_edge (ib, nodes, true);
842       else
843         {
844           node = input_node (file_data, ib, tag);
845           if (node == NULL || node->decl == NULL_TREE)
846             internal_error ("bytecode stream: found empty cgraph node");
847           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
848           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
849         }
850
851       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
852     }
853
854   /* Input toplevel asms.  */
855   len = lto_input_uleb128 (ib);
856   while (len)
857     {
858       char *str = (char *)xmalloc (len + 1);
859       for (i = 0; i < len; ++i)
860         str[i] = lto_input_1_unsigned (ib);
861       cgraph_add_asm_node (build_string (len, str));
862       free (str);
863
864       len = lto_input_uleb128 (ib);
865     }
866
867   for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
868     {
869       int ref = (int) (intptr_t) node->global.inlined_to;
870
871       /* Fixup inlined_to from reference to pointer.  */
872       if (ref != LCC_NOT_FOUND)
873         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
874       else
875         node->global.inlined_to = NULL;
876
877       ref = (int) (intptr_t) node->same_comdat_group;
878
879       /* Fixup same_comdat_group from reference to pointer.  */
880       if (ref != LCC_NOT_FOUND)
881         node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
882       else
883         node->same_comdat_group = NULL;
884     }
885
886   VEC_free (cgraph_node_ptr, heap, nodes);
887 }
888
889 /* Read a varpool from IB using the info in FILE_DATA.  */
890
891 static void
892 input_varpool_1 (struct lto_file_decl_data *file_data,
893                 struct lto_input_block *ib)
894 {
895   unsigned HOST_WIDE_INT len;
896
897   len = lto_input_uleb128 (ib);
898   while (len)
899     {
900       input_varpool_node (file_data, ib);
901       len--;
902     }
903 }
904
905 static struct gcov_ctr_summary lto_gcov_summary;
906
907 /* Input profile_info from IB.  */
908 static void
909 input_profile_summary (struct lto_input_block *ib)
910 {
911   unsigned int runs = lto_input_uleb128 (ib);
912   if (runs)
913     {
914       if (!profile_info)
915         {
916           profile_info = &lto_gcov_summary;
917           lto_gcov_summary.runs = runs;
918           lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
919           lto_gcov_summary.run_max = lto_input_sleb128 (ib);
920           lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
921         }
922       /* We can support this by scaling all counts to nearest common multiple
923          of all different runs, but it is perhaps not worth the effort.  */
924       else if (profile_info->runs != runs
925                || profile_info->sum_all != lto_input_sleb128 (ib)
926                || profile_info->run_max != lto_input_sleb128 (ib)
927                || profile_info->sum_max != lto_input_sleb128 (ib))
928         sorry ("Combining units with different profiles is not supported.");
929       /* We allow some units to have profile and other to not have one.  This will
930          just make unprofiled units to be size optimized that is sane.  */
931     }
932
933 }
934
935 /* Input and merge the cgraph from each of the .o files passed to
936    lto1.  */
937
938 void
939 input_cgraph (void)
940 {
941   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
942   struct lto_file_decl_data *file_data;
943   unsigned int j = 0;
944   struct cgraph_node *node;
945
946   while ((file_data = file_data_vec[j++]))
947     {
948       const char *data;
949       size_t len;
950       struct lto_input_block *ib;
951
952       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
953                                           &data, &len);
954       input_profile_summary (ib);
955       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
956       input_cgraph_1 (file_data, ib);
957       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
958                                       ib, data, len);
959
960       ib = lto_create_simple_input_block (file_data, LTO_section_varpool,
961                                           &data, &len);
962       input_varpool_1 (file_data, ib);
963       lto_destroy_simple_input_block (file_data, LTO_section_varpool,
964                                       ib, data, len);
965
966       /* Assume that every file read needs to be processed by LTRANS.  */
967       if (flag_wpa)
968         lto_mark_file_for_ltrans (file_data);
969     }
970
971   /* Clear out the aux field that was used to store enough state to
972      tell which nodes should be overwritten.  */
973   for (node = cgraph_nodes; node; node = node->next)
974     {
975       /* Some nodes may have been created by cgraph_node.  This
976          happens when the callgraph contains nested functions.  If the
977          node for the parent function was never emitted to the gimple
978          file, cgraph_node will create a node for it when setting the
979          context of the nested function.  */
980       if (node->local.lto_file_data)
981         node->aux = NULL;
982     }
983 }