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);
671 lto_symtab_encoder_encode (encoder
, ref
->referred
);
674 /* Find all symbols we want to stream into given partition and insert them
677 The function actually replaces IN_ENCODER by new one. The reason is that
678 streaming code needs clone's origin to be streamed before clone. This
679 means that we need to insert the nodes in specific order. This order is
680 ignored by the partitioning logic earlier. */
683 compute_ltrans_boundary (lto_symtab_encoder_t in_encoder
)
685 struct cgraph_node
*node
;
686 struct cgraph_edge
*edge
;
688 lto_symtab_encoder_t encoder
;
689 lto_symtab_encoder_iterator lsei
;
691 encoder
= lto_symtab_encoder_new ();
693 /* Go over all entries in the IN_ENCODER and duplicate them to
694 ENCODER. At the same time insert masters of clones so
695 every master appears before clone. */
696 for (lsei
= lsei_start_function_in_partition (in_encoder
);
697 !lsei_end_p (lsei
); lsei_next_function_in_partition (&lsei
))
699 node
= lsei_cgraph_node (lsei
);
700 add_node_to (encoder
, node
, true);
701 lto_set_symtab_encoder_in_partition (encoder
, (symtab_node
)node
);
702 add_references (encoder
, &node
->symbol
.ref_list
);
704 for (lsei
= lsei_start_variable_in_partition (in_encoder
);
705 !lsei_end_p (lsei
); lsei_next_variable_in_partition (&lsei
))
707 struct varpool_node
*vnode
= lsei_varpool_node (lsei
);
708 gcc_assert (!vnode
->alias
|| vnode
->alias_of
);
709 lto_set_symtab_encoder_in_partition (encoder
, (symtab_node
)vnode
);
710 lto_set_symtab_encoder_encode_initializer (encoder
, vnode
);
711 add_references (encoder
, &vnode
->symbol
.ref_list
);
713 /* Pickle in also the initializer of all referenced readonly variables
714 to help folding. Constant pool variables are not shared, so we must
716 for (i
= 0; i
< lto_symtab_encoder_size (encoder
); i
++)
718 symtab_node node
= lto_symtab_encoder_deref (encoder
, i
);
719 if (symtab_variable_p (node
))
721 struct varpool_node
*vnode
= varpool (node
);
722 if (DECL_INITIAL (vnode
->symbol
.decl
)
723 && !lto_symtab_encoder_encode_initializer_p (encoder
,
725 && const_value_known_p (vnode
->symbol
.decl
))
727 lto_set_symtab_encoder_encode_initializer (encoder
, vnode
);
728 add_references (encoder
, &vnode
->symbol
.ref_list
);
733 /* Go over all the nodes again to include callees that are not in
735 for (lsei
= lsei_start_function_in_partition (encoder
);
736 !lsei_end_p (lsei
); lsei_next_function_in_partition (&lsei
))
738 node
= lsei_cgraph_node (lsei
);
739 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
741 struct cgraph_node
*callee
= edge
->callee
;
742 if (!lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
)callee
))
744 /* We should have moved all the inlines. */
745 gcc_assert (!callee
->global
.inlined_to
);
746 add_node_to (encoder
, callee
, false);
750 lto_symtab_encoder_delete (in_encoder
);
754 /* Output the part of the symtab in SET and VSET. */
759 struct cgraph_node
*node
;
760 struct lto_simple_output_block
*ob
;
761 lto_symtab_encoder_iterator lsei
;
763 lto_symtab_encoder_t encoder
;
764 static bool asm_nodes_output
= false;
767 output_cgraph_opt_summary ();
769 ob
= lto_create_simple_output_block (LTO_section_symtab_nodes
);
771 output_profile_summary (ob
);
773 /* An encoder for cgraph nodes should have been created by
774 ipa_write_summaries_1. */
775 gcc_assert (ob
->decl_state
->symtab_node_encoder
);
776 encoder
= ob
->decl_state
->symtab_node_encoder
;
778 /* Write out the nodes. We must first output a node and then its clones,
779 otherwise at a time reading back the node there would be nothing to clone
781 n_nodes
= lto_symtab_encoder_size (encoder
);
782 for (i
= 0; i
< n_nodes
; i
++)
784 symtab_node node
= lto_symtab_encoder_deref (encoder
, i
);
785 if (symtab_function_p (node
))
786 lto_output_node (ob
, cgraph (node
), encoder
);
788 lto_output_varpool_node (ob
, varpool (node
), encoder
);
792 /* Go over the nodes in SET again to write edges. */
793 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
794 lsei_next_function_in_partition (&lsei
))
796 node
= lsei_cgraph_node (lsei
);
797 output_outgoing_cgraph_edges (node
->callees
, ob
, encoder
);
798 output_outgoing_cgraph_edges (node
->indirect_calls
, ob
, encoder
);
801 streamer_write_uhwi_stream (ob
->main_stream
, 0);
803 lto_destroy_simple_output_block (ob
);
805 /* Emit toplevel asms.
806 When doing WPA we must output every asm just once. Since we do not partition asm
807 nodes at all, output them to first output. This is kind of hack, but should work
809 if (!asm_nodes_output
)
811 asm_nodes_output
= true;
812 lto_output_toplevel_asms ();
815 output_refs (encoder
);
818 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
819 STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
820 NODE or to replace the values in it, for instance because the first
821 time we saw it, the function body was not available but now it
822 is. BP is a bitpack with all the bitflags for NODE read from the
826 input_overwrite_node (struct lto_file_decl_data
*file_data
,
827 struct cgraph_node
*node
,
828 enum LTO_symtab_tags tag
,
829 struct bitpack_d
*bp
)
831 node
->symbol
.aux
= (void *) tag
;
832 node
->symbol
.lto_file_data
= file_data
;
834 node
->local
.local
= bp_unpack_value (bp
, 1);
835 node
->symbol
.externally_visible
= bp_unpack_value (bp
, 1);
836 node
->local
.finalized
= bp_unpack_value (bp
, 1);
837 node
->local
.versionable
= bp_unpack_value (bp
, 1);
838 node
->local
.can_change_signature
= bp_unpack_value (bp
, 1);
839 node
->local
.redefined_extern_inline
= bp_unpack_value (bp
, 1);
840 node
->symbol
.force_output
= bp_unpack_value (bp
, 1);
841 node
->symbol
.address_taken
= bp_unpack_value (bp
, 1);
842 node
->abstract_and_needed
= bp_unpack_value (bp
, 1);
843 node
->symbol
.used_from_other_partition
= bp_unpack_value (bp
, 1);
844 node
->lowered
= bp_unpack_value (bp
, 1);
845 node
->analyzed
= tag
== LTO_symtab_analyzed_node
;
846 node
->symbol
.in_other_partition
= bp_unpack_value (bp
, 1);
847 if (node
->symbol
.in_other_partition
848 /* Avoid updating decl when we are seeing just inline clone.
849 When inlining function that has functions already inlined into it,
850 we produce clones of inline clones.
852 WPA partitioning might put each clone into different unit and
853 we might end up streaming inline clone from other partition
854 to support clone we are interested in. */
856 || node
->clone_of
->symbol
.decl
!= node
->symbol
.decl
))
858 DECL_EXTERNAL (node
->symbol
.decl
) = 1;
859 TREE_STATIC (node
->symbol
.decl
) = 0;
861 node
->alias
= bp_unpack_value (bp
, 1);
862 node
->frequency
= (enum node_frequency
)bp_unpack_value (bp
, 2);
863 node
->only_called_at_startup
= bp_unpack_value (bp
, 1);
864 node
->only_called_at_exit
= bp_unpack_value (bp
, 1);
865 node
->tm_clone
= bp_unpack_value (bp
, 1);
866 node
->thunk
.thunk_p
= bp_unpack_value (bp
, 1);
867 node
->symbol
.resolution
= bp_unpack_enum (bp
, ld_plugin_symbol_resolution
,
871 /* Read a node from input_block IB. TAG is the node's tag just read.
872 Return the node read or overwriten. */
874 static struct cgraph_node
*
875 input_node (struct lto_file_decl_data
*file_data
,
876 struct lto_input_block
*ib
,
877 enum LTO_symtab_tags tag
,
878 VEC(symtab_node
, heap
) *nodes
)
881 struct cgraph_node
*node
;
884 int ref
= LCC_NOT_FOUND
, ref2
= LCC_NOT_FOUND
;
888 order
= streamer_read_hwi (ib
) + order_base
;
889 clone_ref
= streamer_read_hwi (ib
);
891 decl_index
= streamer_read_uhwi (ib
);
892 fn_decl
= lto_file_decl_data_get_fn_decl (file_data
, decl_index
);
894 if (clone_ref
!= LCC_NOT_FOUND
)
896 node
= cgraph_clone_node (cgraph (VEC_index (symtab_node
, nodes
, clone_ref
)), fn_decl
,
897 0, CGRAPH_FREQ_BASE
, false, NULL
, false);
900 node
= cgraph_get_create_node (fn_decl
);
902 node
->symbol
.order
= order
;
903 if (order
>= symtab_order
)
904 symtab_order
= order
+ 1;
906 node
->count
= streamer_read_hwi (ib
);
907 node
->count_materialization_scale
= streamer_read_hwi (ib
);
909 if (tag
== LTO_symtab_analyzed_node
)
910 ref
= streamer_read_hwi (ib
);
912 ref2
= streamer_read_hwi (ib
);
914 /* Make sure that we have not read this node before. Nodes that
915 have already been read will have their tag stored in the 'aux'
916 field. Since built-in functions can be referenced in multiple
917 functions, they are expected to be read more than once. */
918 if (node
->symbol
.aux
&& !DECL_BUILT_IN (node
->symbol
.decl
))
919 internal_error ("bytecode stream: found multiple instances of cgraph "
920 "node %d", node
->uid
);
922 bp
= streamer_read_bitpack (ib
);
923 input_overwrite_node (file_data
, node
, tag
, &bp
);
925 /* Store a reference for now, and fix up later to be a pointer. */
926 node
->global
.inlined_to
= (cgraph_node_ptr
) (intptr_t) ref
;
928 /* Store a reference for now, and fix up later to be a pointer. */
929 node
->symbol
.same_comdat_group
= (symtab_node
) (intptr_t) ref2
;
931 if (node
->thunk
.thunk_p
)
933 int type
= streamer_read_uhwi (ib
);
934 HOST_WIDE_INT fixed_offset
= streamer_read_uhwi (ib
);
935 HOST_WIDE_INT virtual_value
= streamer_read_uhwi (ib
);
937 node
->thunk
.fixed_offset
= fixed_offset
;
938 node
->thunk
.this_adjusting
= (type
& 2);
939 node
->thunk
.virtual_value
= virtual_value
;
940 node
->thunk
.virtual_offset_p
= (type
& 4);
942 if (node
->thunk
.thunk_p
|| node
->alias
)
944 if (streamer_read_hwi_in_range (ib
, "alias nonzero flag", 0, 1))
946 decl_index
= streamer_read_uhwi (ib
);
947 node
->thunk
.alias
= lto_file_decl_data_get_fn_decl (file_data
,
954 /* Read a node from input_block IB. TAG is the node's tag just read.
955 Return the node read or overwriten. */
957 static struct varpool_node
*
958 input_varpool_node (struct lto_file_decl_data
*file_data
,
959 struct lto_input_block
*ib
)
963 struct varpool_node
*node
;
965 int ref
= LCC_NOT_FOUND
;
966 bool non_null_aliasof
;
969 order
= streamer_read_hwi (ib
) + order_base
;
970 decl_index
= streamer_read_uhwi (ib
);
971 var_decl
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
972 node
= varpool_node (var_decl
);
973 node
->symbol
.order
= order
;
974 if (order
>= symtab_order
)
975 symtab_order
= order
+ 1;
976 node
->symbol
.lto_file_data
= file_data
;
978 bp
= streamer_read_bitpack (ib
);
979 node
->symbol
.externally_visible
= bp_unpack_value (&bp
, 1);
980 node
->symbol
.force_output
= bp_unpack_value (&bp
, 1);
981 node
->finalized
= bp_unpack_value (&bp
, 1);
982 node
->alias
= bp_unpack_value (&bp
, 1);
983 non_null_aliasof
= bp_unpack_value (&bp
, 1);
984 node
->symbol
.used_from_other_partition
= bp_unpack_value (&bp
, 1);
985 node
->symbol
.in_other_partition
= bp_unpack_value (&bp
, 1);
986 node
->analyzed
= (node
->finalized
&& (!node
->alias
|| !node
->symbol
.in_other_partition
));
987 if (node
->symbol
.in_other_partition
)
989 DECL_EXTERNAL (node
->symbol
.decl
) = 1;
990 TREE_STATIC (node
->symbol
.decl
) = 0;
992 if (non_null_aliasof
)
994 decl_index
= streamer_read_uhwi (ib
);
995 node
->alias_of
= lto_file_decl_data_get_var_decl (file_data
, decl_index
);
997 ref
= streamer_read_hwi (ib
);
998 /* Store a reference for now, and fix up later to be a pointer. */
999 node
->symbol
.same_comdat_group
= (symtab_node
) (intptr_t) ref
;
1000 node
->symbol
.resolution
= streamer_read_enum (ib
, ld_plugin_symbol_resolution
,
1006 /* Read a node from input_block IB. TAG is the node's tag just read.
1007 Return the node read or overwriten. */
1010 input_ref (struct lto_input_block
*ib
,
1011 symtab_node referring_node
,
1012 VEC(symtab_node
, heap
) *nodes
)
1014 symtab_node node
= NULL
;
1015 struct bitpack_d bp
;
1016 enum ipa_ref_use use
;
1018 bp
= streamer_read_bitpack (ib
);
1019 use
= (enum ipa_ref_use
) bp_unpack_value (&bp
, 2);
1020 node
= VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
));
1021 ipa_record_reference (referring_node
, node
, use
, NULL
);
1024 /* Read an edge from IB. NODES points to a vector of previously read nodes for
1025 decoding caller and callee of the edge to be read. If INDIRECT is true, the
1026 edge being read is indirect (in the sense that it has
1027 indirect_unknown_callee set). */
1030 input_edge (struct lto_input_block
*ib
, VEC(symtab_node
, heap
) *nodes
,
1033 struct cgraph_node
*caller
, *callee
;
1034 struct cgraph_edge
*edge
;
1035 unsigned int stmt_id
;
1038 cgraph_inline_failed_t inline_failed
;
1039 struct bitpack_d bp
;
1042 caller
= cgraph (VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
)));
1043 if (caller
== NULL
|| caller
->symbol
.decl
== NULL_TREE
)
1044 internal_error ("bytecode stream: no caller found while reading edge");
1048 callee
= cgraph (VEC_index (symtab_node
, nodes
, streamer_read_hwi (ib
)));
1049 if (callee
== NULL
|| callee
->symbol
.decl
== NULL_TREE
)
1050 internal_error ("bytecode stream: no callee found while reading edge");
1055 count
= (gcov_type
) streamer_read_hwi (ib
);
1057 bp
= streamer_read_bitpack (ib
);
1058 inline_failed
= bp_unpack_enum (&bp
, cgraph_inline_failed_enum
, CIF_N_REASONS
);
1059 stmt_id
= bp_unpack_var_len_unsigned (&bp
);
1060 freq
= (int) bp_unpack_var_len_unsigned (&bp
);
1063 edge
= cgraph_create_indirect_edge (caller
, NULL
, 0, count
, freq
);
1065 edge
= cgraph_create_edge (caller
, callee
, NULL
, count
, freq
);
1067 edge
->indirect_inlining_edge
= bp_unpack_value (&bp
, 1);
1068 edge
->lto_stmt_uid
= stmt_id
;
1069 edge
->inline_failed
= inline_failed
;
1070 edge
->call_stmt_cannot_inline_p
= bp_unpack_value (&bp
, 1);
1071 edge
->can_throw_external
= bp_unpack_value (&bp
, 1);
1074 if (bp_unpack_value (&bp
, 1))
1075 ecf_flags
|= ECF_CONST
;
1076 if (bp_unpack_value (&bp
, 1))
1077 ecf_flags
|= ECF_PURE
;
1078 if (bp_unpack_value (&bp
, 1))
1079 ecf_flags
|= ECF_NORETURN
;
1080 if (bp_unpack_value (&bp
, 1))
1081 ecf_flags
|= ECF_MALLOC
;
1082 if (bp_unpack_value (&bp
, 1))
1083 ecf_flags
|= ECF_NOTHROW
;
1084 if (bp_unpack_value (&bp
, 1))
1085 ecf_flags
|= ECF_RETURNS_TWICE
;
1086 edge
->indirect_info
->ecf_flags
= ecf_flags
;
1091 /* Read a cgraph from IB using the info in FILE_DATA. */
1093 static VEC(symtab_node
, heap
) *
1094 input_cgraph_1 (struct lto_file_decl_data
*file_data
,
1095 struct lto_input_block
*ib
)
1097 enum LTO_symtab_tags tag
;
1098 VEC(symtab_node
, heap
) *nodes
= NULL
;
1102 tag
= streamer_read_enum (ib
, LTO_symtab_tags
, LTO_symtab_last_tag
);
1103 order_base
= symtab_order
;
1106 if (tag
== LTO_symtab_edge
)
1107 input_edge (ib
, nodes
, false);
1108 else if (tag
== LTO_symtab_indirect_edge
)
1109 input_edge (ib
, nodes
, true);
1110 else if (tag
== LTO_symtab_variable
)
1112 node
= (symtab_node
)input_varpool_node (file_data
, ib
);
1113 VEC_safe_push (symtab_node
, heap
, nodes
, node
);
1114 lto_symtab_encoder_encode (file_data
->symtab_node_encoder
, node
);
1118 node
= (symtab_node
)input_node (file_data
, ib
, tag
, nodes
);
1119 if (node
== NULL
|| node
->symbol
.decl
== NULL_TREE
)
1120 internal_error ("bytecode stream: found empty cgraph node");
1121 VEC_safe_push (symtab_node
, heap
, nodes
, node
);
1122 lto_symtab_encoder_encode (file_data
->symtab_node_encoder
, node
);
1125 tag
= streamer_read_enum (ib
, LTO_symtab_tags
, LTO_symtab_last_tag
);
1128 lto_input_toplevel_asms (file_data
, order_base
);
1130 /* AUX pointers should be all non-zero for function nodes read from the stream. */
1131 #ifdef ENABLE_CHECKING
1132 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1133 gcc_assert (node
->symbol
.aux
|| !symtab_function_p (node
));
1135 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1138 if (symtab_function_p (node
))
1140 ref
= (int) (intptr_t) cgraph (node
)->global
.inlined_to
;
1142 /* We share declaration of builtins, so we may read same node twice. */
1143 if (!node
->symbol
.aux
)
1145 node
->symbol
.aux
= NULL
;
1147 /* Fixup inlined_to from reference to pointer. */
1148 if (ref
!= LCC_NOT_FOUND
)
1149 cgraph (node
)->global
.inlined_to
= cgraph (VEC_index (symtab_node
, nodes
, ref
));
1151 cgraph (node
)->global
.inlined_to
= NULL
;
1154 ref
= (int) (intptr_t) node
->symbol
.same_comdat_group
;
1156 /* Fixup same_comdat_group from reference to pointer. */
1157 if (ref
!= LCC_NOT_FOUND
)
1158 node
->symbol
.same_comdat_group
= VEC_index (symtab_node
, nodes
, ref
);
1160 node
->symbol
.same_comdat_group
= NULL
;
1162 FOR_EACH_VEC_ELT (symtab_node
, nodes
, i
, node
)
1163 node
->symbol
.aux
= symtab_function_p (node
) ? (void *)1 : NULL
;
1167 /* Input ipa_refs. */
1170 input_refs (struct lto_input_block
*ib
,
1171 VEC(symtab_node
, heap
) *nodes
)
1178 count
= streamer_read_uhwi (ib
);
1181 idx
= streamer_read_uhwi (ib
);
1182 node
= VEC_index (symtab_node
, nodes
, idx
);
1185 input_ref (ib
, node
, nodes
);
1192 static struct gcov_ctr_summary lto_gcov_summary
;
1194 /* Input profile_info from IB. */
1196 input_profile_summary (struct lto_input_block
*ib
,
1197 struct lto_file_decl_data
*file_data
)
1199 unsigned int runs
= streamer_read_uhwi (ib
);
1202 file_data
->profile_info
.runs
= runs
;
1203 file_data
->profile_info
.sum_max
= streamer_read_uhwi (ib
);
1208 /* Rescale profile summaries to the same number of runs in the whole unit. */
1211 merge_profile_summaries (struct lto_file_decl_data
**file_data_vec
)
1213 struct lto_file_decl_data
*file_data
;
1215 gcov_unsigned_t max_runs
= 0;
1216 struct cgraph_node
*node
;
1217 struct cgraph_edge
*edge
;
1219 /* Find unit with maximal number of runs. If we ever get serious about
1220 roundoff errors, we might also consider computing smallest common
1222 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1223 if (max_runs
< file_data
->profile_info
.runs
)
1224 max_runs
= file_data
->profile_info
.runs
;
1229 /* Simple overflow check. We probably don't need to support that many train
1230 runs. Such a large value probably imply data corruption anyway. */
1231 if (max_runs
> INT_MAX
/ REG_BR_PROB_BASE
)
1233 sorry ("At most %i profile runs is supported. Perhaps corrupted profile?",
1234 INT_MAX
/ REG_BR_PROB_BASE
);
1238 profile_info
= <o_gcov_summary
;
1239 lto_gcov_summary
.runs
= max_runs
;
1240 lto_gcov_summary
.sum_max
= 0;
1242 /* Rescale all units to the maximal number of runs.
1243 sum_max can not be easily merged, as we have no idea what files come from
1244 the same run. We do not use the info anyway, so leave it 0. */
1245 for (j
= 0; (file_data
= file_data_vec
[j
]) != NULL
; j
++)
1246 if (file_data
->profile_info
.runs
)
1248 int scale
= ((REG_BR_PROB_BASE
* max_runs
1249 + file_data
->profile_info
.runs
/ 2)
1250 / file_data
->profile_info
.runs
);
1251 lto_gcov_summary
.sum_max
= MAX (lto_gcov_summary
.sum_max
,
1252 (file_data
->profile_info
.sum_max
1254 + REG_BR_PROB_BASE
/ 2)
1255 / REG_BR_PROB_BASE
);
1258 /* Watch roundoff errors. */
1259 if (lto_gcov_summary
.sum_max
< max_runs
)
1260 lto_gcov_summary
.sum_max
= max_runs
;
1262 /* If merging already happent at WPA time, we are done. */
1266 /* Now compute count_materialization_scale of each node.
1267 During LTRANS we already have values of count_materialization_scale
1268 computed, so just update them. */
1269 FOR_EACH_FUNCTION (node
)
1270 if (node
->symbol
.lto_file_data
1271 && node
->symbol
.lto_file_data
->profile_info
.runs
)
1276 ((node
->count_materialization_scale
* max_runs
1277 + node
->symbol
.lto_file_data
->profile_info
.runs
/ 2)
1278 / node
->symbol
.lto_file_data
->profile_info
.runs
);
1279 node
->count_materialization_scale
= scale
;
1281 fatal_error ("Profile information in %s corrupted",
1282 file_data
->file_name
);
1284 if (scale
== REG_BR_PROB_BASE
)
1286 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1287 edge
->count
= ((edge
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1288 / REG_BR_PROB_BASE
);
1289 node
->count
= ((node
->count
* scale
+ REG_BR_PROB_BASE
/ 2)
1290 / REG_BR_PROB_BASE
);
1294 /* Input and merge the symtab from each of the .o files passed to
1300 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1301 struct lto_file_decl_data
*file_data
;
1303 struct cgraph_node
*node
;
1305 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1307 while ((file_data
= file_data_vec
[j
++]))
1311 struct lto_input_block
*ib
;
1312 VEC(symtab_node
, heap
) *nodes
;
1314 ib
= lto_create_simple_input_block (file_data
, LTO_section_symtab_nodes
,
1317 fatal_error ("cannot find LTO cgraph in %s", file_data
->file_name
);
1318 input_profile_summary (ib
, file_data
);
1319 file_data
->symtab_node_encoder
= lto_symtab_encoder_new ();
1320 nodes
= input_cgraph_1 (file_data
, ib
);
1321 lto_destroy_simple_input_block (file_data
, LTO_section_symtab_nodes
,
1324 ib
= lto_create_simple_input_block (file_data
, LTO_section_refs
,
1327 fatal_error("cannot find LTO section refs in %s", file_data
->file_name
);
1328 input_refs (ib
, nodes
);
1329 lto_destroy_simple_input_block (file_data
, LTO_section_refs
,
1332 input_cgraph_opt_summary (nodes
);
1333 VEC_free (symtab_node
, heap
, nodes
);
1336 merge_profile_summaries (file_data_vec
);
1338 /* Clear out the aux field that was used to store enough state to
1339 tell which nodes should be overwritten. */
1340 FOR_EACH_FUNCTION (node
)
1342 /* Some nodes may have been created by cgraph_node. This
1343 happens when the callgraph contains nested functions. If the
1344 node for the parent function was never emitted to the gimple
1345 file, cgraph_node will create a node for it when setting the
1346 context of the nested function. */
1347 if (node
->symbol
.lto_file_data
)
1348 node
->symbol
.aux
= NULL
;
1352 /* True when we need optimization summary for NODE. */
1355 output_cgraph_opt_summary_p (struct cgraph_node
*node
)
1357 return (node
->clone_of
1358 && (node
->clone
.tree_map
1359 || node
->clone
.args_to_skip
1360 || node
->clone
.combined_args_to_skip
));
1363 /* Output optimization summary for EDGE to OB. */
1365 output_edge_opt_summary (struct output_block
*ob ATTRIBUTE_UNUSED
,
1366 struct cgraph_edge
*edge ATTRIBUTE_UNUSED
)
1370 /* Output optimization summary for NODE to OB. */
1373 output_node_opt_summary (struct output_block
*ob
,
1374 struct cgraph_node
*node
,
1375 lto_symtab_encoder_t encoder
)
1379 struct ipa_replace_map
*map
;
1380 struct bitpack_d bp
;
1382 struct cgraph_edge
*e
;
1384 if (node
->clone
.args_to_skip
)
1386 streamer_write_uhwi (ob
, bitmap_count_bits (node
->clone
.args_to_skip
));
1387 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.args_to_skip
, 0, index
, bi
)
1388 streamer_write_uhwi (ob
, index
);
1391 streamer_write_uhwi (ob
, 0);
1392 if (node
->clone
.combined_args_to_skip
)
1394 streamer_write_uhwi (ob
, bitmap_count_bits (node
->clone
.combined_args_to_skip
));
1395 EXECUTE_IF_SET_IN_BITMAP (node
->clone
.combined_args_to_skip
, 0, index
, bi
)
1396 streamer_write_uhwi (ob
, index
);
1399 streamer_write_uhwi (ob
, 0);
1400 streamer_write_uhwi (ob
, VEC_length (ipa_replace_map_p
,
1401 node
->clone
.tree_map
));
1402 FOR_EACH_VEC_ELT (ipa_replace_map_p
, node
->clone
.tree_map
, i
, map
)
1407 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->symbol
.decl
); parm
;
1408 parm
= DECL_CHAIN (parm
), parm_num
++)
1409 if (map
->old_tree
== parm
)
1411 /* At the moment we assume all old trees to be PARM_DECLs, because we have no
1412 mechanism to store function local declarations into summaries. */
1414 streamer_write_uhwi (ob
, parm_num
);
1415 gcc_assert (EXPR_LOCATION (map
->new_tree
) == UNKNOWN_LOCATION
);
1416 stream_write_tree (ob
, map
->new_tree
, true);
1417 bp
= bitpack_create (ob
->main_stream
);
1418 bp_pack_value (&bp
, map
->replace_p
, 1);
1419 bp_pack_value (&bp
, map
->ref_p
, 1);
1420 streamer_write_bitpack (&bp
);
1423 if (lto_symtab_encoder_in_partition_p (encoder
, (symtab_node
) node
))
1425 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1426 output_edge_opt_summary (ob
, e
);
1427 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1428 output_edge_opt_summary (ob
, e
);
1432 /* Output optimization summaries stored in callgraph.
1433 At the moment it is the clone info structure. */
1436 output_cgraph_opt_summary (void)
1440 lto_symtab_encoder_t encoder
;
1441 struct output_block
*ob
= create_output_block (LTO_section_cgraph_opt_sum
);
1444 ob
->cgraph_node
= NULL
;
1445 encoder
= ob
->decl_state
->symtab_node_encoder
;
1446 n_nodes
= lto_symtab_encoder_size (encoder
);
1447 for (i
= 0; i
< n_nodes
; i
++)
1448 if (symtab_function_p (node
= lto_symtab_encoder_deref (encoder
, i
))
1449 && output_cgraph_opt_summary_p (cgraph (node
)))
1451 streamer_write_uhwi (ob
, count
);
1452 for (i
= 0; i
< n_nodes
; i
++)
1454 node
= lto_symtab_encoder_deref (encoder
, i
);
1455 if (symtab_function_p (node
)
1456 && output_cgraph_opt_summary_p (cgraph (node
)))
1458 streamer_write_uhwi (ob
, i
);
1459 output_node_opt_summary (ob
, cgraph (node
), encoder
);
1462 produce_asm (ob
, NULL
);
1463 destroy_output_block (ob
);
1466 /* Input optimisation summary of EDGE. */
1469 input_edge_opt_summary (struct cgraph_edge
*edge ATTRIBUTE_UNUSED
,
1470 struct lto_input_block
*ib_main ATTRIBUTE_UNUSED
)
1474 /* Input optimisation summary of NODE. */
1477 input_node_opt_summary (struct cgraph_node
*node
,
1478 struct lto_input_block
*ib_main
,
1479 struct data_in
*data_in
)
1484 struct bitpack_d bp
;
1485 struct cgraph_edge
*e
;
1487 count
= streamer_read_uhwi (ib_main
);
1489 node
->clone
.args_to_skip
= BITMAP_GGC_ALLOC ();
1490 for (i
= 0; i
< count
; i
++)
1492 bit
= streamer_read_uhwi (ib_main
);
1493 bitmap_set_bit (node
->clone
.args_to_skip
, bit
);
1495 count
= streamer_read_uhwi (ib_main
);
1497 node
->clone
.combined_args_to_skip
= BITMAP_GGC_ALLOC ();
1498 for (i
= 0; i
< count
; i
++)
1500 bit
= streamer_read_uhwi (ib_main
);
1501 bitmap_set_bit (node
->clone
.combined_args_to_skip
, bit
);
1503 count
= streamer_read_uhwi (ib_main
);
1504 for (i
= 0; i
< count
; i
++)
1508 struct ipa_replace_map
*map
= ggc_alloc_ipa_replace_map ();
1510 VEC_safe_push (ipa_replace_map_p
, gc
, node
->clone
.tree_map
, map
);
1511 for (parm_num
= 0, parm
= DECL_ARGUMENTS (node
->symbol
.decl
); parm_num
;
1512 parm
= DECL_CHAIN (parm
))
1514 map
->parm_num
= streamer_read_uhwi (ib_main
);
1515 map
->old_tree
= NULL
;
1516 map
->new_tree
= stream_read_tree (ib_main
, data_in
);
1517 bp
= streamer_read_bitpack (ib_main
);
1518 map
->replace_p
= bp_unpack_value (&bp
, 1);
1519 map
->ref_p
= bp_unpack_value (&bp
, 1);
1521 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1522 input_edge_opt_summary (e
, ib_main
);
1523 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1524 input_edge_opt_summary (e
, ib_main
);
1527 /* Read section in file FILE_DATA of length LEN with data DATA. */
1530 input_cgraph_opt_section (struct lto_file_decl_data
*file_data
,
1531 const char *data
, size_t len
, VEC (symtab_node
,
1534 const struct lto_function_header
*header
=
1535 (const struct lto_function_header
*) data
;
1536 const int cfg_offset
= sizeof (struct lto_function_header
);
1537 const int main_offset
= cfg_offset
+ header
->cfg_size
;
1538 const int string_offset
= main_offset
+ header
->main_size
;
1539 struct data_in
*data_in
;
1540 struct lto_input_block ib_main
;
1544 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
1548 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
1549 header
->string_size
, NULL
);
1550 count
= streamer_read_uhwi (&ib_main
);
1552 for (i
= 0; i
< count
; i
++)
1554 int ref
= streamer_read_uhwi (&ib_main
);
1555 input_node_opt_summary (cgraph (VEC_index (symtab_node
, nodes
, ref
)),
1558 lto_free_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
, data
,
1560 lto_data_in_delete (data_in
);
1563 /* Input optimization summary of cgraph. */
1566 input_cgraph_opt_summary (VEC (symtab_node
, heap
) * nodes
)
1568 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
1569 struct lto_file_decl_data
*file_data
;
1572 while ((file_data
= file_data_vec
[j
++]))
1576 lto_get_section_data (file_data
, LTO_section_cgraph_opt_sum
, NULL
,
1580 input_cgraph_opt_section (file_data
, data
, len
, nodes
);