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 if (edge
->indirect_unknown_callee
)
143 lto_output_uleb128_stream (ob
->main_stream
, LTO_cgraph_indirect_edge
);
145 lto_output_uleb128_stream (ob
->main_stream
, LTO_cgraph_edge
);
147 ref
= lto_cgraph_encoder_lookup (encoder
, edge
->caller
);
148 gcc_assert (ref
!= LCC_NOT_FOUND
);
149 lto_output_sleb128_stream (ob
->main_stream
, ref
);
151 if (!edge
->indirect_unknown_callee
)
153 ref
= lto_cgraph_encoder_lookup (encoder
, edge
->callee
);
154 gcc_assert (ref
!= LCC_NOT_FOUND
);
155 lto_output_sleb128_stream (ob
->main_stream
, ref
);
158 lto_output_sleb128_stream (ob
->main_stream
, edge
->count
);
160 bp
= bitpack_create ();
161 uid
= flag_wpa
? edge
->lto_stmt_uid
: gimple_uid (edge
->call_stmt
);
162 bp_pack_value (bp
, uid
, HOST_BITS_PER_INT
);
163 bp_pack_value (bp
, edge
->inline_failed
, HOST_BITS_PER_INT
);
164 bp_pack_value (bp
, edge
->frequency
, HOST_BITS_PER_INT
);
165 bp_pack_value (bp
, edge
->loop_nest
, 30);
166 bp_pack_value (bp
, edge
->indirect_inlining_edge
, 1);
167 bp_pack_value (bp
, edge
->call_stmt_cannot_inline_p
, 1);
168 bp_pack_value (bp
, edge
->can_throw_external
, 1);
169 lto_output_bitpack (ob
->main_stream
, bp
);
173 /* Return true when node is reachable from other partition. */
176 reachable_from_other_partition_p (struct cgraph_node
*node
, cgraph_node_set set
)
178 struct cgraph_edge
*e
;
183 if (node
->global
.inlined_to
)
185 for (e
= node
->callers
; e
; e
= e
->next_caller
)
186 if (!cgraph_node_in_set_p (e
->caller
, set
))
191 /* Output the cgraph NODE to OB. ENCODER is used to find the
192 reference number of NODE->inlined_to. SET is the set of nodes we
193 are writing to the current file. If NODE is not in SET, then NODE
194 is a boundary of a cgraph_node_set and we pretend NODE just has a
195 decl and no callees. WRITTEN_DECLS is the set of FUNCTION_DECLs
196 that have had their callgraph node written so far. This is used to
197 determine if NODE is a clone of a previously written node. */
200 lto_output_node (struct lto_simple_output_block
*ob
, struct cgraph_node
*node
,
201 lto_cgraph_encoder_t encoder
, cgraph_node_set set
,
202 bitmap written_decls
)
205 struct bitpack_d
*bp
;
206 unsigned local
, externally_visible
, inlinable
, analyzed
;
207 bool boundary_p
, wrote_decl_p
;
209 bool in_other_partition
= false;
211 boundary_p
= !cgraph_node_in_set_p (node
, set
);
212 wrote_decl_p
= bitmap_bit_p (written_decls
, DECL_UID (node
->decl
));
214 switch (cgraph_function_body_availability (node
))
216 case AVAIL_NOT_AVAILABLE
:
217 tag
= LTO_cgraph_unavail_node
;
220 case AVAIL_AVAILABLE
:
222 tag
= LTO_cgraph_avail_node
;
225 case AVAIL_OVERWRITABLE
:
226 tag
= LTO_cgraph_overwritable_node
;
234 tag
= LTO_cgraph_unavail_node
;
236 lto_output_uleb128_stream (ob
->main_stream
, tag
);
238 local
= node
->local
.local
;
239 externally_visible
= node
->local
.externally_visible
;
240 inlinable
= node
->local
.inlinable
;
241 analyzed
= node
->analyzed
;
243 /* In WPA mode, we only output part of the call-graph. Also, we
244 fake cgraph node attributes. There are two cases that we care.
246 Boundary nodes: There are nodes that are not part of SET but are
247 called from within SET. We artificially make them look like
248 externally visible nodes with no function body.
250 Cherry-picked nodes: These are nodes we pulled from other
251 translation units into SET during IPA-inlining. We make them as
252 local static nodes to prevent clashes with other local statics. */
255 /* Inline clones can not be part of boundary.
256 gcc_assert (!node->global.inlined_to);
258 FIXME: At the moment they can be, when partition contains an inline
259 clone that is clone of inline clone from outside partition. We can
260 reshape the clone tree and make other tree to be the root, but it
261 needs a bit extra work and will be promplty done by cgraph_remove_node
262 after reading back. */
263 in_other_partition
= 1;
267 lto_output_uleb128_stream (ob
->main_stream
, wrote_decl_p
);
270 bitmap_set_bit (written_decls
, DECL_UID (node
->decl
));
272 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, node
->decl
);
273 lto_output_sleb128_stream (ob
->main_stream
, node
->count
);
275 bp
= bitpack_create ();
276 bp_pack_value (bp
, local
, 1);
277 bp_pack_value (bp
, externally_visible
, 1);
278 bp_pack_value (bp
, node
->local
.finalized
, 1);
279 bp_pack_value (bp
, inlinable
, 1);
280 bp_pack_value (bp
, node
->local
.disregard_inline_limits
, 1);
281 bp_pack_value (bp
, node
->local
.redefined_extern_inline
, 1);
282 bp_pack_value (bp
, node
->local
.for_functions_valid
, 1);
283 bp_pack_value (bp
, node
->local
.vtable_method
, 1);
284 bp_pack_value (bp
, node
->needed
, 1);
285 bp_pack_value (bp
, node
->address_taken
, 1);
286 bp_pack_value (bp
, node
->abstract_and_needed
, 1);
287 bp_pack_value (bp
, node
->reachable
, 1);
288 bp_pack_value (bp
, analyzed
&& reachable_from_other_partition_p (node
, set
), 1);
289 bp_pack_value (bp
, node
->lowered
, 1);
290 bp_pack_value (bp
, analyzed
, 1);
291 bp_pack_value (bp
, in_other_partition
, 1);
292 bp_pack_value (bp
, node
->process
, 1);
293 bp_pack_value (bp
, node
->alias
, 1);
294 bp_pack_value (bp
, node
->finalized_by_frontend
, 1);
295 bp_pack_value (bp
, node
->frequency
, 2);
296 lto_output_bitpack (ob
->main_stream
, bp
);
299 if (tag
!= LTO_cgraph_unavail_node
)
301 lto_output_sleb128_stream (ob
->main_stream
,
302 node
->local
.inline_summary
.estimated_self_stack_size
);
303 lto_output_sleb128_stream (ob
->main_stream
,
304 node
->local
.inline_summary
.self_size
);
305 lto_output_sleb128_stream (ob
->main_stream
,
306 node
->local
.inline_summary
.size_inlining_benefit
);
307 lto_output_sleb128_stream (ob
->main_stream
,
308 node
->local
.inline_summary
.self_time
);
309 lto_output_sleb128_stream (ob
->main_stream
,
310 node
->local
.inline_summary
.time_inlining_benefit
);
313 /* FIXME lto: Outputting global info is not neccesary until after
314 inliner was run. Global structure holds results of propagation
316 lto_output_sleb128_stream (ob
->main_stream
,
317 node
->global
.estimated_stack_size
);
318 lto_output_sleb128_stream (ob
->main_stream
,
319 node
->global
.stack_frame_offset
);
320 if (node
->global
.inlined_to
&& !boundary_p
)
322 ref
= lto_cgraph_encoder_lookup (encoder
, node
->global
.inlined_to
);
323 gcc_assert (ref
!= LCC_NOT_FOUND
);
327 lto_output_sleb128_stream (ob
->main_stream
, ref
);
329 lto_output_sleb128_stream (ob
->main_stream
, node
->global
.time
);
330 lto_output_sleb128_stream (ob
->main_stream
, node
->global
.size
);
331 lto_output_sleb128_stream (ob
->main_stream
,
332 node
->global
.estimated_growth
);
333 lto_output_uleb128_stream (ob
->main_stream
, node
->global
.inlined
);
334 if (node
->same_comdat_group
&& !boundary_p
)
336 ref
= lto_cgraph_encoder_lookup (encoder
, node
->same_comdat_group
);
337 gcc_assert (ref
!= LCC_NOT_FOUND
);
341 lto_output_sleb128_stream (ob
->main_stream
, ref
);
345 struct cgraph_node
*alias
;
346 unsigned long alias_count
= 1;
347 for (alias
= node
->same_body
; alias
->next
; alias
= alias
->next
)
349 lto_output_uleb128_stream (ob
->main_stream
, alias_count
);
352 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
354 if (alias
->thunk
.thunk_p
)
356 lto_output_uleb128_stream
358 1 + (alias
->thunk
.this_adjusting
!= 0) * 2
359 + (alias
->thunk
.virtual_offset_p
!= 0) * 4);
360 lto_output_uleb128_stream (ob
->main_stream
,
361 alias
->thunk
.fixed_offset
);
362 lto_output_uleb128_stream (ob
->main_stream
,
363 alias
->thunk
.virtual_value
);
364 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
369 lto_output_uleb128_stream (ob
->main_stream
, 0);
370 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
373 alias
= alias
->previous
;
378 lto_output_uleb128_stream (ob
->main_stream
, 0);
381 /* Stream out profile_summary to OB. */
384 output_profile_summary (struct lto_simple_output_block
*ob
)
388 /* We do not output num, it is not terribly useful. */
389 gcc_assert (profile_info
->runs
);
390 lto_output_uleb128_stream (ob
->main_stream
, profile_info
->runs
);
391 lto_output_sleb128_stream (ob
->main_stream
, profile_info
->sum_all
);
392 lto_output_sleb128_stream (ob
->main_stream
, profile_info
->run_max
);
393 lto_output_sleb128_stream (ob
->main_stream
, profile_info
->sum_max
);
396 lto_output_uleb128_stream (ob
->main_stream
, 0);
399 /* Add NODE into encoder as well as nodes it is cloned from.
400 Do it in a way so clones appear first. */
402 add_node_to (lto_cgraph_encoder_t encoder
, struct cgraph_node
*node
)
405 add_node_to (encoder
, node
->clone_of
);
406 lto_cgraph_encoder_encode (encoder
, node
);
409 /* Output all callees or indirect outgoing edges. EDGE must be the first such
413 output_outgoing_cgraph_edges (struct cgraph_edge
*edge
,
414 struct lto_simple_output_block
*ob
,
415 lto_cgraph_encoder_t encoder
)
420 /* Output edges in backward direction, so the reconstructed callgraph match
421 and it is easy to associate call sites in the IPA pass summaries. */
422 while (edge
->next_callee
)
423 edge
= edge
->next_callee
;
424 for (; edge
; edge
= edge
->prev_callee
)
425 lto_output_edge (ob
, edge
, encoder
);
428 /* Output the part of the cgraph in SET. */
431 output_cgraph (cgraph_node_set set
)
433 struct cgraph_node
*node
;
434 struct lto_simple_output_block
*ob
;
435 cgraph_node_set_iterator csi
;
436 struct cgraph_edge
*edge
;
438 bitmap written_decls
;
439 lto_cgraph_encoder_t encoder
;
440 struct cgraph_asm_node
*can
;
442 ob
= lto_create_simple_output_block (LTO_section_cgraph
);
444 output_profile_summary (ob
);
446 /* An encoder for cgraph nodes should have been created by
447 ipa_write_summaries_1. */
448 gcc_assert (ob
->decl_state
->cgraph_node_encoder
);
449 encoder
= ob
->decl_state
->cgraph_node_encoder
;
451 /* The FUNCTION_DECLs for which we have written a node. The first
452 node found is written as the "original" node, the remaining nodes
453 are considered its clones. */
454 written_decls
= lto_bitmap_alloc ();
456 /* Go over all the nodes in SET and assign references. */
457 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
459 node
= csi_node (csi
);
460 add_node_to (encoder
, node
);
463 /* Go over all the nodes again to include callees that are not in
465 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
467 node
= csi_node (csi
);
468 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
470 struct cgraph_node
*callee
= edge
->callee
;
471 if (!cgraph_node_in_set_p (callee
, set
))
473 /* We should have moved all the inlines. */
474 gcc_assert (!callee
->global
.inlined_to
);
475 add_node_to (encoder
, callee
);
480 /* Write out the nodes. We must first output a node and then its clones,
481 otherwise at a time reading back the node there would be nothing to clone
483 n_nodes
= lto_cgraph_encoder_size (encoder
);
484 for (i
= 0; i
< n_nodes
; i
++)
486 node
= lto_cgraph_encoder_deref (encoder
, i
);
487 lto_output_node (ob
, node
, encoder
, set
, written_decls
);
490 lto_bitmap_free (written_decls
);
492 /* Go over the nodes in SET again to write edges. */
493 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
495 node
= csi_node (csi
);
496 output_outgoing_cgraph_edges (node
->callees
, ob
, encoder
);
497 output_outgoing_cgraph_edges (node
->indirect_calls
, ob
, encoder
);
500 lto_output_uleb128_stream (ob
->main_stream
, 0);
502 /* Emit toplevel asms. */
503 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
505 int len
= TREE_STRING_LENGTH (can
->asm_str
);
506 lto_output_uleb128_stream (ob
->main_stream
, len
);
507 for (i
= 0; i
< len
; ++i
)
508 lto_output_1_stream (ob
->main_stream
,
509 TREE_STRING_POINTER (can
->asm_str
)[i
]);
512 lto_output_uleb128_stream (ob
->main_stream
, 0);
514 lto_destroy_simple_output_block (ob
);
517 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
518 STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
519 NODE or to replace the values in it, for instance because the first
520 time we saw it, the function body was not available but now it
521 is. BP is a bitpack with all the bitflags for NODE read from the
525 input_overwrite_node (struct lto_file_decl_data
*file_data
,
526 struct cgraph_node
*node
,
527 enum LTO_cgraph_tags tag
,
528 struct bitpack_d
*bp
,
529 unsigned int stack_size
,
530 unsigned int self_time
,
531 unsigned int time_inlining_benefit
,
532 unsigned int self_size
,
533 unsigned int size_inlining_benefit
)
535 node
->aux
= (void *) tag
;
536 node
->local
.inline_summary
.estimated_self_stack_size
= stack_size
;
537 node
->local
.inline_summary
.self_time
= self_time
;
538 node
->local
.inline_summary
.time_inlining_benefit
= time_inlining_benefit
;
539 node
->local
.inline_summary
.self_size
= self_size
;
540 node
->local
.inline_summary
.size_inlining_benefit
= size_inlining_benefit
;
541 node
->global
.time
= self_time
;
542 node
->global
.size
= self_size
;
543 node
->local
.lto_file_data
= file_data
;
545 node
->local
.local
= bp_unpack_value (bp
, 1);
546 node
->local
.externally_visible
= bp_unpack_value (bp
, 1);
547 node
->local
.finalized
= bp_unpack_value (bp
, 1);
548 node
->local
.inlinable
= bp_unpack_value (bp
, 1);
549 node
->local
.disregard_inline_limits
= bp_unpack_value (bp
, 1);
550 node
->local
.redefined_extern_inline
= bp_unpack_value (bp
, 1);
551 node
->local
.for_functions_valid
= bp_unpack_value (bp
, 1);
552 node
->local
.vtable_method
= bp_unpack_value (bp
, 1);
553 node
->needed
= bp_unpack_value (bp
, 1);
554 node
->address_taken
= bp_unpack_value (bp
, 1);
555 node
->abstract_and_needed
= bp_unpack_value (bp
, 1);
556 node
->reachable
= bp_unpack_value (bp
, 1);
557 node
->reachable_from_other_partition
= bp_unpack_value (bp
, 1);
558 node
->lowered
= bp_unpack_value (bp
, 1);
559 node
->analyzed
= bp_unpack_value (bp
, 1);
560 node
->in_other_partition
= bp_unpack_value (bp
, 1);
561 node
->process
= bp_unpack_value (bp
, 1);
562 node
->alias
= bp_unpack_value (bp
, 1);
563 node
->finalized_by_frontend
= bp_unpack_value (bp
, 1);
564 node
->frequency
= (enum node_frequency
)bp_unpack_value (bp
, 2);
568 /* Read a node from input_block IB. TAG is the node's tag just read.
569 Return the node read or overwriten. */
571 static struct cgraph_node
*
572 input_node (struct lto_file_decl_data
*file_data
,
573 struct lto_input_block
*ib
,
574 enum LTO_cgraph_tags tag
)
577 struct cgraph_node
*node
;
578 struct bitpack_d
*bp
;
582 int estimated_stack_size
= 0;
583 int stack_frame_offset
= 0;
584 int ref
= LCC_NOT_FOUND
, ref2
= LCC_NOT_FOUND
;
585 int estimated_growth
= 0;
590 int time_inlining_benefit
= 0;
591 int size_inlining_benefit
= 0;
592 unsigned long same_body_count
= 0;
593 bool inlined
= false;
595 clone_p
= (lto_input_uleb128 (ib
) != 0);
597 decl_index
= lto_input_uleb128 (ib
);
598 fn_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
601 node
= cgraph_clone_node (cgraph_node (fn_decl
), 0,
602 CGRAPH_FREQ_BASE
, 0, false, NULL
);
605 node
= cgraph_node (fn_decl
);
607 node
->count
= lto_input_sleb128 (ib
);
608 bp
= lto_input_bitpack (ib
);
610 if (tag
!= LTO_cgraph_unavail_node
)
612 stack_size
= lto_input_sleb128 (ib
);
613 self_size
= lto_input_sleb128 (ib
);
614 size_inlining_benefit
= lto_input_sleb128 (ib
);
615 self_time
= lto_input_sleb128 (ib
);
616 time_inlining_benefit
= lto_input_sleb128 (ib
);
619 estimated_stack_size
= lto_input_sleb128 (ib
);
620 stack_frame_offset
= lto_input_sleb128 (ib
);
621 ref
= lto_input_sleb128 (ib
);
622 time
= lto_input_sleb128 (ib
);
623 size
= lto_input_sleb128 (ib
);
624 estimated_growth
= lto_input_sleb128 (ib
);
625 inlined
= lto_input_uleb128 (ib
);
626 ref2
= lto_input_sleb128 (ib
);
627 same_body_count
= lto_input_uleb128 (ib
);
629 /* Make sure that we have not read this node before. Nodes that
630 have already been read will have their tag stored in the 'aux'
631 field. Since built-in functions can be referenced in multiple
632 functions, they are expected to be read more than once. */
633 if (node
->aux
&& !DECL_IS_BUILTIN (node
->decl
))
634 internal_error ("bytecode stream: found multiple instances of cgraph "
635 "node %d", node
->uid
);
637 input_overwrite_node (file_data
, node
, tag
, bp
, stack_size
, self_time
,
638 time_inlining_benefit
, self_size
,
639 size_inlining_benefit
);
642 node
->global
.estimated_stack_size
= estimated_stack_size
;
643 node
->global
.stack_frame_offset
= stack_frame_offset
;
644 node
->global
.time
= time
;
645 node
->global
.size
= size
;
647 /* Store a reference for now, and fix up later to be a pointer. */
648 node
->global
.inlined_to
= (cgraph_node_ptr
) (intptr_t) ref
;
650 node
->global
.estimated_growth
= estimated_growth
;
651 node
->global
.inlined
= inlined
;
653 /* Store a reference for now, and fix up later to be a pointer. */
654 node
->same_comdat_group
= (cgraph_node_ptr
) (intptr_t) ref2
;
656 while (same_body_count
-- > 0)
660 decl_index
= lto_input_uleb128 (ib
);
661 alias_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
662 type
= lto_input_uleb128 (ib
);
666 decl_index
= lto_input_uleb128 (ib
);
667 real_alias
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
668 cgraph_same_body_alias (alias_decl
, real_alias
);
672 HOST_WIDE_INT fixed_offset
= lto_input_uleb128 (ib
);
673 HOST_WIDE_INT virtual_value
= lto_input_uleb128 (ib
);
675 decl_index
= lto_input_uleb128 (ib
);
676 real_alias
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
677 cgraph_add_thunk (alias_decl
, fn_decl
, type
& 2, fixed_offset
,
679 (type
& 4) ? size_int (virtual_value
) : NULL_TREE
,
687 /* Read an edge from IB. NODES points to a vector of previously read nodes for
688 decoding caller and callee of the edge to be read. If INDIRECT is true, the
689 edge being read is indirect (in the sense that it has
690 indirect_unknown_callee set). */
693 input_edge (struct lto_input_block
*ib
, VEC(cgraph_node_ptr
, heap
) *nodes
,
696 struct cgraph_node
*caller
, *callee
;
697 struct cgraph_edge
*edge
;
698 unsigned int stmt_id
;
702 cgraph_inline_failed_t inline_failed
;
703 struct bitpack_d
*bp
;
704 enum ld_plugin_symbol_resolution caller_resolution
;
706 caller
= VEC_index (cgraph_node_ptr
, nodes
, lto_input_sleb128 (ib
));
707 if (caller
== NULL
|| caller
->decl
== NULL_TREE
)
708 internal_error ("bytecode stream: no caller found while reading edge");
712 callee
= VEC_index (cgraph_node_ptr
, nodes
, lto_input_sleb128 (ib
));
713 if (callee
== NULL
|| callee
->decl
== NULL_TREE
)
714 internal_error ("bytecode stream: no callee found while reading edge");
719 count
= (gcov_type
) lto_input_sleb128 (ib
);
721 bp
= lto_input_bitpack (ib
);
722 stmt_id
= (unsigned int) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
723 inline_failed
= (cgraph_inline_failed_t
) bp_unpack_value (bp
,
725 freq
= (int) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
726 nest
= (unsigned) bp_unpack_value (bp
, 30);
728 /* If the caller was preempted, don't create the edge.
729 ??? Should we ever have edges from a preempted caller? */
730 caller_resolution
= lto_symtab_get_resolution (caller
->decl
);
731 if (caller_resolution
== LDPR_PREEMPTED_REG
732 || caller_resolution
== LDPR_PREEMPTED_IR
)
736 edge
= cgraph_create_indirect_edge (caller
, NULL
, count
, freq
, nest
);
738 edge
= cgraph_create_edge (caller
, callee
, NULL
, count
, freq
, nest
);
740 edge
->indirect_inlining_edge
= bp_unpack_value (bp
, 1);
741 edge
->lto_stmt_uid
= stmt_id
;
742 edge
->inline_failed
= inline_failed
;
743 edge
->call_stmt_cannot_inline_p
= bp_unpack_value (bp
, 1);
744 edge
->can_throw_external
= bp_unpack_value (bp
, 1);
749 /* Read a cgraph from IB using the info in FILE_DATA. */
752 input_cgraph_1 (struct lto_file_decl_data
*file_data
,
753 struct lto_input_block
*ib
)
755 enum LTO_cgraph_tags tag
;
756 VEC(cgraph_node_ptr
, heap
) *nodes
= NULL
;
757 struct cgraph_node
*node
;
759 unsigned HOST_WIDE_INT len
;
761 tag
= (enum LTO_cgraph_tags
) lto_input_uleb128 (ib
);
764 if (tag
== LTO_cgraph_edge
)
765 input_edge (ib
, nodes
, false);
766 else if (tag
== LTO_cgraph_indirect_edge
)
767 input_edge (ib
, nodes
, true);
770 node
= input_node (file_data
, ib
, tag
);
771 if (node
== NULL
|| node
->decl
== NULL_TREE
)
772 internal_error ("bytecode stream: found empty cgraph node");
773 VEC_safe_push (cgraph_node_ptr
, heap
, nodes
, node
);
774 lto_cgraph_encoder_encode (file_data
->cgraph_node_encoder
, node
);
777 tag
= (enum LTO_cgraph_tags
) lto_input_uleb128 (ib
);
780 /* Input toplevel asms. */
781 len
= lto_input_uleb128 (ib
);
784 char *str
= (char *)xmalloc (len
+ 1);
785 for (i
= 0; i
< len
; ++i
)
786 str
[i
] = lto_input_1_unsigned (ib
);
787 cgraph_add_asm_node (build_string (len
, str
));
790 len
= lto_input_uleb128 (ib
);
793 for (i
= 0; VEC_iterate (cgraph_node_ptr
, nodes
, i
, node
); i
++)
795 int ref
= (int) (intptr_t) node
->global
.inlined_to
;
797 /* Fixup inlined_to from reference to pointer. */
798 if (ref
!= LCC_NOT_FOUND
)
799 node
->global
.inlined_to
= VEC_index (cgraph_node_ptr
, nodes
, ref
);
801 node
->global
.inlined_to
= NULL
;
803 ref
= (int) (intptr_t) node
->same_comdat_group
;
805 /* Fixup same_comdat_group from reference to pointer. */
806 if (ref
!= LCC_NOT_FOUND
)
807 node
->same_comdat_group
= VEC_index (cgraph_node_ptr
, nodes
, ref
);
809 node
->same_comdat_group
= NULL
;
812 VEC_free (cgraph_node_ptr
, heap
, nodes
);
815 static struct gcov_ctr_summary lto_gcov_summary
;
817 /* Input profile_info from IB. */
819 input_profile_summary (struct lto_input_block
*ib
)
821 unsigned int runs
= lto_input_uleb128 (ib
);
826 profile_info
= <o_gcov_summary
;
827 lto_gcov_summary
.runs
= runs
;
828 lto_gcov_summary
.sum_all
= lto_input_sleb128 (ib
);
829 lto_gcov_summary
.run_max
= lto_input_sleb128 (ib
);
830 lto_gcov_summary
.sum_max
= lto_input_sleb128 (ib
);
832 /* We can support this by scaling all counts to nearest common multiple
833 of all different runs, but it is perhaps not worth the effort. */
834 else if (profile_info
->runs
!= runs
835 || profile_info
->sum_all
!= lto_input_sleb128 (ib
)
836 || profile_info
->run_max
!= lto_input_sleb128 (ib
)
837 || profile_info
->sum_max
!= lto_input_sleb128 (ib
))
838 sorry ("Combining units with different profiles is not supported.");
839 /* We allow some units to have profile and other to not have one. This will
840 just make unprofiled units to be size optimized that is sane. */
845 /* Input and merge the cgraph from each of the .o files passed to
851 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
852 struct lto_file_decl_data
*file_data
;
854 struct cgraph_node
*node
;
856 while ((file_data
= file_data_vec
[j
++]))
860 struct lto_input_block
*ib
;
862 ib
= lto_create_simple_input_block (file_data
, LTO_section_cgraph
,
864 input_profile_summary (ib
);
865 file_data
->cgraph_node_encoder
= lto_cgraph_encoder_new ();
866 input_cgraph_1 (file_data
, ib
);
867 lto_destroy_simple_input_block (file_data
, LTO_section_cgraph
,
870 /* Assume that every file read needs to be processed by LTRANS. */
872 lto_mark_file_for_ltrans (file_data
);
875 /* Clear out the aux field that was used to store enough state to
876 tell which nodes should be overwritten. */
877 for (node
= cgraph_nodes
; node
; node
= node
->next
)
879 /* Some nodes may have been created by cgraph_node. This
880 happens when the callgraph contains nested functions. If the
881 node for the parent function was never emitted to the gimple
882 file, cgraph_node will create a node for it when setting the
883 context of the nested function. */
884 if (node
->local
.lto_file_data
)