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"
43 #include "pointer-set.h"
44 #include "lto-streamer.h"
45 #include "data-streamer.h"
46 #include "tree-streamer.h"
49 static void output_cgraph_opt_summary (void);
50 static void input_cgraph_opt_summary (VEC (symtab_node
, heap
) * nodes
);
52 /* Number of LDPR values known to GCC. */
53 #define LDPR_NUM_KNOWN (LDPR_PREVAILING_DEF_IRONLY_EXP + 1)
55 /* All node orders are ofsetted by ORDER_BASE. */
56 static int order_base
;
58 /* Cgraph streaming is organized as set of record whose type
59 is indicated by a tag. */
62 /* Must leave 0 for the stopper. */
64 /* Cgraph node without body available. */
65 LTO_symtab_unavail_node
= 1,
66 /* Cgraph node with function body. */
67 LTO_symtab_analyzed_node
,
70 LTO_symtab_indirect_edge
,
75 /* Create a new symtab encoder. */
78 lto_symtab_encoder_new (void)
80 lto_symtab_encoder_t encoder
= XCNEW (struct lto_symtab_encoder_d
);
81 encoder
->map
= pointer_map_create ();
82 encoder
->nodes
= NULL
;
83 encoder
->body
= pointer_set_create ();
84 encoder
->initializer
= pointer_set_create ();
85 encoder
->in_partition
= pointer_set_create ();
90 /* Delete ENCODER and its components. */
93 lto_symtab_encoder_delete (lto_symtab_encoder_t encoder
)
95 VEC_free (symtab_node
, heap
, encoder
->nodes
);
96 pointer_map_destroy (encoder
->map
);
97 pointer_set_destroy (encoder
->body
);
98 pointer_set_destroy (encoder
->initializer
);
99 pointer_set_destroy (encoder
->in_partition
);
104 /* Return the existing reference number of NODE in the symtab encoder in
105 output block OB. Assign a new reference if this is the first time
109 lto_symtab_encoder_encode (lto_symtab_encoder_t encoder
,
115 slot
= pointer_map_contains (encoder
->map
, node
);
118 ref
= VEC_length (symtab_node
, encoder
->nodes
);
119 slot
= pointer_map_insert (encoder
->map
, node
);
120 *slot
= (void *) (intptr_t) ref
;
121 VEC_safe_push (symtab_node
, heap
, encoder
->nodes
, node
);
124 ref
= (int) (intptr_t) *slot
;
130 /* Look up NODE in encoder. Return NODE's reference if it has been encoded
131 or LCC_NOT_FOUND if it is not there. */
134 lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder
,
137 void **slot
= pointer_map_contains (encoder
->map
, node
);
138 return (slot
? (int) (intptr_t) *slot
: LCC_NOT_FOUND
);
142 /* Return TRUE if we should encode initializer of NODE (if any). */
145 lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t encoder
,
146 struct cgraph_node
*node
)
148 return pointer_set_contains (encoder
->body
, node
);
151 /* Return TRUE if we should encode body of NODE (if any). */
154 lto_set_symtab_encoder_encode_body (lto_symtab_encoder_t encoder
,
155 struct cgraph_node
*node
)
157 pointer_set_insert (encoder
->body
, node
);
160 /* Return TRUE if we should encode initializer of NODE (if any). */
163 lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t encoder
,
164 struct varpool_node
*node
)
166 return pointer_set_contains (encoder
->initializer
, node
);
169 /* Return TRUE if we should encode initializer of NODE (if any). */
172 lto_set_symtab_encoder_encode_initializer (lto_symtab_encoder_t encoder
,
173 struct varpool_node
*node
)
175 pointer_set_insert (encoder
->initializer
, node
);
178 /* Return TRUE if we should encode initializer of NODE (if any). */
181 lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t encoder
,
184 return pointer_set_contains (encoder
->in_partition
, node
);
187 /* Return TRUE if we should encode body of NODE (if any). */
190 lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t encoder
,
193 lto_symtab_encoder_encode (encoder
, (symtab_node
)node
);
194 pointer_set_insert (encoder
->in_partition
, node
);
197 /* Output the cgraph EDGE to OB using ENCODER. */
200 lto_output_edge (struct lto_simple_output_block
*ob
, struct cgraph_edge
*edge
,
201 lto_symtab_encoder_t encoder
)
207 if (edge
->indirect_unknown_callee
)
208 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
209 LTO_symtab_indirect_edge
);
211 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
214 ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)edge
->caller
);
215 gcc_assert (ref
!= LCC_NOT_FOUND
);
216 streamer_write_hwi_stream (ob
->main_stream
, ref
);
218 if (!edge
->indirect_unknown_callee
)
220 ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)edge
->callee
);
221 gcc_assert (ref
!= LCC_NOT_FOUND
);
222 streamer_write_hwi_stream (ob
->main_stream
, ref
);
225 streamer_write_hwi_stream (ob
->main_stream
, edge
->count
);
227 bp
= bitpack_create (ob
->main_stream
);
228 uid
= (!gimple_has_body_p (edge
->caller
->symbol
.decl
)
229 ? edge
->lto_stmt_uid
: gimple_uid (edge
->call_stmt
));
230 bp_pack_enum (&bp
, cgraph_inline_failed_enum
,
231 CIF_N_REASONS
, edge
->inline_failed
);
232 bp_pack_var_len_unsigned (&bp
, uid
);
233 bp_pack_var_len_unsigned (&bp
, edge
->frequency
);
234 bp_pack_value (&bp
, edge
->indirect_inlining_edge
, 1);
235 bp_pack_value (&bp
, edge
->call_stmt_cannot_inline_p
, 1);
236 bp_pack_value (&bp
, edge
->can_throw_external
, 1);
237 if (edge
->indirect_unknown_callee
)
239 int flags
= edge
->indirect_info
->ecf_flags
;
240 bp_pack_value (&bp
, (flags
& ECF_CONST
) != 0, 1);
241 bp_pack_value (&bp
, (flags
& ECF_PURE
) != 0, 1);
242 bp_pack_value (&bp
, (flags
& ECF_NORETURN
) != 0, 1);
243 bp_pack_value (&bp
, (flags
& ECF_MALLOC
) != 0, 1);
244 bp_pack_value (&bp
, (flags
& ECF_NOTHROW
) != 0, 1);
245 bp_pack_value (&bp
, (flags
& ECF_RETURNS_TWICE
) != 0, 1);
246 /* Flags that should not appear on indirect calls. */
247 gcc_assert (!(flags
& (ECF_LOOPING_CONST_OR_PURE
253 streamer_write_bitpack (&bp
);
256 /* Return if LIST contain references from other partitions. */
259 referenced_from_other_partition_p (struct ipa_ref_list
*list
, lto_symtab_encoder_t encoder
)
263 for (i
= 0; ipa_ref_list_referring_iterate (list
, i
, ref
); i
++)
265 if (ref
->referring
->symbol
.in_other_partition
266 || !lto_symtab_encoder_in_partition_p (encoder
, ref
->referring
))
272 /* Return true when node is reachable from other partition. */
275 reachable_from_other_partition_p (struct cgraph_node
*node
, lto_symtab_encoder_t encoder
)
277 struct cgraph_edge
*e
;
280 if (node
->global
.inlined_to
)
282 for (e
= node
->callers
; e
; e
= e
->next_caller
)
283 if (e
->caller
->symbol
.in_other_partition
284 || !lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)e
->caller
))
289 /* Return if LIST contain references from other partitions. */
292 referenced_from_this_partition_p (struct ipa_ref_list
*list
,
293 lto_symtab_encoder_t encoder
)
297 for (i
= 0; ipa_ref_list_referring_iterate (list
, i
, ref
); i
++)
298 if (lto_symtab_encoder_in_partition_p (encoder
, ref
->referring
))
303 /* Return true when node is reachable from other partition. */
306 reachable_from_this_partition_p (struct cgraph_node
*node
, lto_symtab_encoder_t encoder
)
308 struct cgraph_edge
*e
;
309 for (e
= node
->callers
; e
; e
= e
->next_caller
)
310 if (lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)e
->caller
))
315 /* Output the cgraph NODE to OB. ENCODER is used to find the
316 reference number of NODE->inlined_to. SET is the set of nodes we
317 are writing to the current file. If NODE is not in SET, then NODE
318 is a boundary of a cgraph_node_set and we pretend NODE just has a
319 decl and no callees. WRITTEN_DECLS is the set of FUNCTION_DECLs
320 that have had their callgraph node written so far. This is used to
321 determine if NODE is a clone of a previously written node. */
324 lto_output_node (struct lto_simple_output_block
*ob
, struct cgraph_node
*node
,
325 lto_symtab_encoder_t encoder
)
331 bool in_other_partition
= false;
332 struct cgraph_node
*clone_of
;
334 boundary_p
= !lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)node
);
336 if (node
->analyzed
&& !boundary_p
)
337 tag
= LTO_symtab_analyzed_node
;
339 tag
= LTO_symtab_unavail_node
;
341 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
343 streamer_write_hwi_stream (ob
->main_stream
, node
->symbol
.order
);
345 /* In WPA mode, we only output part of the call-graph. Also, we
346 fake cgraph node attributes. There are two cases that we care.
348 Boundary nodes: There are nodes that are not part of SET but are
349 called from within SET. We artificially make them look like
350 externally visible nodes with no function body.
352 Cherry-picked nodes: These are nodes we pulled from other
353 translation units into SET during IPA-inlining. We make them as
354 local static nodes to prevent clashes with other local statics. */
355 if (boundary_p
&& node
->analyzed
&& !DECL_EXTERNAL (node
->symbol
.decl
))
357 /* Inline clones can not be part of boundary.
358 gcc_assert (!node->global.inlined_to);
360 FIXME: At the moment they can be, when partition contains an inline
361 clone that is clone of inline clone from outside partition. We can
362 reshape the clone tree and make other tree to be the root, but it
363 needs a bit extra work and will be promplty done by cgraph_remove_node
364 after reading back. */
365 in_other_partition
= 1;
368 clone_of
= node
->clone_of
;
370 && (ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)clone_of
)) == LCC_NOT_FOUND
)
371 if (clone_of
->prev_sibling_clone
)
372 clone_of
= clone_of
->prev_sibling_clone
;
374 clone_of
= clone_of
->clone_of
;
376 if (LTO_symtab_analyzed_node
)
377 gcc_assert (clone_of
|| !node
->clone_of
);
379 streamer_write_hwi_stream (ob
->main_stream
, LCC_NOT_FOUND
);
381 streamer_write_hwi_stream (ob
->main_stream
, ref
);
384 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, node
->symbol
.decl
);
385 streamer_write_hwi_stream (ob
->main_stream
, node
->count
);
386 streamer_write_hwi_stream (ob
->main_stream
, node
->count_materialization_scale
);
388 if (tag
== LTO_symtab_analyzed_node
)
390 if (node
->global
.inlined_to
)
392 ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)node
->global
.inlined_to
);
393 gcc_assert (ref
!= LCC_NOT_FOUND
);
398 streamer_write_hwi_stream (ob
->main_stream
, ref
);
401 if (node
->symbol
.same_comdat_group
&& !boundary_p
)
403 ref
= lto_symtab_encoder_lookup (encoder
,
404 node
->symbol
.same_comdat_group
);
405 gcc_assert (ref
!= LCC_NOT_FOUND
);
409 streamer_write_hwi_stream (ob
->main_stream
, ref
);
411 bp
= bitpack_create (ob
->main_stream
);
412 bp_pack_value (&bp
, node
->local
.local
, 1);
413 bp_pack_value (&bp
, node
->symbol
.externally_visible
, 1);
414 bp_pack_value (&bp
, node
->local
.finalized
, 1);
415 bp_pack_value (&bp
, node
->local
.versionable
, 1);
416 bp_pack_value (&bp
, node
->local
.can_change_signature
, 1);
417 bp_pack_value (&bp
, node
->local
.redefined_extern_inline
, 1);
418 bp_pack_value (&bp
, node
->symbol
.force_output
, 1);
419 bp_pack_value (&bp
, node
->symbol
.address_taken
, 1);
420 bp_pack_value (&bp
, node
->abstract_and_needed
, 1);
421 bp_pack_value (&bp
, tag
== LTO_symtab_analyzed_node
422 && !DECL_EXTERNAL (node
->symbol
.decl
)
423 && !DECL_COMDAT (node
->symbol
.decl
)
424 && (reachable_from_other_partition_p (node
, encoder
)
425 || referenced_from_other_partition_p (&node
->symbol
.ref_list
,
427 bp_pack_value (&bp
, node
->lowered
, 1);
428 bp_pack_value (&bp
, in_other_partition
, 1);
429 /* Real aliases in a boundary become non-aliases. However we still stream
430 alias info on weakrefs.
431 TODO: We lose a bit of information here - when we know that variable is
432 defined in other unit, we may use the info on aliases to resolve
433 symbol1 != symbol2 type tests that we can do only for locally defined objects
435 bp_pack_value (&bp
, node
->alias
&& (!boundary_p
|| DECL_EXTERNAL (node
->symbol
.decl
)), 1);
436 bp_pack_value (&bp
, node
->frequency
, 2);
437 bp_pack_value (&bp
, node
->only_called_at_startup
, 1);
438 bp_pack_value (&bp
, node
->only_called_at_exit
, 1);
439 bp_pack_value (&bp
, node
->tm_clone
, 1);
440 bp_pack_value (&bp
, node
->thunk
.thunk_p
&& !boundary_p
, 1);
441 bp_pack_enum (&bp
, ld_plugin_symbol_resolution
,
442 LDPR_NUM_KNOWN
, node
->symbol
.resolution
);
443 streamer_write_bitpack (&bp
);
445 if (node
->thunk
.thunk_p
&& !boundary_p
)
447 streamer_write_uhwi_stream
449 1 + (node
->thunk
.this_adjusting
!= 0) * 2
450 + (node
->thunk
.virtual_offset_p
!= 0) * 4);
451 streamer_write_uhwi_stream (ob
->main_stream
, node
->thunk
.fixed_offset
);
452 streamer_write_uhwi_stream (ob
->main_stream
, node
->thunk
.virtual_value
);
454 if ((node
->alias
|| node
->thunk
.thunk_p
)
455 && (!boundary_p
|| (node
->alias
&& DECL_EXTERNAL (node
->symbol
.decl
))))
457 streamer_write_hwi_in_range (ob
->main_stream
, 0, 1,
458 node
->thunk
.alias
!= NULL
);
459 if (node
->thunk
.alias
!= NULL
)
460 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
465 /* Output the varpool NODE to OB.
466 If NODE is not in SET, then NODE is a boundary. */
469 lto_output_varpool_node (struct lto_simple_output_block
*ob
, struct varpool_node
*node
,
470 lto_symtab_encoder_t encoder
)
472 bool boundary_p
= (node
->analyzed
473 && !lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)node
));
477 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
478 LTO_symtab_variable
);
479 streamer_write_hwi_stream (ob
->main_stream
, node
->symbol
.order
);
480 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, node
->symbol
.decl
);
481 bp
= bitpack_create (ob
->main_stream
);
482 bp_pack_value (&bp
, node
->symbol
.externally_visible
, 1);
483 bp_pack_value (&bp
, node
->symbol
.force_output
, 1);
484 bp_pack_value (&bp
, node
->finalized
, 1);
485 bp_pack_value (&bp
, node
->alias
, 1);
486 bp_pack_value (&bp
, node
->alias_of
!= NULL
, 1);
487 gcc_assert (node
->finalized
|| !node
->analyzed
);
488 /* Constant pool initializers can be de-unified into individual ltrans units.
489 FIXME: Alternatively at -Os we may want to avoid generating for them the local
490 labels and share them across LTRANS partitions. */
491 if (DECL_IN_CONSTANT_POOL (node
->symbol
.decl
)
492 && !DECL_EXTERNAL (node
->symbol
.decl
)
493 && !DECL_COMDAT (node
->symbol
.decl
))
495 bp_pack_value (&bp
, 0, 1); /* used_from_other_parition. */
496 bp_pack_value (&bp
, 0, 1); /* in_other_partition. */
500 bp_pack_value (&bp
, node
->analyzed
501 && referenced_from_other_partition_p (&node
->symbol
.ref_list
,
503 bp_pack_value (&bp
, boundary_p
&& !DECL_EXTERNAL (node
->symbol
.decl
), 1);
504 /* in_other_partition. */
506 streamer_write_bitpack (&bp
);
508 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, node
->alias_of
);
509 if (node
->symbol
.same_comdat_group
&& !boundary_p
)
511 ref
= lto_symtab_encoder_lookup (encoder
,
512 node
->symbol
.same_comdat_group
);
513 gcc_assert (ref
!= LCC_NOT_FOUND
);
517 streamer_write_hwi_stream (ob
->main_stream
, ref
);
518 streamer_write_enum (ob
->main_stream
, ld_plugin_symbol_resolution
,
519 LDPR_NUM_KNOWN
, node
->symbol
.resolution
);
522 /* Output the varpool NODE to OB.
523 If NODE is not in SET, then NODE is a boundary. */
526 lto_output_ref (struct lto_simple_output_block
*ob
, struct ipa_ref
*ref
,
527 lto_symtab_encoder_t encoder
)
532 bp
= bitpack_create (ob
->main_stream
);
533 bp_pack_value (&bp
, ref
->use
, 2);
534 streamer_write_bitpack (&bp
);
535 nref
= lto_symtab_encoder_lookup (encoder
, ref
->referred
);
536 gcc_assert (nref
!= LCC_NOT_FOUND
);
537 streamer_write_hwi_stream (ob
->main_stream
, nref
);
540 /* Stream out profile_summary to OB. */
543 output_profile_summary (struct lto_simple_output_block
*ob
)
547 /* We do not output num, sum_all and run_max, they are not used by
548 GCC profile feedback and they are difficult to merge from multiple
550 gcc_assert (profile_info
->runs
);
551 streamer_write_uhwi_stream (ob
->main_stream
, profile_info
->runs
);
552 streamer_write_uhwi_stream (ob
->main_stream
, profile_info
->sum_max
);
555 streamer_write_uhwi_stream (ob
->main_stream
, 0);
558 /* Add NODE into encoder as well as nodes it is cloned from.
559 Do it in a way so clones appear first. */
562 add_node_to (lto_symtab_encoder_t encoder
, struct cgraph_node
*node
,
566 add_node_to (encoder
, node
->clone_of
, include_body
);
567 else if (include_body
)
568 lto_set_symtab_encoder_encode_body (encoder
, node
);
569 lto_symtab_encoder_encode (encoder
, (symtab_node
)node
);
572 /* Add all references in LIST to encoders. */
575 add_references (lto_symtab_encoder_t encoder
,
576 struct ipa_ref_list
*list
)
580 for (i
= 0; ipa_ref_list_reference_iterate (list
, i
, ref
); i
++)
581 if (symtab_function_p (ref
->referred
))
582 add_node_to (encoder
, ipa_ref_node (ref
), false);
585 struct varpool_node
*vnode
= ipa_ref_varpool_node (ref
);
586 lto_symtab_encoder_encode (encoder
, (symtab_node
)vnode
);
590 /* Output all callees or indirect outgoing edges. EDGE must be the first such
594 output_outgoing_cgraph_edges (struct cgraph_edge
*edge
,
595 struct lto_simple_output_block
*ob
,
596 lto_symtab_encoder_t encoder
)
601 /* Output edges in backward direction, so the reconstructed callgraph match
602 and it is easy to associate call sites in the IPA pass summaries. */
603 while (edge
->next_callee
)
604 edge
= edge
->next_callee
;
605 for (; edge
; edge
= edge
->prev_callee
)
606 lto_output_edge (ob
, edge
, encoder
);
609 /* Output the part of the cgraph in SET. */
612 output_refs (lto_symtab_encoder_t encoder
)
614 lto_symtab_encoder_iterator lsei
;
615 struct lto_simple_output_block
*ob
;
620 ob
= lto_create_simple_output_block (LTO_section_refs
);
622 for (lsei
= lsei_start_in_partition (encoder
); !lsei_end_p (lsei
);
623 lsei_next_in_partition (&lsei
))
625 symtab_node node
= lsei_node (lsei
);
627 count
= ipa_ref_list_nreferences (&node
->symbol
.ref_list
);
630 streamer_write_uhwi_stream (ob
->main_stream
, count
);
631 streamer_write_uhwi_stream (ob
->main_stream
,
632 lto_symtab_encoder_lookup (encoder
, node
));
633 for (i
= 0; ipa_ref_list_reference_iterate (&node
->symbol
.ref_list
,
635 lto_output_ref (ob
, ref
, encoder
);
639 streamer_write_uhwi_stream (ob
->main_stream
, 0);
641 lto_destroy_simple_output_block (ob
);
644 /* Find out all cgraph and varpool nodes we want to encode in current unit
645 and insert them to encoders. */
647 compute_ltrans_boundary (struct lto_out_decl_state
*state
,
648 cgraph_node_set set
, varpool_node_set vset
)
650 struct cgraph_node
*node
;
651 cgraph_node_set_iterator csi
;
652 varpool_node_set_iterator vsi
;
653 struct cgraph_edge
*edge
;
655 lto_symtab_encoder_t encoder
;
657 encoder
= state
->symtab_node_encoder
= lto_symtab_encoder_new ();
659 /* Go over all the nodes in SET and assign references. */
660 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
662 node
= csi_node (csi
);
663 add_node_to (encoder
, node
, true);
664 lto_set_symtab_encoder_in_partition (encoder
, (symtab_node
)node
);
665 add_references (encoder
, &node
->symbol
.ref_list
);
667 for (vsi
= vsi_start (vset
); !vsi_end_p (vsi
); vsi_next (&vsi
))
669 struct varpool_node
*vnode
= vsi_node (vsi
);
670 gcc_assert (!vnode
->alias
|| vnode
->alias_of
);
671 lto_set_symtab_encoder_in_partition (encoder
, (symtab_node
)vnode
);
672 lto_set_symtab_encoder_encode_initializer (encoder
, vnode
);
673 add_references (encoder
, &vnode
->symbol
.ref_list
);
675 /* Pickle in also the initializer of all referenced readonly variables
676 to help folding. Constant pool variables are not shared, so we must
678 for (i
= 0; i
< lto_symtab_encoder_size (encoder
); i
++)
680 symtab_node node
= lto_symtab_encoder_deref (encoder
, i
);
681 if (symtab_variable_p (node
))
683 struct varpool_node
*vnode
= varpool (node
);
684 if (DECL_INITIAL (vnode
->symbol
.decl
)
685 && !lto_symtab_encoder_encode_initializer_p (encoder
,
687 && const_value_known_p (vnode
->symbol
.decl
))
689 lto_set_symtab_encoder_encode_initializer (encoder
, vnode
);
690 add_references (encoder
, &vnode
->symbol
.ref_list
);
692 else if (vnode
->alias
|| vnode
->alias_of
)
693 add_references (encoder
, &vnode
->symbol
.ref_list
);
697 /* Go over all the nodes again to include callees that are not in
699 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
701 node
= csi_node (csi
);
702 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
704 struct cgraph_node
*callee
= edge
->callee
;
705 if (!cgraph_node_in_set_p (callee
, set
))
707 /* We should have moved all the inlines. */
708 gcc_assert (!callee
->global
.inlined_to
);
709 add_node_to (encoder
, callee
, false);
715 /* Output the part of the symtab in SET and VSET. */
720 struct cgraph_node
*node
;
721 struct lto_simple_output_block
*ob
;
722 lto_symtab_encoder_iterator lsei
;
724 lto_symtab_encoder_t encoder
;
725 static bool asm_nodes_output
= false;
728 output_cgraph_opt_summary ();
730 ob
= lto_create_simple_output_block (LTO_section_symtab_nodes
);
732 output_profile_summary (ob
);
734 /* An encoder for cgraph nodes should have been created by
735 ipa_write_summaries_1. */
736 gcc_assert (ob
->decl_state
->symtab_node_encoder
);
737 encoder
= ob
->decl_state
->symtab_node_encoder
;
739 /* Write out the nodes. We must first output a node and then its clones,
740 otherwise at a time reading back the node there would be nothing to clone
742 n_nodes
= lto_symtab_encoder_size (encoder
);
743 for (i
= 0; i
< n_nodes
; i
++)
745 symtab_node node
= lto_symtab_encoder_deref (encoder
, i
);
746 if (symtab_function_p (node
))
747 lto_output_node (ob
, cgraph (node
), encoder
);
749 lto_output_varpool_node (ob
, varpool (node
), encoder
);
753 /* Go over the nodes in SET again to write edges. */
754 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
755 lsei_next_function_in_partition (&lsei
))
757 node
= lsei_cgraph_node (lsei
);
758 output_outgoing_cgraph_edges (node
->callees
, ob
, encoder
);
759 output_outgoing_cgraph_edges (node
->indirect_calls
, ob
, encoder
);
762 streamer_write_uhwi_stream (ob
->main_stream
, 0);
764 lto_destroy_simple_output_block (ob
);
766 /* Emit toplevel asms.
767 When doing WPA we must output every asm just once. Since we do not partition asm
768 nodes at all, output them to first output. This is kind of hack, but should work
770 if (!asm_nodes_output
)
772 asm_nodes_output
= true;
773 lto_output_toplevel_asms ();
776 output_refs (encoder
);
779 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
780 STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
781 NODE or to replace the values in it, for instance because the first
782 time we saw it, the function body was not available but now it
783 is. BP is a bitpack with all the bitflags for NODE read from the
787 input_overwrite_node (struct lto_file_decl_data
*file_data
,
788 struct cgraph_node
*node
,
789 enum LTO_symtab_tags tag
,
790 struct bitpack_d
*bp
)
792 node
->symbol
.aux
= (void *) tag
;
793 node
->symbol
.lto_file_data
= file_data
;
795 node
->local
.local
= bp_unpack_value (bp
, 1);
796 node
->symbol
.externally_visible
= bp_unpack_value (bp
, 1);
797 node
->local
.finalized
= bp_unpack_value (bp
, 1);
798 node
->local
.versionable
= bp_unpack_value (bp
, 1);
799 node
->local
.can_change_signature
= bp_unpack_value (bp
, 1);
800 node
->local
.redefined_extern_inline
= bp_unpack_value (bp
, 1);
801 node
->symbol
.force_output
= bp_unpack_value (bp
, 1);
802 node
->symbol
.address_taken
= bp_unpack_value (bp
, 1);
803 node
->abstract_and_needed
= bp_unpack_value (bp
, 1);
804 node
->symbol
.used_from_other_partition
= bp_unpack_value (bp
, 1);
805 node
->lowered
= bp_unpack_value (bp
, 1);
806 node
->analyzed
= tag
== LTO_symtab_analyzed_node
;
807 node
->symbol
.in_other_partition
= bp_unpack_value (bp
, 1);
808 if (node
->symbol
.in_other_partition
809 /* Avoid updating decl when we are seeing just inline clone.
810 When inlining function that has functions already inlined into it,
811 we produce clones of inline clones.
813 WPA partitioning might put each clone into different unit and
814 we might end up streaming inline clone from other partition
815 to support clone we are interested in. */
817 || node
->clone_of
->symbol
.decl
!= node
->symbol
.decl
))
819 DECL_EXTERNAL (node
->symbol
.decl
) = 1;
820 TREE_STATIC (node
->symbol
.decl
) = 0;
822 node
->alias
= bp_unpack_value (bp
, 1);
823 node
->frequency
= (enum node_frequency
)bp_unpack_value (bp
, 2);
824 node
->only_called_at_startup
= bp_unpack_value (bp
, 1);
825 node
->only_called_at_exit
= bp_unpack_value (bp
, 1);
826 node
->tm_clone
= bp_unpack_value (bp
, 1);
827 node
->thunk
.thunk_p
= bp_unpack_value (bp
, 1);
828 node
->symbol
.resolution
= bp_unpack_enum (bp
, ld_plugin_symbol_resolution
,
832 /* Read a node from input_block IB. TAG is the node's tag just read.
833 Return the node read or overwriten. */
835 static struct cgraph_node
*
836 input_node (struct lto_file_decl_data
*file_data
,
837 struct lto_input_block
*ib
,
838 enum LTO_symtab_tags tag
,
839 VEC(symtab_node
, heap
) *nodes
)
842 struct cgraph_node
*node
;
845 int ref
= LCC_NOT_FOUND
, ref2
= LCC_NOT_FOUND
;
849 order
= streamer_read_hwi (ib
) + order_base
;
850 clone_ref
= streamer_read_hwi (ib
);
852 decl_index
= streamer_read_uhwi (ib
);
853 fn_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
855 if (clone_ref
!= LCC_NOT_FOUND
)
857 node
= cgraph_clone_node (cgraph (VEC_index (symtab_node
, nodes
, clone_ref
)), fn_decl
,
858 0, CGRAPH_FREQ_BASE
, false, NULL
, false);
861 node
= cgraph_get_create_node (fn_decl
);
863 node
->symbol
.order
= order
;
864 if (order
>= symtab_order
)
865 symtab_order
= order
+ 1;
867 node
->count
= streamer_read_hwi (ib
);
868 node
->count_materialization_scale
= streamer_read_hwi (ib
);
870 if (tag
== LTO_symtab_analyzed_node
)
871 ref
= streamer_read_hwi (ib
);
873 ref2
= streamer_read_hwi (ib
);
875 /* Make sure that we have not read this node before. Nodes that
876 have already been read will have their tag stored in the 'aux'
877 field. Since built-in functions can be referenced in multiple
878 functions, they are expected to be read more than once. */
879 if (node
->symbol
.aux
&& !DECL_BUILT_IN (node
->symbol
.decl
))
880 internal_error ("bytecode stream: found multiple instances of cgraph "
881 "node %d", node
->uid
);
883 bp
= streamer_read_bitpack (ib
);
884 input_overwrite_node (file_data
, node
, tag
, &bp
);
886 /* Store a reference for now, and fix up later to be a pointer. */
887 node
->global
.inlined_to
= (cgraph_node_ptr
) (intptr_t) ref
;
889 /* Store a reference for now, and fix up later to be a pointer. */
890 node
->symbol
.same_comdat_group
= (symtab_node
) (intptr_t) ref2
;
892 if (node
->thunk
.thunk_p
)
894 int type
= streamer_read_uhwi (ib
);
895 HOST_WIDE_INT fixed_offset
= streamer_read_uhwi (ib
);
896 HOST_WIDE_INT virtual_value
= streamer_read_uhwi (ib
);
898 node
->thunk
.fixed_offset
= fixed_offset
;
899 node
->thunk
.this_adjusting
= (type
& 2);
900 node
->thunk
.virtual_value
= virtual_value
;
901 node
->thunk
.virtual_offset_p
= (type
& 4);
903 if (node
->thunk
.thunk_p
|| node
->alias
)
905 if (streamer_read_hwi_in_range (ib
, "alias nonzero flag", 0, 1))
907 decl_index
= streamer_read_uhwi (ib
);
908 node
->thunk
.alias
= lto_file_decl_data_get_fn_decl (file_data
,
915 /* Read a node from input_block IB. TAG is the node's tag just read.
916 Return the node read or overwriten. */
918 static struct varpool_node
*
919 input_varpool_node (struct lto_file_decl_data
*file_data
,
920 struct lto_input_block
*ib
)
924 struct varpool_node
*node
;
926 int ref
= LCC_NOT_FOUND
;
927 bool non_null_aliasof
;
930 order
= streamer_read_hwi (ib
) + order_base
;
931 decl_index
= streamer_read_uhwi (ib
);
932 var_decl
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
933 node
= varpool_node (var_decl
);
934 node
->symbol
.order
= order
;
935 if (order
>= symtab_order
)
936 symtab_order
= order
+ 1;
937 node
->symbol
.lto_file_data
= file_data
;
939 bp
= streamer_read_bitpack (ib
);
940 node
->symbol
.externally_visible
= bp_unpack_value (&bp
, 1);
941 node
->symbol
.force_output
= bp_unpack_value (&bp
, 1);
942 node
->finalized
= bp_unpack_value (&bp
, 1);
943 node
->alias
= bp_unpack_value (&bp
, 1);
944 non_null_aliasof
= bp_unpack_value (&bp
, 1);
945 node
->symbol
.used_from_other_partition
= bp_unpack_value (&bp
, 1);
946 node
->symbol
.in_other_partition
= bp_unpack_value (&bp
, 1);
947 node
->analyzed
= (node
->finalized
&& (!node
->alias
|| !node
->symbol
.in_other_partition
));
948 if (node
->symbol
.in_other_partition
)
950 DECL_EXTERNAL (node
->symbol
.decl
) = 1;
951 TREE_STATIC (node
->symbol
.decl
) = 0;
953 if (non_null_aliasof
)
955 decl_index
= streamer_read_uhwi (ib
);
956 node
->alias_of
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
958 ref
= streamer_read_hwi (ib
);
959 /* Store a reference for now, and fix up later to be a pointer. */
960 node
->symbol
.same_comdat_group
= (symtab_node
) (intptr_t) ref
;
961 node
->symbol
.resolution
= streamer_read_enum (ib
, ld_plugin_symbol_resolution
,
967 /* Read a node from input_block IB. TAG is the node's tag just read.
968 Return the node read or overwriten. */
971 input_ref (struct lto_input_block
*ib
,
972 symtab_node referring_node
,
973 VEC(symtab_node
, heap
) *nodes
)
975 symtab_node node
= NULL
;
977 enum ipa_ref_use use
;
979 bp
= streamer_read_bitpack (ib
);
980 use
= (enum ipa_ref_use
) bp_unpack_value (&bp
, 2);
981 node
= VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
));
982 ipa_record_reference (referring_node
, node
, use
, NULL
);
985 /* Read an edge from IB. NODES points to a vector of previously read nodes for
986 decoding caller and callee of the edge to be read. If INDIRECT is true, the
987 edge being read is indirect (in the sense that it has
988 indirect_unknown_callee set). */
991 input_edge (struct lto_input_block
*ib
, VEC(symtab_node
, heap
) *nodes
,
994 struct cgraph_node
*caller
, *callee
;
995 struct cgraph_edge
*edge
;
996 unsigned int stmt_id
;
999 cgraph_inline_failed_t inline_failed
;
1000 struct bitpack_d bp
;
1003 caller
= cgraph (VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
)));
1004 if (caller
== NULL
|| caller
->symbol
.decl
== NULL_TREE
)
1005 internal_error ("bytecode stream: no caller found while reading edge");
1009 callee
= cgraph (VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
)));
1010 if (callee
== NULL
|| callee
->symbol
.decl
== NULL_TREE
)
1011 internal_error ("bytecode stream: no callee found while reading edge");
1016 count
= (gcov_type
) streamer_read_hwi (ib
);
1018 bp
= streamer_read_bitpack (ib
);
1019 inline_failed
= bp_unpack_enum (&bp
, cgraph_inline_failed_enum
, CIF_N_REASONS
);
1020 stmt_id
= bp_unpack_var_len_unsigned (&bp
);
1021 freq
= (int) bp_unpack_var_len_unsigned (&bp
);
1024 edge
= cgraph_create_indirect_edge (caller
, NULL
, 0, count
, freq
);
1026 edge
= cgraph_create_edge (caller
, callee
, NULL
, count
, freq
);
1028 edge
->indirect_inlining_edge
= bp_unpack_value (&bp
, 1);
1029 edge
->lto_stmt_uid
= stmt_id
;
1030 edge
->inline_failed
= inline_failed
;
1031 edge
->call_stmt_cannot_inline_p
= bp_unpack_value (&bp
, 1);
1032 edge
->can_throw_external
= bp_unpack_value (&bp
, 1);
1035 if (bp_unpack_value (&bp
, 1))
1036 ecf_flags
|= ECF_CONST
;
1037 if (bp_unpack_value (&bp
, 1))
1038 ecf_flags
|= ECF_PURE
;
1039 if (bp_unpack_value (&bp
, 1))
1040 ecf_flags
|= ECF_NORETURN
;
1041 if (bp_unpack_value (&bp
, 1))
1042 ecf_flags
|= ECF_MALLOC
;
1043 if (bp_unpack_value (&bp
, 1))
1044 ecf_flags
|= ECF_NOTHROW
;
1045 if (bp_unpack_value (&bp
, 1))
1046 ecf_flags
|= ECF_RETURNS_TWICE
;
1047 edge
->indirect_info
->ecf_flags
= ecf_flags
;
1052 /* Read a cgraph from IB using the info in FILE_DATA. */
1054 static VEC(symtab_node
, heap
) *
1055 input_cgraph_1 (struct lto_file_decl_data
*file_data
,
1056 struct lto_input_block
*ib
)
1058 enum LTO_symtab_tags tag
;
1059 VEC(symtab_node
, heap
) *nodes
= NULL
;
1063 tag
= streamer_read_enum (ib
, LTO_symtab_tags
, LTO_symtab_last_tag
);
1064 order_base
= symtab_order
;
1067 if (tag
== LTO_symtab_edge
)
1068 input_edge (ib
, nodes
, false);
1069 else if (tag
== LTO_symtab_indirect_edge
)
1070 input_edge (ib
, nodes
, true);
1071 else if (tag
== LTO_symtab_variable
)
1073 node
= (symtab_node
)input_varpool_node (file_data
, ib
);
1074 VEC_safe_push (symtab_node
, heap
, nodes
, node
);
1075 lto_symtab_encoder_encode (file_data
->symtab_node_encoder
, node
);
1079 node
= (symtab_node
)input_node (file_data
, ib
, tag
, nodes
);
1080 if (node
== NULL
|| node
->symbol
.decl
== NULL_TREE
)
1081 internal_error ("bytecode stream: found empty cgraph node");
1082 VEC_safe_push (symtab_node
, heap
, nodes
, node
);
1083 lto_symtab_encoder_encode (file_data
->symtab_node_encoder
, node
);
1086 tag
= streamer_read_enum (ib
, LTO_symtab_tags
, LTO_symtab_last_tag
);
1089 lto_input_toplevel_asms (file_data
, order_base
);
1091 /* AUX pointers should be all non-zero for function nodes read from the stream. */
1092 #ifdef ENABLE_CHECKING
1093 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1094 gcc_assert (node
->symbol
.aux
|| !symtab_function_p (node
));
1096 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1099 if (symtab_function_p (node
))
1101 ref
= (int) (intptr_t) cgraph (node
)->global
.inlined_to
;
1103 /* We share declaration of builtins, so we may read same node twice. */
1104 if (!node
->symbol
.aux
)
1106 node
->symbol
.aux
= NULL
;
1108 /* Fixup inlined_to from reference to pointer. */
1109 if (ref
!= LCC_NOT_FOUND
)
1110 cgraph (node
)->global
.inlined_to
= cgraph (VEC_index (symtab_node
, nodes
, ref
));
1112 cgraph (node
)->global
.inlined_to
= NULL
;
1115 ref
= (int) (intptr_t) node
->symbol
.same_comdat_group
;
1117 /* Fixup same_comdat_group from reference to pointer. */
1118 if (ref
!= LCC_NOT_FOUND
)
1119 node
->symbol
.same_comdat_group
= VEC_index (symtab_node
, nodes
, ref
);
1121 node
->symbol
.same_comdat_group
= NULL
;
1123 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1124 node
->symbol
.aux
= symtab_function_p (node
) ? (void *)1 : NULL
;
1128 /* Input ipa_refs. */
1131 input_refs (struct lto_input_block
*ib
,
1132 VEC(symtab_node
, heap
) *nodes
)
1139 count
= streamer_read_uhwi (ib
);
1142 idx
= streamer_read_uhwi (ib
);
1143 node
= VEC_index (symtab_node
, nodes
, idx
);
1146 input_ref (ib
, node
, nodes
);
1153 static struct gcov_ctr_summary lto_gcov_summary
;
1155 /* Input profile_info from IB. */
1157 input_profile_summary (struct lto_input_block
*ib
,
1158 struct lto_file_decl_data
*file_data
)
1160 unsigned int runs
= streamer_read_uhwi (ib
);
1163 file_data
->profile_info
.runs
= runs
;
1164 file_data
->profile_info
.sum_max
= streamer_read_uhwi (ib
);
1169 /* Rescale profile summaries to the same number of runs in the whole unit. */
1172 merge_profile_summaries (struct lto_file_decl_data
**file_data_vec
)
1174 struct lto_file_decl_data
*file_data
;
1176 gcov_unsigned_t max_runs
= 0;
1177 struct cgraph_node
*node
;
1178 struct cgraph_edge
*edge
;
1180 /* Find unit with maximal number of runs. If we ever get serious about
1181 roundoff errors, we might also consider computing smallest common
1183 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1184 if (max_runs
< file_data
->profile_info
.runs
)
1185 max_runs
= file_data
->profile_info
.runs
;
1190 /* Simple overflow check. We probably don't need to support that many train
1191 runs. Such a large value probably imply data corruption anyway. */
1192 if (max_runs
> INT_MAX
/ REG_BR_PROB_BASE
)
1194 sorry ("At most %i profile runs is supported. Perhaps corrupted profile?",
1195 INT_MAX
/ REG_BR_PROB_BASE
);
1199 profile_info
= <o_gcov_summary
;
1200 lto_gcov_summary
.runs
= max_runs
;
1201 lto_gcov_summary
.sum_max
= 0;
1203 /* Rescale all units to the maximal number of runs.
1204 sum_max can not be easily merged, as we have no idea what files come from
1205 the same run. We do not use the info anyway, so leave it 0. */
1206 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1207 if (file_data
->profile_info
.runs
)
1209 int scale
= ((REG_BR_PROB_BASE
* max_runs
1210 + file_data
->profile_info
.runs
/ 2)
1211 / file_data
->profile_info
.runs
);
1212 lto_gcov_summary
.sum_max
= MAX (lto_gcov_summary
.sum_max
,
1213 (file_data
->profile_info
.sum_max
1215 + REG_BR_PROB_BASE
/ 2)
1216 / REG_BR_PROB_BASE
);
1219 /* Watch roundoff errors. */
1220 if (lto_gcov_summary
.sum_max
< max_runs
)
1221 lto_gcov_summary
.sum_max
= max_runs
;
1223 /* If merging already happent at WPA time, we are done. */
1227 /* Now compute count_materialization_scale of each node.
1228 During LTRANS we already have values of count_materialization_scale
1229 computed, so just update them. */
1230 FOR_EACH_FUNCTION (node
)
1231 if (node
->symbol
.lto_file_data
1232 && node
->symbol
.lto_file_data
->profile_info
.runs
)
1237 ((node
->count_materialization_scale
* max_runs
1238 + node
->symbol
.lto_file_data
->profile_info
.runs
/ 2)
1239 / node
->symbol
.lto_file_data
->profile_info
.runs
);
1240 node
->count_materialization_scale
= scale
;
1242 fatal_error ("Profile information in %s corrupted",
1243 file_data
->file_name
);
1245 if (scale
== REG_BR_PROB_BASE
)
1247 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1248 edge
->count
= ((edge
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1249 / REG_BR_PROB_BASE
);
1250 node
->count
= ((node
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1251 / REG_BR_PROB_BASE
);
1255 /* Input and merge the symtab from each of the .o files passed to
1261 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1262 struct lto_file_decl_data
*file_data
;
1264 struct cgraph_node
*node
;
1266 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1268 while ((file_data
= file_data_vec
[j
++]))
1272 struct lto_input_block
*ib
;
1273 VEC(symtab_node
, heap
) *nodes
;
1275 ib
= lto_create_simple_input_block (file_data
, LTO_section_symtab_nodes
,
1278 fatal_error ("cannot find LTO cgraph in %s", file_data
->file_name
);
1279 input_profile_summary (ib
, file_data
);
1280 file_data
->symtab_node_encoder
= lto_symtab_encoder_new ();
1281 nodes
= input_cgraph_1 (file_data
, ib
);
1282 lto_destroy_simple_input_block (file_data
, LTO_section_symtab_nodes
,
1285 ib
= lto_create_simple_input_block (file_data
, LTO_section_refs
,
1288 fatal_error("cannot find LTO section refs in %s", file_data
->file_name
);
1289 input_refs (ib
, nodes
);
1290 lto_destroy_simple_input_block (file_data
, LTO_section_refs
,
1293 input_cgraph_opt_summary (nodes
);
1294 VEC_free (symtab_node
, heap
, nodes
);
1297 merge_profile_summaries (file_data_vec
);
1299 /* Clear out the aux field that was used to store enough state to
1300 tell which nodes should be overwritten. */
1301 FOR_EACH_FUNCTION (node
)
1303 /* Some nodes may have been created by cgraph_node. This
1304 happens when the callgraph contains nested functions. If the
1305 node for the parent function was never emitted to the gimple
1306 file, cgraph_node will create a node for it when setting the
1307 context of the nested function. */
1308 if (node
->symbol
.lto_file_data
)
1309 node
->symbol
.aux
= NULL
;
1313 /* True when we need optimization summary for NODE. */
1316 output_cgraph_opt_summary_p (struct cgraph_node
*node
)
1318 return (node
->clone_of
1319 && (node
->clone
.tree_map
1320 || node
->clone
.args_to_skip
1321 || node
->clone
.combined_args_to_skip
));
1324 /* Output optimization summary for EDGE to OB. */
1326 output_edge_opt_summary (struct output_block
*ob ATTRIBUTE_UNUSED
,
1327 struct cgraph_edge
*edge ATTRIBUTE_UNUSED
)
1331 /* Output optimization summary for NODE to OB. */
1334 output_node_opt_summary (struct output_block
*ob
,
1335 struct cgraph_node
*node
,
1336 lto_symtab_encoder_t encoder
)
1340 struct ipa_replace_map
*map
;
1341 struct bitpack_d bp
;
1343 struct cgraph_edge
*e
;
1345 if (node
->clone
.args_to_skip
)
1347 streamer_write_uhwi (ob
, bitmap_count_bits (node
->clone
.args_to_skip
));
1348 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.args_to_skip
, 0, index
, bi
)
1349 streamer_write_uhwi (ob
, index
);
1352 streamer_write_uhwi (ob
, 0);
1353 if (node
->clone
.combined_args_to_skip
)
1355 streamer_write_uhwi (ob
, bitmap_count_bits (node
->clone
.combined_args_to_skip
));
1356 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.combined_args_to_skip
, 0, index
, bi
)
1357 streamer_write_uhwi (ob
, index
);
1360 streamer_write_uhwi (ob
, 0);
1361 streamer_write_uhwi (ob
, VEC_length (ipa_replace_map_p
,
1362 node
->clone
.tree_map
));
1363 FOR_EACH_VEC_ELT (ipa_replace_map_p
, node
->clone
.tree_map
, i
, map
)
1368 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->symbol
.decl
); parm
;
1369 parm
= DECL_CHAIN (parm
), parm_num
++)
1370 if (map
->old_tree
== parm
)
1372 /* At the moment we assume all old trees to be PARM_DECLs, because we have no
1373 mechanism to store function local declarations into summaries. */
1375 streamer_write_uhwi (ob
, parm_num
);
1376 stream_write_tree (ob
, map
->new_tree
, true);
1377 bp
= bitpack_create (ob
->main_stream
);
1378 bp_pack_value (&bp
, map
->replace_p
, 1);
1379 bp_pack_value (&bp
, map
->ref_p
, 1);
1380 streamer_write_bitpack (&bp
);
1383 if (lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
) node
))
1385 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1386 output_edge_opt_summary (ob
, e
);
1387 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1388 output_edge_opt_summary (ob
, e
);
1392 /* Output optimization summaries stored in callgraph.
1393 At the moment it is the clone info structure. */
1396 output_cgraph_opt_summary (void)
1400 lto_symtab_encoder_t encoder
;
1401 struct output_block
*ob
= create_output_block (LTO_section_cgraph_opt_sum
);
1404 ob
->cgraph_node
= NULL
;
1405 encoder
= ob
->decl_state
->symtab_node_encoder
;
1406 n_nodes
= lto_symtab_encoder_size (encoder
);
1407 for (i
= 0; i
< n_nodes
; i
++)
1408 if (symtab_function_p (node
= lto_symtab_encoder_deref (encoder
, i
))
1409 && output_cgraph_opt_summary_p (cgraph (node
)))
1411 streamer_write_uhwi (ob
, count
);
1412 for (i
= 0; i
< n_nodes
; i
++)
1414 node
= lto_symtab_encoder_deref (encoder
, i
);
1415 if (symtab_function_p (node
)
1416 && output_cgraph_opt_summary_p (cgraph (node
)))
1418 streamer_write_uhwi (ob
, i
);
1419 output_node_opt_summary (ob
, cgraph (node
), encoder
);
1422 produce_asm (ob
, NULL
);
1423 destroy_output_block (ob
);
1426 /* Input optimisation summary of EDGE. */
1429 input_edge_opt_summary (struct cgraph_edge
*edge ATTRIBUTE_UNUSED
,
1430 struct lto_input_block
*ib_main ATTRIBUTE_UNUSED
)
1434 /* Input optimisation summary of NODE. */
1437 input_node_opt_summary (struct cgraph_node
*node
,
1438 struct lto_input_block
*ib_main
,
1439 struct data_in
*data_in
)
1444 struct bitpack_d bp
;
1445 struct cgraph_edge
*e
;
1447 count
= streamer_read_uhwi (ib_main
);
1449 node
->clone
.args_to_skip
= BITMAP_GGC_ALLOC ();
1450 for (i
= 0; i
< count
; i
++)
1452 bit
= streamer_read_uhwi (ib_main
);
1453 bitmap_set_bit (node
->clone
.args_to_skip
, bit
);
1455 count
= streamer_read_uhwi (ib_main
);
1457 node
->clone
.combined_args_to_skip
= BITMAP_GGC_ALLOC ();
1458 for (i
= 0; i
< count
; i
++)
1460 bit
= streamer_read_uhwi (ib_main
);
1461 bitmap_set_bit (node
->clone
.combined_args_to_skip
, bit
);
1463 count
= streamer_read_uhwi (ib_main
);
1464 for (i
= 0; i
< count
; i
++)
1468 struct ipa_replace_map
*map
= ggc_alloc_ipa_replace_map ();
1470 VEC_safe_push (ipa_replace_map_p
, gc
, node
->clone
.tree_map
, map
);
1471 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->symbol
.decl
); parm_num
;
1472 parm
= DECL_CHAIN (parm
))
1474 map
->parm_num
= streamer_read_uhwi (ib_main
);
1475 map
->old_tree
= NULL
;
1476 map
->new_tree
= stream_read_tree (ib_main
, data_in
);
1477 bp
= streamer_read_bitpack (ib_main
);
1478 map
->replace_p
= bp_unpack_value (&bp
, 1);
1479 map
->ref_p
= bp_unpack_value (&bp
, 1);
1481 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1482 input_edge_opt_summary (e
, ib_main
);
1483 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1484 input_edge_opt_summary (e
, ib_main
);
1487 /* Read section in file FILE_DATA of length LEN with data DATA. */
1490 input_cgraph_opt_section (struct lto_file_decl_data
*file_data
,
1491 const char *data
, size_t len
, VEC (symtab_node
,
1494 const struct lto_function_header
*header
=
1495 (const struct lto_function_header
*) data
;
1496 const int cfg_offset
= sizeof (struct lto_function_header
);
1497 const int main_offset
= cfg_offset
+ header
->cfg_size
;
1498 const int string_offset
= main_offset
+ header
->main_size
;
1499 struct data_in
*data_in
;
1500 struct lto_input_block ib_main
;
1504 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
1508 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
1509 header
->string_size
, NULL
);
1510 count
= streamer_read_uhwi (&ib_main
);
1512 for (i
= 0; i
< count
; i
++)
1514 int ref
= streamer_read_uhwi (&ib_main
);
1515 input_node_opt_summary (cgraph (VEC_index (symtab_node
, nodes
, ref
)),
1518 lto_free_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
, data
,
1520 lto_data_in_delete (data_in
);
1523 /* Input optimization summary of cgraph. */
1526 input_cgraph_opt_summary (VEC (symtab_node
, heap
) * nodes
)
1528 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1529 struct lto_file_decl_data
*file_data
;
1532 while ((file_data
= file_data_vec
[j
++]))
1536 lto_get_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
,
1540 input_cgraph_opt_section (file_data
, data
, len
, nodes
);