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
;
87 /* Delete ENCODER and its components. */
90 lto_symtab_encoder_delete (lto_symtab_encoder_t encoder
)
92 VEC_free (lto_encoder_entry
, heap
, encoder
->nodes
);
93 pointer_map_destroy (encoder
->map
);
98 /* Return the existing reference number of NODE in the symtab encoder in
99 output block OB. Assign a new reference if this is the first time
103 lto_symtab_encoder_encode (lto_symtab_encoder_t encoder
,
109 slot
= pointer_map_contains (encoder
->map
, node
);
112 lto_encoder_entry entry
= {node
, false, false, false};
113 ref
= VEC_length (lto_encoder_entry
, encoder
->nodes
);
115 slot
= pointer_map_insert (encoder
->map
, node
);
116 *slot
= (void *) (intptr_t) (ref
+ 1);
117 VEC_safe_push (lto_encoder_entry
, heap
, encoder
->nodes
, &entry
);
120 ref
= (size_t) *slot
- 1;
125 /* Remove NODE from encoder. */
128 lto_symtab_encoder_delete_node (lto_symtab_encoder_t encoder
,
131 void **slot
, **last_slot
;
133 lto_encoder_entry last_node
;
135 slot
= pointer_map_contains (encoder
->map
, node
);
136 if (slot
== NULL
|| !*slot
)
139 index
= (size_t) *slot
- 1;
140 gcc_checking_assert (VEC_index (lto_encoder_entry
,
141 encoder
->nodes
, index
).node
144 /* Remove from vector. We do this by swapping node with the last element
146 last_node
= VEC_pop (lto_encoder_entry
, encoder
->nodes
);
147 if (last_node
.node
!= node
)
149 last_slot
= pointer_map_contains (encoder
->map
, last_node
.node
);
150 gcc_checking_assert (last_slot
&& *last_slot
);
151 *last_slot
= (void *)(size_t) (index
+ 1);
153 /* Move the last element to the original spot of NODE. */
154 VEC_replace (lto_encoder_entry
, encoder
->nodes
, index
,
158 /* Remove element from hash table. */
164 /* Return TRUE if we should encode initializer of NODE (if any). */
167 lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t encoder
,
168 struct cgraph_node
*node
)
170 int index
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)node
);
171 return VEC_index (lto_encoder_entry
, encoder
->nodes
, index
).body
;
174 /* Return TRUE if we should encode body of NODE (if any). */
177 lto_set_symtab_encoder_encode_body (lto_symtab_encoder_t encoder
,
178 struct cgraph_node
*node
)
180 int index
= lto_symtab_encoder_encode (encoder
, (symtab_node
)node
);
181 gcc_checking_assert (VEC_index (lto_encoder_entry
, encoder
->nodes
,
182 index
).node
== (symtab_node
)node
);
183 VEC_index (lto_encoder_entry
, encoder
->nodes
, index
).body
= true;
186 /* Return TRUE if we should encode initializer of NODE (if any). */
189 lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t encoder
,
190 struct varpool_node
*node
)
192 int index
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)node
);
193 if (index
== LCC_NOT_FOUND
)
195 return VEC_index (lto_encoder_entry
, encoder
->nodes
, index
).initializer
;
198 /* Return TRUE if we should encode initializer of NODE (if any). */
201 lto_set_symtab_encoder_encode_initializer (lto_symtab_encoder_t encoder
,
202 struct varpool_node
*node
)
204 int index
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)node
);
205 VEC_index (lto_encoder_entry
, encoder
->nodes
, index
).initializer
= true;
208 /* Return TRUE if we should encode initializer of NODE (if any). */
211 lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t encoder
,
214 int index
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)node
);
215 if (index
== LCC_NOT_FOUND
)
217 return VEC_index (lto_encoder_entry
, encoder
->nodes
, index
).in_partition
;
220 /* Return TRUE if we should encode body of NODE (if any). */
223 lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t encoder
,
226 int index
= lto_symtab_encoder_encode (encoder
, (symtab_node
)node
);
227 VEC_index (lto_encoder_entry
, encoder
->nodes
, index
).in_partition
= true;
230 /* Output the cgraph EDGE to OB using ENCODER. */
233 lto_output_edge (struct lto_simple_output_block
*ob
, struct cgraph_edge
*edge
,
234 lto_symtab_encoder_t encoder
)
240 if (edge
->indirect_unknown_callee
)
241 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
242 LTO_symtab_indirect_edge
);
244 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
247 ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)edge
->caller
);
248 gcc_assert (ref
!= LCC_NOT_FOUND
);
249 streamer_write_hwi_stream (ob
->main_stream
, ref
);
251 if (!edge
->indirect_unknown_callee
)
253 ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)edge
->callee
);
254 gcc_assert (ref
!= LCC_NOT_FOUND
);
255 streamer_write_hwi_stream (ob
->main_stream
, ref
);
258 streamer_write_hwi_stream (ob
->main_stream
, edge
->count
);
260 bp
= bitpack_create (ob
->main_stream
);
261 uid
= (!gimple_has_body_p (edge
->caller
->symbol
.decl
)
262 ? edge
->lto_stmt_uid
: gimple_uid (edge
->call_stmt
));
263 bp_pack_enum (&bp
, cgraph_inline_failed_enum
,
264 CIF_N_REASONS
, edge
->inline_failed
);
265 bp_pack_var_len_unsigned (&bp
, uid
);
266 bp_pack_var_len_unsigned (&bp
, edge
->frequency
);
267 bp_pack_value (&bp
, edge
->indirect_inlining_edge
, 1);
268 bp_pack_value (&bp
, edge
->call_stmt_cannot_inline_p
, 1);
269 bp_pack_value (&bp
, edge
->can_throw_external
, 1);
270 if (edge
->indirect_unknown_callee
)
272 int flags
= edge
->indirect_info
->ecf_flags
;
273 bp_pack_value (&bp
, (flags
& ECF_CONST
) != 0, 1);
274 bp_pack_value (&bp
, (flags
& ECF_PURE
) != 0, 1);
275 bp_pack_value (&bp
, (flags
& ECF_NORETURN
) != 0, 1);
276 bp_pack_value (&bp
, (flags
& ECF_MALLOC
) != 0, 1);
277 bp_pack_value (&bp
, (flags
& ECF_NOTHROW
) != 0, 1);
278 bp_pack_value (&bp
, (flags
& ECF_RETURNS_TWICE
) != 0, 1);
279 /* Flags that should not appear on indirect calls. */
280 gcc_assert (!(flags
& (ECF_LOOPING_CONST_OR_PURE
286 streamer_write_bitpack (&bp
);
289 /* Return if LIST contain references from other partitions. */
292 referenced_from_other_partition_p (struct ipa_ref_list
*list
, lto_symtab_encoder_t encoder
)
296 for (i
= 0; ipa_ref_list_referring_iterate (list
, i
, ref
); i
++)
298 if (ref
->referring
->symbol
.in_other_partition
299 || !lto_symtab_encoder_in_partition_p (encoder
, ref
->referring
))
305 /* Return true when node is reachable from other partition. */
308 reachable_from_other_partition_p (struct cgraph_node
*node
, lto_symtab_encoder_t encoder
)
310 struct cgraph_edge
*e
;
313 if (node
->global
.inlined_to
)
315 for (e
= node
->callers
; e
; e
= e
->next_caller
)
316 if (e
->caller
->symbol
.in_other_partition
317 || !lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)e
->caller
))
322 /* Return if LIST contain references from other partitions. */
325 referenced_from_this_partition_p (struct ipa_ref_list
*list
,
326 lto_symtab_encoder_t encoder
)
330 for (i
= 0; ipa_ref_list_referring_iterate (list
, i
, ref
); i
++)
331 if (lto_symtab_encoder_in_partition_p (encoder
, ref
->referring
))
336 /* Return true when node is reachable from other partition. */
339 reachable_from_this_partition_p (struct cgraph_node
*node
, lto_symtab_encoder_t encoder
)
341 struct cgraph_edge
*e
;
342 for (e
= node
->callers
; e
; e
= e
->next_caller
)
343 if (lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)e
->caller
))
348 /* Output the cgraph NODE to OB. ENCODER is used to find the
349 reference number of NODE->inlined_to. SET is the set of nodes we
350 are writing to the current file. If NODE is not in SET, then NODE
351 is a boundary of a cgraph_node_set and we pretend NODE just has a
352 decl and no callees. WRITTEN_DECLS is the set of FUNCTION_DECLs
353 that have had their callgraph node written so far. This is used to
354 determine if NODE is a clone of a previously written node. */
357 lto_output_node (struct lto_simple_output_block
*ob
, struct cgraph_node
*node
,
358 lto_symtab_encoder_t encoder
)
364 bool in_other_partition
= false;
365 struct cgraph_node
*clone_of
;
367 boundary_p
= !lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)node
);
369 if (node
->analyzed
&& !boundary_p
)
370 tag
= LTO_symtab_analyzed_node
;
372 tag
= LTO_symtab_unavail_node
;
374 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
376 streamer_write_hwi_stream (ob
->main_stream
, node
->symbol
.order
);
378 /* In WPA mode, we only output part of the call-graph. Also, we
379 fake cgraph node attributes. There are two cases that we care.
381 Boundary nodes: There are nodes that are not part of SET but are
382 called from within SET. We artificially make them look like
383 externally visible nodes with no function body.
385 Cherry-picked nodes: These are nodes we pulled from other
386 translation units into SET during IPA-inlining. We make them as
387 local static nodes to prevent clashes with other local statics. */
388 if (boundary_p
&& node
->analyzed
&& !DECL_EXTERNAL (node
->symbol
.decl
))
390 /* Inline clones can not be part of boundary.
391 gcc_assert (!node->global.inlined_to);
393 FIXME: At the moment they can be, when partition contains an inline
394 clone that is clone of inline clone from outside partition. We can
395 reshape the clone tree and make other tree to be the root, but it
396 needs a bit extra work and will be promplty done by cgraph_remove_node
397 after reading back. */
398 in_other_partition
= 1;
401 clone_of
= node
->clone_of
;
403 && (ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)clone_of
)) == LCC_NOT_FOUND
)
404 if (clone_of
->prev_sibling_clone
)
405 clone_of
= clone_of
->prev_sibling_clone
;
407 clone_of
= clone_of
->clone_of
;
409 if (LTO_symtab_analyzed_node
)
410 gcc_assert (clone_of
|| !node
->clone_of
);
412 streamer_write_hwi_stream (ob
->main_stream
, LCC_NOT_FOUND
);
414 streamer_write_hwi_stream (ob
->main_stream
, ref
);
417 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, node
->symbol
.decl
);
418 streamer_write_hwi_stream (ob
->main_stream
, node
->count
);
419 streamer_write_hwi_stream (ob
->main_stream
, node
->count_materialization_scale
);
421 if (tag
== LTO_symtab_analyzed_node
)
423 if (node
->global
.inlined_to
)
425 ref
= lto_symtab_encoder_lookup (encoder
, (symtab_node
)node
->global
.inlined_to
);
426 gcc_assert (ref
!= LCC_NOT_FOUND
);
431 streamer_write_hwi_stream (ob
->main_stream
, ref
);
434 if (node
->symbol
.same_comdat_group
&& !boundary_p
)
436 ref
= lto_symtab_encoder_lookup (encoder
,
437 node
->symbol
.same_comdat_group
);
438 gcc_assert (ref
!= LCC_NOT_FOUND
);
442 streamer_write_hwi_stream (ob
->main_stream
, ref
);
444 bp
= bitpack_create (ob
->main_stream
);
445 bp_pack_value (&bp
, node
->local
.local
, 1);
446 bp_pack_value (&bp
, node
->symbol
.externally_visible
, 1);
447 bp_pack_value (&bp
, node
->local
.finalized
, 1);
448 bp_pack_value (&bp
, node
->local
.versionable
, 1);
449 bp_pack_value (&bp
, node
->local
.can_change_signature
, 1);
450 bp_pack_value (&bp
, node
->local
.redefined_extern_inline
, 1);
451 bp_pack_value (&bp
, node
->symbol
.force_output
, 1);
452 bp_pack_value (&bp
, node
->symbol
.address_taken
, 1);
453 bp_pack_value (&bp
, node
->abstract_and_needed
, 1);
454 bp_pack_value (&bp
, tag
== LTO_symtab_analyzed_node
455 && !DECL_EXTERNAL (node
->symbol
.decl
)
456 && !DECL_COMDAT (node
->symbol
.decl
)
457 && (reachable_from_other_partition_p (node
, encoder
)
458 || referenced_from_other_partition_p (&node
->symbol
.ref_list
,
460 bp_pack_value (&bp
, node
->lowered
, 1);
461 bp_pack_value (&bp
, in_other_partition
, 1);
462 /* Real aliases in a boundary become non-aliases. However we still stream
463 alias info on weakrefs.
464 TODO: We lose a bit of information here - when we know that variable is
465 defined in other unit, we may use the info on aliases to resolve
466 symbol1 != symbol2 type tests that we can do only for locally defined objects
468 bp_pack_value (&bp
, node
->alias
&& (!boundary_p
|| DECL_EXTERNAL (node
->symbol
.decl
)), 1);
469 bp_pack_value (&bp
, node
->frequency
, 2);
470 bp_pack_value (&bp
, node
->only_called_at_startup
, 1);
471 bp_pack_value (&bp
, node
->only_called_at_exit
, 1);
472 bp_pack_value (&bp
, node
->tm_clone
, 1);
473 bp_pack_value (&bp
, node
->thunk
.thunk_p
&& !boundary_p
, 1);
474 bp_pack_enum (&bp
, ld_plugin_symbol_resolution
,
475 LDPR_NUM_KNOWN
, node
->symbol
.resolution
);
476 streamer_write_bitpack (&bp
);
478 if (node
->thunk
.thunk_p
&& !boundary_p
)
480 streamer_write_uhwi_stream
482 1 + (node
->thunk
.this_adjusting
!= 0) * 2
483 + (node
->thunk
.virtual_offset_p
!= 0) * 4);
484 streamer_write_uhwi_stream (ob
->main_stream
, node
->thunk
.fixed_offset
);
485 streamer_write_uhwi_stream (ob
->main_stream
, node
->thunk
.virtual_value
);
487 if ((node
->alias
|| node
->thunk
.thunk_p
)
488 && (!boundary_p
|| (node
->alias
&& DECL_EXTERNAL (node
->symbol
.decl
))))
490 streamer_write_hwi_in_range (ob
->main_stream
, 0, 1,
491 node
->thunk
.alias
!= NULL
);
492 if (node
->thunk
.alias
!= NULL
)
493 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
,
498 /* Output the varpool NODE to OB.
499 If NODE is not in SET, then NODE is a boundary. */
502 lto_output_varpool_node (struct lto_simple_output_block
*ob
, struct varpool_node
*node
,
503 lto_symtab_encoder_t encoder
)
505 bool boundary_p
= (node
->analyzed
506 && !lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)node
));
510 streamer_write_enum (ob
->main_stream
, LTO_symtab_tags
, LTO_symtab_last_tag
,
511 LTO_symtab_variable
);
512 streamer_write_hwi_stream (ob
->main_stream
, node
->symbol
.order
);
513 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, node
->symbol
.decl
);
514 bp
= bitpack_create (ob
->main_stream
);
515 bp_pack_value (&bp
, node
->symbol
.externally_visible
, 1);
516 bp_pack_value (&bp
, node
->symbol
.force_output
, 1);
517 bp_pack_value (&bp
, node
->finalized
, 1);
518 bp_pack_value (&bp
, node
->alias
, 1);
519 bp_pack_value (&bp
, node
->alias_of
!= NULL
, 1);
520 gcc_assert (node
->finalized
|| !node
->analyzed
);
521 /* Constant pool initializers can be de-unified into individual ltrans units.
522 FIXME: Alternatively at -Os we may want to avoid generating for them the local
523 labels and share them across LTRANS partitions. */
524 if (DECL_IN_CONSTANT_POOL (node
->symbol
.decl
)
525 && !DECL_EXTERNAL (node
->symbol
.decl
)
526 && !DECL_COMDAT (node
->symbol
.decl
))
528 bp_pack_value (&bp
, 0, 1); /* used_from_other_parition. */
529 bp_pack_value (&bp
, 0, 1); /* in_other_partition. */
533 bp_pack_value (&bp
, node
->analyzed
534 && referenced_from_other_partition_p (&node
->symbol
.ref_list
,
536 bp_pack_value (&bp
, boundary_p
&& !DECL_EXTERNAL (node
->symbol
.decl
), 1);
537 /* in_other_partition. */
539 streamer_write_bitpack (&bp
);
541 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, node
->alias_of
);
542 if (node
->symbol
.same_comdat_group
&& !boundary_p
)
544 ref
= lto_symtab_encoder_lookup (encoder
,
545 node
->symbol
.same_comdat_group
);
546 gcc_assert (ref
!= LCC_NOT_FOUND
);
550 streamer_write_hwi_stream (ob
->main_stream
, ref
);
551 streamer_write_enum (ob
->main_stream
, ld_plugin_symbol_resolution
,
552 LDPR_NUM_KNOWN
, node
->symbol
.resolution
);
555 /* Output the varpool NODE to OB.
556 If NODE is not in SET, then NODE is a boundary. */
559 lto_output_ref (struct lto_simple_output_block
*ob
, struct ipa_ref
*ref
,
560 lto_symtab_encoder_t encoder
)
565 bp
= bitpack_create (ob
->main_stream
);
566 bp_pack_value (&bp
, ref
->use
, 2);
567 streamer_write_bitpack (&bp
);
568 nref
= lto_symtab_encoder_lookup (encoder
, ref
->referred
);
569 gcc_assert (nref
!= LCC_NOT_FOUND
);
570 streamer_write_hwi_stream (ob
->main_stream
, nref
);
573 /* Stream out profile_summary to OB. */
576 output_profile_summary (struct lto_simple_output_block
*ob
)
580 /* We do not output num, sum_all and run_max, they are not used by
581 GCC profile feedback and they are difficult to merge from multiple
583 gcc_assert (profile_info
->runs
);
584 streamer_write_uhwi_stream (ob
->main_stream
, profile_info
->runs
);
585 streamer_write_uhwi_stream (ob
->main_stream
, profile_info
->sum_max
);
588 streamer_write_uhwi_stream (ob
->main_stream
, 0);
591 /* Output all callees or indirect outgoing edges. EDGE must be the first such
595 output_outgoing_cgraph_edges (struct cgraph_edge
*edge
,
596 struct lto_simple_output_block
*ob
,
597 lto_symtab_encoder_t encoder
)
602 /* Output edges in backward direction, so the reconstructed callgraph match
603 and it is easy to associate call sites in the IPA pass summaries. */
604 while (edge
->next_callee
)
605 edge
= edge
->next_callee
;
606 for (; edge
; edge
= edge
->prev_callee
)
607 lto_output_edge (ob
, edge
, encoder
);
610 /* Output the part of the cgraph in SET. */
613 output_refs (lto_symtab_encoder_t encoder
)
615 lto_symtab_encoder_iterator lsei
;
616 struct lto_simple_output_block
*ob
;
621 ob
= lto_create_simple_output_block (LTO_section_refs
);
623 for (lsei
= lsei_start_in_partition (encoder
); !lsei_end_p (lsei
);
624 lsei_next_in_partition (&lsei
))
626 symtab_node node
= lsei_node (lsei
);
628 count
= ipa_ref_list_nreferences (&node
->symbol
.ref_list
);
631 streamer_write_uhwi_stream (ob
->main_stream
, count
);
632 streamer_write_uhwi_stream (ob
->main_stream
,
633 lto_symtab_encoder_lookup (encoder
, node
));
634 for (i
= 0; ipa_ref_list_reference_iterate (&node
->symbol
.ref_list
,
636 lto_output_ref (ob
, ref
, encoder
);
640 streamer_write_uhwi_stream (ob
->main_stream
, 0);
642 lto_destroy_simple_output_block (ob
);
645 /* Add NODE into encoder as well as nodes it is cloned from.
646 Do it in a way so clones appear first. */
649 add_node_to (lto_symtab_encoder_t encoder
, struct cgraph_node
*node
,
653 add_node_to (encoder
, node
->clone_of
, include_body
);
654 else if (include_body
)
655 lto_set_symtab_encoder_encode_body (encoder
, node
);
656 lto_symtab_encoder_encode (encoder
, (symtab_node
)node
);
659 /* Add all references in LIST to encoders. */
662 add_references (lto_symtab_encoder_t encoder
,
663 struct ipa_ref_list
*list
)
667 for (i
= 0; ipa_ref_list_reference_iterate (list
, i
, ref
); i
++)
668 if (symtab_function_p (ref
->referred
))
669 add_node_to (encoder
, ipa_ref_node (ref
), false);
672 struct varpool_node
*vnode
= ipa_ref_varpool_node (ref
);
673 lto_symtab_encoder_encode (encoder
, (symtab_node
)vnode
);
677 /* Find all symbols we want to stream into given partition and insert them
680 The function actually replaces IN_ENCODER by new one. The reason is that
681 streaming code needs clone's origin to be streamed before clone. This
682 means that we need to insert the nodes in specific order. This order is
683 ignored by the partitioning logic earlier. */
686 compute_ltrans_boundary (lto_symtab_encoder_t in_encoder
)
688 struct cgraph_node
*node
;
689 struct cgraph_edge
*edge
;
691 lto_symtab_encoder_t encoder
;
692 lto_symtab_encoder_iterator lsei
;
694 encoder
= lto_symtab_encoder_new ();
696 /* Go over all entries in the IN_ENCODER and duplicate them to
697 ENCODER. At the same time insert masters of clones so
698 every master appears before clone. */
699 for (lsei
= lsei_start_function_in_partition (in_encoder
);
700 !lsei_end_p (lsei
); lsei_next_function_in_partition (&lsei
))
702 node
= lsei_cgraph_node (lsei
);
703 add_node_to (encoder
, node
, true);
704 lto_set_symtab_encoder_in_partition (encoder
, (symtab_node
)node
);
705 add_references (encoder
, &node
->symbol
.ref_list
);
707 for (lsei
= lsei_start_variable_in_partition (in_encoder
);
708 !lsei_end_p (lsei
); lsei_next_variable_in_partition (&lsei
))
710 struct varpool_node
*vnode
= lsei_varpool_node (lsei
);
711 gcc_assert (!vnode
->alias
|| vnode
->alias_of
);
712 lto_set_symtab_encoder_in_partition (encoder
, (symtab_node
)vnode
);
713 lto_set_symtab_encoder_encode_initializer (encoder
, vnode
);
714 add_references (encoder
, &vnode
->symbol
.ref_list
);
716 /* Pickle in also the initializer of all referenced readonly variables
717 to help folding. Constant pool variables are not shared, so we must
719 for (i
= 0; i
< lto_symtab_encoder_size (encoder
); i
++)
721 symtab_node node
= lto_symtab_encoder_deref (encoder
, i
);
722 if (symtab_variable_p (node
))
724 struct varpool_node
*vnode
= varpool (node
);
725 if (DECL_INITIAL (vnode
->symbol
.decl
)
726 && !lto_symtab_encoder_encode_initializer_p (encoder
,
728 && const_value_known_p (vnode
->symbol
.decl
))
730 lto_set_symtab_encoder_encode_initializer (encoder
, vnode
);
731 add_references (encoder
, &vnode
->symbol
.ref_list
);
736 /* Go over all the nodes again to include callees that are not in
738 for (lsei
= lsei_start_function_in_partition (encoder
);
739 !lsei_end_p (lsei
); lsei_next_function_in_partition (&lsei
))
741 node
= lsei_cgraph_node (lsei
);
742 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
744 struct cgraph_node
*callee
= edge
->callee
;
745 if (!lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)callee
))
747 /* We should have moved all the inlines. */
748 gcc_assert (!callee
->global
.inlined_to
);
749 add_node_to (encoder
, callee
, false);
753 lto_symtab_encoder_delete (in_encoder
);
757 /* Output the part of the symtab in SET and VSET. */
762 struct cgraph_node
*node
;
763 struct lto_simple_output_block
*ob
;
764 lto_symtab_encoder_iterator lsei
;
766 lto_symtab_encoder_t encoder
;
767 static bool asm_nodes_output
= false;
770 output_cgraph_opt_summary ();
772 ob
= lto_create_simple_output_block (LTO_section_symtab_nodes
);
774 output_profile_summary (ob
);
776 /* An encoder for cgraph nodes should have been created by
777 ipa_write_summaries_1. */
778 gcc_assert (ob
->decl_state
->symtab_node_encoder
);
779 encoder
= ob
->decl_state
->symtab_node_encoder
;
781 /* Write out the nodes. We must first output a node and then its clones,
782 otherwise at a time reading back the node there would be nothing to clone
784 n_nodes
= lto_symtab_encoder_size (encoder
);
785 for (i
= 0; i
< n_nodes
; i
++)
787 symtab_node node
= lto_symtab_encoder_deref (encoder
, i
);
788 if (symtab_function_p (node
))
789 lto_output_node (ob
, cgraph (node
), encoder
);
791 lto_output_varpool_node (ob
, varpool (node
), encoder
);
795 /* Go over the nodes in SET again to write edges. */
796 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
797 lsei_next_function_in_partition (&lsei
))
799 node
= lsei_cgraph_node (lsei
);
800 output_outgoing_cgraph_edges (node
->callees
, ob
, encoder
);
801 output_outgoing_cgraph_edges (node
->indirect_calls
, ob
, encoder
);
804 streamer_write_uhwi_stream (ob
->main_stream
, 0);
806 lto_destroy_simple_output_block (ob
);
808 /* Emit toplevel asms.
809 When doing WPA we must output every asm just once. Since we do not partition asm
810 nodes at all, output them to first output. This is kind of hack, but should work
812 if (!asm_nodes_output
)
814 asm_nodes_output
= true;
815 lto_output_toplevel_asms ();
818 output_refs (encoder
);
821 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
822 STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
823 NODE or to replace the values in it, for instance because the first
824 time we saw it, the function body was not available but now it
825 is. BP is a bitpack with all the bitflags for NODE read from the
829 input_overwrite_node (struct lto_file_decl_data
*file_data
,
830 struct cgraph_node
*node
,
831 enum LTO_symtab_tags tag
,
832 struct bitpack_d
*bp
)
834 node
->symbol
.aux
= (void *) tag
;
835 node
->symbol
.lto_file_data
= file_data
;
837 node
->local
.local
= bp_unpack_value (bp
, 1);
838 node
->symbol
.externally_visible
= bp_unpack_value (bp
, 1);
839 node
->local
.finalized
= bp_unpack_value (bp
, 1);
840 node
->local
.versionable
= bp_unpack_value (bp
, 1);
841 node
->local
.can_change_signature
= bp_unpack_value (bp
, 1);
842 node
->local
.redefined_extern_inline
= bp_unpack_value (bp
, 1);
843 node
->symbol
.force_output
= bp_unpack_value (bp
, 1);
844 node
->symbol
.address_taken
= bp_unpack_value (bp
, 1);
845 node
->abstract_and_needed
= bp_unpack_value (bp
, 1);
846 node
->symbol
.used_from_other_partition
= bp_unpack_value (bp
, 1);
847 node
->lowered
= bp_unpack_value (bp
, 1);
848 node
->analyzed
= tag
== LTO_symtab_analyzed_node
;
849 node
->symbol
.in_other_partition
= bp_unpack_value (bp
, 1);
850 if (node
->symbol
.in_other_partition
851 /* Avoid updating decl when we are seeing just inline clone.
852 When inlining function that has functions already inlined into it,
853 we produce clones of inline clones.
855 WPA partitioning might put each clone into different unit and
856 we might end up streaming inline clone from other partition
857 to support clone we are interested in. */
859 || node
->clone_of
->symbol
.decl
!= node
->symbol
.decl
))
861 DECL_EXTERNAL (node
->symbol
.decl
) = 1;
862 TREE_STATIC (node
->symbol
.decl
) = 0;
864 node
->alias
= bp_unpack_value (bp
, 1);
865 node
->frequency
= (enum node_frequency
)bp_unpack_value (bp
, 2);
866 node
->only_called_at_startup
= bp_unpack_value (bp
, 1);
867 node
->only_called_at_exit
= bp_unpack_value (bp
, 1);
868 node
->tm_clone
= bp_unpack_value (bp
, 1);
869 node
->thunk
.thunk_p
= bp_unpack_value (bp
, 1);
870 node
->symbol
.resolution
= bp_unpack_enum (bp
, ld_plugin_symbol_resolution
,
874 /* Read a node from input_block IB. TAG is the node's tag just read.
875 Return the node read or overwriten. */
877 static struct cgraph_node
*
878 input_node (struct lto_file_decl_data
*file_data
,
879 struct lto_input_block
*ib
,
880 enum LTO_symtab_tags tag
,
881 VEC(symtab_node
, heap
) *nodes
)
884 struct cgraph_node
*node
;
887 int ref
= LCC_NOT_FOUND
, ref2
= LCC_NOT_FOUND
;
891 order
= streamer_read_hwi (ib
) + order_base
;
892 clone_ref
= streamer_read_hwi (ib
);
894 decl_index
= streamer_read_uhwi (ib
);
895 fn_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
897 if (clone_ref
!= LCC_NOT_FOUND
)
899 node
= cgraph_clone_node (cgraph (VEC_index (symtab_node
, nodes
, clone_ref
)), fn_decl
,
900 0, CGRAPH_FREQ_BASE
, false, NULL
, false);
903 node
= cgraph_get_create_node (fn_decl
);
905 node
->symbol
.order
= order
;
906 if (order
>= symtab_order
)
907 symtab_order
= order
+ 1;
909 node
->count
= streamer_read_hwi (ib
);
910 node
->count_materialization_scale
= streamer_read_hwi (ib
);
912 if (tag
== LTO_symtab_analyzed_node
)
913 ref
= streamer_read_hwi (ib
);
915 ref2
= streamer_read_hwi (ib
);
917 /* Make sure that we have not read this node before. Nodes that
918 have already been read will have their tag stored in the 'aux'
919 field. Since built-in functions can be referenced in multiple
920 functions, they are expected to be read more than once. */
921 if (node
->symbol
.aux
&& !DECL_BUILT_IN (node
->symbol
.decl
))
922 internal_error ("bytecode stream: found multiple instances of cgraph "
923 "node %d", node
->uid
);
925 bp
= streamer_read_bitpack (ib
);
926 input_overwrite_node (file_data
, node
, tag
, &bp
);
928 /* Store a reference for now, and fix up later to be a pointer. */
929 node
->global
.inlined_to
= (cgraph_node_ptr
) (intptr_t) ref
;
931 /* Store a reference for now, and fix up later to be a pointer. */
932 node
->symbol
.same_comdat_group
= (symtab_node
) (intptr_t) ref2
;
934 if (node
->thunk
.thunk_p
)
936 int type
= streamer_read_uhwi (ib
);
937 HOST_WIDE_INT fixed_offset
= streamer_read_uhwi (ib
);
938 HOST_WIDE_INT virtual_value
= streamer_read_uhwi (ib
);
940 node
->thunk
.fixed_offset
= fixed_offset
;
941 node
->thunk
.this_adjusting
= (type
& 2);
942 node
->thunk
.virtual_value
= virtual_value
;
943 node
->thunk
.virtual_offset_p
= (type
& 4);
945 if (node
->thunk
.thunk_p
|| node
->alias
)
947 if (streamer_read_hwi_in_range (ib
, "alias nonzero flag", 0, 1))
949 decl_index
= streamer_read_uhwi (ib
);
950 node
->thunk
.alias
= lto_file_decl_data_get_fn_decl (file_data
,
957 /* Read a node from input_block IB. TAG is the node's tag just read.
958 Return the node read or overwriten. */
960 static struct varpool_node
*
961 input_varpool_node (struct lto_file_decl_data
*file_data
,
962 struct lto_input_block
*ib
)
966 struct varpool_node
*node
;
968 int ref
= LCC_NOT_FOUND
;
969 bool non_null_aliasof
;
972 order
= streamer_read_hwi (ib
) + order_base
;
973 decl_index
= streamer_read_uhwi (ib
);
974 var_decl
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
975 node
= varpool_node (var_decl
);
976 node
->symbol
.order
= order
;
977 if (order
>= symtab_order
)
978 symtab_order
= order
+ 1;
979 node
->symbol
.lto_file_data
= file_data
;
981 bp
= streamer_read_bitpack (ib
);
982 node
->symbol
.externally_visible
= bp_unpack_value (&bp
, 1);
983 node
->symbol
.force_output
= bp_unpack_value (&bp
, 1);
984 node
->finalized
= bp_unpack_value (&bp
, 1);
985 node
->alias
= bp_unpack_value (&bp
, 1);
986 non_null_aliasof
= bp_unpack_value (&bp
, 1);
987 node
->symbol
.used_from_other_partition
= bp_unpack_value (&bp
, 1);
988 node
->symbol
.in_other_partition
= bp_unpack_value (&bp
, 1);
989 node
->analyzed
= (node
->finalized
&& (!node
->alias
|| !node
->symbol
.in_other_partition
));
990 if (node
->symbol
.in_other_partition
)
992 DECL_EXTERNAL (node
->symbol
.decl
) = 1;
993 TREE_STATIC (node
->symbol
.decl
) = 0;
995 if (non_null_aliasof
)
997 decl_index
= streamer_read_uhwi (ib
);
998 node
->alias_of
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
1000 ref
= streamer_read_hwi (ib
);
1001 /* Store a reference for now, and fix up later to be a pointer. */
1002 node
->symbol
.same_comdat_group
= (symtab_node
) (intptr_t) ref
;
1003 node
->symbol
.resolution
= streamer_read_enum (ib
, ld_plugin_symbol_resolution
,
1009 /* Read a node from input_block IB. TAG is the node's tag just read.
1010 Return the node read or overwriten. */
1013 input_ref (struct lto_input_block
*ib
,
1014 symtab_node referring_node
,
1015 VEC(symtab_node
, heap
) *nodes
)
1017 symtab_node node
= NULL
;
1018 struct bitpack_d bp
;
1019 enum ipa_ref_use use
;
1021 bp
= streamer_read_bitpack (ib
);
1022 use
= (enum ipa_ref_use
) bp_unpack_value (&bp
, 2);
1023 node
= VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
));
1024 ipa_record_reference (referring_node
, node
, use
, NULL
);
1027 /* Read an edge from IB. NODES points to a vector of previously read nodes for
1028 decoding caller and callee of the edge to be read. If INDIRECT is true, the
1029 edge being read is indirect (in the sense that it has
1030 indirect_unknown_callee set). */
1033 input_edge (struct lto_input_block
*ib
, VEC(symtab_node
, heap
) *nodes
,
1036 struct cgraph_node
*caller
, *callee
;
1037 struct cgraph_edge
*edge
;
1038 unsigned int stmt_id
;
1041 cgraph_inline_failed_t inline_failed
;
1042 struct bitpack_d bp
;
1045 caller
= cgraph (VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
)));
1046 if (caller
== NULL
|| caller
->symbol
.decl
== NULL_TREE
)
1047 internal_error ("bytecode stream: no caller found while reading edge");
1051 callee
= cgraph (VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
)));
1052 if (callee
== NULL
|| callee
->symbol
.decl
== NULL_TREE
)
1053 internal_error ("bytecode stream: no callee found while reading edge");
1058 count
= (gcov_type
) streamer_read_hwi (ib
);
1060 bp
= streamer_read_bitpack (ib
);
1061 inline_failed
= bp_unpack_enum (&bp
, cgraph_inline_failed_enum
, CIF_N_REASONS
);
1062 stmt_id
= bp_unpack_var_len_unsigned (&bp
);
1063 freq
= (int) bp_unpack_var_len_unsigned (&bp
);
1066 edge
= cgraph_create_indirect_edge (caller
, NULL
, 0, count
, freq
);
1068 edge
= cgraph_create_edge (caller
, callee
, NULL
, count
, freq
);
1070 edge
->indirect_inlining_edge
= bp_unpack_value (&bp
, 1);
1071 edge
->lto_stmt_uid
= stmt_id
;
1072 edge
->inline_failed
= inline_failed
;
1073 edge
->call_stmt_cannot_inline_p
= bp_unpack_value (&bp
, 1);
1074 edge
->can_throw_external
= bp_unpack_value (&bp
, 1);
1077 if (bp_unpack_value (&bp
, 1))
1078 ecf_flags
|= ECF_CONST
;
1079 if (bp_unpack_value (&bp
, 1))
1080 ecf_flags
|= ECF_PURE
;
1081 if (bp_unpack_value (&bp
, 1))
1082 ecf_flags
|= ECF_NORETURN
;
1083 if (bp_unpack_value (&bp
, 1))
1084 ecf_flags
|= ECF_MALLOC
;
1085 if (bp_unpack_value (&bp
, 1))
1086 ecf_flags
|= ECF_NOTHROW
;
1087 if (bp_unpack_value (&bp
, 1))
1088 ecf_flags
|= ECF_RETURNS_TWICE
;
1089 edge
->indirect_info
->ecf_flags
= ecf_flags
;
1094 /* Read a cgraph from IB using the info in FILE_DATA. */
1096 static VEC(symtab_node
, heap
) *
1097 input_cgraph_1 (struct lto_file_decl_data
*file_data
,
1098 struct lto_input_block
*ib
)
1100 enum LTO_symtab_tags tag
;
1101 VEC(symtab_node
, heap
) *nodes
= NULL
;
1105 tag
= streamer_read_enum (ib
, LTO_symtab_tags
, LTO_symtab_last_tag
);
1106 order_base
= symtab_order
;
1109 if (tag
== LTO_symtab_edge
)
1110 input_edge (ib
, nodes
, false);
1111 else if (tag
== LTO_symtab_indirect_edge
)
1112 input_edge (ib
, nodes
, true);
1113 else if (tag
== LTO_symtab_variable
)
1115 node
= (symtab_node
)input_varpool_node (file_data
, ib
);
1116 VEC_safe_push (symtab_node
, heap
, nodes
, node
);
1117 lto_symtab_encoder_encode (file_data
->symtab_node_encoder
, node
);
1121 node
= (symtab_node
)input_node (file_data
, ib
, tag
, nodes
);
1122 if (node
== NULL
|| node
->symbol
.decl
== NULL_TREE
)
1123 internal_error ("bytecode stream: found empty cgraph node");
1124 VEC_safe_push (symtab_node
, heap
, nodes
, node
);
1125 lto_symtab_encoder_encode (file_data
->symtab_node_encoder
, node
);
1128 tag
= streamer_read_enum (ib
, LTO_symtab_tags
, LTO_symtab_last_tag
);
1131 lto_input_toplevel_asms (file_data
, order_base
);
1133 /* AUX pointers should be all non-zero for function nodes read from the stream. */
1134 #ifdef ENABLE_CHECKING
1135 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1136 gcc_assert (node
->symbol
.aux
|| !symtab_function_p (node
));
1138 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1141 if (symtab_function_p (node
))
1143 ref
= (int) (intptr_t) cgraph (node
)->global
.inlined_to
;
1145 /* We share declaration of builtins, so we may read same node twice. */
1146 if (!node
->symbol
.aux
)
1148 node
->symbol
.aux
= NULL
;
1150 /* Fixup inlined_to from reference to pointer. */
1151 if (ref
!= LCC_NOT_FOUND
)
1152 cgraph (node
)->global
.inlined_to
= cgraph (VEC_index (symtab_node
, nodes
, ref
));
1154 cgraph (node
)->global
.inlined_to
= NULL
;
1157 ref
= (int) (intptr_t) node
->symbol
.same_comdat_group
;
1159 /* Fixup same_comdat_group from reference to pointer. */
1160 if (ref
!= LCC_NOT_FOUND
)
1161 node
->symbol
.same_comdat_group
= VEC_index (symtab_node
, nodes
, ref
);
1163 node
->symbol
.same_comdat_group
= NULL
;
1165 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1166 node
->symbol
.aux
= symtab_function_p (node
) ? (void *)1 : NULL
;
1170 /* Input ipa_refs. */
1173 input_refs (struct lto_input_block
*ib
,
1174 VEC(symtab_node
, heap
) *nodes
)
1181 count
= streamer_read_uhwi (ib
);
1184 idx
= streamer_read_uhwi (ib
);
1185 node
= VEC_index (symtab_node
, nodes
, idx
);
1188 input_ref (ib
, node
, nodes
);
1195 static struct gcov_ctr_summary lto_gcov_summary
;
1197 /* Input profile_info from IB. */
1199 input_profile_summary (struct lto_input_block
*ib
,
1200 struct lto_file_decl_data
*file_data
)
1202 unsigned int runs
= streamer_read_uhwi (ib
);
1205 file_data
->profile_info
.runs
= runs
;
1206 file_data
->profile_info
.sum_max
= streamer_read_uhwi (ib
);
1211 /* Rescale profile summaries to the same number of runs in the whole unit. */
1214 merge_profile_summaries (struct lto_file_decl_data
**file_data_vec
)
1216 struct lto_file_decl_data
*file_data
;
1218 gcov_unsigned_t max_runs
= 0;
1219 struct cgraph_node
*node
;
1220 struct cgraph_edge
*edge
;
1222 /* Find unit with maximal number of runs. If we ever get serious about
1223 roundoff errors, we might also consider computing smallest common
1225 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1226 if (max_runs
< file_data
->profile_info
.runs
)
1227 max_runs
= file_data
->profile_info
.runs
;
1232 /* Simple overflow check. We probably don't need to support that many train
1233 runs. Such a large value probably imply data corruption anyway. */
1234 if (max_runs
> INT_MAX
/ REG_BR_PROB_BASE
)
1236 sorry ("At most %i profile runs is supported. Perhaps corrupted profile?",
1237 INT_MAX
/ REG_BR_PROB_BASE
);
1241 profile_info
= <o_gcov_summary
;
1242 lto_gcov_summary
.runs
= max_runs
;
1243 lto_gcov_summary
.sum_max
= 0;
1245 /* Rescale all units to the maximal number of runs.
1246 sum_max can not be easily merged, as we have no idea what files come from
1247 the same run. We do not use the info anyway, so leave it 0. */
1248 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1249 if (file_data
->profile_info
.runs
)
1251 int scale
= ((REG_BR_PROB_BASE
* max_runs
1252 + file_data
->profile_info
.runs
/ 2)
1253 / file_data
->profile_info
.runs
);
1254 lto_gcov_summary
.sum_max
= MAX (lto_gcov_summary
.sum_max
,
1255 (file_data
->profile_info
.sum_max
1257 + REG_BR_PROB_BASE
/ 2)
1258 / REG_BR_PROB_BASE
);
1261 /* Watch roundoff errors. */
1262 if (lto_gcov_summary
.sum_max
< max_runs
)
1263 lto_gcov_summary
.sum_max
= max_runs
;
1265 /* If merging already happent at WPA time, we are done. */
1269 /* Now compute count_materialization_scale of each node.
1270 During LTRANS we already have values of count_materialization_scale
1271 computed, so just update them. */
1272 FOR_EACH_FUNCTION (node
)
1273 if (node
->symbol
.lto_file_data
1274 && node
->symbol
.lto_file_data
->profile_info
.runs
)
1279 ((node
->count_materialization_scale
* max_runs
1280 + node
->symbol
.lto_file_data
->profile_info
.runs
/ 2)
1281 / node
->symbol
.lto_file_data
->profile_info
.runs
);
1282 node
->count_materialization_scale
= scale
;
1284 fatal_error ("Profile information in %s corrupted",
1285 file_data
->file_name
);
1287 if (scale
== REG_BR_PROB_BASE
)
1289 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1290 edge
->count
= ((edge
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1291 / REG_BR_PROB_BASE
);
1292 node
->count
= ((node
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1293 / REG_BR_PROB_BASE
);
1297 /* Input and merge the symtab from each of the .o files passed to
1303 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1304 struct lto_file_decl_data
*file_data
;
1306 struct cgraph_node
*node
;
1308 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1310 while ((file_data
= file_data_vec
[j
++]))
1314 struct lto_input_block
*ib
;
1315 VEC(symtab_node
, heap
) *nodes
;
1317 ib
= lto_create_simple_input_block (file_data
, LTO_section_symtab_nodes
,
1320 fatal_error ("cannot find LTO cgraph in %s", file_data
->file_name
);
1321 input_profile_summary (ib
, file_data
);
1322 file_data
->symtab_node_encoder
= lto_symtab_encoder_new ();
1323 nodes
= input_cgraph_1 (file_data
, ib
);
1324 lto_destroy_simple_input_block (file_data
, LTO_section_symtab_nodes
,
1327 ib
= lto_create_simple_input_block (file_data
, LTO_section_refs
,
1330 fatal_error("cannot find LTO section refs in %s", file_data
->file_name
);
1331 input_refs (ib
, nodes
);
1332 lto_destroy_simple_input_block (file_data
, LTO_section_refs
,
1335 input_cgraph_opt_summary (nodes
);
1336 VEC_free (symtab_node
, heap
, nodes
);
1339 merge_profile_summaries (file_data_vec
);
1341 /* Clear out the aux field that was used to store enough state to
1342 tell which nodes should be overwritten. */
1343 FOR_EACH_FUNCTION (node
)
1345 /* Some nodes may have been created by cgraph_node. This
1346 happens when the callgraph contains nested functions. If the
1347 node for the parent function was never emitted to the gimple
1348 file, cgraph_node will create a node for it when setting the
1349 context of the nested function. */
1350 if (node
->symbol
.lto_file_data
)
1351 node
->symbol
.aux
= NULL
;
1355 /* True when we need optimization summary for NODE. */
1358 output_cgraph_opt_summary_p (struct cgraph_node
*node
)
1360 return (node
->clone_of
1361 && (node
->clone
.tree_map
1362 || node
->clone
.args_to_skip
1363 || node
->clone
.combined_args_to_skip
));
1366 /* Output optimization summary for EDGE to OB. */
1368 output_edge_opt_summary (struct output_block
*ob ATTRIBUTE_UNUSED
,
1369 struct cgraph_edge
*edge ATTRIBUTE_UNUSED
)
1373 /* Output optimization summary for NODE to OB. */
1376 output_node_opt_summary (struct output_block
*ob
,
1377 struct cgraph_node
*node
,
1378 lto_symtab_encoder_t encoder
)
1382 struct ipa_replace_map
*map
;
1383 struct bitpack_d bp
;
1385 struct cgraph_edge
*e
;
1387 if (node
->clone
.args_to_skip
)
1389 streamer_write_uhwi (ob
, bitmap_count_bits (node
->clone
.args_to_skip
));
1390 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.args_to_skip
, 0, index
, bi
)
1391 streamer_write_uhwi (ob
, index
);
1394 streamer_write_uhwi (ob
, 0);
1395 if (node
->clone
.combined_args_to_skip
)
1397 streamer_write_uhwi (ob
, bitmap_count_bits (node
->clone
.combined_args_to_skip
));
1398 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.combined_args_to_skip
, 0, index
, bi
)
1399 streamer_write_uhwi (ob
, index
);
1402 streamer_write_uhwi (ob
, 0);
1403 streamer_write_uhwi (ob
, VEC_length (ipa_replace_map_p
,
1404 node
->clone
.tree_map
));
1405 FOR_EACH_VEC_ELT (ipa_replace_map_p
, node
->clone
.tree_map
, i
, map
)
1410 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->symbol
.decl
); parm
;
1411 parm
= DECL_CHAIN (parm
), parm_num
++)
1412 if (map
->old_tree
== parm
)
1414 /* At the moment we assume all old trees to be PARM_DECLs, because we have no
1415 mechanism to store function local declarations into summaries. */
1417 streamer_write_uhwi (ob
, parm_num
);
1418 stream_write_tree (ob
, map
->new_tree
, true);
1419 bp
= bitpack_create (ob
->main_stream
);
1420 bp_pack_value (&bp
, map
->replace_p
, 1);
1421 bp_pack_value (&bp
, map
->ref_p
, 1);
1422 streamer_write_bitpack (&bp
);
1425 if (lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
) node
))
1427 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1428 output_edge_opt_summary (ob
, e
);
1429 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1430 output_edge_opt_summary (ob
, e
);
1434 /* Output optimization summaries stored in callgraph.
1435 At the moment it is the clone info structure. */
1438 output_cgraph_opt_summary (void)
1442 lto_symtab_encoder_t encoder
;
1443 struct output_block
*ob
= create_output_block (LTO_section_cgraph_opt_sum
);
1446 ob
->cgraph_node
= NULL
;
1447 encoder
= ob
->decl_state
->symtab_node_encoder
;
1448 n_nodes
= lto_symtab_encoder_size (encoder
);
1449 for (i
= 0; i
< n_nodes
; i
++)
1450 if (symtab_function_p (node
= lto_symtab_encoder_deref (encoder
, i
))
1451 && output_cgraph_opt_summary_p (cgraph (node
)))
1453 streamer_write_uhwi (ob
, count
);
1454 for (i
= 0; i
< n_nodes
; i
++)
1456 node
= lto_symtab_encoder_deref (encoder
, i
);
1457 if (symtab_function_p (node
)
1458 && output_cgraph_opt_summary_p (cgraph (node
)))
1460 streamer_write_uhwi (ob
, i
);
1461 output_node_opt_summary (ob
, cgraph (node
), encoder
);
1464 produce_asm (ob
, NULL
);
1465 destroy_output_block (ob
);
1468 /* Input optimisation summary of EDGE. */
1471 input_edge_opt_summary (struct cgraph_edge
*edge ATTRIBUTE_UNUSED
,
1472 struct lto_input_block
*ib_main ATTRIBUTE_UNUSED
)
1476 /* Input optimisation summary of NODE. */
1479 input_node_opt_summary (struct cgraph_node
*node
,
1480 struct lto_input_block
*ib_main
,
1481 struct data_in
*data_in
)
1486 struct bitpack_d bp
;
1487 struct cgraph_edge
*e
;
1489 count
= streamer_read_uhwi (ib_main
);
1491 node
->clone
.args_to_skip
= BITMAP_GGC_ALLOC ();
1492 for (i
= 0; i
< count
; i
++)
1494 bit
= streamer_read_uhwi (ib_main
);
1495 bitmap_set_bit (node
->clone
.args_to_skip
, bit
);
1497 count
= streamer_read_uhwi (ib_main
);
1499 node
->clone
.combined_args_to_skip
= BITMAP_GGC_ALLOC ();
1500 for (i
= 0; i
< count
; i
++)
1502 bit
= streamer_read_uhwi (ib_main
);
1503 bitmap_set_bit (node
->clone
.combined_args_to_skip
, bit
);
1505 count
= streamer_read_uhwi (ib_main
);
1506 for (i
= 0; i
< count
; i
++)
1510 struct ipa_replace_map
*map
= ggc_alloc_ipa_replace_map ();
1512 VEC_safe_push (ipa_replace_map_p
, gc
, node
->clone
.tree_map
, map
);
1513 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->symbol
.decl
); parm_num
;
1514 parm
= DECL_CHAIN (parm
))
1516 map
->parm_num
= streamer_read_uhwi (ib_main
);
1517 map
->old_tree
= NULL
;
1518 map
->new_tree
= stream_read_tree (ib_main
, data_in
);
1519 bp
= streamer_read_bitpack (ib_main
);
1520 map
->replace_p
= bp_unpack_value (&bp
, 1);
1521 map
->ref_p
= bp_unpack_value (&bp
, 1);
1523 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1524 input_edge_opt_summary (e
, ib_main
);
1525 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1526 input_edge_opt_summary (e
, ib_main
);
1529 /* Read section in file FILE_DATA of length LEN with data DATA. */
1532 input_cgraph_opt_section (struct lto_file_decl_data
*file_data
,
1533 const char *data
, size_t len
, VEC (symtab_node
,
1536 const struct lto_function_header
*header
=
1537 (const struct lto_function_header
*) data
;
1538 const int cfg_offset
= sizeof (struct lto_function_header
);
1539 const int main_offset
= cfg_offset
+ header
->cfg_size
;
1540 const int string_offset
= main_offset
+ header
->main_size
;
1541 struct data_in
*data_in
;
1542 struct lto_input_block ib_main
;
1546 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
1550 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
1551 header
->string_size
, NULL
);
1552 count
= streamer_read_uhwi (&ib_main
);
1554 for (i
= 0; i
< count
; i
++)
1556 int ref
= streamer_read_uhwi (&ib_main
);
1557 input_node_opt_summary (cgraph (VEC_index (symtab_node
, nodes
, ref
)),
1560 lto_free_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
, data
,
1562 lto_data_in_delete (data_in
);
1565 /* Input optimization summary of cgraph. */
1568 input_cgraph_opt_summary (VEC (symtab_node
, heap
) * nodes
)
1570 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1571 struct lto_file_decl_data
*file_data
;
1574 while ((file_data
= file_data_vec
[j
++]))
1578 lto_get_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
,
1582 input_cgraph_opt_section (file_data
, data
, len
, nodes
);