1 /* Write and read the cgraph to the memory mapped representation of a
4 Copyright 2009 Free Software Foundation, Inc.
5 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
7 This file is part of GCC.
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
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
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/>. */
25 #include "coretypes.h"
35 #include "langhooks.h"
36 #include "basic-block.h"
37 #include "tree-flow.h"
41 #include "diagnostic.h"
46 #include "pointer-set.h"
47 #include "lto-streamer.h"
50 /* Create a new cgraph encoder. */
53 lto_cgraph_encoder_new (void)
55 lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
56 encoder->map = pointer_map_create ();
57 encoder->nodes = NULL;
62 /* Delete ENCODER and its components. */
65 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
67 VEC_free (cgraph_node_ptr, heap, encoder->nodes);
68 pointer_map_destroy (encoder->map);
73 /* Return the existing reference number of NODE in the cgraph encoder in
74 output block OB. Assign a new reference if this is the first time
78 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
79 struct cgraph_node *node)
84 slot = pointer_map_contains (encoder->map, node);
87 ref = VEC_length (cgraph_node_ptr, encoder->nodes);
88 slot = pointer_map_insert (encoder->map, node);
89 *slot = (void *) (intptr_t) ref;
90 VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
93 ref = (int) (intptr_t) *slot;
99 /* Look up NODE in encoder. Return NODE's reference if it has been encoded
100 or LCC_NOT_FOUND if it is not there. */
103 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
104 struct cgraph_node *node)
106 void **slot = pointer_map_contains (encoder->map, node);
107 return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
111 /* Return the cgraph node corresponding to REF using ENCODER. */
114 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
116 if (ref == LCC_NOT_FOUND)
119 return VEC_index (cgraph_node_ptr, encoder->nodes, ref);
123 /* Return number of encoded nodes in ENCODER. */
126 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
128 return VEC_length (cgraph_node_ptr, encoder->nodes);
132 /* Output the cgraph EDGE to OB using ENCODER. */
135 lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
136 lto_cgraph_encoder_t encoder)
140 struct bitpack_d *bp;
142 lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
144 ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
145 gcc_assert (ref != LCC_NOT_FOUND);
146 lto_output_sleb128_stream (ob->main_stream, ref);
148 ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
149 gcc_assert (ref != LCC_NOT_FOUND);
150 lto_output_sleb128_stream (ob->main_stream, ref);
152 lto_output_sleb128_stream (ob->main_stream, edge->count);
154 bp = bitpack_create ();
155 uid = flag_wpa ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt);
156 bp_pack_value (bp, uid, HOST_BITS_PER_INT);
157 bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
158 bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
159 bp_pack_value (bp, edge->loop_nest, 30);
160 bp_pack_value (bp, edge->indirect_call, 1);
161 bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
162 bp_pack_value (bp, edge->can_throw_external, 1);
163 lto_output_bitpack (ob->main_stream, bp);
167 /* Return true when node is reachable from other partition. */
170 reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
172 struct cgraph_edge *e;
177 if (node->global.inlined_to)
179 for (e = node->callers; e; e = e->next_caller)
180 if (!cgraph_node_in_set_p (e->caller, set))
185 /* Output the cgraph NODE to OB. ENCODER is used to find the
186 reference number of NODE->inlined_to. SET is the set of nodes we
187 are writing to the current file. If NODE is not in SET, then NODE
188 is a boundary of a cgraph_node_set and we pretend NODE just has a
189 decl and no callees. WRITTEN_DECLS is the set of FUNCTION_DECLs
190 that have had their callgraph node written so far. This is used to
191 determine if NODE is a clone of a previously written node. */
194 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
195 lto_cgraph_encoder_t encoder, cgraph_node_set set,
196 bitmap written_decls)
199 struct bitpack_d *bp;
200 unsigned local, externally_visible, inlinable, analyzed;
201 bool boundary_p, wrote_decl_p;
203 bool in_other_partition = false;
205 boundary_p = !cgraph_node_in_set_p (node, set);
206 wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
208 switch (cgraph_function_body_availability (node))
210 case AVAIL_NOT_AVAILABLE:
211 tag = LTO_cgraph_unavail_node;
214 case AVAIL_AVAILABLE:
216 tag = LTO_cgraph_avail_node;
219 case AVAIL_OVERWRITABLE:
220 tag = LTO_cgraph_overwritable_node;
228 tag = LTO_cgraph_unavail_node;
230 lto_output_uleb128_stream (ob->main_stream, tag);
232 local = node->local.local;
233 externally_visible = node->local.externally_visible;
234 inlinable = node->local.inlinable;
235 analyzed = node->analyzed;
237 /* In WPA mode, we only output part of the call-graph. Also, we
238 fake cgraph node attributes. There are two cases that we care.
240 Boundary nodes: There are nodes that are not part of SET but are
241 called from within SET. We artificially make them look like
242 externally visible nodes with no function body.
244 Cherry-picked nodes: These are nodes we pulled from other
245 translation units into SET during IPA-inlining. We make them as
246 local static nodes to prevent clashes with other local statics. */
249 /* Inline clones can not be part of boundary.
250 gcc_assert (!node->global.inlined_to);
252 FIXME: At the moment they can be, when partition contains an inline
253 clone that is clone of inline clone from outside partition. We can
254 reshape the clone tree and make other tree to be the root, but it
255 needs a bit extra work and will be promplty done by cgraph_remove_node
256 after reading back. */
257 in_other_partition = 1;
261 lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
264 bitmap_set_bit (written_decls, DECL_UID (node->decl));
266 lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
267 lto_output_sleb128_stream (ob->main_stream, node->count);
269 bp = bitpack_create ();
270 bp_pack_value (bp, local, 1);
271 bp_pack_value (bp, externally_visible, 1);
272 bp_pack_value (bp, node->local.finalized, 1);
273 bp_pack_value (bp, inlinable, 1);
274 bp_pack_value (bp, node->local.disregard_inline_limits, 1);
275 bp_pack_value (bp, node->local.redefined_extern_inline, 1);
276 bp_pack_value (bp, node->local.for_functions_valid, 1);
277 bp_pack_value (bp, node->local.vtable_method, 1);
278 bp_pack_value (bp, node->needed, 1);
279 bp_pack_value (bp, node->address_taken, 1);
280 bp_pack_value (bp, node->abstract_and_needed, 1);
281 bp_pack_value (bp, node->reachable, 1);
282 bp_pack_value (bp, analyzed && reachable_from_other_partition_p (node, set), 1);
283 bp_pack_value (bp, node->lowered, 1);
284 bp_pack_value (bp, analyzed, 1);
285 bp_pack_value (bp, in_other_partition, 1);
286 bp_pack_value (bp, node->process, 1);
287 bp_pack_value (bp, node->alias, 1);
288 bp_pack_value (bp, node->finalized_by_frontend, 1);
289 lto_output_bitpack (ob->main_stream, bp);
292 if (tag != LTO_cgraph_unavail_node)
294 lto_output_sleb128_stream (ob->main_stream,
295 node->local.inline_summary.estimated_self_stack_size);
296 lto_output_sleb128_stream (ob->main_stream,
297 node->local.inline_summary.self_size);
298 lto_output_sleb128_stream (ob->main_stream,
299 node->local.inline_summary.size_inlining_benefit);
300 lto_output_sleb128_stream (ob->main_stream,
301 node->local.inline_summary.self_time);
302 lto_output_sleb128_stream (ob->main_stream,
303 node->local.inline_summary.time_inlining_benefit);
306 /* FIXME lto: Outputting global info is not neccesary until after
307 inliner was run. Global structure holds results of propagation
309 lto_output_sleb128_stream (ob->main_stream,
310 node->global.estimated_stack_size);
311 lto_output_sleb128_stream (ob->main_stream,
312 node->global.stack_frame_offset);
313 if (node->global.inlined_to && !boundary_p)
315 ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
316 gcc_assert (ref != LCC_NOT_FOUND);
320 lto_output_sleb128_stream (ob->main_stream, ref);
322 lto_output_sleb128_stream (ob->main_stream, node->global.time);
323 lto_output_sleb128_stream (ob->main_stream, node->global.size);
324 lto_output_sleb128_stream (ob->main_stream,
325 node->global.estimated_growth);
326 lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
327 if (node->same_comdat_group)
329 ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
330 gcc_assert (ref != LCC_NOT_FOUND);
334 lto_output_sleb128_stream (ob->main_stream, ref);
338 struct cgraph_node *alias;
339 unsigned long alias_count = 1;
340 for (alias = node->same_body; alias->next; alias = alias->next)
342 lto_output_uleb128_stream (ob->main_stream, alias_count);
345 lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
347 if (alias->thunk.thunk_p)
349 lto_output_uleb128_stream
351 1 + (alias->thunk.this_adjusting != 0) * 2
352 + (alias->thunk.virtual_offset_p != 0) * 4);
353 lto_output_uleb128_stream (ob->main_stream,
354 alias->thunk.fixed_offset);
355 lto_output_uleb128_stream (ob->main_stream,
356 alias->thunk.virtual_value);
357 lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
362 lto_output_uleb128_stream (ob->main_stream, 0);
363 lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
366 alias = alias->previous;
371 lto_output_uleb128_stream (ob->main_stream, 0);
374 /* Stream out profile_summary to OB. */
377 output_profile_summary (struct lto_simple_output_block *ob)
381 /* We do not output num, it is not terribly useful. */
382 gcc_assert (profile_info->runs);
383 lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
384 lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
385 lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
386 lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
389 lto_output_uleb128_stream (ob->main_stream, 0);
392 /* Add NODE into encoder as well as nodes it is cloned from.
393 Do it in a way so clones appear first. */
395 add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
398 add_node_to (encoder, node->clone_of);
399 lto_cgraph_encoder_encode (encoder, node);
402 /* Output the part of the cgraph in SET. */
405 output_cgraph (cgraph_node_set set)
407 struct cgraph_node *node;
408 struct lto_simple_output_block *ob;
409 cgraph_node_set_iterator csi;
410 struct cgraph_edge *edge;
412 bitmap written_decls;
413 lto_cgraph_encoder_t encoder;
414 struct cgraph_asm_node *can;
416 ob = lto_create_simple_output_block (LTO_section_cgraph);
418 output_profile_summary (ob);
420 /* An encoder for cgraph nodes should have been created by
421 ipa_write_summaries_1. */
422 gcc_assert (ob->decl_state->cgraph_node_encoder);
423 encoder = ob->decl_state->cgraph_node_encoder;
425 /* The FUNCTION_DECLs for which we have written a node. The first
426 node found is written as the "original" node, the remaining nodes
427 are considered its clones. */
428 written_decls = lto_bitmap_alloc ();
430 /* Go over all the nodes in SET and assign references. */
431 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
433 node = csi_node (csi);
434 add_node_to (encoder, node);
437 /* Go over all the nodes again to include callees that are not in
439 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
441 node = csi_node (csi);
442 for (edge = node->callees; edge; edge = edge->next_callee)
444 struct cgraph_node *callee = edge->callee;
445 if (!cgraph_node_in_set_p (callee, set))
447 /* We should have moved all the inlines. */
448 gcc_assert (!callee->global.inlined_to);
449 add_node_to (encoder, callee);
450 /* Also with each included function include all other functions
451 in the same comdat group. */
452 if (callee->same_comdat_group)
454 struct cgraph_node *next;
455 for (next = callee->same_comdat_group;
457 next = next->same_comdat_group)
458 if (!cgraph_node_in_set_p (next, set))
459 add_node_to (encoder, next);
463 /* Also with each included function include all other functions
464 in the same comdat group. */
465 if (node->same_comdat_group)
467 struct cgraph_node *next;
468 for (next = node->same_comdat_group;
470 next = next->same_comdat_group)
471 if (!cgraph_node_in_set_p (next, set))
472 add_node_to (encoder, next);
476 /* Write out the nodes. We must first output a node and then its clones,
477 otherwise at a time reading back the node there would be nothing to clone
479 n_nodes = lto_cgraph_encoder_size (encoder);
480 for (i = 0; i < n_nodes; i++)
482 node = lto_cgraph_encoder_deref (encoder, i);
483 lto_output_node (ob, node, encoder, set, written_decls);
486 lto_bitmap_free (written_decls);
488 /* Go over the nodes in SET again to write edges. */
489 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
491 node = csi_node (csi);
494 /* Output edges in backward direction, so the reconstructed callgraph
495 match and it is easy to associate call sites in the IPA pass summaries. */
496 edge = node->callees;
497 while (edge->next_callee)
498 edge = edge->next_callee;
499 for (; edge; edge = edge->prev_callee)
500 lto_output_edge (ob, edge, encoder);
504 lto_output_uleb128_stream (ob->main_stream, 0);
506 /* Emit toplevel asms. */
507 for (can = cgraph_asm_nodes; can; can = can->next)
509 int len = TREE_STRING_LENGTH (can->asm_str);
510 lto_output_uleb128_stream (ob->main_stream, len);
511 for (i = 0; i < len; ++i)
512 lto_output_1_stream (ob->main_stream,
513 TREE_STRING_POINTER (can->asm_str)[i]);
516 lto_output_uleb128_stream (ob->main_stream, 0);
518 lto_destroy_simple_output_block (ob);
522 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
523 STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
524 NODE or to replace the values in it, for instance because the first
525 time we saw it, the function body was not available but now it
526 is. BP is a bitpack with all the bitflags for NODE read from the
530 input_overwrite_node (struct lto_file_decl_data *file_data,
531 struct cgraph_node *node,
532 enum LTO_cgraph_tags tag,
533 struct bitpack_d *bp,
534 unsigned int stack_size,
535 unsigned int self_time,
536 unsigned int time_inlining_benefit,
537 unsigned int self_size,
538 unsigned int size_inlining_benefit)
540 node->aux = (void *) tag;
541 node->local.inline_summary.estimated_self_stack_size = stack_size;
542 node->local.inline_summary.self_time = self_time;
543 node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
544 node->local.inline_summary.self_size = self_size;
545 node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
546 node->global.time = self_time;
547 node->global.size = self_size;
548 node->local.lto_file_data = file_data;
550 node->local.local = bp_unpack_value (bp, 1);
551 node->local.externally_visible = bp_unpack_value (bp, 1);
552 node->local.finalized = bp_unpack_value (bp, 1);
553 node->local.inlinable = bp_unpack_value (bp, 1);
554 node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
555 node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
556 node->local.for_functions_valid = bp_unpack_value (bp, 1);
557 node->local.vtable_method = bp_unpack_value (bp, 1);
558 node->needed = bp_unpack_value (bp, 1);
559 node->address_taken = bp_unpack_value (bp, 1);
560 node->abstract_and_needed = bp_unpack_value (bp, 1);
561 node->reachable = bp_unpack_value (bp, 1);
562 node->reachable_from_other_partition = bp_unpack_value (bp, 1);
563 node->lowered = bp_unpack_value (bp, 1);
564 node->analyzed = bp_unpack_value (bp, 1);
565 node->in_other_partition = bp_unpack_value (bp, 1);
566 node->process = bp_unpack_value (bp, 1);
567 node->alias = bp_unpack_value (bp, 1);
568 node->finalized_by_frontend = bp_unpack_value (bp, 1);
572 /* Read a node from input_block IB. TAG is the node's tag just read.
573 Return the node read or overwriten. */
575 static struct cgraph_node *
576 input_node (struct lto_file_decl_data *file_data,
577 struct lto_input_block *ib,
578 enum LTO_cgraph_tags tag)
581 struct cgraph_node *node;
582 struct bitpack_d *bp;
586 int estimated_stack_size = 0;
587 int stack_frame_offset = 0;
588 int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
589 int estimated_growth = 0;
594 int time_inlining_benefit = 0;
595 int size_inlining_benefit = 0;
596 unsigned long same_body_count = 0;
597 bool inlined = false;
599 clone_p = (lto_input_uleb128 (ib) != 0);
601 decl_index = lto_input_uleb128 (ib);
602 fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
605 node = cgraph_clone_node (cgraph_node (fn_decl), 0,
606 CGRAPH_FREQ_BASE, 0, false, NULL);
609 node = cgraph_node (fn_decl);
611 node->count = lto_input_sleb128 (ib);
612 bp = lto_input_bitpack (ib);
614 if (tag != LTO_cgraph_unavail_node)
616 stack_size = lto_input_sleb128 (ib);
617 self_size = lto_input_sleb128 (ib);
618 size_inlining_benefit = lto_input_sleb128 (ib);
619 self_time = lto_input_sleb128 (ib);
620 time_inlining_benefit = lto_input_sleb128 (ib);
623 estimated_stack_size = lto_input_sleb128 (ib);
624 stack_frame_offset = lto_input_sleb128 (ib);
625 ref = lto_input_sleb128 (ib);
626 time = lto_input_sleb128 (ib);
627 size = lto_input_sleb128 (ib);
628 estimated_growth = lto_input_sleb128 (ib);
629 inlined = lto_input_uleb128 (ib);
630 ref2 = lto_input_sleb128 (ib);
631 same_body_count = lto_input_uleb128 (ib);
633 /* Make sure that we have not read this node before. Nodes that
634 have already been read will have their tag stored in the 'aux'
635 field. Since built-in functions can be referenced in multiple
636 functions, they are expected to be read more than once. */
637 if (node->aux && !DECL_IS_BUILTIN (node->decl))
638 internal_error ("bytecode stream: found multiple instances of cgraph "
639 "node %d", node->uid);
641 input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
642 time_inlining_benefit, self_size,
643 size_inlining_benefit);
646 node->global.estimated_stack_size = estimated_stack_size;
647 node->global.stack_frame_offset = stack_frame_offset;
648 node->global.time = time;
649 node->global.size = size;
651 /* Store a reference for now, and fix up later to be a pointer. */
652 node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
654 node->global.estimated_growth = estimated_growth;
655 node->global.inlined = inlined;
657 /* Store a reference for now, and fix up later to be a pointer. */
658 node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
660 while (same_body_count-- > 0)
664 decl_index = lto_input_uleb128 (ib);
665 alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
666 type = lto_input_uleb128 (ib);
670 decl_index = lto_input_uleb128 (ib);
671 real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
672 cgraph_same_body_alias (alias_decl, real_alias);
676 HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
677 HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
679 decl_index = lto_input_uleb128 (ib);
680 real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
681 cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
683 (type & 4) ? size_int (virtual_value) : NULL_TREE,
691 /* Read an edge from IB. NODES points to a vector of previously read
692 nodes for decoding caller and callee of the edge to be read. */
695 input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
697 struct cgraph_node *caller, *callee;
698 struct cgraph_edge *edge;
699 unsigned int stmt_id;
703 cgraph_inline_failed_t inline_failed;
704 struct bitpack_d *bp;
705 enum ld_plugin_symbol_resolution caller_resolution;
707 caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
708 if (caller == NULL || caller->decl == NULL_TREE)
709 internal_error ("bytecode stream: no caller found while reading edge");
711 callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
712 if (callee == NULL || callee->decl == NULL_TREE)
713 internal_error ("bytecode stream: no callee found while reading edge");
715 count = (gcov_type) lto_input_sleb128 (ib);
717 bp = lto_input_bitpack (ib);
718 stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
719 inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
721 freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
722 nest = (unsigned) bp_unpack_value (bp, 30);
724 /* If the caller was preempted, don't create the edge.
725 ??? Should we ever have edges from a preempted caller? */
726 caller_resolution = lto_symtab_get_resolution (caller->decl);
727 if (caller_resolution == LDPR_PREEMPTED_REG
728 || caller_resolution == LDPR_PREEMPTED_IR)
731 edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
732 edge->lto_stmt_uid = stmt_id;
733 edge->inline_failed = inline_failed;
734 edge->indirect_call = bp_unpack_value (bp, 1);
735 edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
736 edge->can_throw_external = bp_unpack_value (bp, 1);
741 /* Read a cgraph from IB using the info in FILE_DATA. */
744 input_cgraph_1 (struct lto_file_decl_data *file_data,
745 struct lto_input_block *ib)
747 enum LTO_cgraph_tags tag;
748 VEC(cgraph_node_ptr, heap) *nodes = NULL;
749 struct cgraph_node *node;
751 unsigned HOST_WIDE_INT len;
753 tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
756 if (tag == LTO_cgraph_edge)
757 input_edge (ib, nodes);
760 node = input_node (file_data, ib, tag);
761 if (node == NULL || node->decl == NULL_TREE)
762 internal_error ("bytecode stream: found empty cgraph node");
763 VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
764 lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
767 tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
770 /* Input toplevel asms. */
771 len = lto_input_uleb128 (ib);
774 char *str = (char *)xmalloc (len + 1);
775 for (i = 0; i < len; ++i)
776 str[i] = lto_input_1_unsigned (ib);
777 cgraph_add_asm_node (build_string (len, str));
780 len = lto_input_uleb128 (ib);
783 for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
785 int ref = (int) (intptr_t) node->global.inlined_to;
787 /* Fixup inlined_to from reference to pointer. */
788 if (ref != LCC_NOT_FOUND)
789 node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
791 node->global.inlined_to = NULL;
793 ref = (int) (intptr_t) node->same_comdat_group;
795 /* Fixup same_comdat_group from reference to pointer. */
796 if (ref != LCC_NOT_FOUND)
797 node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
799 node->same_comdat_group = NULL;
802 VEC_free (cgraph_node_ptr, heap, nodes);
805 static struct gcov_ctr_summary lto_gcov_summary;
807 /* Input profile_info from IB. */
809 input_profile_summary (struct lto_input_block *ib)
811 unsigned int runs = lto_input_uleb128 (ib);
816 profile_info = <o_gcov_summary;
817 lto_gcov_summary.runs = runs;
818 lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
819 lto_gcov_summary.run_max = lto_input_sleb128 (ib);
820 lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
822 /* We can support this by scaling all counts to nearest common multiple
823 of all different runs, but it is perhaps not worth the effort. */
824 else if (profile_info->runs != runs
825 || profile_info->sum_all != lto_input_sleb128 (ib)
826 || profile_info->run_max != lto_input_sleb128 (ib)
827 || profile_info->sum_max != lto_input_sleb128 (ib))
828 sorry ("Combining units with different profiles is not supported.");
829 /* We allow some units to have profile and other to not have one. This will
830 just make unprofiled units to be size optimized that is sane. */
835 /* Input and merge the cgraph from each of the .o files passed to
841 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
842 struct lto_file_decl_data *file_data;
844 struct cgraph_node *node;
846 while ((file_data = file_data_vec[j++]))
850 struct lto_input_block *ib;
852 ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
854 input_profile_summary (ib);
855 file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
856 input_cgraph_1 (file_data, ib);
857 lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
860 /* Assume that every file read needs to be processed by LTRANS. */
862 lto_mark_file_for_ltrans (file_data);
865 /* Clear out the aux field that was used to store enough state to
866 tell which nodes should be overwritten. */
867 for (node = cgraph_nodes; node; node = node->next)
869 /* Some nodes may have been created by cgraph_node. This
870 happens when the callgraph contains nested functions. If the
871 node for the parent function was never emitted to the gimple
872 file, cgraph_node will create a node for it when setting the
873 context of the nested function. */
874 if (node->local.lto_file_data)