1 /* LTO partitioning logic routines.
2 Copyright (C) 2009-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
25 #include "gcc-symtab.h"
26 #include "basic-block.h"
27 #include "tree-ssa-alias.h"
28 #include "internal-fn.h"
29 #include "gimple-expr.h"
34 #include "lto-streamer.h"
37 #include "ipa-inline.h"
38 #include "ipa-utils.h"
39 #include "lto-partition.h"
41 vec
<ltrans_partition
> ltrans_partitions
;
43 static void add_symbol_to_partition (ltrans_partition part
, symtab_node
*node
);
46 /* Create new partition with name NAME. */
48 static ltrans_partition
49 new_partition (const char *name
)
51 ltrans_partition part
= XCNEW (struct ltrans_partition_def
);
52 part
->encoder
= lto_symtab_encoder_new (false);
55 ltrans_partitions
.safe_push (part
);
59 /* Free memory used by ltrans datastructures. */
62 free_ltrans_partitions (void)
65 ltrans_partition part
;
66 for (idx
= 0; ltrans_partitions
.iterate (idx
, &part
); idx
++)
68 if (part
->initializers_visited
)
69 pointer_set_destroy (part
->initializers_visited
);
70 /* Symtab encoder is freed after streaming. */
73 ltrans_partitions
.release ();
76 /* Return true if symbol is already in some partition. */
79 symbol_partitioned_p (symtab_node
*node
)
84 /* Add references into the partition. */
86 add_references_to_partition (ltrans_partition part
, symtab_node
*node
)
91 /* Add all duplicated references to the partition. */
92 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
93 if (symtab_get_symbol_partitioning_class (ref
->referred
) == SYMBOL_DUPLICATE
)
94 add_symbol_to_partition (part
, ref
->referred
);
95 /* References to a readonly variable may be constant foled into its value.
96 Recursively look into the initializers of the constant variable and add
98 else if (is_a
<varpool_node
> (ref
->referred
)
99 && ctor_for_folding (ref
->referred
->decl
) != error_mark_node
100 && !lto_symtab_encoder_in_partition_p (part
->encoder
, ref
->referred
))
102 if (!part
->initializers_visited
)
103 part
->initializers_visited
= pointer_set_create ();
104 if (!pointer_set_insert (part
->initializers_visited
, ref
->referred
))
105 add_references_to_partition (part
, ref
->referred
);
109 /* Helper function for add_symbol_to_partition doing the actual dirty work
110 of adding NODE to PART. */
113 add_symbol_to_partition_1 (ltrans_partition part
, symtab_node
*node
)
115 enum symbol_partitioning_class c
= symtab_get_symbol_partitioning_class (node
);
120 /* If NODE is already there, we have nothing to do. */
121 if (lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
124 /* non-duplicated aliases or tunks of a duplicated symbol needs to be output
127 Be lax about comdats; they may or may not be duplicated and we may
128 end up in need to duplicate keyed comdat because it has unkeyed alias. */
129 if (c
== SYMBOL_PARTITION
&& !DECL_COMDAT (node
->decl
)
130 && symbol_partitioned_p (node
))
133 /* Be sure that we never try to duplicate partitioned symbol
134 or add external symbol. */
135 gcc_assert (c
!= SYMBOL_EXTERNAL
136 && (c
== SYMBOL_DUPLICATE
|| !symbol_partitioned_p (node
)));
138 lto_set_symtab_encoder_in_partition (part
->encoder
, node
);
140 if (symbol_partitioned_p (node
))
142 node
->in_other_partition
= 1;
143 if (cgraph_dump_file
)
144 fprintf (cgraph_dump_file
, "Symbol node %s now used in multiple partitions\n",
147 node
->aux
= (void *)((size_t)node
->aux
+ 1);
149 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
> (node
))
151 struct cgraph_edge
*e
;
152 part
->insns
+= inline_summary (cnode
)->self_size
;
154 /* Add all inline clones and callees that are duplicated. */
155 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
156 if (!e
->inline_failed
)
157 add_symbol_to_partition_1 (part
, e
->callee
);
158 else if (symtab_get_symbol_partitioning_class (e
->callee
) == SYMBOL_DUPLICATE
)
159 add_symbol_to_partition (part
, e
->callee
);
161 /* Add all thunks associated with the function. */
162 for (e
= cnode
->callers
; e
; e
= e
->next_caller
)
163 if (e
->caller
->thunk
.thunk_p
)
164 add_symbol_to_partition_1 (part
, e
->caller
);
167 add_references_to_partition (part
, node
);
169 /* Add all aliases associated with the symbol. */
170 for (i
= 0; ipa_ref_list_referring_iterate (&node
->ref_list
, i
, ref
); i
++)
171 if (ref
->use
== IPA_REF_ALIAS
&& !node
->weakref
)
172 add_symbol_to_partition_1 (part
, ref
->referring
);
174 /* Ensure that SAME_COMDAT_GROUP lists all allways added in a group. */
175 if (node
->same_comdat_group
)
176 for (node1
= node
->same_comdat_group
;
177 node1
!= node
; node1
= node1
->same_comdat_group
)
180 bool added
= add_symbol_to_partition_1 (part
, node1
);
186 /* If symbol NODE is really part of other symbol's definition (i.e. it is
187 internal label, thunk, alias or so), return the outer symbol.
188 When add_symbol_to_partition_1 is called on the outer symbol it must
189 eventually add NODE, too. */
191 contained_in_symbol (symtab_node
*node
)
193 /* Weakrefs are never contained in anything. */
196 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
> (node
))
198 cnode
= cgraph_function_node (cnode
, NULL
);
199 if (cnode
->global
.inlined_to
)
200 cnode
= cnode
->global
.inlined_to
;
203 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
> (node
))
204 return varpool_variable_node (vnode
, NULL
);
208 /* Add symbol NODE to partition. When definition of NODE is part
209 of other symbol definition, add the other symbol, too. */
212 add_symbol_to_partition (ltrans_partition part
, symtab_node
*node
)
216 /* Verify that we do not try to duplicate something that can not be. */
217 gcc_checking_assert (symtab_get_symbol_partitioning_class (node
) == SYMBOL_DUPLICATE
218 || !symbol_partitioned_p (node
));
220 while ((node1
= contained_in_symbol (node
)) != node
)
223 /* If we have duplicated symbol contained in something we can not duplicate,
224 we are very badly screwed. The other way is possible, so we do not
225 assert this in add_symbol_to_partition_1.
227 Be lax about comdats; they may or may not be duplicated and we may
228 end up in need to duplicate keyed comdat because it has unkeyed alias. */
230 gcc_assert (symtab_get_symbol_partitioning_class (node
) == SYMBOL_DUPLICATE
231 || DECL_COMDAT (node
->decl
)
232 || !symbol_partitioned_p (node
));
234 add_symbol_to_partition_1 (part
, node
);
237 /* Undo all additions until number of cgraph nodes in PARITION is N_CGRAPH_NODES
238 and number of varpool nodes is N_VARPOOL_NODES. */
241 undo_partition (ltrans_partition partition
, unsigned int n_nodes
)
243 while (lto_symtab_encoder_size (partition
->encoder
) > (int)n_nodes
)
245 symtab_node
*node
= lto_symtab_encoder_deref (partition
->encoder
,
248 /* After UNDO we no longer know what was visited. */
249 if (partition
->initializers_visited
)
250 pointer_set_destroy (partition
->initializers_visited
);
251 partition
->initializers_visited
= NULL
;
253 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
> (node
))
254 partition
->insns
-= inline_summary (cnode
)->self_size
;
255 lto_symtab_encoder_delete_node (partition
->encoder
, node
);
256 node
->aux
= (void *)((size_t)node
->aux
- 1);
260 /* Group cgrah nodes by input files. This is used mainly for testing
264 lto_1_to_1_map (void)
267 struct lto_file_decl_data
*file_data
;
268 struct pointer_map_t
*pmap
;
269 ltrans_partition partition
;
273 pmap
= pointer_map_create ();
275 FOR_EACH_SYMBOL (node
)
277 if (symtab_get_symbol_partitioning_class (node
) != SYMBOL_PARTITION
278 || symbol_partitioned_p (node
))
281 file_data
= node
->lto_file_data
;
285 slot
= pointer_map_contains (pmap
, file_data
);
287 partition
= (ltrans_partition
) *slot
;
290 partition
= new_partition (file_data
->file_name
);
291 slot
= pointer_map_insert (pmap
, file_data
);
296 else if (!file_data
&& ltrans_partitions
.length ())
297 partition
= ltrans_partitions
[0];
300 partition
= new_partition ("");
301 slot
= pointer_map_insert (pmap
, NULL
);
306 add_symbol_to_partition (partition
, node
);
309 /* If the cgraph is empty, create one cgraph node set so that there is still
310 an output file for any variables that need to be exported in a DSO. */
312 new_partition ("empty");
314 pointer_map_destroy (pmap
);
318 /* Maximal partitioning. Put every new symbol into new partition if possible. */
324 ltrans_partition partition
;
327 FOR_EACH_SYMBOL (node
)
329 if (symtab_get_symbol_partitioning_class (node
) != SYMBOL_PARTITION
330 || symbol_partitioned_p (node
))
332 partition
= new_partition (node
->asm_name ());
333 add_symbol_to_partition (partition
, node
);
337 new_partition ("empty");
340 /* Helper function for qsort; sort nodes by order. */
342 node_cmp (const void *pa
, const void *pb
)
344 const struct cgraph_node
*a
= *(const struct cgraph_node
* const *) pa
;
345 const struct cgraph_node
*b
= *(const struct cgraph_node
* const *) pb
;
347 /* Profile reorder flag enables function reordering based on first execution
348 of a function. All functions with profile are placed in ascending
349 order at the beginning. */
351 if (flag_profile_reorder_functions
)
353 /* Functions with time profile are sorted in ascending order. */
354 if (a
->tp_first_run
&& b
->tp_first_run
)
355 return a
->tp_first_run
!= b
->tp_first_run
356 ? a
->tp_first_run
- b
->tp_first_run
357 : a
->order
- b
->order
;
359 /* Functions with time profile are sorted before the functions
360 that do not have the profile. */
361 if (a
->tp_first_run
|| b
->tp_first_run
)
362 return b
->tp_first_run
- a
->tp_first_run
;
365 return b
->order
- a
->order
;
368 /* Helper function for qsort; sort nodes by order. */
370 varpool_node_cmp (const void *pa
, const void *pb
)
372 const varpool_node
*a
= *(const varpool_node
* const *) pa
;
373 const varpool_node
*b
= *(const varpool_node
* const *) pb
;
374 return b
->order
- a
->order
;
377 /* Group cgraph nodes into equally-sized partitions.
379 The partitioning algorithm is simple: nodes are taken in predefined order.
380 The order corresponds to the order we want functions to have in the final
381 output. In the future this will be given by function reordering pass, but
382 at the moment we use the topological order, which is a good approximation.
384 The goal is to partition this linear order into intervals (partitions) so
385 that all the partitions have approximately the same size and the number of
386 callgraph or IPA reference edges crossing boundaries is minimal.
388 This is a lot faster (O(n) in size of callgraph) than algorithms doing
389 priority-based graph clustering that are generally O(n^2) and, since
390 WHOPR is designed to make things go well across partitions, it leads
393 We compute the expected size of a partition as:
395 max (total_size / lto_partitions, min_partition_size)
397 We use dynamic expected size of partition so small programs are partitioned
398 into enough partitions to allow use of multiple CPUs, while large programs
399 are not partitioned too much. Creating too many partitions significantly
400 increases the streaming overhead.
402 In the future, we would like to bound the maximal size of partitions so as
403 to prevent the LTRANS stage from consuming too much memory. At the moment,
404 however, the WPA stage is the most memory intensive for large benchmarks,
405 since too many types and declarations are read into memory.
407 The function implements a simple greedy algorithm. Nodes are being added
408 to the current partition until after 3/4 of the expected partition size is
409 reached. Past this threshold, we keep track of boundary size (number of
410 edges going to other partitions) and continue adding functions until after
411 the current partition has grown to twice the expected partition size. Then
412 the process is undone to the point where the minimal ratio of boundary size
413 and in-partition calls was reached. */
416 lto_balanced_map (void)
419 int n_varpool_nodes
= 0, varpool_pos
= 0, best_varpool_pos
= 0;
420 struct cgraph_node
**order
= XNEWVEC (struct cgraph_node
*, cgraph_max_uid
);
421 varpool_node
**varpool_order
= NULL
;
423 struct cgraph_node
*node
;
424 int total_size
= 0, best_total_size
= 0;
426 ltrans_partition partition
;
427 int last_visited_node
= 0;
429 int cost
= 0, internal
= 0;
430 int best_n_nodes
= 0, best_i
= 0, best_cost
=
431 INT_MAX
, best_internal
= 0;
433 int current_order
= -1;
435 FOR_EACH_VARIABLE (vnode
)
436 gcc_assert (!vnode
->aux
);
438 FOR_EACH_DEFINED_FUNCTION (node
)
439 if (symtab_get_symbol_partitioning_class (node
) == SYMBOL_PARTITION
)
441 order
[n_nodes
++] = node
;
442 total_size
+= inline_summary (node
)->size
;
445 /* Streaming works best when the source units do not cross partition
446 boundaries much. This is because importing function from a source
447 unit tends to import a lot of global trees defined there. We should
448 get better about minimizing the function bounday, but until that
449 things works smoother if we order in source order. */
450 qsort (order
, n_nodes
, sizeof (struct cgraph_node
*), node_cmp
);
452 if (cgraph_dump_file
)
453 for(i
= 0; i
< n_nodes
; i
++)
454 fprintf (cgraph_dump_file
, "Balanced map symbol order:%s:%u\n", order
[i
]->name (), order
[i
]->tp_first_run
);
456 if (!flag_toplevel_reorder
)
458 FOR_EACH_VARIABLE (vnode
)
459 if (symtab_get_symbol_partitioning_class (vnode
) == SYMBOL_PARTITION
)
461 varpool_order
= XNEWVEC (varpool_node
*, n_varpool_nodes
);
464 FOR_EACH_VARIABLE (vnode
)
465 if (symtab_get_symbol_partitioning_class (vnode
) == SYMBOL_PARTITION
)
466 varpool_order
[n_varpool_nodes
++] = vnode
;
467 qsort (varpool_order
, n_varpool_nodes
, sizeof (varpool_node
*),
471 /* Compute partition size and create the first partition. */
472 partition_size
= total_size
/ PARAM_VALUE (PARAM_LTO_PARTITIONS
);
473 if (partition_size
< PARAM_VALUE (MIN_PARTITION_SIZE
))
474 partition_size
= PARAM_VALUE (MIN_PARTITION_SIZE
);
476 partition
= new_partition ("");
477 if (cgraph_dump_file
)
478 fprintf (cgraph_dump_file
, "Total unit size: %i, partition size: %i\n",
479 total_size
, partition_size
);
481 for (i
= 0; i
< n_nodes
; i
++)
483 if (symbol_partitioned_p (order
[i
]))
486 current_order
= order
[i
]->order
;
488 if (!flag_toplevel_reorder
)
489 while (varpool_pos
< n_varpool_nodes
490 && varpool_order
[varpool_pos
]->order
< current_order
)
492 if (!symbol_partitioned_p (varpool_order
[varpool_pos
]))
493 add_symbol_to_partition (partition
, varpool_order
[varpool_pos
]);
497 add_symbol_to_partition (partition
, order
[i
]);
498 total_size
-= inline_summary (order
[i
])->size
;
501 /* Once we added a new node to the partition, we also want to add
502 all referenced variables unless they was already added into some
504 add_symbol_to_partition adds possibly multiple nodes and
505 variables that are needed to satisfy needs of ORDER[i].
506 We remember last visited cgraph and varpool node from last iteration
507 of outer loop that allows us to process every new addition.
509 At the same time we compute size of the boundary into COST. Every
510 callgraph or IPA reference edge leaving the partition contributes into
511 COST. Every edge inside partition was earlier computed as one leaving
512 it and thus we need to subtract it from COST. */
513 while (last_visited_node
< lto_symtab_encoder_size (partition
->encoder
))
515 struct ipa_ref_list
*refs
;
518 symtab_node
*snode
= lto_symtab_encoder_deref (partition
->encoder
,
521 if (cgraph_node
*node
= dyn_cast
<cgraph_node
> (snode
))
523 struct cgraph_edge
*edge
;
525 refs
= &node
->ref_list
;
529 gcc_assert (node
->definition
|| node
->weakref
);
531 /* Compute boundary cost of callgraph edges. */
532 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
533 if (edge
->callee
->definition
)
535 int edge_cost
= edge
->frequency
;
540 gcc_assert (edge_cost
> 0);
541 index
= lto_symtab_encoder_lookup (partition
->encoder
,
543 if (index
!= LCC_NOT_FOUND
544 && index
< last_visited_node
- 1)
545 cost
-= edge_cost
, internal
+= edge_cost
;
549 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
551 int edge_cost
= edge
->frequency
;
554 gcc_assert (edge
->caller
->definition
);
557 gcc_assert (edge_cost
> 0);
558 index
= lto_symtab_encoder_lookup (partition
->encoder
,
560 if (index
!= LCC_NOT_FOUND
561 && index
< last_visited_node
- 1)
569 refs
= &snode
->ref_list
;
573 /* Compute boundary cost of IPA REF edges and at the same time look into
574 variables referenced from current partition and try to add them. */
575 for (j
= 0; ipa_ref_list_reference_iterate (refs
, j
, ref
); j
++)
576 if (is_a
<varpool_node
> (ref
->referred
))
580 vnode
= ipa_ref_varpool_node (ref
);
581 if (!vnode
->definition
)
583 if (!symbol_partitioned_p (vnode
) && flag_toplevel_reorder
584 && symtab_get_symbol_partitioning_class (vnode
) == SYMBOL_PARTITION
)
585 add_symbol_to_partition (partition
, vnode
);
586 index
= lto_symtab_encoder_lookup (partition
->encoder
,
588 if (index
!= LCC_NOT_FOUND
589 && index
< last_visited_node
- 1)
598 node
= ipa_ref_node (ref
);
599 if (!node
->definition
)
601 index
= lto_symtab_encoder_lookup (partition
->encoder
,
603 if (index
!= LCC_NOT_FOUND
604 && index
< last_visited_node
- 1)
609 for (j
= 0; ipa_ref_list_referring_iterate (refs
, j
, ref
); j
++)
610 if (is_a
<varpool_node
> (ref
->referring
))
614 vnode
= ipa_ref_referring_varpool_node (ref
);
615 gcc_assert (vnode
->definition
);
616 if (!symbol_partitioned_p (vnode
) && flag_toplevel_reorder
617 && symtab_get_symbol_partitioning_class (vnode
) == SYMBOL_PARTITION
)
618 add_symbol_to_partition (partition
, vnode
);
619 index
= lto_symtab_encoder_lookup (partition
->encoder
,
621 if (index
!= LCC_NOT_FOUND
622 && index
< last_visited_node
- 1)
631 node
= ipa_ref_referring_node (ref
);
632 gcc_assert (node
->definition
);
633 index
= lto_symtab_encoder_lookup (partition
->encoder
,
635 if (index
!= LCC_NOT_FOUND
636 && index
< last_visited_node
- 1)
643 /* If the partition is large enough, start looking for smallest boundary cost. */
644 if (partition
->insns
< partition_size
* 3 / 4
645 || best_cost
== INT_MAX
647 || (best_internal
* (HOST_WIDE_INT
) cost
648 > (internal
* (HOST_WIDE_INT
)best_cost
)))
649 && partition
->insns
< partition_size
* 5 / 4))
652 best_internal
= internal
;
654 best_n_nodes
= lto_symtab_encoder_size (partition
->encoder
);
655 best_total_size
= total_size
;
656 best_varpool_pos
= varpool_pos
;
658 if (cgraph_dump_file
)
659 fprintf (cgraph_dump_file
, "Step %i: added %s/%i, size %i, cost %i/%i "
660 "best %i/%i, step %i\n", i
,
661 order
[i
]->name (), order
[i
]->order
,
662 partition
->insns
, cost
, internal
,
663 best_cost
, best_internal
, best_i
);
664 /* Partition is too large, unwind into step when best cost was reached and
665 start new partition. */
666 if (partition
->insns
> 2 * partition_size
)
670 if (cgraph_dump_file
)
671 fprintf (cgraph_dump_file
, "Unwinding %i insertions to step %i\n",
673 undo_partition (partition
, best_n_nodes
);
674 varpool_pos
= best_varpool_pos
;
677 /* When we are finished, avoid creating empty partition. */
678 while (i
< n_nodes
- 1 && symbol_partitioned_p (order
[i
+ 1]))
680 if (i
== n_nodes
- 1)
682 partition
= new_partition ("");
683 last_visited_node
= 0;
684 total_size
= best_total_size
;
687 if (cgraph_dump_file
)
688 fprintf (cgraph_dump_file
, "New partition\n");
692 /* Since the size of partitions is just approximate, update the size after
693 we finished current one. */
694 if (npartitions
< PARAM_VALUE (PARAM_LTO_PARTITIONS
))
695 partition_size
= total_size
696 / (PARAM_VALUE (PARAM_LTO_PARTITIONS
) - npartitions
);
698 partition_size
= INT_MAX
;
700 if (partition_size
< PARAM_VALUE (MIN_PARTITION_SIZE
))
701 partition_size
= PARAM_VALUE (MIN_PARTITION_SIZE
);
706 /* Varables that are not reachable from the code go into last partition. */
707 if (flag_toplevel_reorder
)
709 FOR_EACH_VARIABLE (vnode
)
710 if (symtab_get_symbol_partitioning_class (vnode
) == SYMBOL_PARTITION
711 && !symbol_partitioned_p (vnode
))
712 add_symbol_to_partition (partition
, vnode
);
716 while (varpool_pos
< n_varpool_nodes
)
718 if (!symbol_partitioned_p (varpool_order
[varpool_pos
]))
719 add_symbol_to_partition (partition
, varpool_order
[varpool_pos
]);
722 free (varpool_order
);
727 /* Mangle NODE symbol name into a local name.
728 This is necessary to do
729 1) if two or more static vars of same assembler name
730 are merged into single ltrans unit.
731 2) if prevoiusly static var was promoted hidden to avoid possible conflict
732 with symbols defined out of the LTO world.
736 privatize_symbol_name (symtab_node
*node
)
738 tree decl
= node
->decl
;
739 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
741 /* Our renaming machinery do not handle more than one change of assembler name.
742 We should not need more than one anyway. */
743 if (node
->lto_file_data
744 && lto_get_decl_name_mapping (node
->lto_file_data
, name
) != name
)
746 if (cgraph_dump_file
)
747 fprintf (cgraph_dump_file
,
748 "Not privatizing symbol name: %s. It privatized already.\n",
752 /* Avoid mangling of already mangled clones.
753 ??? should have a flag whether a symbol has a 'private' name already,
754 since we produce some symbols like that i.e. for global constructors
755 that are not really clones. */
756 if (node
->unique_name
)
758 if (cgraph_dump_file
)
759 fprintf (cgraph_dump_file
,
760 "Not privatizing symbol name: %s. Has unique name.\n",
764 change_decl_assembler_name (decl
, clone_function_name (decl
, "lto_priv"));
765 if (node
->lto_file_data
)
766 lto_record_renamed_decl (node
->lto_file_data
, name
,
768 (DECL_ASSEMBLER_NAME (decl
)));
769 if (cgraph_dump_file
)
770 fprintf (cgraph_dump_file
,
771 "Privatizing symbol name: %s -> %s\n",
772 name
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
776 /* Promote variable VNODE to be static. */
779 promote_symbol (symtab_node
*node
)
781 /* We already promoted ... */
782 if (DECL_VISIBILITY (node
->decl
) == VISIBILITY_HIDDEN
783 && DECL_VISIBILITY_SPECIFIED (node
->decl
)
784 && TREE_PUBLIC (node
->decl
))
787 gcc_checking_assert (!TREE_PUBLIC (node
->decl
)
788 && !DECL_EXTERNAL (node
->decl
));
789 /* Be sure that newly public symbol does not conflict with anything already
790 defined by the non-LTO part. */
791 privatize_symbol_name (node
);
792 TREE_PUBLIC (node
->decl
) = 1;
793 DECL_VISIBILITY (node
->decl
) = VISIBILITY_HIDDEN
;
794 DECL_VISIBILITY_SPECIFIED (node
->decl
) = true;
795 if (cgraph_dump_file
)
796 fprintf (cgraph_dump_file
,
797 "Promoting as hidden: %s\n", node
->name ());
800 /* Return true if NODE needs named section even if it won't land in the partition
802 FIXME: we should really not use named sections for inline clones and master clones. */
805 may_need_named_section_p (lto_symtab_encoder_t encoder
, symtab_node
*node
)
807 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
> (node
);
810 if (symtab_real_symbol_p (node
))
813 || (lto_symtab_encoder_lookup (encoder
, node
) != LCC_NOT_FOUND
814 && lto_symtab_encoder_encode_body_p (encoder
,
818 /* If NODE represents a static variable. See if there are other variables
819 of the same name in partition ENCODER (or in whole compilation unit if
820 ENCODER is NULL) and if so, mangle the statics. Always mangle all
821 conflicting statics, so we reduce changes of silently miscompiling
822 asm statements referring to them by symbol name. */
825 rename_statics (lto_symtab_encoder_t encoder
, symtab_node
*node
)
827 tree decl
= node
->decl
;
829 tree name
= DECL_ASSEMBLER_NAME (decl
);
831 /* See if this is static symbol. */
832 if ((node
->externally_visible
833 /* FIXME: externally_visible is somewhat illogically not set for
834 external symbols (i.e. those not defined). Remove this test
835 once this is fixed. */
836 || DECL_EXTERNAL (node
->decl
)
837 || !symtab_real_symbol_p (node
))
838 && !may_need_named_section_p (encoder
, node
))
841 /* Now walk symbols sharing the same name and see if there are any conflicts.
842 (all types of symbols counts here, since we can not have static of the
843 same name as external or public symbol.) */
844 for (s
= symtab_node_for_asm (name
);
845 s
; s
= s
->next_sharing_asm_name
)
846 if ((symtab_real_symbol_p (s
) || may_need_named_section_p (encoder
, s
))
847 && s
->decl
!= node
->decl
849 || lto_symtab_encoder_lookup (encoder
, s
) != LCC_NOT_FOUND
))
852 /* OK, no confict, so we have nothing to do. */
856 if (cgraph_dump_file
)
857 fprintf (cgraph_dump_file
,
858 "Renaming statics with asm name: %s\n", node
->name ());
860 /* Assign every symbol in the set that shares the same ASM name an unique
862 for (s
= symtab_node_for_asm (name
); s
;)
863 if (!s
->externally_visible
864 && ((symtab_real_symbol_p (s
)
865 && !DECL_EXTERNAL (node
->decl
)
866 && !TREE_PUBLIC (node
->decl
))
867 || may_need_named_section_p (encoder
, s
))
869 || lto_symtab_encoder_lookup (encoder
, s
) != LCC_NOT_FOUND
))
871 if (privatize_symbol_name (s
))
872 /* Re-start from beginning since we do not know how many symbols changed a name. */
873 s
= symtab_node_for_asm (name
);
874 else s
= s
->next_sharing_asm_name
;
876 else s
= s
->next_sharing_asm_name
;
879 /* Find out all static decls that need to be promoted to global because
880 of cross file sharing. This function must be run in the WPA mode after
881 all inlinees are added. */
884 lto_promote_cross_file_statics (void)
888 gcc_assert (flag_wpa
);
890 /* First compute boundaries. */
891 n_sets
= ltrans_partitions
.length ();
892 for (i
= 0; i
< n_sets
; i
++)
894 ltrans_partition part
895 = ltrans_partitions
[i
];
896 part
->encoder
= compute_ltrans_boundary (part
->encoder
);
899 /* Look at boundaries and promote symbols as needed. */
900 for (i
= 0; i
< n_sets
; i
++)
902 lto_symtab_encoder_iterator lsei
;
903 lto_symtab_encoder_t encoder
= ltrans_partitions
[i
]->encoder
;
905 for (lsei
= lsei_start (encoder
); !lsei_end_p (lsei
);
908 symtab_node
*node
= lsei_node (lsei
);
910 /* If symbol is static, rename it if its assembler name clash with
911 anything else in this unit. */
912 rename_statics (encoder
, node
);
914 /* No need to promote if symbol already is externally visible ... */
915 if (node
->externally_visible
916 /* ... or if it is part of current partition ... */
917 || lto_symtab_encoder_in_partition_p (encoder
, node
)
918 /* ... or if we do not partition it. This mean that it will
919 appear in every partition refernecing it. */
920 || symtab_get_symbol_partitioning_class (node
) != SYMBOL_PARTITION
)
923 promote_symbol (node
);
928 /* Rename statics in the whole unit in the case that
929 we do -flto-partition=none. */
932 lto_promote_statics_nonwpa (void)
935 FOR_EACH_SYMBOL (node
)
936 rename_statics (NULL
, node
);