OSDN Git Service

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