1 /* Write and read the cgraph to the memory mapped representation of a
4 Copyright 2009, 2010, 2011 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"
33 #include "langhooks.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
39 #include "diagnostic-core.h"
44 #include "pointer-set.h"
45 #include "lto-streamer.h"
46 #include "data-streamer.h"
47 #include "tree-streamer.h"
50 static void output_varpool (cgraph_node_set
, varpool_node_set
);
51 static void output_cgraph_opt_summary (cgraph_node_set set
);
52 static void input_cgraph_opt_summary (VEC (cgraph_node_ptr
, heap
) * nodes
);
54 /* Number of LDPR values known to GCC. */
55 #define LDPR_NUM_KNOWN (LDPR_RESOLVED_DYN + 1)
57 /* Cgraph streaming is organized as set of record whose type
58 is indicated by a tag. */
61 /* Must leave 0 for the stopper. */
63 /* Cgraph node without body available. */
64 LTO_cgraph_unavail_node
= 1,
65 /* Cgraph node with function body. */
66 LTO_cgraph_analyzed_node
,
69 LTO_cgraph_indirect_edge
,
73 /* Create a new cgraph encoder. */
76 lto_cgraph_encoder_new (void)
78 lto_cgraph_encoder_t encoder
= XCNEW (struct lto_cgraph_encoder_d
);
79 encoder
->map
= pointer_map_create ();
80 encoder
->nodes
= NULL
;
81 encoder
->body
= pointer_set_create ();
86 /* Delete ENCODER and its components. */
89 lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder
)
91 VEC_free (cgraph_node_ptr
, heap
, encoder
->nodes
);
92 pointer_map_destroy (encoder
->map
);
93 pointer_set_destroy (encoder
->body
);
98 /* Return the existing reference number of NODE in the cgraph encoder in
99 output block OB. Assign a new reference if this is the first time
103 lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder
,
104 struct cgraph_node
*node
)
109 slot
= pointer_map_contains (encoder
->map
, node
);
112 ref
= VEC_length (cgraph_node_ptr
, encoder
->nodes
);
113 slot
= pointer_map_insert (encoder
->map
, node
);
114 *slot
= (void *) (intptr_t) ref
;
115 VEC_safe_push (cgraph_node_ptr
, heap
, encoder
->nodes
, node
);
118 ref
= (int) (intptr_t) *slot
;
123 #define LCC_NOT_FOUND (-1)
125 /* Look up NODE in encoder. Return NODE's reference if it has been encoded
126 or LCC_NOT_FOUND if it is not there. */
129 lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder
,
130 struct cgraph_node
*node
)
132 void **slot
= pointer_map_contains (encoder
->map
, node
);
133 return (slot
? (int) (intptr_t) *slot
: LCC_NOT_FOUND
);
137 /* Return the cgraph node corresponding to REF using ENCODER. */
140 lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder
, int ref
)
142 if (ref
== LCC_NOT_FOUND
)
145 return VEC_index (cgraph_node_ptr
, encoder
->nodes
, ref
);
149 /* Return TRUE if we should encode initializer of NODE (if any). */
152 lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t encoder
,
153 struct cgraph_node
*node
)
155 return pointer_set_contains (encoder
->body
, node
);
158 /* Return TRUE if we should encode body of NODE (if any). */
161 lto_set_cgraph_encoder_encode_body (lto_cgraph_encoder_t encoder
,
162 struct cgraph_node
*node
)
164 pointer_set_insert (encoder
->body
, node
);
167 /* Create a new varpool encoder. */
169 lto_varpool_encoder_t
170 lto_varpool_encoder_new (void)
172 lto_varpool_encoder_t encoder
= XCNEW (struct lto_varpool_encoder_d
);
173 encoder
->map
= pointer_map_create ();
174 encoder
->initializer
= pointer_set_create ();
175 encoder
->nodes
= NULL
;
180 /* Delete ENCODER and its components. */
183 lto_varpool_encoder_delete (lto_varpool_encoder_t encoder
)
185 VEC_free (varpool_node_ptr
, heap
, encoder
->nodes
);
186 pointer_map_destroy (encoder
->map
);
187 pointer_set_destroy (encoder
->initializer
);
192 /* Return the existing reference number of NODE in the varpool encoder in
193 output block OB. Assign a new reference if this is the first time
197 lto_varpool_encoder_encode (lto_varpool_encoder_t encoder
,
198 struct varpool_node
*node
)
203 slot
= pointer_map_contains (encoder
->map
, node
);
206 ref
= VEC_length (varpool_node_ptr
, encoder
->nodes
);
207 slot
= pointer_map_insert (encoder
->map
, node
);
208 *slot
= (void *) (intptr_t) ref
;
209 VEC_safe_push (varpool_node_ptr
, heap
, encoder
->nodes
, node
);
212 ref
= (int) (intptr_t) *slot
;
217 /* Look up NODE in encoder. Return NODE's reference if it has been encoded
218 or LCC_NOT_FOUND if it is not there. */
221 lto_varpool_encoder_lookup (lto_varpool_encoder_t encoder
,
222 struct varpool_node
*node
)
224 void **slot
= pointer_map_contains (encoder
->map
, node
);
225 return (slot
? (int) (intptr_t) *slot
: LCC_NOT_FOUND
);
229 /* Return the varpool node corresponding to REF using ENCODER. */
231 struct varpool_node
*
232 lto_varpool_encoder_deref (lto_varpool_encoder_t encoder
, int ref
)
234 if (ref
== LCC_NOT_FOUND
)
237 return VEC_index (varpool_node_ptr
, encoder
->nodes
, ref
);
241 /* Return TRUE if we should encode initializer of NODE (if any). */
244 lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t encoder
,
245 struct varpool_node
*node
)
247 return pointer_set_contains (encoder
->initializer
, node
);
250 /* Return TRUE if we should encode initializer of NODE (if any). */
253 lto_set_varpool_encoder_encode_initializer (lto_varpool_encoder_t encoder
,
254 struct varpool_node
*node
)
256 pointer_set_insert (encoder
->initializer
, node
);
259 /* Output the cgraph EDGE to OB using ENCODER. */
262 lto_output_edge (struct lto_simple_output_block
*ob
, struct cgraph_edge
*edge
,
263 lto_cgraph_encoder_t encoder
)
269 if (edge
->indirect_unknown_callee
)
270 lto_output_enum (ob
->main_stream
, LTO_cgraph_tags
, LTO_cgraph_last_tag
,
271 LTO_cgraph_indirect_edge
);
273 lto_output_enum (ob
->main_stream
, LTO_cgraph_tags
, LTO_cgraph_last_tag
,
276 ref
= lto_cgraph_encoder_lookup (encoder
, edge
->caller
);
277 gcc_assert (ref
!= LCC_NOT_FOUND
);
278 lto_output_sleb128_stream (ob
->main_stream
, ref
);
280 if (!edge
->indirect_unknown_callee
)
282 ref
= lto_cgraph_encoder_lookup (encoder
, edge
->callee
);
283 gcc_assert (ref
!= LCC_NOT_FOUND
);
284 lto_output_sleb128_stream (ob
->main_stream
, ref
);
287 lto_output_sleb128_stream (ob
->main_stream
, edge
->count
);
289 bp
= bitpack_create (ob
->main_stream
);
290 uid
= (!gimple_has_body_p (edge
->caller
->decl
)
291 ? edge
->lto_stmt_uid
: gimple_uid (edge
->call_stmt
));
292 bp_pack_enum (&bp
, cgraph_inline_failed_enum
,
293 CIF_N_REASONS
, edge
->inline_failed
);
294 bp_pack_var_len_unsigned (&bp
, uid
);
295 bp_pack_var_len_unsigned (&bp
, edge
->frequency
);
296 bp_pack_value (&bp
, edge
->indirect_inlining_edge
, 1);
297 bp_pack_value (&bp
, edge
->call_stmt_cannot_inline_p
, 1);
298 bp_pack_value (&bp
, edge
->can_throw_external
, 1);
299 if (edge
->indirect_unknown_callee
)
301 int flags
= edge
->indirect_info
->ecf_flags
;
302 bp_pack_value (&bp
, (flags
& ECF_CONST
) != 0, 1);
303 bp_pack_value (&bp
, (flags
& ECF_PURE
) != 0, 1);
304 bp_pack_value (&bp
, (flags
& ECF_NORETURN
) != 0, 1);
305 bp_pack_value (&bp
, (flags
& ECF_MALLOC
) != 0, 1);
306 bp_pack_value (&bp
, (flags
& ECF_NOTHROW
) != 0, 1);
307 bp_pack_value (&bp
, (flags
& ECF_RETURNS_TWICE
) != 0, 1);
308 /* Flags that should not appear on indirect calls. */
309 gcc_assert (!(flags
& (ECF_LOOPING_CONST_OR_PURE
315 lto_output_bitpack (&bp
);
318 /* Return if LIST contain references from other partitions. */
321 referenced_from_other_partition_p (struct ipa_ref_list
*list
, cgraph_node_set set
,
322 varpool_node_set vset
)
326 for (i
= 0; ipa_ref_list_refering_iterate (list
, i
, ref
); i
++)
328 if (ref
->refering_type
== IPA_REF_CGRAPH
)
330 if (ipa_ref_refering_node (ref
)->in_other_partition
331 || !cgraph_node_in_set_p (ipa_ref_refering_node (ref
), set
))
336 if (ipa_ref_refering_varpool_node (ref
)->in_other_partition
337 || !varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref
),
345 /* Return true when node is reachable from other partition. */
348 reachable_from_other_partition_p (struct cgraph_node
*node
, cgraph_node_set set
)
350 struct cgraph_edge
*e
;
353 if (node
->global
.inlined_to
)
355 for (e
= node
->callers
; e
; e
= e
->next_caller
)
356 if (e
->caller
->in_other_partition
357 || !cgraph_node_in_set_p (e
->caller
, set
))
362 /* Return if LIST contain references from other partitions. */
365 referenced_from_this_partition_p (struct ipa_ref_list
*list
, cgraph_node_set set
,
366 varpool_node_set vset
)
370 for (i
= 0; ipa_ref_list_refering_iterate (list
, i
, ref
); i
++)
372 if (ref
->refering_type
== IPA_REF_CGRAPH
)
374 if (cgraph_node_in_set_p (ipa_ref_refering_node (ref
), set
))
379 if (varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref
),
387 /* Return true when node is reachable from other partition. */
390 reachable_from_this_partition_p (struct cgraph_node
*node
, cgraph_node_set set
)
392 struct cgraph_edge
*e
;
393 for (e
= node
->callers
; e
; e
= e
->next_caller
)
394 if (cgraph_node_in_set_p (e
->caller
, set
))
399 /* Output the cgraph NODE to OB. ENCODER is used to find the
400 reference number of NODE->inlined_to. SET is the set of nodes we
401 are writing to the current file. If NODE is not in SET, then NODE
402 is a boundary of a cgraph_node_set and we pretend NODE just has a
403 decl and no callees. WRITTEN_DECLS is the set of FUNCTION_DECLs
404 that have had their callgraph node written so far. This is used to
405 determine if NODE is a clone of a previously written node. */
408 lto_output_node (struct lto_simple_output_block
*ob
, struct cgraph_node
*node
,
409 lto_cgraph_encoder_t encoder
, cgraph_node_set set
,
410 varpool_node_set vset
)
416 bool in_other_partition
= false;
417 struct cgraph_node
*clone_of
;
419 boundary_p
= !cgraph_node_in_set_p (node
, set
);
421 if (node
->analyzed
&& !boundary_p
)
422 tag
= LTO_cgraph_analyzed_node
;
424 tag
= LTO_cgraph_unavail_node
;
426 lto_output_enum (ob
->main_stream
, LTO_cgraph_tags
, LTO_cgraph_last_tag
, tag
);
428 /* In WPA mode, we only output part of the call-graph. Also, we
429 fake cgraph node attributes. There are two cases that we care.
431 Boundary nodes: There are nodes that are not part of SET but are
432 called from within SET. We artificially make them look like
433 externally visible nodes with no function body.
435 Cherry-picked nodes: These are nodes we pulled from other
436 translation units into SET during IPA-inlining. We make them as
437 local static nodes to prevent clashes with other local statics. */
438 if (boundary_p
&& node
->analyzed
)
440 /* Inline clones can not be part of boundary.
441 gcc_assert (!node->global.inlined_to);
443 FIXME: At the moment they can be, when partition contains an inline
444 clone that is clone of inline clone from outside partition. We can
445 reshape the clone tree and make other tree to be the root, but it
446 needs a bit extra work and will be promplty done by cgraph_remove_node
447 after reading back. */
448 in_other_partition
= 1;
451 clone_of
= node
->clone_of
;
453 && (ref
= lto_cgraph_encoder_lookup (encoder
, clone_of
)) == LCC_NOT_FOUND
)
454 if (clone_of
->prev_sibling_clone
)
455 clone_of
= clone_of
->prev_sibling_clone
;
457 clone_of
= clone_of
->clone_of
;
459 if (LTO_cgraph_analyzed_node
)
460 gcc_assert (clone_of
|| !node
->clone_of
);
462 lto_output_sleb128_stream (ob
->main_stream
, LCC_NOT_FOUND
);
464 lto_output_sleb128_stream (ob
->main_stream
, ref
);
467 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, node
->decl
);
468 lto_output_sleb128_stream (ob
->main_stream
, node
->count
);
469 lto_output_sleb128_stream (ob
->main_stream
, node
->count_materialization_scale
);
471 if (tag
== LTO_cgraph_analyzed_node
)
473 if (node
->global
.inlined_to
)
475 ref
= lto_cgraph_encoder_lookup (encoder
, node
->global
.inlined_to
);
476 gcc_assert (ref
!= LCC_NOT_FOUND
);
481 lto_output_sleb128_stream (ob
->main_stream
, ref
);
484 if (node
->same_comdat_group
&& !boundary_p
)
486 ref
= lto_cgraph_encoder_lookup (encoder
, node
->same_comdat_group
);
487 gcc_assert (ref
!= LCC_NOT_FOUND
);
491 lto_output_sleb128_stream (ob
->main_stream
, ref
);
493 bp
= bitpack_create (ob
->main_stream
);
494 bp_pack_value (&bp
, node
->local
.local
, 1);
495 bp_pack_value (&bp
, node
->local
.externally_visible
, 1);
496 bp_pack_value (&bp
, node
->local
.finalized
, 1);
497 bp_pack_value (&bp
, node
->local
.can_change_signature
, 1);
498 bp_pack_value (&bp
, node
->local
.redefined_extern_inline
, 1);
499 bp_pack_value (&bp
, node
->needed
, 1);
500 bp_pack_value (&bp
, node
->address_taken
, 1);
501 bp_pack_value (&bp
, node
->abstract_and_needed
, 1);
502 bp_pack_value (&bp
, tag
== LTO_cgraph_analyzed_node
503 && !DECL_EXTERNAL (node
->decl
)
504 && !DECL_COMDAT (node
->decl
)
505 && (reachable_from_other_partition_p (node
, set
)
506 || referenced_from_other_partition_p (&node
->ref_list
, set
, vset
)), 1);
507 bp_pack_value (&bp
, node
->lowered
, 1);
508 bp_pack_value (&bp
, in_other_partition
, 1);
509 bp_pack_value (&bp
, node
->alias
&& !boundary_p
, 1);
510 bp_pack_value (&bp
, node
->frequency
, 2);
511 bp_pack_value (&bp
, node
->only_called_at_startup
, 1);
512 bp_pack_value (&bp
, node
->only_called_at_exit
, 1);
513 bp_pack_value (&bp
, node
->thunk
.thunk_p
&& !boundary_p
, 1);
514 bp_pack_enum (&bp
, ld_plugin_symbol_resolution
,
515 LDPR_NUM_KNOWN
, node
->resolution
);
516 lto_output_bitpack (&bp
);
518 if (node
->thunk
.thunk_p
&& !boundary_p
)
520 lto_output_uleb128_stream
522 1 + (node
->thunk
.this_adjusting
!= 0) * 2
523 + (node
->thunk
.virtual_offset_p
!= 0) * 4);
524 lto_output_uleb128_stream (ob
->main_stream
,
525 node
->thunk
.fixed_offset
);
526 lto_output_uleb128_stream (ob
->main_stream
,
527 node
->thunk
.virtual_value
);
529 if ((node
->alias
|| node
->thunk
.thunk_p
) && !boundary_p
)
531 lto_output_int_in_range (ob
->main_stream
, 0, 1,
532 node
->thunk
.alias
!= NULL
);
533 if (node
->thunk
.alias
!= NULL
)
534 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
539 /* Output the varpool NODE to OB.
540 If NODE is not in SET, then NODE is a boundary. */
543 lto_output_varpool_node (struct lto_simple_output_block
*ob
, struct varpool_node
*node
,
544 lto_varpool_encoder_t varpool_encoder
,
545 cgraph_node_set set
, varpool_node_set vset
)
547 bool boundary_p
= !varpool_node_in_set_p (node
, vset
) && node
->analyzed
;
551 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, node
->decl
);
552 bp
= bitpack_create (ob
->main_stream
);
553 bp_pack_value (&bp
, node
->externally_visible
, 1);
554 bp_pack_value (&bp
, node
->force_output
, 1);
555 bp_pack_value (&bp
, node
->finalized
, 1);
556 bp_pack_value (&bp
, node
->alias
, 1);
557 bp_pack_value (&bp
, node
->alias_of
!= NULL
, 1);
558 gcc_assert (node
->finalized
|| !node
->analyzed
);
559 gcc_assert (node
->needed
);
560 /* Constant pool initializers can be de-unified into individual ltrans units.
561 FIXME: Alternatively at -Os we may want to avoid generating for them the local
562 labels and share them across LTRANS partitions. */
563 if (DECL_IN_CONSTANT_POOL (node
->decl
)
564 && !DECL_COMDAT (node
->decl
))
566 bp_pack_value (&bp
, 0, 1); /* used_from_other_parition. */
567 bp_pack_value (&bp
, 0, 1); /* in_other_partition. */
571 bp_pack_value (&bp
, node
->analyzed
572 && referenced_from_other_partition_p (&node
->ref_list
,
574 bp_pack_value (&bp
, boundary_p
, 1); /* in_other_partition. */
576 lto_output_bitpack (&bp
);
578 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, node
->alias_of
);
579 if (node
->same_comdat_group
&& !boundary_p
)
581 ref
= lto_varpool_encoder_lookup (varpool_encoder
, node
->same_comdat_group
);
582 gcc_assert (ref
!= LCC_NOT_FOUND
);
586 lto_output_sleb128_stream (ob
->main_stream
, ref
);
587 lto_output_enum (ob
->main_stream
, ld_plugin_symbol_resolution
,
588 LDPR_NUM_KNOWN
, node
->resolution
);
591 /* Output the varpool NODE to OB.
592 If NODE is not in SET, then NODE is a boundary. */
595 lto_output_ref (struct lto_simple_output_block
*ob
, struct ipa_ref
*ref
,
596 lto_cgraph_encoder_t encoder
,
597 lto_varpool_encoder_t varpool_encoder
)
600 bp
= bitpack_create (ob
->main_stream
);
601 bp_pack_value (&bp
, ref
->refered_type
, 1);
602 bp_pack_value (&bp
, ref
->use
, 2);
603 lto_output_bitpack (&bp
);
604 if (ref
->refered_type
== IPA_REF_CGRAPH
)
606 int nref
= lto_cgraph_encoder_lookup (encoder
, ipa_ref_node (ref
));
607 gcc_assert (nref
!= LCC_NOT_FOUND
);
608 lto_output_sleb128_stream (ob
->main_stream
, nref
);
612 int nref
= lto_varpool_encoder_lookup (varpool_encoder
,
613 ipa_ref_varpool_node (ref
));
614 gcc_assert (nref
!= LCC_NOT_FOUND
);
615 lto_output_sleb128_stream (ob
->main_stream
, nref
);
619 /* Stream out profile_summary to OB. */
622 output_profile_summary (struct lto_simple_output_block
*ob
)
626 /* We do not output num, sum_all and run_max, they are not used by
627 GCC profile feedback and they are difficult to merge from multiple
629 gcc_assert (profile_info
->runs
);
630 lto_output_uleb128_stream (ob
->main_stream
, profile_info
->runs
);
631 lto_output_uleb128_stream (ob
->main_stream
, profile_info
->sum_max
);
634 lto_output_uleb128_stream (ob
->main_stream
, 0);
637 /* Add NODE into encoder as well as nodes it is cloned from.
638 Do it in a way so clones appear first. */
641 add_node_to (lto_cgraph_encoder_t encoder
, struct cgraph_node
*node
,
645 add_node_to (encoder
, node
->clone_of
, include_body
);
646 else if (include_body
)
647 lto_set_cgraph_encoder_encode_body (encoder
, node
);
648 lto_cgraph_encoder_encode (encoder
, node
);
651 /* Add all references in LIST to encoders. */
654 add_references (lto_cgraph_encoder_t encoder
,
655 lto_varpool_encoder_t varpool_encoder
,
656 struct ipa_ref_list
*list
)
660 for (i
= 0; ipa_ref_list_reference_iterate (list
, i
, ref
); i
++)
661 if (ref
->refered_type
== IPA_REF_CGRAPH
)
662 add_node_to (encoder
, ipa_ref_node (ref
), false);
665 struct varpool_node
*vnode
= ipa_ref_varpool_node (ref
);
666 lto_varpool_encoder_encode (varpool_encoder
, vnode
);
670 /* Output all callees or indirect outgoing edges. EDGE must be the first such
674 output_outgoing_cgraph_edges (struct cgraph_edge
*edge
,
675 struct lto_simple_output_block
*ob
,
676 lto_cgraph_encoder_t encoder
)
681 /* Output edges in backward direction, so the reconstructed callgraph match
682 and it is easy to associate call sites in the IPA pass summaries. */
683 while (edge
->next_callee
)
684 edge
= edge
->next_callee
;
685 for (; edge
; edge
= edge
->prev_callee
)
686 lto_output_edge (ob
, edge
, encoder
);
689 /* Output the part of the cgraph in SET. */
692 output_refs (cgraph_node_set set
, varpool_node_set vset
,
693 lto_cgraph_encoder_t encoder
,
694 lto_varpool_encoder_t varpool_encoder
)
696 cgraph_node_set_iterator csi
;
697 varpool_node_set_iterator vsi
;
698 struct lto_simple_output_block
*ob
;
703 ob
= lto_create_simple_output_block (LTO_section_refs
);
705 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
707 struct cgraph_node
*node
= csi_node (csi
);
709 count
= ipa_ref_list_nreferences (&node
->ref_list
);
712 lto_output_uleb128_stream (ob
->main_stream
, count
);
713 lto_output_uleb128_stream (ob
->main_stream
,
714 lto_cgraph_encoder_lookup (encoder
, node
));
715 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
716 lto_output_ref (ob
, ref
, encoder
, varpool_encoder
);
720 lto_output_uleb128_stream (ob
->main_stream
, 0);
722 for (vsi
= vsi_start (vset
); !vsi_end_p (vsi
); vsi_next (&vsi
))
724 struct varpool_node
*node
= vsi_node (vsi
);
726 count
= ipa_ref_list_nreferences (&node
->ref_list
);
729 lto_output_uleb128_stream (ob
->main_stream
, count
);
730 lto_output_uleb128_stream (ob
->main_stream
,
731 lto_varpool_encoder_lookup (varpool_encoder
,
733 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
734 lto_output_ref (ob
, ref
, encoder
, varpool_encoder
);
738 lto_output_uleb128_stream (ob
->main_stream
, 0);
740 lto_destroy_simple_output_block (ob
);
743 /* Find out all cgraph and varpool nodes we want to encode in current unit
744 and insert them to encoders. */
746 compute_ltrans_boundary (struct lto_out_decl_state
*state
,
747 cgraph_node_set set
, varpool_node_set vset
)
749 struct cgraph_node
*node
;
750 cgraph_node_set_iterator csi
;
751 varpool_node_set_iterator vsi
;
752 struct cgraph_edge
*edge
;
754 lto_cgraph_encoder_t encoder
;
755 lto_varpool_encoder_t varpool_encoder
;
757 encoder
= state
->cgraph_node_encoder
= lto_cgraph_encoder_new ();
758 varpool_encoder
= state
->varpool_node_encoder
= lto_varpool_encoder_new ();
760 /* Go over all the nodes in SET and assign references. */
761 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
763 node
= csi_node (csi
);
764 add_node_to (encoder
, node
, true);
765 add_references (encoder
, varpool_encoder
, &node
->ref_list
);
767 for (vsi
= vsi_start (vset
); !vsi_end_p (vsi
); vsi_next (&vsi
))
769 struct varpool_node
*vnode
= vsi_node (vsi
);
770 gcc_assert (!vnode
->alias
|| vnode
->alias_of
);
771 lto_varpool_encoder_encode (varpool_encoder
, vnode
);
772 lto_set_varpool_encoder_encode_initializer (varpool_encoder
, vnode
);
773 add_references (encoder
, varpool_encoder
, &vnode
->ref_list
);
775 /* Pickle in also the initializer of all referenced readonly variables
776 to help folding. Constant pool variables are not shared, so we must
778 for (i
= 0; i
< lto_varpool_encoder_size (varpool_encoder
); i
++)
780 struct varpool_node
*vnode
= lto_varpool_encoder_deref (varpool_encoder
, i
);
781 if (DECL_INITIAL (vnode
->decl
)
782 && !lto_varpool_encoder_encode_initializer_p (varpool_encoder
,
784 && const_value_known_p (vnode
->decl
))
786 lto_set_varpool_encoder_encode_initializer (varpool_encoder
, vnode
);
787 add_references (encoder
, varpool_encoder
, &vnode
->ref_list
);
791 /* Go over all the nodes again to include callees that are not in
793 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
795 node
= csi_node (csi
);
796 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
798 struct cgraph_node
*callee
= edge
->callee
;
799 if (!cgraph_node_in_set_p (callee
, set
))
801 /* We should have moved all the inlines. */
802 gcc_assert (!callee
->global
.inlined_to
);
803 add_node_to (encoder
, callee
, false);
809 /* Output the part of the cgraph in SET. */
812 output_cgraph (cgraph_node_set set
, varpool_node_set vset
)
814 struct cgraph_node
*node
;
815 struct lto_simple_output_block
*ob
;
816 cgraph_node_set_iterator csi
;
818 lto_cgraph_encoder_t encoder
;
819 lto_varpool_encoder_t varpool_encoder
;
820 struct cgraph_asm_node
*can
;
821 static bool asm_nodes_output
= false;
824 output_cgraph_opt_summary (set
);
826 ob
= lto_create_simple_output_block (LTO_section_cgraph
);
828 output_profile_summary (ob
);
830 /* An encoder for cgraph nodes should have been created by
831 ipa_write_summaries_1. */
832 gcc_assert (ob
->decl_state
->cgraph_node_encoder
);
833 gcc_assert (ob
->decl_state
->varpool_node_encoder
);
834 encoder
= ob
->decl_state
->cgraph_node_encoder
;
835 varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
837 /* Write out the nodes. We must first output a node and then its clones,
838 otherwise at a time reading back the node there would be nothing to clone
840 n_nodes
= lto_cgraph_encoder_size (encoder
);
841 for (i
= 0; i
< n_nodes
; i
++)
843 node
= lto_cgraph_encoder_deref (encoder
, i
);
844 lto_output_node (ob
, node
, encoder
, set
, vset
);
847 /* Go over the nodes in SET again to write edges. */
848 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
850 node
= csi_node (csi
);
851 output_outgoing_cgraph_edges (node
->callees
, ob
, encoder
);
852 output_outgoing_cgraph_edges (node
->indirect_calls
, ob
, encoder
);
855 lto_output_uleb128_stream (ob
->main_stream
, 0);
857 /* Emit toplevel asms.
858 When doing WPA we must output every asm just once. Since we do not partition asm
859 nodes at all, output them to first output. This is kind of hack, but should work
861 if (!asm_nodes_output
)
863 asm_nodes_output
= true;
864 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
866 int len
= TREE_STRING_LENGTH (can
->asm_str
);
867 lto_output_uleb128_stream (ob
->main_stream
, len
);
868 for (i
= 0; i
< len
; ++i
)
869 lto_output_1_stream (ob
->main_stream
,
870 TREE_STRING_POINTER (can
->asm_str
)[i
]);
874 lto_output_uleb128_stream (ob
->main_stream
, 0);
876 lto_destroy_simple_output_block (ob
);
877 output_varpool (set
, vset
);
878 output_refs (set
, vset
, encoder
, varpool_encoder
);
881 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
882 STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
883 NODE or to replace the values in it, for instance because the first
884 time we saw it, the function body was not available but now it
885 is. BP is a bitpack with all the bitflags for NODE read from the
889 input_overwrite_node (struct lto_file_decl_data
*file_data
,
890 struct cgraph_node
*node
,
891 enum LTO_cgraph_tags tag
,
892 struct bitpack_d
*bp
)
894 node
->aux
= (void *) tag
;
895 node
->local
.lto_file_data
= file_data
;
897 node
->local
.local
= bp_unpack_value (bp
, 1);
898 node
->local
.externally_visible
= bp_unpack_value (bp
, 1);
899 node
->local
.finalized
= bp_unpack_value (bp
, 1);
900 node
->local
.can_change_signature
= bp_unpack_value (bp
, 1);
901 node
->local
.redefined_extern_inline
= bp_unpack_value (bp
, 1);
902 node
->needed
= bp_unpack_value (bp
, 1);
903 node
->address_taken
= bp_unpack_value (bp
, 1);
904 node
->abstract_and_needed
= bp_unpack_value (bp
, 1);
905 node
->reachable_from_other_partition
= bp_unpack_value (bp
, 1);
906 node
->lowered
= bp_unpack_value (bp
, 1);
907 node
->analyzed
= tag
== LTO_cgraph_analyzed_node
;
908 node
->in_other_partition
= bp_unpack_value (bp
, 1);
909 if (node
->in_other_partition
910 /* Avoid updating decl when we are seeing just inline clone.
911 When inlining function that has functions already inlined into it,
912 we produce clones of inline clones.
914 WPA partitioning might put each clone into different unit and
915 we might end up streaming inline clone from other partition
916 to support clone we are interested in. */
918 || node
->clone_of
->decl
!= node
->decl
))
920 DECL_EXTERNAL (node
->decl
) = 1;
921 TREE_STATIC (node
->decl
) = 0;
923 node
->alias
= bp_unpack_value (bp
, 1);
924 node
->frequency
= (enum node_frequency
)bp_unpack_value (bp
, 2);
925 node
->only_called_at_startup
= bp_unpack_value (bp
, 1);
926 node
->only_called_at_exit
= bp_unpack_value (bp
, 1);
927 node
->thunk
.thunk_p
= bp_unpack_value (bp
, 1);
928 node
->resolution
= bp_unpack_enum (bp
, ld_plugin_symbol_resolution
,
932 /* Output the part of the cgraph in SET. */
935 output_varpool (cgraph_node_set set
, varpool_node_set vset
)
937 struct lto_simple_output_block
*ob
= lto_create_simple_output_block (LTO_section_varpool
);
938 lto_varpool_encoder_t varpool_encoder
= ob
->decl_state
->varpool_node_encoder
;
939 int len
= lto_varpool_encoder_size (varpool_encoder
), i
;
941 lto_output_uleb128_stream (ob
->main_stream
, len
);
943 /* Write out the nodes. We must first output a node and then its clones,
944 otherwise at a time reading back the node there would be nothing to clone
946 for (i
= 0; i
< len
; i
++)
948 lto_output_varpool_node (ob
, lto_varpool_encoder_deref (varpool_encoder
, i
),
953 lto_destroy_simple_output_block (ob
);
956 /* Read a node from input_block IB. TAG is the node's tag just read.
957 Return the node read or overwriten. */
959 static struct cgraph_node
*
960 input_node (struct lto_file_decl_data
*file_data
,
961 struct lto_input_block
*ib
,
962 enum LTO_cgraph_tags tag
,
963 VEC(cgraph_node_ptr
, heap
) *nodes
)
966 struct cgraph_node
*node
;
969 int ref
= LCC_NOT_FOUND
, ref2
= LCC_NOT_FOUND
;
972 clone_ref
= lto_input_sleb128 (ib
);
974 decl_index
= lto_input_uleb128 (ib
);
975 fn_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
977 if (clone_ref
!= LCC_NOT_FOUND
)
979 node
= cgraph_clone_node (VEC_index (cgraph_node_ptr
, nodes
, clone_ref
), fn_decl
,
980 0, CGRAPH_FREQ_BASE
, false, NULL
, false);
983 node
= cgraph_get_create_node (fn_decl
);
985 node
->count
= lto_input_sleb128 (ib
);
986 node
->count_materialization_scale
= lto_input_sleb128 (ib
);
988 if (tag
== LTO_cgraph_analyzed_node
)
989 ref
= lto_input_sleb128 (ib
);
991 ref2
= lto_input_sleb128 (ib
);
993 /* Make sure that we have not read this node before. Nodes that
994 have already been read will have their tag stored in the 'aux'
995 field. Since built-in functions can be referenced in multiple
996 functions, they are expected to be read more than once. */
997 if (node
->aux
&& !DECL_IS_BUILTIN (node
->decl
))
998 internal_error ("bytecode stream: found multiple instances of cgraph "
999 "node %d", node
->uid
);
1001 bp
= lto_input_bitpack (ib
);
1002 input_overwrite_node (file_data
, node
, tag
, &bp
);
1004 /* Store a reference for now, and fix up later to be a pointer. */
1005 node
->global
.inlined_to
= (cgraph_node_ptr
) (intptr_t) ref
;
1007 /* Store a reference for now, and fix up later to be a pointer. */
1008 node
->same_comdat_group
= (cgraph_node_ptr
) (intptr_t) ref2
;
1010 if (node
->thunk
.thunk_p
)
1012 int type
= lto_input_uleb128 (ib
);
1013 HOST_WIDE_INT fixed_offset
= lto_input_uleb128 (ib
);
1014 HOST_WIDE_INT virtual_value
= lto_input_uleb128 (ib
);
1016 node
->thunk
.fixed_offset
= fixed_offset
;
1017 node
->thunk
.this_adjusting
= (type
& 2);
1018 node
->thunk
.virtual_value
= virtual_value
;
1019 node
->thunk
.virtual_offset_p
= (type
& 4);
1021 if (node
->thunk
.thunk_p
|| node
->alias
)
1023 if (lto_input_int_in_range (ib
, "alias nonzero flag", 0, 1))
1025 decl_index
= lto_input_uleb128 (ib
);
1026 node
->thunk
.alias
= lto_file_decl_data_get_fn_decl (file_data
,
1033 /* Read a node from input_block IB. TAG is the node's tag just read.
1034 Return the node read or overwriten. */
1036 static struct varpool_node
*
1037 input_varpool_node (struct lto_file_decl_data
*file_data
,
1038 struct lto_input_block
*ib
)
1042 struct varpool_node
*node
;
1043 struct bitpack_d bp
;
1044 int ref
= LCC_NOT_FOUND
;
1045 bool non_null_aliasof
;
1047 decl_index
= lto_input_uleb128 (ib
);
1048 var_decl
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
1049 node
= varpool_node (var_decl
);
1050 node
->lto_file_data
= file_data
;
1052 bp
= lto_input_bitpack (ib
);
1053 node
->externally_visible
= bp_unpack_value (&bp
, 1);
1054 node
->force_output
= bp_unpack_value (&bp
, 1);
1055 node
->finalized
= bp_unpack_value (&bp
, 1);
1056 node
->alias
= bp_unpack_value (&bp
, 1);
1057 non_null_aliasof
= bp_unpack_value (&bp
, 1);
1058 node
->analyzed
= node
->finalized
;
1059 node
->used_from_other_partition
= bp_unpack_value (&bp
, 1);
1060 node
->in_other_partition
= bp_unpack_value (&bp
, 1);
1061 if (node
->in_other_partition
)
1063 DECL_EXTERNAL (node
->decl
) = 1;
1064 TREE_STATIC (node
->decl
) = 0;
1066 if (node
->finalized
)
1067 varpool_mark_needed_node (node
);
1068 if (non_null_aliasof
)
1070 decl_index
= lto_input_uleb128 (ib
);
1071 node
->alias_of
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
1073 ref
= lto_input_sleb128 (ib
);
1074 /* Store a reference for now, and fix up later to be a pointer. */
1075 node
->same_comdat_group
= (struct varpool_node
*) (intptr_t) ref
;
1076 node
->resolution
= lto_input_enum (ib
, ld_plugin_symbol_resolution
,
1082 /* Read a node from input_block IB. TAG is the node's tag just read.
1083 Return the node read or overwriten. */
1086 input_ref (struct lto_input_block
*ib
,
1087 struct cgraph_node
*refering_node
,
1088 struct varpool_node
*refering_varpool_node
,
1089 VEC(cgraph_node_ptr
, heap
) *nodes
,
1090 VEC(varpool_node_ptr
, heap
) *varpool_nodes
)
1092 struct cgraph_node
*node
= NULL
;
1093 struct varpool_node
*varpool_node
= NULL
;
1094 struct bitpack_d bp
;
1095 enum ipa_ref_type type
;
1096 enum ipa_ref_use use
;
1098 bp
= lto_input_bitpack (ib
);
1099 type
= (enum ipa_ref_type
) bp_unpack_value (&bp
, 1);
1100 use
= (enum ipa_ref_use
) bp_unpack_value (&bp
, 2);
1101 if (type
== IPA_REF_CGRAPH
)
1102 node
= VEC_index (cgraph_node_ptr
, nodes
, lto_input_sleb128 (ib
));
1104 varpool_node
= VEC_index (varpool_node_ptr
, varpool_nodes
, lto_input_sleb128 (ib
));
1105 ipa_record_reference (refering_node
, refering_varpool_node
,
1106 node
, varpool_node
, use
, NULL
);
1109 /* Read an edge from IB. NODES points to a vector of previously read nodes for
1110 decoding caller and callee of the edge to be read. If INDIRECT is true, the
1111 edge being read is indirect (in the sense that it has
1112 indirect_unknown_callee set). */
1115 input_edge (struct lto_input_block
*ib
, VEC(cgraph_node_ptr
, heap
) *nodes
,
1118 struct cgraph_node
*caller
, *callee
;
1119 struct cgraph_edge
*edge
;
1120 unsigned int stmt_id
;
1123 cgraph_inline_failed_t inline_failed
;
1124 struct bitpack_d bp
;
1127 caller
= VEC_index (cgraph_node_ptr
, nodes
, lto_input_sleb128 (ib
));
1128 if (caller
== NULL
|| caller
->decl
== NULL_TREE
)
1129 internal_error ("bytecode stream: no caller found while reading edge");
1133 callee
= VEC_index (cgraph_node_ptr
, nodes
, lto_input_sleb128 (ib
));
1134 if (callee
== NULL
|| callee
->decl
== NULL_TREE
)
1135 internal_error ("bytecode stream: no callee found while reading edge");
1140 count
= (gcov_type
) lto_input_sleb128 (ib
);
1142 bp
= lto_input_bitpack (ib
);
1143 inline_failed
= bp_unpack_enum (&bp
, cgraph_inline_failed_enum
, CIF_N_REASONS
);
1144 stmt_id
= bp_unpack_var_len_unsigned (&bp
);
1145 freq
= (int) bp_unpack_var_len_unsigned (&bp
);
1148 edge
= cgraph_create_indirect_edge (caller
, NULL
, 0, count
, freq
);
1150 edge
= cgraph_create_edge (caller
, callee
, NULL
, count
, freq
);
1152 edge
->indirect_inlining_edge
= bp_unpack_value (&bp
, 1);
1153 edge
->lto_stmt_uid
= stmt_id
;
1154 edge
->inline_failed
= inline_failed
;
1155 edge
->call_stmt_cannot_inline_p
= bp_unpack_value (&bp
, 1);
1156 edge
->can_throw_external
= bp_unpack_value (&bp
, 1);
1159 if (bp_unpack_value (&bp
, 1))
1160 ecf_flags
|= ECF_CONST
;
1161 if (bp_unpack_value (&bp
, 1))
1162 ecf_flags
|= ECF_PURE
;
1163 if (bp_unpack_value (&bp
, 1))
1164 ecf_flags
|= ECF_NORETURN
;
1165 if (bp_unpack_value (&bp
, 1))
1166 ecf_flags
|= ECF_MALLOC
;
1167 if (bp_unpack_value (&bp
, 1))
1168 ecf_flags
|= ECF_NOTHROW
;
1169 if (bp_unpack_value (&bp
, 1))
1170 ecf_flags
|= ECF_RETURNS_TWICE
;
1171 edge
->indirect_info
->ecf_flags
= ecf_flags
;
1176 /* Read a cgraph from IB using the info in FILE_DATA. */
1178 static VEC(cgraph_node_ptr
, heap
) *
1179 input_cgraph_1 (struct lto_file_decl_data
*file_data
,
1180 struct lto_input_block
*ib
)
1182 enum LTO_cgraph_tags tag
;
1183 VEC(cgraph_node_ptr
, heap
) *nodes
= NULL
;
1184 struct cgraph_node
*node
;
1186 unsigned HOST_WIDE_INT len
;
1188 tag
= lto_input_enum (ib
, LTO_cgraph_tags
, LTO_cgraph_last_tag
);
1191 if (tag
== LTO_cgraph_edge
)
1192 input_edge (ib
, nodes
, false);
1193 else if (tag
== LTO_cgraph_indirect_edge
)
1194 input_edge (ib
, nodes
, true);
1197 node
= input_node (file_data
, ib
, tag
,nodes
);
1198 if (node
== NULL
|| node
->decl
== NULL_TREE
)
1199 internal_error ("bytecode stream: found empty cgraph node");
1200 VEC_safe_push (cgraph_node_ptr
, heap
, nodes
, node
);
1201 lto_cgraph_encoder_encode (file_data
->cgraph_node_encoder
, node
);
1204 tag
= lto_input_enum (ib
, LTO_cgraph_tags
, LTO_cgraph_last_tag
);
1207 /* Input toplevel asms. */
1208 len
= lto_input_uleb128 (ib
);
1211 char *str
= (char *)xmalloc (len
+ 1);
1212 for (i
= 0; i
< len
; ++i
)
1213 str
[i
] = lto_input_1_unsigned (ib
);
1214 cgraph_add_asm_node (build_string (len
, str
));
1217 len
= lto_input_uleb128 (ib
);
1219 /* AUX pointers should be all non-zero for nodes read from the stream. */
1220 #ifdef ENABLE_CHECKING
1221 FOR_EACH_VEC_ELT (cgraph_node_ptr
, nodes
, i
, node
)
1222 gcc_assert (node
->aux
);
1224 FOR_EACH_VEC_ELT (cgraph_node_ptr
, nodes
, i
, node
)
1226 int ref
= (int) (intptr_t) node
->global
.inlined_to
;
1228 /* We share declaration of builtins, so we may read same node twice. */
1233 /* Fixup inlined_to from reference to pointer. */
1234 if (ref
!= LCC_NOT_FOUND
)
1235 node
->global
.inlined_to
= VEC_index (cgraph_node_ptr
, nodes
, ref
);
1237 node
->global
.inlined_to
= NULL
;
1239 ref
= (int) (intptr_t) node
->same_comdat_group
;
1241 /* Fixup same_comdat_group from reference to pointer. */
1242 if (ref
!= LCC_NOT_FOUND
)
1243 node
->same_comdat_group
= VEC_index (cgraph_node_ptr
, nodes
, ref
);
1245 node
->same_comdat_group
= NULL
;
1247 FOR_EACH_VEC_ELT (cgraph_node_ptr
, nodes
, i
, node
)
1248 node
->aux
= (void *)1;
1252 /* Read a varpool from IB using the info in FILE_DATA. */
1254 static VEC(varpool_node_ptr
, heap
) *
1255 input_varpool_1 (struct lto_file_decl_data
*file_data
,
1256 struct lto_input_block
*ib
)
1258 unsigned HOST_WIDE_INT len
;
1259 VEC(varpool_node_ptr
, heap
) *varpool
= NULL
;
1261 struct varpool_node
*node
;
1263 len
= lto_input_uleb128 (ib
);
1266 VEC_safe_push (varpool_node_ptr
, heap
, varpool
,
1267 input_varpool_node (file_data
, ib
));
1270 #ifdef ENABLE_CHECKING
1271 FOR_EACH_VEC_ELT (varpool_node_ptr
, varpool
, i
, node
)
1272 gcc_assert (!node
->aux
);
1274 FOR_EACH_VEC_ELT (varpool_node_ptr
, varpool
, i
, node
)
1276 int ref
= (int) (intptr_t) node
->same_comdat_group
;
1277 /* We share declaration of builtins, so we may read same node twice. */
1280 node
->aux
= (void *)1;
1282 /* Fixup same_comdat_group from reference to pointer. */
1283 if (ref
!= LCC_NOT_FOUND
)
1284 node
->same_comdat_group
= VEC_index (varpool_node_ptr
, varpool
, ref
);
1286 node
->same_comdat_group
= NULL
;
1288 FOR_EACH_VEC_ELT (varpool_node_ptr
, varpool
, i
, node
)
1293 /* Input ipa_refs. */
1296 input_refs (struct lto_input_block
*ib
,
1297 VEC(cgraph_node_ptr
, heap
) *nodes
,
1298 VEC(varpool_node_ptr
, heap
) *varpool
)
1304 struct cgraph_node
*node
;
1305 count
= lto_input_uleb128 (ib
);
1308 idx
= lto_input_uleb128 (ib
);
1309 node
= VEC_index (cgraph_node_ptr
, nodes
, idx
);
1312 input_ref (ib
, node
, NULL
, nodes
, varpool
);
1318 struct varpool_node
*node
;
1319 count
= lto_input_uleb128 (ib
);
1322 node
= VEC_index (varpool_node_ptr
, varpool
, lto_input_uleb128 (ib
));
1325 input_ref (ib
, NULL
, node
, nodes
, varpool
);
1332 static struct gcov_ctr_summary lto_gcov_summary
;
1334 /* Input profile_info from IB. */
1336 input_profile_summary (struct lto_input_block
*ib
,
1337 struct lto_file_decl_data
*file_data
)
1339 unsigned int runs
= lto_input_uleb128 (ib
);
1342 file_data
->profile_info
.runs
= runs
;
1343 file_data
->profile_info
.sum_max
= lto_input_uleb128 (ib
);
1348 /* Rescale profile summaries to the same number of runs in the whole unit. */
1351 merge_profile_summaries (struct lto_file_decl_data
**file_data_vec
)
1353 struct lto_file_decl_data
*file_data
;
1355 gcov_unsigned_t max_runs
= 0;
1356 struct cgraph_node
*node
;
1357 struct cgraph_edge
*edge
;
1359 /* Find unit with maximal number of runs. If we ever get serious about
1360 roundoff errors, we might also consider computing smallest common
1362 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1363 if (max_runs
< file_data
->profile_info
.runs
)
1364 max_runs
= file_data
->profile_info
.runs
;
1369 /* Simple overflow check. We probably don't need to support that many train
1370 runs. Such a large value probably imply data corruption anyway. */
1371 if (max_runs
> INT_MAX
/ REG_BR_PROB_BASE
)
1373 sorry ("At most %i profile runs is supported. Perhaps corrupted profile?",
1374 INT_MAX
/ REG_BR_PROB_BASE
);
1378 profile_info
= <o_gcov_summary
;
1379 lto_gcov_summary
.runs
= max_runs
;
1380 lto_gcov_summary
.sum_max
= 0;
1382 /* Rescale all units to the maximal number of runs.
1383 sum_max can not be easily merged, as we have no idea what files come from
1384 the same run. We do not use the info anyway, so leave it 0. */
1385 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1386 if (file_data
->profile_info
.runs
)
1388 int scale
= ((REG_BR_PROB_BASE
* max_runs
1389 + file_data
->profile_info
.runs
/ 2)
1390 / file_data
->profile_info
.runs
);
1391 lto_gcov_summary
.sum_max
= MAX (lto_gcov_summary
.sum_max
,
1392 (file_data
->profile_info
.sum_max
1394 + REG_BR_PROB_BASE
/ 2)
1395 / REG_BR_PROB_BASE
);
1398 /* Watch roundoff errors. */
1399 if (lto_gcov_summary
.sum_max
< max_runs
)
1400 lto_gcov_summary
.sum_max
= max_runs
;
1402 /* If merging already happent at WPA time, we are done. */
1406 /* Now compute count_materialization_scale of each node.
1407 During LTRANS we already have values of count_materialization_scale
1408 computed, so just update them. */
1409 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1410 if (node
->local
.lto_file_data
1411 && node
->local
.lto_file_data
->profile_info
.runs
)
1416 ((node
->count_materialization_scale
* max_runs
1417 + node
->local
.lto_file_data
->profile_info
.runs
/ 2)
1418 / node
->local
.lto_file_data
->profile_info
.runs
);
1419 node
->count_materialization_scale
= scale
;
1421 fatal_error ("Profile information in %s corrupted",
1422 file_data
->file_name
);
1424 if (scale
== REG_BR_PROB_BASE
)
1426 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1427 edge
->count
= ((edge
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1428 / REG_BR_PROB_BASE
);
1429 node
->count
= ((node
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1430 / REG_BR_PROB_BASE
);
1434 /* Input and merge the cgraph from each of the .o files passed to
1440 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1441 struct lto_file_decl_data
*file_data
;
1443 struct cgraph_node
*node
;
1445 while ((file_data
= file_data_vec
[j
++]))
1449 struct lto_input_block
*ib
;
1450 VEC(cgraph_node_ptr
, heap
) *nodes
;
1451 VEC(varpool_node_ptr
, heap
) *varpool
;
1453 ib
= lto_create_simple_input_block (file_data
, LTO_section_cgraph
,
1456 fatal_error ("cannot find LTO cgraph in %s", file_data
->file_name
);
1457 input_profile_summary (ib
, file_data
);
1458 file_data
->cgraph_node_encoder
= lto_cgraph_encoder_new ();
1459 nodes
= input_cgraph_1 (file_data
, ib
);
1460 lto_destroy_simple_input_block (file_data
, LTO_section_cgraph
,
1463 ib
= lto_create_simple_input_block (file_data
, LTO_section_varpool
,
1466 fatal_error ("cannot find LTO varpool in %s", file_data
->file_name
);
1467 varpool
= input_varpool_1 (file_data
, ib
);
1468 lto_destroy_simple_input_block (file_data
, LTO_section_varpool
,
1471 ib
= lto_create_simple_input_block (file_data
, LTO_section_refs
,
1474 fatal_error("cannot find LTO section refs in %s", file_data
->file_name
);
1475 input_refs (ib
, nodes
, varpool
);
1476 lto_destroy_simple_input_block (file_data
, LTO_section_refs
,
1479 input_cgraph_opt_summary (nodes
);
1480 VEC_free (cgraph_node_ptr
, heap
, nodes
);
1481 VEC_free (varpool_node_ptr
, heap
, varpool
);
1484 merge_profile_summaries (file_data_vec
);
1486 /* Clear out the aux field that was used to store enough state to
1487 tell which nodes should be overwritten. */
1488 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1490 /* Some nodes may have been created by cgraph_node. This
1491 happens when the callgraph contains nested functions. If the
1492 node for the parent function was never emitted to the gimple
1493 file, cgraph_node will create a node for it when setting the
1494 context of the nested function. */
1495 if (node
->local
.lto_file_data
)
1500 /* True when we need optimization summary for NODE. */
1503 output_cgraph_opt_summary_p (struct cgraph_node
*node
, cgraph_node_set set
)
1505 struct cgraph_edge
*e
;
1507 if (cgraph_node_in_set_p (node
, set
))
1509 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1510 if (e
->indirect_info
1511 && e
->indirect_info
->thunk_delta
!= 0)
1514 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1515 if (e
->indirect_info
->thunk_delta
!= 0)
1519 return (node
->clone_of
1520 && (node
->clone
.tree_map
1521 || node
->clone
.args_to_skip
1522 || node
->clone
.combined_args_to_skip
));
1525 /* Output optimization summary for EDGE to OB. */
1527 output_edge_opt_summary (struct output_block
*ob
,
1528 struct cgraph_edge
*edge
)
1530 if (edge
->indirect_info
)
1531 lto_output_sleb128_stream (ob
->main_stream
,
1532 edge
->indirect_info
->thunk_delta
);
1534 lto_output_sleb128_stream (ob
->main_stream
, 0);
1537 /* Output optimization summary for NODE to OB. */
1540 output_node_opt_summary (struct output_block
*ob
,
1541 struct cgraph_node
*node
,
1542 cgraph_node_set set
)
1546 struct ipa_replace_map
*map
;
1547 struct bitpack_d bp
;
1549 struct cgraph_edge
*e
;
1551 if (node
->clone
.args_to_skip
)
1553 lto_output_uleb128_stream (ob
->main_stream
,
1554 bitmap_count_bits (node
->clone
.args_to_skip
));
1555 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.args_to_skip
, 0, index
, bi
)
1556 lto_output_uleb128_stream (ob
->main_stream
, index
);
1559 lto_output_uleb128_stream (ob
->main_stream
, 0);
1560 if (node
->clone
.combined_args_to_skip
)
1562 lto_output_uleb128_stream (ob
->main_stream
,
1563 bitmap_count_bits (node
->clone
.combined_args_to_skip
));
1564 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.combined_args_to_skip
, 0, index
, bi
)
1565 lto_output_uleb128_stream (ob
->main_stream
, index
);
1568 lto_output_uleb128_stream (ob
->main_stream
, 0);
1569 lto_output_uleb128_stream (ob
->main_stream
,
1570 VEC_length (ipa_replace_map_p
, node
->clone
.tree_map
));
1571 FOR_EACH_VEC_ELT (ipa_replace_map_p
, node
->clone
.tree_map
, i
, map
)
1576 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->decl
); parm
;
1577 parm
= DECL_CHAIN (parm
), parm_num
++)
1578 if (map
->old_tree
== parm
)
1580 /* At the moment we assume all old trees to be PARM_DECLs, because we have no
1581 mechanism to store function local declarations into summaries. */
1583 lto_output_uleb128_stream (ob
->main_stream
, parm_num
);
1584 lto_output_tree (ob
, map
->new_tree
, true);
1585 bp
= bitpack_create (ob
->main_stream
);
1586 bp_pack_value (&bp
, map
->replace_p
, 1);
1587 bp_pack_value (&bp
, map
->ref_p
, 1);
1588 lto_output_bitpack (&bp
);
1591 if (cgraph_node_in_set_p (node
, set
))
1593 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1594 output_edge_opt_summary (ob
, e
);
1595 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1596 output_edge_opt_summary (ob
, e
);
1600 /* Output optimization summaries stored in callgraph.
1601 At the moment it is the clone info structure. */
1604 output_cgraph_opt_summary (cgraph_node_set set
)
1606 struct cgraph_node
*node
;
1608 lto_cgraph_encoder_t encoder
;
1609 struct output_block
*ob
= create_output_block (LTO_section_cgraph_opt_sum
);
1612 ob
->cgraph_node
= NULL
;
1613 encoder
= ob
->decl_state
->cgraph_node_encoder
;
1614 n_nodes
= lto_cgraph_encoder_size (encoder
);
1615 for (i
= 0; i
< n_nodes
; i
++)
1616 if (output_cgraph_opt_summary_p (lto_cgraph_encoder_deref (encoder
, i
),
1619 lto_output_uleb128_stream (ob
->main_stream
, count
);
1620 for (i
= 0; i
< n_nodes
; i
++)
1622 node
= lto_cgraph_encoder_deref (encoder
, i
);
1623 if (output_cgraph_opt_summary_p (node
, set
))
1625 lto_output_uleb128_stream (ob
->main_stream
, i
);
1626 output_node_opt_summary (ob
, node
, set
);
1629 produce_asm (ob
, NULL
);
1630 destroy_output_block (ob
);
1633 /* Input optimisation summary of EDGE. */
1636 input_edge_opt_summary (struct cgraph_edge
*edge
,
1637 struct lto_input_block
*ib_main
)
1639 HOST_WIDE_INT thunk_delta
;
1640 thunk_delta
= lto_input_sleb128 (ib_main
);
1641 if (thunk_delta
!= 0)
1643 gcc_assert (!edge
->indirect_info
);
1644 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
1645 edge
->indirect_info
->thunk_delta
= thunk_delta
;
1649 /* Input optimisation summary of NODE. */
1652 input_node_opt_summary (struct cgraph_node
*node
,
1653 struct lto_input_block
*ib_main
,
1654 struct data_in
*data_in
)
1659 struct bitpack_d bp
;
1660 struct cgraph_edge
*e
;
1662 count
= lto_input_uleb128 (ib_main
);
1664 node
->clone
.args_to_skip
= BITMAP_GGC_ALLOC ();
1665 for (i
= 0; i
< count
; i
++)
1667 bit
= lto_input_uleb128 (ib_main
);
1668 bitmap_set_bit (node
->clone
.args_to_skip
, bit
);
1670 count
= lto_input_uleb128 (ib_main
);
1672 node
->clone
.combined_args_to_skip
= BITMAP_GGC_ALLOC ();
1673 for (i
= 0; i
< count
; i
++)
1675 bit
= lto_input_uleb128 (ib_main
);
1676 bitmap_set_bit (node
->clone
.combined_args_to_skip
, bit
);
1678 count
= lto_input_uleb128 (ib_main
);
1679 for (i
= 0; i
< count
; i
++)
1683 struct ipa_replace_map
*map
= ggc_alloc_ipa_replace_map ();
1685 VEC_safe_push (ipa_replace_map_p
, gc
, node
->clone
.tree_map
, map
);
1686 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->decl
); parm_num
;
1687 parm
= DECL_CHAIN (parm
))
1689 map
->parm_num
= lto_input_uleb128 (ib_main
);
1690 map
->old_tree
= NULL
;
1691 map
->new_tree
= lto_input_tree (ib_main
, data_in
);
1692 bp
= lto_input_bitpack (ib_main
);
1693 map
->replace_p
= bp_unpack_value (&bp
, 1);
1694 map
->ref_p
= bp_unpack_value (&bp
, 1);
1696 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1697 input_edge_opt_summary (e
, ib_main
);
1698 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1699 input_edge_opt_summary (e
, ib_main
);
1702 /* Read section in file FILE_DATA of length LEN with data DATA. */
1705 input_cgraph_opt_section (struct lto_file_decl_data
*file_data
,
1706 const char *data
, size_t len
, VEC (cgraph_node_ptr
,
1709 const struct lto_function_header
*header
=
1710 (const struct lto_function_header
*) data
;
1711 const int32_t cfg_offset
= sizeof (struct lto_function_header
);
1712 const int32_t main_offset
= cfg_offset
+ header
->cfg_size
;
1713 const int32_t string_offset
= main_offset
+ header
->main_size
;
1714 struct data_in
*data_in
;
1715 struct lto_input_block ib_main
;
1719 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
1723 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
1724 header
->string_size
, NULL
);
1725 count
= lto_input_uleb128 (&ib_main
);
1727 for (i
= 0; i
< count
; i
++)
1729 int ref
= lto_input_uleb128 (&ib_main
);
1730 input_node_opt_summary (VEC_index (cgraph_node_ptr
, nodes
, ref
),
1733 lto_free_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
, data
,
1735 lto_data_in_delete (data_in
);
1738 /* Input optimization summary of cgraph. */
1741 input_cgraph_opt_summary (VEC (cgraph_node_ptr
, heap
) * nodes
)
1743 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1744 struct lto_file_decl_data
*file_data
;
1747 while ((file_data
= file_data_vec
[j
++]))
1751 lto_get_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
,
1755 input_cgraph_opt_section (file_data
, data
, len
, nodes
);