OSDN Git Service

338250aeb0dfcb59f8c703a661241d42a43d5802
[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   /* FIXME: We have no idea how we move references around.  For moment assume that
378      everything is used externally.  */
379   bp_pack_value (bp, flag_wpa, 1);  /* used_from_other_parition.  */
380   bp_pack_value (bp, boundary_p, 1);  /* in_other_partition.  */
381   /* Also emit any extra name aliases.  */
382   for (alias = node->extra_name; alias; alias = alias->next)
383     count++;
384   bp_pack_value (bp, count != 0, 1);
385   lto_output_bitpack (ob->main_stream, bp);
386   bitpack_delete (bp);
387
388   if (count)
389     {
390       lto_output_uleb128_stream (ob->main_stream, count);
391       for (alias = node->extra_name; alias; alias = alias->next)
392         lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
393     }
394 }
395
396 /* Stream out profile_summary to OB.  */
397
398 static void
399 output_profile_summary (struct lto_simple_output_block *ob)
400 {
401   if (profile_info)
402     {
403       /* We do not output num, it is not terribly useful.  */
404       gcc_assert (profile_info->runs);
405       lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
406       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
407       lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
408       lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
409     }
410   else
411     lto_output_uleb128_stream (ob->main_stream, 0);
412 }
413
414 /* Add NODE into encoder as well as nodes it is cloned from.
415    Do it in a way so clones appear first.  */
416 static void
417 add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
418 {
419   if (node->clone_of)
420     add_node_to (encoder, node->clone_of);
421   lto_cgraph_encoder_encode (encoder, node);
422 }
423
424 /* Output all callees or indirect outgoing edges.  EDGE must be the first such
425    edge.  */
426
427 static void
428 output_outgoing_cgraph_edges (struct cgraph_edge *edge,
429                               struct lto_simple_output_block *ob,
430                               lto_cgraph_encoder_t encoder)
431 {
432   if (!edge)
433     return;
434
435   /* Output edges in backward direction, so the reconstructed callgraph match
436      and it is easy to associate call sites in the IPA pass summaries.  */
437   while (edge->next_callee)
438     edge = edge->next_callee;
439   for (; edge; edge = edge->prev_callee)
440     lto_output_edge (ob, edge, encoder);
441 }
442
443 /* Output the part of the cgraph in SET.  */
444
445 void
446 output_cgraph (cgraph_node_set set)
447 {
448   struct cgraph_node *node;
449   struct lto_simple_output_block *ob;
450   cgraph_node_set_iterator csi;
451   struct cgraph_edge *edge;
452   int i, n_nodes;
453   bitmap written_decls;
454   lto_cgraph_encoder_t encoder;
455   struct cgraph_asm_node *can;
456
457   ob = lto_create_simple_output_block (LTO_section_cgraph);
458
459   output_profile_summary (ob);
460
461   /* An encoder for cgraph nodes should have been created by
462      ipa_write_summaries_1.  */
463   gcc_assert (ob->decl_state->cgraph_node_encoder);
464   encoder = ob->decl_state->cgraph_node_encoder;
465
466   /* The FUNCTION_DECLs for which we have written a node.  The first
467      node found is written as the "original" node, the remaining nodes
468      are considered its clones.  */
469   written_decls = lto_bitmap_alloc ();
470
471   /* Go over all the nodes in SET and assign references.  */
472   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
473     {
474       node = csi_node (csi);
475       add_node_to (encoder, node);
476     }
477
478   /* Go over all the nodes again to include callees that are not in
479      SET.  */
480   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
481     {
482       node = csi_node (csi);
483       for (edge = node->callees; edge; edge = edge->next_callee)
484         {
485           struct cgraph_node *callee = edge->callee;
486           if (!cgraph_node_in_set_p (callee, set))
487             {
488               /* We should have moved all the inlines.  */
489               gcc_assert (!callee->global.inlined_to);
490               add_node_to (encoder, callee);
491             }
492         }
493     }
494
495   /* Write out the nodes.  We must first output a node and then its clones,
496      otherwise at a time reading back the node there would be nothing to clone
497      from.  */
498   n_nodes = lto_cgraph_encoder_size (encoder);
499   for (i = 0; i < n_nodes; i++)
500     {
501       node = lto_cgraph_encoder_deref (encoder, i);
502       lto_output_node (ob, node, encoder, set, written_decls);
503     }
504
505   lto_bitmap_free (written_decls);
506
507   /* Go over the nodes in SET again to write edges.  */
508   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
509     {
510       node = csi_node (csi);
511       output_outgoing_cgraph_edges (node->callees, ob, encoder);
512       output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
513     }
514
515   lto_output_uleb128_stream (ob->main_stream, 0);
516
517   /* Emit toplevel asms.  */
518   for (can = cgraph_asm_nodes; can; can = can->next)
519     {
520       int len = TREE_STRING_LENGTH (can->asm_str);
521       lto_output_uleb128_stream (ob->main_stream, len);
522       for (i = 0; i < len; ++i)
523         lto_output_1_stream (ob->main_stream,
524                              TREE_STRING_POINTER (can->asm_str)[i]);
525     }
526
527   lto_output_uleb128_stream (ob->main_stream, 0);
528
529   lto_destroy_simple_output_block (ob);
530 }
531
532 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
533    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
534    NODE or to replace the values in it, for instance because the first
535    time we saw it, the function body was not available but now it
536    is.  BP is a bitpack with all the bitflags for NODE read from the
537    stream.  */
538
539 static void
540 input_overwrite_node (struct lto_file_decl_data *file_data,
541                       struct cgraph_node *node,
542                       enum LTO_cgraph_tags tag,
543                       struct bitpack_d *bp,
544                       unsigned int stack_size,
545                       unsigned int self_time,
546                       unsigned int time_inlining_benefit,
547                       unsigned int self_size,
548                       unsigned int size_inlining_benefit)
549 {
550   node->aux = (void *) tag;
551   node->local.inline_summary.estimated_self_stack_size = stack_size;
552   node->local.inline_summary.self_time = self_time;
553   node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
554   node->local.inline_summary.self_size = self_size;
555   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
556   node->global.time = self_time;
557   node->global.size = self_size;
558   node->global.estimated_stack_size = stack_size;
559   node->global.estimated_growth = INT_MIN;
560   node->local.lto_file_data = file_data;
561
562   node->local.local = bp_unpack_value (bp, 1);
563   node->local.externally_visible = bp_unpack_value (bp, 1);
564   node->local.finalized = bp_unpack_value (bp, 1);
565   node->local.inlinable = bp_unpack_value (bp, 1);
566   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
567   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
568   node->local.vtable_method = bp_unpack_value (bp, 1);
569   node->needed = bp_unpack_value (bp, 1);
570   node->address_taken = bp_unpack_value (bp, 1);
571   node->abstract_and_needed = bp_unpack_value (bp, 1);
572   node->reachable_from_other_partition = bp_unpack_value (bp, 1);
573   node->lowered = bp_unpack_value (bp, 1);
574   node->analyzed = tag == LTO_cgraph_analyzed_node;
575   node->in_other_partition = bp_unpack_value (bp, 1);
576   node->alias = bp_unpack_value (bp, 1);
577   node->finalized_by_frontend = bp_unpack_value (bp, 1);
578   node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
579 }
580
581 /* Output the part of the cgraph in SET.  */
582
583 void
584 output_varpool (varpool_node_set set)
585 {
586   struct varpool_node *node;
587   struct lto_simple_output_block *ob;
588   int len = 0;
589
590   ob = lto_create_simple_output_block (LTO_section_varpool);
591
592   for (node = varpool_nodes; node; node = node->next)
593     if (node->needed && node->analyzed)
594       len++;
595
596   lto_output_uleb128_stream (ob->main_stream, len);
597
598   /* Write out the nodes.  We must first output a node and then its clones,
599      otherwise at a time reading back the node there would be nothing to clone
600      from.  */
601   for (node = varpool_nodes; node; node = node->next)
602     if (node->needed && node->analyzed)
603       lto_output_varpool_node (ob, node, set);
604
605   lto_destroy_simple_output_block (ob);
606 }
607
608 /* Read a node from input_block IB.  TAG is the node's tag just read.
609    Return the node read or overwriten.  */
610
611 static struct cgraph_node *
612 input_node (struct lto_file_decl_data *file_data,
613             struct lto_input_block *ib,
614             enum LTO_cgraph_tags tag)
615 {
616   tree fn_decl;
617   struct cgraph_node *node;
618   struct bitpack_d *bp;
619   int stack_size = 0;
620   unsigned decl_index;
621   bool clone_p;
622   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
623   int self_time = 0;
624   int self_size = 0;
625   int time_inlining_benefit = 0;
626   int size_inlining_benefit = 0;
627   unsigned long same_body_count = 0;
628
629   clone_p = (lto_input_uleb128 (ib) != 0);
630
631   decl_index = lto_input_uleb128 (ib);
632   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
633
634   if (clone_p)
635     node = cgraph_clone_node (cgraph_node (fn_decl), 0,
636                               CGRAPH_FREQ_BASE, 0, false, NULL);
637
638   else
639     node = cgraph_node (fn_decl);
640
641   node->count = lto_input_sleb128 (ib);
642   bp = lto_input_bitpack (ib);
643
644   if (tag == LTO_cgraph_analyzed_node)
645     {
646       stack_size = lto_input_sleb128 (ib);
647       self_size = lto_input_sleb128 (ib);
648       size_inlining_benefit = lto_input_sleb128 (ib);
649       self_time = lto_input_sleb128 (ib);
650       time_inlining_benefit = lto_input_sleb128 (ib);
651
652       ref = lto_input_sleb128 (ib);
653     }
654
655   ref2 = lto_input_sleb128 (ib);
656   same_body_count = lto_input_uleb128 (ib);
657
658   /* Make sure that we have not read this node before.  Nodes that
659      have already been read will have their tag stored in the 'aux'
660      field.  Since built-in functions can be referenced in multiple
661      functions, they are expected to be read more than once.  */
662   if (node->aux && !DECL_IS_BUILTIN (node->decl))
663     internal_error ("bytecode stream: found multiple instances of cgraph "
664                     "node %d", node->uid);
665
666   input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
667                         time_inlining_benefit, self_size,
668                         size_inlining_benefit);
669   bitpack_delete (bp);
670
671   /* Store a reference for now, and fix up later to be a pointer.  */
672   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
673
674   /* Store a reference for now, and fix up later to be a pointer.  */
675   node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
676
677   while (same_body_count-- > 0)
678     {
679       tree alias_decl;
680       int type;
681       decl_index = lto_input_uleb128 (ib);
682       alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
683       type = lto_input_uleb128 (ib);
684       if (!type)
685         {
686           tree real_alias;
687           decl_index = lto_input_uleb128 (ib);
688           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
689           cgraph_same_body_alias (alias_decl, real_alias);
690         }
691       else
692         {
693           HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
694           HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
695           tree real_alias;
696           decl_index = lto_input_uleb128 (ib);
697           real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
698           cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
699                             virtual_value,
700                             (type & 4) ? size_int (virtual_value) : NULL_TREE,
701                             real_alias);
702         }
703     }
704   return node;
705 }
706
707 /* Read a node from input_block IB.  TAG is the node's tag just read.
708    Return the node read or overwriten.  */
709
710 static struct varpool_node *
711 input_varpool_node (struct lto_file_decl_data *file_data,
712                     struct lto_input_block *ib)
713 {
714   int decl_index;
715   tree var_decl;
716   struct varpool_node *node;
717   struct bitpack_d *bp;
718   bool aliases_p;
719   int count;
720
721   decl_index = lto_input_uleb128 (ib);
722   var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
723   node = varpool_node (var_decl);
724
725   bp = lto_input_bitpack (ib);
726   node->externally_visible = bp_unpack_value (bp, 1);
727   node->force_output = bp_unpack_value (bp, 1);
728   node->finalized = bp_unpack_value (bp, 1);
729   node->analyzed = 1; 
730   node->used_from_other_partition = bp_unpack_value (bp, 1);
731   node->in_other_partition = bp_unpack_value (bp, 1);
732   aliases_p = bp_unpack_value (bp, 1);
733   if (node->finalized)
734     varpool_mark_needed_node (node);
735   bitpack_delete (bp);
736   if (aliases_p)
737     {
738       count = lto_input_uleb128 (ib);
739       for (; count > 0; count --)
740         {
741           tree decl = lto_file_decl_data_get_var_decl (file_data,
742                                                        lto_input_uleb128 (ib));
743           varpool_extra_name_alias (decl, var_decl);
744         }
745     }
746   return node;
747 }
748
749
750 /* Read an edge from IB.  NODES points to a vector of previously read nodes for
751    decoding caller and callee of the edge to be read.  If INDIRECT is true, the
752    edge being read is indirect (in the sense that it has
753    indirect_unknown_callee set).  */
754
755 static void
756 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
757             bool indirect)
758 {
759   struct cgraph_node *caller, *callee;
760   struct cgraph_edge *edge;
761   unsigned int stmt_id;
762   gcov_type count;
763   int freq;
764   unsigned int nest;
765   cgraph_inline_failed_t inline_failed;
766   struct bitpack_d *bp;
767   enum ld_plugin_symbol_resolution caller_resolution;
768
769   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
770   if (caller == NULL || caller->decl == NULL_TREE)
771     internal_error ("bytecode stream: no caller found while reading edge");
772
773   if (!indirect)
774     {
775       callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
776       if (callee == NULL || callee->decl == NULL_TREE)
777         internal_error ("bytecode stream: no callee found while reading edge");
778     }
779   else
780     callee = NULL;
781
782   count = (gcov_type) lto_input_sleb128 (ib);
783
784   bp = lto_input_bitpack (ib);
785   stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
786   inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
787                                                             HOST_BITS_PER_INT);
788   freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
789   nest = (unsigned) bp_unpack_value (bp, 30);
790
791   /* If the caller was preempted, don't create the edge.
792      ???  Should we ever have edges from a preempted caller?  */
793   caller_resolution = lto_symtab_get_resolution (caller->decl);
794   if (caller_resolution == LDPR_PREEMPTED_REG
795       || caller_resolution == LDPR_PREEMPTED_IR)
796     return;
797
798   if (indirect)
799     edge = cgraph_create_indirect_edge (caller, NULL, count, freq, nest);
800   else
801     edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
802
803   edge->indirect_inlining_edge = bp_unpack_value (bp, 1);
804   edge->lto_stmt_uid = stmt_id;
805   edge->inline_failed = inline_failed;
806   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
807   edge->can_throw_external = bp_unpack_value (bp, 1);
808   bitpack_delete (bp);
809 }
810
811
812 /* Read a cgraph from IB using the info in FILE_DATA.  */
813
814 static void
815 input_cgraph_1 (struct lto_file_decl_data *file_data,
816                 struct lto_input_block *ib)
817 {
818   enum LTO_cgraph_tags tag;
819   VEC(cgraph_node_ptr, heap) *nodes = NULL;
820   struct cgraph_node *node;
821   unsigned i;
822   unsigned HOST_WIDE_INT len;
823
824   tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
825   while (tag)
826     {
827       if (tag == LTO_cgraph_edge)
828         input_edge (ib, nodes, false);
829       else if (tag == LTO_cgraph_indirect_edge)
830         input_edge (ib, nodes, true);
831       else
832         {
833           node = input_node (file_data, ib, tag);
834           if (node == NULL || node->decl == NULL_TREE)
835             internal_error ("bytecode stream: found empty cgraph node");
836           VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
837           lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
838         }
839
840       tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
841     }
842
843   /* Input toplevel asms.  */
844   len = lto_input_uleb128 (ib);
845   while (len)
846     {
847       char *str = (char *)xmalloc (len + 1);
848       for (i = 0; i < len; ++i)
849         str[i] = lto_input_1_unsigned (ib);
850       cgraph_add_asm_node (build_string (len, str));
851       free (str);
852
853       len = lto_input_uleb128 (ib);
854     }
855
856   for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
857     {
858       int ref = (int) (intptr_t) node->global.inlined_to;
859
860       /* Fixup inlined_to from reference to pointer.  */
861       if (ref != LCC_NOT_FOUND)
862         node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
863       else
864         node->global.inlined_to = NULL;
865
866       ref = (int) (intptr_t) node->same_comdat_group;
867
868       /* Fixup same_comdat_group from reference to pointer.  */
869       if (ref != LCC_NOT_FOUND)
870         node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
871       else
872         node->same_comdat_group = NULL;
873     }
874
875   VEC_free (cgraph_node_ptr, heap, nodes);
876 }
877
878 /* Read a varpool from IB using the info in FILE_DATA.  */
879
880 static void
881 input_varpool_1 (struct lto_file_decl_data *file_data,
882                 struct lto_input_block *ib)
883 {
884   unsigned HOST_WIDE_INT len;
885
886   len = lto_input_uleb128 (ib);
887   while (len)
888     {
889       input_varpool_node (file_data, ib);
890       len--;
891     }
892 }
893
894 static struct gcov_ctr_summary lto_gcov_summary;
895
896 /* Input profile_info from IB.  */
897 static void
898 input_profile_summary (struct lto_input_block *ib)
899 {
900   unsigned int runs = lto_input_uleb128 (ib);
901   if (runs)
902     {
903       if (!profile_info)
904         {
905           profile_info = &lto_gcov_summary;
906           lto_gcov_summary.runs = runs;
907           lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
908           lto_gcov_summary.run_max = lto_input_sleb128 (ib);
909           lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
910         }
911       /* We can support this by scaling all counts to nearest common multiple
912          of all different runs, but it is perhaps not worth the effort.  */
913       else if (profile_info->runs != runs
914                || profile_info->sum_all != lto_input_sleb128 (ib)
915                || profile_info->run_max != lto_input_sleb128 (ib)
916                || profile_info->sum_max != lto_input_sleb128 (ib))
917         sorry ("Combining units with different profiles is not supported.");
918       /* We allow some units to have profile and other to not have one.  This will
919          just make unprofiled units to be size optimized that is sane.  */
920     }
921
922 }
923
924 /* Input and merge the cgraph from each of the .o files passed to
925    lto1.  */
926
927 void
928 input_cgraph (void)
929 {
930   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
931   struct lto_file_decl_data *file_data;
932   unsigned int j = 0;
933   struct cgraph_node *node;
934
935   while ((file_data = file_data_vec[j++]))
936     {
937       const char *data;
938       size_t len;
939       struct lto_input_block *ib;
940
941       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
942                                           &data, &len);
943       input_profile_summary (ib);
944       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
945       input_cgraph_1 (file_data, ib);
946       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
947                                       ib, data, len);
948
949       ib = lto_create_simple_input_block (file_data, LTO_section_varpool,
950                                           &data, &len);
951       input_varpool_1 (file_data, ib);
952       lto_destroy_simple_input_block (file_data, LTO_section_varpool,
953                                       ib, data, len);
954
955       /* Assume that every file read needs to be processed by LTRANS.  */
956       if (flag_wpa)
957         lto_mark_file_for_ltrans (file_data);
958     }
959
960   /* Clear out the aux field that was used to store enough state to
961      tell which nodes should be overwritten.  */
962   for (node = cgraph_nodes; node; node = node->next)
963     {
964       /* Some nodes may have been created by cgraph_node.  This
965          happens when the callgraph contains nested functions.  If the
966          node for the parent function was never emitted to the gimple
967          file, cgraph_node will create a node for it when setting the
968          context of the nested function.  */
969       if (node->local.lto_file_data)
970         node->aux = NULL;
971     }
972 }