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"
34 #include "langhooks.h"
35 #include "basic-block.h"
36 #include "tree-flow.h"
40 #include "diagnostic.h"
45 #include "pointer-set.h"
46 #include "lto-streamer.h"
49 /* Cgraph streaming is organized as set of record whose type
50 is indicated by a tag. */
53 /* Must leave 0 for the stopper. */
55 /* Cgraph node without body available. */
56 LTO_cgraph_unavail_node
= 1,
57 /* Cgraph node with function body. */
58 LTO_cgraph_analyzed_node
,
61 LTO_cgraph_indirect_edge
64 /* Create a new cgraph encoder. */
67 lto_cgraph_encoder_new (void)
69 lto_cgraph_encoder_t encoder
= XCNEW (struct lto_cgraph_encoder_d
);
70 encoder
->map
= pointer_map_create ();
71 encoder
->nodes
= NULL
;
76 /* Delete ENCODER and its components. */
79 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder
)
81 VEC_free (cgraph_node_ptr
, heap
, encoder
->nodes
);
82 pointer_map_destroy (encoder
->map
);
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
92 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder
,
93 struct cgraph_node
*node
)
98 slot
= pointer_map_contains (encoder
->map
, node
);
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
);
107 ref
= (int) (intptr_t) *slot
;
112 #define LCC_NOT_FOUND (-1)
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. */
118 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder
,
119 struct cgraph_node
*node
)
121 void **slot
= pointer_map_contains (encoder
->map
, node
);
122 return (slot
? (int) (intptr_t) *slot
: LCC_NOT_FOUND
);
126 /* Return the cgraph node corresponding to REF using ENCODER. */
129 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder
, int ref
)
131 if (ref
== LCC_NOT_FOUND
)
134 return VEC_index (cgraph_node_ptr
, encoder
->nodes
, ref
);
138 /* Return number of encoded nodes in ENCODER. */
141 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder
)
143 return VEC_length (cgraph_node_ptr
, encoder
->nodes
);
147 /* Output the cgraph EDGE to OB using ENCODER. */
150 lto_output_edge (struct lto_simple_output_block
*ob
, struct cgraph_edge
*edge
,
151 lto_cgraph_encoder_t encoder
)
155 struct bitpack_d
*bp
;
157 if (edge
->indirect_unknown_callee
)
158 lto_output_uleb128_stream (ob
->main_stream
, LTO_cgraph_indirect_edge
);
160 lto_output_uleb128_stream (ob
->main_stream
, LTO_cgraph_edge
);
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
);
166 if (!edge
->indirect_unknown_callee
)
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
);
173 lto_output_sleb128_stream (ob
->main_stream
, edge
->count
);
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
);
188 /* Return true when node is reachable from other partition. */
191 reachable_from_other_partition_p (struct cgraph_node
*node
, cgraph_node_set set
)
193 struct cgraph_edge
*e
;
198 if (node
->global
.inlined_to
)
200 for (e
= node
->callers
; e
; e
= e
->next_caller
)
201 if (!cgraph_node_in_set_p (e
->caller
, set
))
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. */
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
)
220 struct bitpack_d
*bp
;
221 bool boundary_p
, wrote_decl_p
;
223 bool in_other_partition
= false;
225 boundary_p
= !cgraph_node_in_set_p (node
, set
);
226 wrote_decl_p
= bitmap_bit_p (written_decls
, DECL_UID (node
->decl
));
228 if (node
->analyzed
&& !boundary_p
)
229 tag
= LTO_cgraph_analyzed_node
;
231 tag
= LTO_cgraph_unavail_node
;
233 lto_output_uleb128_stream (ob
->main_stream
, tag
);
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.
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.
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
)
247 /* Inline clones can not be part of boundary.
248 gcc_assert (!node->global.inlined_to);
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;
258 lto_output_uleb128_stream (ob
->main_stream
, wrote_decl_p
);
261 bitmap_set_bit (written_decls
, DECL_UID (node
->decl
));
263 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, node
->decl
);
264 lto_output_sleb128_stream (ob
->main_stream
, node
->count
);
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
);
287 if (tag
== LTO_cgraph_analyzed_node
)
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
)
301 ref
= lto_cgraph_encoder_lookup (encoder
, node
->global
.inlined_to
);
302 gcc_assert (ref
!= LCC_NOT_FOUND
);
307 lto_output_sleb128_stream (ob
->main_stream
, ref
);
310 if (node
->same_comdat_group
&& !boundary_p
)
312 ref
= lto_cgraph_encoder_lookup (encoder
, node
->same_comdat_group
);
313 gcc_assert (ref
!= LCC_NOT_FOUND
);
317 lto_output_sleb128_stream (ob
->main_stream
, ref
);
321 struct cgraph_node
*alias
;
322 unsigned long alias_count
= 1;
323 for (alias
= node
->same_body
; alias
->next
; alias
= alias
->next
)
325 lto_output_uleb128_stream (ob
->main_stream
, alias_count
);
328 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
330 if (alias
->thunk
.thunk_p
)
332 lto_output_uleb128_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
,
345 lto_output_uleb128_stream (ob
->main_stream
, 0);
346 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
349 alias
= alias
->previous
;
354 lto_output_uleb128_stream (ob
->main_stream
, 0);
357 /* Output the varpool NODE to OB.
358 If NODE is not in SET, then NODE is a boundary. */
361 lto_output_varpool_node (struct lto_simple_output_block
*ob
, struct varpool_node
*node
,
362 varpool_node_set set
)
364 bool boundary_p
= !varpool_node_in_set_p (node
, set
) && node
->analyzed
;
365 struct bitpack_d
*bp
;
366 struct varpool_node
*alias
;
369 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, node
->decl
);
370 bp
= bitpack_create ();
371 bp_pack_value (bp
, node
->externally_visible
, 1);
372 bp_pack_value (bp
, node
->force_output
, 1);
373 bp_pack_value (bp
, node
->finalized
, 1);
374 gcc_assert (node
->finalized
|| !node
->analyzed
);
375 gcc_assert (node
->needed
);
376 gcc_assert (!node
->alias
);
377 /* Constant pool initializers can be de-unified into individual ltrans units.
378 FIXME: Alternatively at -Os we may want to avoid generating for them the local
379 labels and share them across LTRANS partitions. */
380 if (DECL_IN_CONSTANT_POOL (node
->decl
))
382 bp_pack_value (bp
, 0, 1); /* used_from_other_parition. */
383 bp_pack_value (bp
, 0, 1); /* in_other_partition. */
387 /* FIXME: We have no idea how we move references around. For moment assume that
388 everything is used externally. */
389 bp_pack_value (bp
, flag_wpa
, 1); /* used_from_other_parition. */
390 bp_pack_value (bp
, boundary_p
, 1); /* in_other_partition. */
392 /* Also emit any extra name aliases. */
393 for (alias
= node
->extra_name
; alias
; alias
= alias
->next
)
395 bp_pack_value (bp
, count
!= 0, 1);
396 lto_output_bitpack (ob
->main_stream
, bp
);
401 lto_output_uleb128_stream (ob
->main_stream
, count
);
402 for (alias
= node
->extra_name
; alias
; alias
= alias
->next
)
403 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, alias
->decl
);
407 /* Stream out profile_summary to OB. */
410 output_profile_summary (struct lto_simple_output_block
*ob
)
414 /* We do not output num, it is not terribly useful. */
415 gcc_assert (profile_info
->runs
);
416 lto_output_uleb128_stream (ob
->main_stream
, profile_info
->runs
);
417 lto_output_sleb128_stream (ob
->main_stream
, profile_info
->sum_all
);
418 lto_output_sleb128_stream (ob
->main_stream
, profile_info
->run_max
);
419 lto_output_sleb128_stream (ob
->main_stream
, profile_info
->sum_max
);
422 lto_output_uleb128_stream (ob
->main_stream
, 0);
425 /* Add NODE into encoder as well as nodes it is cloned from.
426 Do it in a way so clones appear first. */
428 add_node_to (lto_cgraph_encoder_t encoder
, struct cgraph_node
*node
)
431 add_node_to (encoder
, node
->clone_of
);
432 lto_cgraph_encoder_encode (encoder
, node
);
435 /* Output all callees or indirect outgoing edges. EDGE must be the first such
439 output_outgoing_cgraph_edges (struct cgraph_edge
*edge
,
440 struct lto_simple_output_block
*ob
,
441 lto_cgraph_encoder_t encoder
)
446 /* Output edges in backward direction, so the reconstructed callgraph match
447 and it is easy to associate call sites in the IPA pass summaries. */
448 while (edge
->next_callee
)
449 edge
= edge
->next_callee
;
450 for (; edge
; edge
= edge
->prev_callee
)
451 lto_output_edge (ob
, edge
, encoder
);
454 /* Output the part of the cgraph in SET. */
457 output_cgraph (cgraph_node_set set
)
459 struct cgraph_node
*node
;
460 struct lto_simple_output_block
*ob
;
461 cgraph_node_set_iterator csi
;
462 struct cgraph_edge
*edge
;
464 bitmap written_decls
;
465 lto_cgraph_encoder_t encoder
;
466 struct cgraph_asm_node
*can
;
468 ob
= lto_create_simple_output_block (LTO_section_cgraph
);
470 output_profile_summary (ob
);
472 /* An encoder for cgraph nodes should have been created by
473 ipa_write_summaries_1. */
474 gcc_assert (ob
->decl_state
->cgraph_node_encoder
);
475 encoder
= ob
->decl_state
->cgraph_node_encoder
;
477 /* The FUNCTION_DECLs for which we have written a node. The first
478 node found is written as the "original" node, the remaining nodes
479 are considered its clones. */
480 written_decls
= lto_bitmap_alloc ();
482 /* Go over all the nodes in SET and assign references. */
483 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
485 node
= csi_node (csi
);
486 add_node_to (encoder
, node
);
489 /* Go over all the nodes again to include callees that are not in
491 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
493 node
= csi_node (csi
);
494 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
496 struct cgraph_node
*callee
= edge
->callee
;
497 if (!cgraph_node_in_set_p (callee
, set
))
499 /* We should have moved all the inlines. */
500 gcc_assert (!callee
->global
.inlined_to
);
501 add_node_to (encoder
, callee
);
506 /* Write out the nodes. We must first output a node and then its clones,
507 otherwise at a time reading back the node there would be nothing to clone
509 n_nodes
= lto_cgraph_encoder_size (encoder
);
510 for (i
= 0; i
< n_nodes
; i
++)
512 node
= lto_cgraph_encoder_deref (encoder
, i
);
513 lto_output_node (ob
, node
, encoder
, set
, written_decls
);
516 lto_bitmap_free (written_decls
);
518 /* Go over the nodes in SET again to write edges. */
519 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
521 node
= csi_node (csi
);
522 output_outgoing_cgraph_edges (node
->callees
, ob
, encoder
);
523 output_outgoing_cgraph_edges (node
->indirect_calls
, ob
, encoder
);
526 lto_output_uleb128_stream (ob
->main_stream
, 0);
528 /* Emit toplevel asms. */
529 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
531 int len
= TREE_STRING_LENGTH (can
->asm_str
);
532 lto_output_uleb128_stream (ob
->main_stream
, len
);
533 for (i
= 0; i
< len
; ++i
)
534 lto_output_1_stream (ob
->main_stream
,
535 TREE_STRING_POINTER (can
->asm_str
)[i
]);
538 lto_output_uleb128_stream (ob
->main_stream
, 0);
540 lto_destroy_simple_output_block (ob
);
543 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
544 STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
545 NODE or to replace the values in it, for instance because the first
546 time we saw it, the function body was not available but now it
547 is. BP is a bitpack with all the bitflags for NODE read from the
551 input_overwrite_node (struct lto_file_decl_data
*file_data
,
552 struct cgraph_node
*node
,
553 enum LTO_cgraph_tags tag
,
554 struct bitpack_d
*bp
,
555 unsigned int stack_size
,
556 unsigned int self_time
,
557 unsigned int time_inlining_benefit
,
558 unsigned int self_size
,
559 unsigned int size_inlining_benefit
)
561 node
->aux
= (void *) tag
;
562 node
->local
.inline_summary
.estimated_self_stack_size
= stack_size
;
563 node
->local
.inline_summary
.self_time
= self_time
;
564 node
->local
.inline_summary
.time_inlining_benefit
= time_inlining_benefit
;
565 node
->local
.inline_summary
.self_size
= self_size
;
566 node
->local
.inline_summary
.size_inlining_benefit
= size_inlining_benefit
;
567 node
->global
.time
= self_time
;
568 node
->global
.size
= self_size
;
569 node
->global
.estimated_stack_size
= stack_size
;
570 node
->global
.estimated_growth
= INT_MIN
;
571 node
->local
.lto_file_data
= file_data
;
573 node
->local
.local
= bp_unpack_value (bp
, 1);
574 node
->local
.externally_visible
= bp_unpack_value (bp
, 1);
575 node
->local
.finalized
= bp_unpack_value (bp
, 1);
576 node
->local
.inlinable
= bp_unpack_value (bp
, 1);
577 node
->local
.disregard_inline_limits
= bp_unpack_value (bp
, 1);
578 node
->local
.redefined_extern_inline
= bp_unpack_value (bp
, 1);
579 node
->local
.vtable_method
= bp_unpack_value (bp
, 1);
580 node
->needed
= bp_unpack_value (bp
, 1);
581 node
->address_taken
= bp_unpack_value (bp
, 1);
582 node
->abstract_and_needed
= bp_unpack_value (bp
, 1);
583 node
->reachable_from_other_partition
= bp_unpack_value (bp
, 1);
584 node
->lowered
= bp_unpack_value (bp
, 1);
585 node
->analyzed
= tag
== LTO_cgraph_analyzed_node
;
586 node
->in_other_partition
= bp_unpack_value (bp
, 1);
587 node
->alias
= bp_unpack_value (bp
, 1);
588 node
->finalized_by_frontend
= bp_unpack_value (bp
, 1);
589 node
->frequency
= (enum node_frequency
)bp_unpack_value (bp
, 2);
592 /* Output the part of the cgraph in SET. */
595 output_varpool (varpool_node_set set
)
597 struct varpool_node
*node
;
598 struct lto_simple_output_block
*ob
;
601 ob
= lto_create_simple_output_block (LTO_section_varpool
);
603 for (node
= varpool_nodes
; node
; node
= node
->next
)
604 if (node
->needed
&& node
->analyzed
)
607 lto_output_uleb128_stream (ob
->main_stream
, len
);
609 /* Write out the nodes. We must first output a node and then its clones,
610 otherwise at a time reading back the node there would be nothing to clone
612 for (node
= varpool_nodes
; node
; node
= node
->next
)
613 if (node
->needed
&& node
->analyzed
)
614 lto_output_varpool_node (ob
, node
, set
);
616 lto_destroy_simple_output_block (ob
);
619 /* Read a node from input_block IB. TAG is the node's tag just read.
620 Return the node read or overwriten. */
622 static struct cgraph_node
*
623 input_node (struct lto_file_decl_data
*file_data
,
624 struct lto_input_block
*ib
,
625 enum LTO_cgraph_tags tag
)
628 struct cgraph_node
*node
;
629 struct bitpack_d
*bp
;
633 int ref
= LCC_NOT_FOUND
, ref2
= LCC_NOT_FOUND
;
636 int time_inlining_benefit
= 0;
637 int size_inlining_benefit
= 0;
638 unsigned long same_body_count
= 0;
640 clone_p
= (lto_input_uleb128 (ib
) != 0);
642 decl_index
= lto_input_uleb128 (ib
);
643 fn_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
646 node
= cgraph_clone_node (cgraph_node (fn_decl
), 0,
647 CGRAPH_FREQ_BASE
, 0, false, NULL
);
650 node
= cgraph_node (fn_decl
);
652 node
->count
= lto_input_sleb128 (ib
);
653 bp
= lto_input_bitpack (ib
);
655 if (tag
== LTO_cgraph_analyzed_node
)
657 stack_size
= lto_input_sleb128 (ib
);
658 self_size
= lto_input_sleb128 (ib
);
659 size_inlining_benefit
= lto_input_sleb128 (ib
);
660 self_time
= lto_input_sleb128 (ib
);
661 time_inlining_benefit
= lto_input_sleb128 (ib
);
663 ref
= lto_input_sleb128 (ib
);
666 ref2
= lto_input_sleb128 (ib
);
667 same_body_count
= lto_input_uleb128 (ib
);
669 /* Make sure that we have not read this node before. Nodes that
670 have already been read will have their tag stored in the 'aux'
671 field. Since built-in functions can be referenced in multiple
672 functions, they are expected to be read more than once. */
673 if (node
->aux
&& !DECL_IS_BUILTIN (node
->decl
))
674 internal_error ("bytecode stream: found multiple instances of cgraph "
675 "node %d", node
->uid
);
677 input_overwrite_node (file_data
, node
, tag
, bp
, stack_size
, self_time
,
678 time_inlining_benefit
, self_size
,
679 size_inlining_benefit
);
682 /* Store a reference for now, and fix up later to be a pointer. */
683 node
->global
.inlined_to
= (cgraph_node_ptr
) (intptr_t) ref
;
685 /* Store a reference for now, and fix up later to be a pointer. */
686 node
->same_comdat_group
= (cgraph_node_ptr
) (intptr_t) ref2
;
688 while (same_body_count
-- > 0)
692 decl_index
= lto_input_uleb128 (ib
);
693 alias_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
694 type
= lto_input_uleb128 (ib
);
698 decl_index
= lto_input_uleb128 (ib
);
699 real_alias
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
700 cgraph_same_body_alias (alias_decl
, real_alias
);
704 HOST_WIDE_INT fixed_offset
= lto_input_uleb128 (ib
);
705 HOST_WIDE_INT virtual_value
= lto_input_uleb128 (ib
);
707 decl_index
= lto_input_uleb128 (ib
);
708 real_alias
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
709 cgraph_add_thunk (alias_decl
, fn_decl
, type
& 2, fixed_offset
,
711 (type
& 4) ? size_int (virtual_value
) : NULL_TREE
,
718 /* Read a node from input_block IB. TAG is the node's tag just read.
719 Return the node read or overwriten. */
721 static struct varpool_node
*
722 input_varpool_node (struct lto_file_decl_data
*file_data
,
723 struct lto_input_block
*ib
)
727 struct varpool_node
*node
;
728 struct bitpack_d
*bp
;
732 decl_index
= lto_input_uleb128 (ib
);
733 var_decl
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
734 node
= varpool_node (var_decl
);
736 bp
= lto_input_bitpack (ib
);
737 node
->externally_visible
= bp_unpack_value (bp
, 1);
738 node
->force_output
= bp_unpack_value (bp
, 1);
739 node
->finalized
= bp_unpack_value (bp
, 1);
741 node
->used_from_other_partition
= bp_unpack_value (bp
, 1);
742 node
->in_other_partition
= bp_unpack_value (bp
, 1);
743 aliases_p
= bp_unpack_value (bp
, 1);
745 varpool_mark_needed_node (node
);
749 count
= lto_input_uleb128 (ib
);
750 for (; count
> 0; count
--)
752 tree decl
= lto_file_decl_data_get_var_decl (file_data
,
753 lto_input_uleb128 (ib
));
754 varpool_extra_name_alias (decl
, var_decl
);
761 /* Read an edge from IB. NODES points to a vector of previously read nodes for
762 decoding caller and callee of the edge to be read. If INDIRECT is true, the
763 edge being read is indirect (in the sense that it has
764 indirect_unknown_callee set). */
767 input_edge (struct lto_input_block
*ib
, VEC(cgraph_node_ptr
, heap
) *nodes
,
770 struct cgraph_node
*caller
, *callee
;
771 struct cgraph_edge
*edge
;
772 unsigned int stmt_id
;
776 cgraph_inline_failed_t inline_failed
;
777 struct bitpack_d
*bp
;
778 enum ld_plugin_symbol_resolution caller_resolution
;
780 caller
= VEC_index (cgraph_node_ptr
, nodes
, lto_input_sleb128 (ib
));
781 if (caller
== NULL
|| caller
->decl
== NULL_TREE
)
782 internal_error ("bytecode stream: no caller found while reading edge");
786 callee
= VEC_index (cgraph_node_ptr
, nodes
, lto_input_sleb128 (ib
));
787 if (callee
== NULL
|| callee
->decl
== NULL_TREE
)
788 internal_error ("bytecode stream: no callee found while reading edge");
793 count
= (gcov_type
) lto_input_sleb128 (ib
);
795 bp
= lto_input_bitpack (ib
);
796 stmt_id
= (unsigned int) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
797 inline_failed
= (cgraph_inline_failed_t
) bp_unpack_value (bp
,
799 freq
= (int) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
800 nest
= (unsigned) bp_unpack_value (bp
, 30);
802 /* If the caller was preempted, don't create the edge.
803 ??? Should we ever have edges from a preempted caller? */
804 caller_resolution
= lto_symtab_get_resolution (caller
->decl
);
805 if (caller_resolution
== LDPR_PREEMPTED_REG
806 || caller_resolution
== LDPR_PREEMPTED_IR
)
810 edge
= cgraph_create_indirect_edge (caller
, NULL
, count
, freq
, nest
);
812 edge
= cgraph_create_edge (caller
, callee
, NULL
, count
, freq
, nest
);
814 edge
->indirect_inlining_edge
= bp_unpack_value (bp
, 1);
815 edge
->lto_stmt_uid
= stmt_id
;
816 edge
->inline_failed
= inline_failed
;
817 edge
->call_stmt_cannot_inline_p
= bp_unpack_value (bp
, 1);
818 edge
->can_throw_external
= bp_unpack_value (bp
, 1);
823 /* Read a cgraph from IB using the info in FILE_DATA. */
826 input_cgraph_1 (struct lto_file_decl_data
*file_data
,
827 struct lto_input_block
*ib
)
829 enum LTO_cgraph_tags tag
;
830 VEC(cgraph_node_ptr
, heap
) *nodes
= NULL
;
831 struct cgraph_node
*node
;
833 unsigned HOST_WIDE_INT len
;
835 tag
= (enum LTO_cgraph_tags
) lto_input_uleb128 (ib
);
838 if (tag
== LTO_cgraph_edge
)
839 input_edge (ib
, nodes
, false);
840 else if (tag
== LTO_cgraph_indirect_edge
)
841 input_edge (ib
, nodes
, true);
844 node
= input_node (file_data
, ib
, tag
);
845 if (node
== NULL
|| node
->decl
== NULL_TREE
)
846 internal_error ("bytecode stream: found empty cgraph node");
847 VEC_safe_push (cgraph_node_ptr
, heap
, nodes
, node
);
848 lto_cgraph_encoder_encode (file_data
->cgraph_node_encoder
, node
);
851 tag
= (enum LTO_cgraph_tags
) lto_input_uleb128 (ib
);
854 /* Input toplevel asms. */
855 len
= lto_input_uleb128 (ib
);
858 char *str
= (char *)xmalloc (len
+ 1);
859 for (i
= 0; i
< len
; ++i
)
860 str
[i
] = lto_input_1_unsigned (ib
);
861 cgraph_add_asm_node (build_string (len
, str
));
864 len
= lto_input_uleb128 (ib
);
867 for (i
= 0; VEC_iterate (cgraph_node_ptr
, nodes
, i
, node
); i
++)
869 int ref
= (int) (intptr_t) node
->global
.inlined_to
;
871 /* Fixup inlined_to from reference to pointer. */
872 if (ref
!= LCC_NOT_FOUND
)
873 node
->global
.inlined_to
= VEC_index (cgraph_node_ptr
, nodes
, ref
);
875 node
->global
.inlined_to
= NULL
;
877 ref
= (int) (intptr_t) node
->same_comdat_group
;
879 /* Fixup same_comdat_group from reference to pointer. */
880 if (ref
!= LCC_NOT_FOUND
)
881 node
->same_comdat_group
= VEC_index (cgraph_node_ptr
, nodes
, ref
);
883 node
->same_comdat_group
= NULL
;
886 VEC_free (cgraph_node_ptr
, heap
, nodes
);
889 /* Read a varpool from IB using the info in FILE_DATA. */
892 input_varpool_1 (struct lto_file_decl_data
*file_data
,
893 struct lto_input_block
*ib
)
895 unsigned HOST_WIDE_INT len
;
897 len
= lto_input_uleb128 (ib
);
900 input_varpool_node (file_data
, ib
);
905 static struct gcov_ctr_summary lto_gcov_summary
;
907 /* Input profile_info from IB. */
909 input_profile_summary (struct lto_input_block
*ib
)
911 unsigned int runs
= lto_input_uleb128 (ib
);
916 profile_info
= <o_gcov_summary
;
917 lto_gcov_summary
.runs
= runs
;
918 lto_gcov_summary
.sum_all
= lto_input_sleb128 (ib
);
919 lto_gcov_summary
.run_max
= lto_input_sleb128 (ib
);
920 lto_gcov_summary
.sum_max
= lto_input_sleb128 (ib
);
922 /* We can support this by scaling all counts to nearest common multiple
923 of all different runs, but it is perhaps not worth the effort. */
924 else if (profile_info
->runs
!= runs
925 || profile_info
->sum_all
!= lto_input_sleb128 (ib
)
926 || profile_info
->run_max
!= lto_input_sleb128 (ib
)
927 || profile_info
->sum_max
!= lto_input_sleb128 (ib
))
928 sorry ("Combining units with different profiles is not supported.");
929 /* We allow some units to have profile and other to not have one. This will
930 just make unprofiled units to be size optimized that is sane. */
935 /* Input and merge the cgraph from each of the .o files passed to
941 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
942 struct lto_file_decl_data
*file_data
;
944 struct cgraph_node
*node
;
946 while ((file_data
= file_data_vec
[j
++]))
950 struct lto_input_block
*ib
;
952 ib
= lto_create_simple_input_block (file_data
, LTO_section_cgraph
,
954 input_profile_summary (ib
);
955 file_data
->cgraph_node_encoder
= lto_cgraph_encoder_new ();
956 input_cgraph_1 (file_data
, ib
);
957 lto_destroy_simple_input_block (file_data
, LTO_section_cgraph
,
960 ib
= lto_create_simple_input_block (file_data
, LTO_section_varpool
,
962 input_varpool_1 (file_data
, ib
);
963 lto_destroy_simple_input_block (file_data
, LTO_section_varpool
,
966 /* Assume that every file read needs to be processed by LTRANS. */
968 lto_mark_file_for_ltrans (file_data
);
971 /* Clear out the aux field that was used to store enough state to
972 tell which nodes should be overwritten. */
973 for (node
= cgraph_nodes
; node
; node
= node
->next
)
975 /* Some nodes may have been created by cgraph_node. This
976 happens when the callgraph contains nested functions. If the
977 node for the parent function was never emitted to the gimple
978 file, cgraph_node will create a node for it when setting the
979 context of the nested function. */
980 if (node
->local
.lto_file_data
)