1 /* LTO partitioning logic routines.
2 Copyright (C) 2009-2015 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"
28 #include "basic-block.h"
31 #include "hard-reg-set.h"
33 #include "fold-const.h"
34 #include "internal-fn.h"
36 #include "lto-streamer.h"
39 #include "alloc-pool.h"
40 #include "symbol-summary.h"
42 #include "ipa-inline.h"
43 #include "ipa-utils.h"
44 #include "lto-partition.h"
45 #include "stringpool.h"
47 vec
<ltrans_partition
> ltrans_partitions
;
49 static void add_symbol_to_partition (ltrans_partition part
, symtab_node
*node
);
52 /* Create new partition with name NAME. */
54 static ltrans_partition
55 new_partition (const char *name
)
57 ltrans_partition part
= XCNEW (struct ltrans_partition_def
);
58 part
->encoder
= lto_symtab_encoder_new (false);
62 ltrans_partitions
.safe_push (part
);
66 /* Free memory used by ltrans datastructures. */
69 free_ltrans_partitions (void)
72 ltrans_partition part
;
73 for (idx
= 0; ltrans_partitions
.iterate (idx
, &part
); idx
++)
75 if (part
->initializers_visited
)
76 delete part
->initializers_visited
;
77 /* Symtab encoder is freed after streaming. */
80 ltrans_partitions
.release ();
83 /* Return true if symbol is already in some partition. */
86 symbol_partitioned_p (symtab_node
*node
)
91 /* Add references into the partition. */
93 add_references_to_partition (ltrans_partition part
, symtab_node
*node
)
96 struct ipa_ref
*ref
= NULL
;
98 /* Add all duplicated references to the partition. */
99 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
100 if (ref
->referred
->get_partitioning_class () == SYMBOL_DUPLICATE
)
101 add_symbol_to_partition (part
, ref
->referred
);
102 /* References to a readonly variable may be constant foled into its value.
103 Recursively look into the initializers of the constant variable and add
105 else if (is_a
<varpool_node
*> (ref
->referred
)
106 && (dyn_cast
<varpool_node
*> (ref
->referred
)
107 ->ctor_useable_for_folding_p ()
108 || POINTER_BOUNDS_P (ref
->referred
->decl
))
109 && !lto_symtab_encoder_in_partition_p (part
->encoder
, ref
->referred
))
111 if (!part
->initializers_visited
)
112 part
->initializers_visited
= new hash_set
<symtab_node
*>;
113 if (!part
->initializers_visited
->add (ref
->referred
))
114 add_references_to_partition (part
, ref
->referred
);
118 /* Helper function for add_symbol_to_partition doing the actual dirty work
119 of adding NODE to PART. */
122 add_symbol_to_partition_1 (ltrans_partition part
, symtab_node
*node
)
124 enum symbol_partitioning_class c
= node
->get_partitioning_class ();
128 /* If NODE is already there, we have nothing to do. */
129 if (lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
132 /* non-duplicated aliases or tunks of a duplicated symbol needs to be output
135 Be lax about comdats; they may or may not be duplicated and we may
136 end up in need to duplicate keyed comdat because it has unkeyed alias. */
137 if (c
== SYMBOL_PARTITION
&& !DECL_COMDAT (node
->decl
)
138 && symbol_partitioned_p (node
))
141 /* Be sure that we never try to duplicate partitioned symbol
142 or add external symbol. */
143 gcc_assert (c
!= SYMBOL_EXTERNAL
144 && (c
== SYMBOL_DUPLICATE
|| !symbol_partitioned_p (node
)));
148 lto_set_symtab_encoder_in_partition (part
->encoder
, node
);
150 if (symbol_partitioned_p (node
))
152 node
->in_other_partition
= 1;
153 if (symtab
->dump_file
)
154 fprintf (symtab
->dump_file
,
155 "Symbol node %s now used in multiple partitions\n",
158 node
->aux
= (void *)((size_t)node
->aux
+ 1);
160 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
162 struct cgraph_edge
*e
;
164 part
->insns
+= inline_summaries
->get (cnode
)->self_size
;
166 /* Add all inline clones and callees that are duplicated. */
167 for (e
= cnode
->callees
; e
; e
= e
->next_callee
)
168 if (!e
->inline_failed
)
169 add_symbol_to_partition_1 (part
, e
->callee
);
170 else if (e
->callee
->get_partitioning_class () == SYMBOL_DUPLICATE
)
171 add_symbol_to_partition (part
, e
->callee
);
173 /* Add all thunks associated with the function. */
174 for (e
= cnode
->callers
; e
; e
= e
->next_caller
)
175 if (e
->caller
->thunk
.thunk_p
)
176 add_symbol_to_partition_1 (part
, e
->caller
);
178 /* Instrumented version is actually the same function.
179 Therefore put it into the same partition. */
180 if (cnode
->instrumented_version
)
181 add_symbol_to_partition_1 (part
, cnode
->instrumented_version
);
184 add_references_to_partition (part
, node
);
186 /* Add all aliases associated with the symbol. */
188 FOR_EACH_ALIAS (node
, ref
)
190 add_symbol_to_partition_1 (part
, ref
->referring
);
192 /* Ensure that SAME_COMDAT_GROUP lists all allways added in a group. */
193 if (node
->same_comdat_group
)
194 for (node1
= node
->same_comdat_group
;
195 node1
!= node
; node1
= node1
->same_comdat_group
)
198 bool added
= add_symbol_to_partition_1 (part
, node1
);
204 /* If symbol NODE is really part of other symbol's definition (i.e. it is
205 internal label, thunk, alias or so), return the outer symbol.
206 When add_symbol_to_partition_1 is called on the outer symbol it must
207 eventually add NODE, too. */
209 contained_in_symbol (symtab_node
*node
)
211 /* Weakrefs are never contained in anything. */
214 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
216 cnode
= cnode
->function_symbol ();
217 if (cnode
->global
.inlined_to
)
218 cnode
= cnode
->global
.inlined_to
;
221 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
))
222 return vnode
->ultimate_alias_target ();
226 /* Add symbol NODE to partition. When definition of NODE is part
227 of other symbol definition, add the other symbol, too. */
230 add_symbol_to_partition (ltrans_partition part
, symtab_node
*node
)
234 /* Verify that we do not try to duplicate something that can not be. */
235 gcc_checking_assert (node
->get_partitioning_class () == SYMBOL_DUPLICATE
236 || !symbol_partitioned_p (node
));
238 while ((node1
= contained_in_symbol (node
)) != node
)
241 /* If we have duplicated symbol contained in something we can not duplicate,
242 we are very badly screwed. The other way is possible, so we do not
243 assert this in add_symbol_to_partition_1.
245 Be lax about comdats; they may or may not be duplicated and we may
246 end up in need to duplicate keyed comdat because it has unkeyed alias. */
248 gcc_assert (node
->get_partitioning_class () == SYMBOL_DUPLICATE
249 || DECL_COMDAT (node
->decl
)
250 || !symbol_partitioned_p (node
));
252 add_symbol_to_partition_1 (part
, node
);
255 /* Undo all additions until number of cgraph nodes in PARITION is N_CGRAPH_NODES
256 and number of varpool nodes is N_VARPOOL_NODES. */
259 undo_partition (ltrans_partition partition
, unsigned int n_nodes
)
261 while (lto_symtab_encoder_size (partition
->encoder
) > (int)n_nodes
)
263 symtab_node
*node
= lto_symtab_encoder_deref (partition
->encoder
,
265 partition
->symbols
--;
268 /* After UNDO we no longer know what was visited. */
269 if (partition
->initializers_visited
)
270 delete partition
->initializers_visited
;
271 partition
->initializers_visited
= NULL
;
273 if (!node
->alias
&& (cnode
= dyn_cast
<cgraph_node
*> (node
)))
274 partition
->insns
-= inline_summaries
->get (cnode
)->self_size
;
275 lto_symtab_encoder_delete_node (partition
->encoder
, node
);
276 node
->aux
= (void *)((size_t)node
->aux
- 1);
280 /* Group cgrah nodes by input files. This is used mainly for testing
284 lto_1_to_1_map (void)
287 struct lto_file_decl_data
*file_data
;
288 hash_map
<lto_file_decl_data
*, ltrans_partition
> pmap
;
289 ltrans_partition partition
;
292 FOR_EACH_SYMBOL (node
)
294 if (node
->get_partitioning_class () != SYMBOL_PARTITION
295 || symbol_partitioned_p (node
))
298 file_data
= node
->lto_file_data
;
302 ltrans_partition
*slot
= &pmap
.get_or_insert (file_data
);
307 partition
= new_partition (file_data
->file_name
);
312 else if (!file_data
&& ltrans_partitions
.length ())
313 partition
= ltrans_partitions
[0];
316 partition
= new_partition ("");
317 pmap
.put (NULL
, partition
);
321 add_symbol_to_partition (partition
, node
);
324 /* If the cgraph is empty, create one cgraph node set so that there is still
325 an output file for any variables that need to be exported in a DSO. */
327 new_partition ("empty");
331 /* Maximal partitioning. Put every new symbol into new partition if possible. */
337 ltrans_partition partition
;
340 FOR_EACH_SYMBOL (node
)
342 if (node
->get_partitioning_class () != SYMBOL_PARTITION
343 || symbol_partitioned_p (node
))
345 partition
= new_partition (node
->asm_name ());
346 add_symbol_to_partition (partition
, node
);
350 new_partition ("empty");
353 /* Helper function for qsort; sort nodes by order. noreorder functions must have
354 been removed earlier. */
356 node_cmp (const void *pa
, const void *pb
)
358 const struct cgraph_node
*a
= *(const struct cgraph_node
* const *) pa
;
359 const struct cgraph_node
*b
= *(const struct cgraph_node
* const *) pb
;
361 /* Profile reorder flag enables function reordering based on first execution
362 of a function. All functions with profile are placed in ascending
363 order at the beginning. */
365 if (flag_profile_reorder_functions
)
367 /* Functions with time profile are sorted in ascending order. */
368 if (a
->tp_first_run
&& b
->tp_first_run
)
369 return a
->tp_first_run
!= b
->tp_first_run
370 ? a
->tp_first_run
- b
->tp_first_run
371 : a
->order
- b
->order
;
373 /* Functions with time profile are sorted before the functions
374 that do not have the profile. */
375 if (a
->tp_first_run
|| b
->tp_first_run
)
376 return b
->tp_first_run
- a
->tp_first_run
;
379 return b
->order
- a
->order
;
382 /* Helper function for qsort; sort nodes by order. */
384 varpool_node_cmp (const void *pa
, const void *pb
)
386 const symtab_node
*a
= *static_cast<const symtab_node
* const *> (pa
);
387 const symtab_node
*b
= *static_cast<const symtab_node
* const *> (pb
);
388 return b
->order
- a
->order
;
391 /* Add all symtab nodes from NEXT_NODE to PARTITION in order. */
394 add_sorted_nodes (vec
<symtab_node
*> &next_nodes
, ltrans_partition partition
)
399 next_nodes
.qsort (varpool_node_cmp
);
400 FOR_EACH_VEC_ELT (next_nodes
, i
, node
)
401 if (!symbol_partitioned_p (node
))
402 add_symbol_to_partition (partition
, node
);
406 /* Group cgraph nodes into equally-sized partitions.
408 The partitioning algorithm is simple: nodes are taken in predefined order.
409 The order corresponds to the order we want functions to have in the final
410 output. In the future this will be given by function reordering pass, but
411 at the moment we use the topological order, which is a good approximation.
413 The goal is to partition this linear order into intervals (partitions) so
414 that all the partitions have approximately the same size and the number of
415 callgraph or IPA reference edges crossing boundaries is minimal.
417 This is a lot faster (O(n) in size of callgraph) than algorithms doing
418 priority-based graph clustering that are generally O(n^2) and, since
419 WHOPR is designed to make things go well across partitions, it leads
422 We compute the expected size of a partition as:
424 max (total_size / lto_partitions, min_partition_size)
426 We use dynamic expected size of partition so small programs are partitioned
427 into enough partitions to allow use of multiple CPUs, while large programs
428 are not partitioned too much. Creating too many partitions significantly
429 increases the streaming overhead.
431 In the future, we would like to bound the maximal size of partitions so as
432 to prevent the LTRANS stage from consuming too much memory. At the moment,
433 however, the WPA stage is the most memory intensive for large benchmarks,
434 since too many types and declarations are read into memory.
436 The function implements a simple greedy algorithm. Nodes are being added
437 to the current partition until after 3/4 of the expected partition size is
438 reached. Past this threshold, we keep track of boundary size (number of
439 edges going to other partitions) and continue adding functions until after
440 the current partition has grown to twice the expected partition size. Then
441 the process is undone to the point where the minimal ratio of boundary size
442 and in-partition calls was reached. */
445 lto_balanced_map (int n_lto_partitions
)
448 int n_varpool_nodes
= 0, varpool_pos
= 0, best_varpool_pos
= 0;
449 struct cgraph_node
**order
= XNEWVEC (cgraph_node
*, symtab
->cgraph_max_uid
);
450 auto_vec
<cgraph_node
*> noreorder
;
451 auto_vec
<varpool_node
*> varpool_order
;
453 struct cgraph_node
*node
;
454 int original_total_size
, total_size
= 0, best_total_size
= 0;
456 ltrans_partition partition
;
457 int last_visited_node
= 0;
459 int cost
= 0, internal
= 0;
460 int best_n_nodes
= 0, best_i
= 0, best_cost
=
461 INT_MAX
, best_internal
= 0;
463 int current_order
= -1;
464 int noreorder_pos
= 0;
466 FOR_EACH_VARIABLE (vnode
)
467 gcc_assert (!vnode
->aux
);
469 FOR_EACH_DEFINED_FUNCTION (node
)
470 if (node
->get_partitioning_class () == SYMBOL_PARTITION
)
472 if (node
->no_reorder
)
473 noreorder
.safe_push (node
);
475 order
[n_nodes
++] = node
;
477 total_size
+= inline_summaries
->get (node
)->size
;
480 original_total_size
= total_size
;
482 /* Streaming works best when the source units do not cross partition
483 boundaries much. This is because importing function from a source
484 unit tends to import a lot of global trees defined there. We should
485 get better about minimizing the function bounday, but until that
486 things works smoother if we order in source order. */
487 qsort (order
, n_nodes
, sizeof (struct cgraph_node
*), node_cmp
);
488 noreorder
.qsort (node_cmp
);
490 if (symtab
->dump_file
)
492 for(i
= 0; i
< n_nodes
; i
++)
493 fprintf (symtab
->dump_file
, "Balanced map symbol order:%s:%u\n",
494 order
[i
]->name (), order
[i
]->tp_first_run
);
495 for(i
= 0; i
< (int)noreorder
.length(); i
++)
496 fprintf (symtab
->dump_file
, "Balanced map symbol no_reorder:%s:%u\n",
497 noreorder
[i
]->name (), noreorder
[i
]->tp_first_run
);
500 /* Collect all variables that should not be reordered. */
501 FOR_EACH_VARIABLE (vnode
)
502 if (vnode
->get_partitioning_class () == SYMBOL_PARTITION
503 && (!flag_toplevel_reorder
|| vnode
->no_reorder
))
504 varpool_order
.safe_push (vnode
);
505 n_varpool_nodes
= varpool_order
.length ();
506 varpool_order
.qsort (varpool_node_cmp
);
508 /* Compute partition size and create the first partition. */
509 partition_size
= total_size
/ n_lto_partitions
;
510 if (partition_size
< PARAM_VALUE (MIN_PARTITION_SIZE
))
511 partition_size
= PARAM_VALUE (MIN_PARTITION_SIZE
);
513 partition
= new_partition ("");
514 if (symtab
->dump_file
)
515 fprintf (symtab
->dump_file
, "Total unit size: %i, partition size: %i\n",
516 total_size
, partition_size
);
518 auto_vec
<symtab_node
*> next_nodes
;
520 for (i
= 0; i
< n_nodes
; i
++)
522 if (symbol_partitioned_p (order
[i
]))
525 current_order
= order
[i
]->order
;
527 /* Output noreorder and varpool in program order first. */
528 next_nodes
.truncate (0);
529 while (varpool_pos
< n_varpool_nodes
530 && varpool_order
[varpool_pos
]->order
< current_order
)
531 next_nodes
.safe_push (varpool_order
[varpool_pos
++]);
532 while (noreorder_pos
< (int)noreorder
.length ()
533 && noreorder
[noreorder_pos
]->order
< current_order
)
535 if (!noreorder
[noreorder_pos
]->alias
)
536 total_size
-= inline_summaries
->get (noreorder
[noreorder_pos
])->size
;
537 next_nodes
.safe_push (noreorder
[noreorder_pos
++]);
539 add_sorted_nodes (next_nodes
, partition
);
541 add_symbol_to_partition (partition
, order
[i
]);
542 if (!order
[i
]->alias
)
543 total_size
-= inline_summaries
->get (order
[i
])->size
;
546 /* Once we added a new node to the partition, we also want to add
547 all referenced variables unless they was already added into some
549 add_symbol_to_partition adds possibly multiple nodes and
550 variables that are needed to satisfy needs of ORDER[i].
551 We remember last visited cgraph and varpool node from last iteration
552 of outer loop that allows us to process every new addition.
554 At the same time we compute size of the boundary into COST. Every
555 callgraph or IPA reference edge leaving the partition contributes into
556 COST. Every edge inside partition was earlier computed as one leaving
557 it and thus we need to subtract it from COST. */
558 while (last_visited_node
< lto_symtab_encoder_size (partition
->encoder
))
560 symtab_node
*refs_node
;
562 struct ipa_ref
*ref
= NULL
;
563 symtab_node
*snode
= lto_symtab_encoder_deref (partition
->encoder
,
566 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (snode
))
568 struct cgraph_edge
*edge
;
574 gcc_assert (node
->definition
|| node
->weakref
);
576 /* Compute boundary cost of callgraph edges. */
577 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
578 if (edge
->callee
->definition
)
580 int edge_cost
= edge
->frequency
;
585 gcc_assert (edge_cost
> 0);
586 index
= lto_symtab_encoder_lookup (partition
->encoder
,
588 if (index
!= LCC_NOT_FOUND
589 && index
< last_visited_node
- 1)
590 cost
-= edge_cost
, internal
+= edge_cost
;
594 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
596 int edge_cost
= edge
->frequency
;
599 gcc_assert (edge
->caller
->definition
);
602 gcc_assert (edge_cost
> 0);
603 index
= lto_symtab_encoder_lookup (partition
->encoder
,
605 if (index
!= LCC_NOT_FOUND
606 && index
< last_visited_node
- 1)
618 /* Compute boundary cost of IPA REF edges and at the same time look into
619 variables referenced from current partition and try to add them. */
620 for (j
= 0; refs_node
->iterate_reference (j
, ref
); j
++)
621 if (is_a
<varpool_node
*> (ref
->referred
))
625 vnode
= dyn_cast
<varpool_node
*> (ref
->referred
);
626 if (!vnode
->definition
)
628 if (!symbol_partitioned_p (vnode
) && flag_toplevel_reorder
629 && !vnode
->no_reorder
630 && vnode
->get_partitioning_class () == SYMBOL_PARTITION
)
631 add_symbol_to_partition (partition
, vnode
);
632 index
= lto_symtab_encoder_lookup (partition
->encoder
,
634 if (index
!= LCC_NOT_FOUND
635 && index
< last_visited_node
- 1)
644 node
= dyn_cast
<cgraph_node
*> (ref
->referred
);
645 if (!node
->definition
)
647 index
= lto_symtab_encoder_lookup (partition
->encoder
,
649 if (index
!= LCC_NOT_FOUND
650 && index
< last_visited_node
- 1)
655 for (j
= 0; refs_node
->iterate_referring (j
, ref
); j
++)
656 if (is_a
<varpool_node
*> (ref
->referring
))
660 vnode
= dyn_cast
<varpool_node
*> (ref
->referring
);
661 gcc_assert (vnode
->definition
);
662 /* It is better to couple variables with their users, because it allows them
663 to be removed. Coupling with objects they refer to only helps to reduce
664 number of symbols promoted to hidden. */
665 if (!symbol_partitioned_p (vnode
) && flag_toplevel_reorder
666 && !vnode
->no_reorder
667 && !vnode
->can_remove_if_no_refs_p ()
668 && vnode
->get_partitioning_class () == SYMBOL_PARTITION
)
669 add_symbol_to_partition (partition
, vnode
);
670 index
= lto_symtab_encoder_lookup (partition
->encoder
,
672 if (index
!= LCC_NOT_FOUND
673 && index
< last_visited_node
- 1)
682 node
= dyn_cast
<cgraph_node
*> (ref
->referring
);
683 gcc_assert (node
->definition
);
684 index
= lto_symtab_encoder_lookup (partition
->encoder
,
686 if (index
!= LCC_NOT_FOUND
687 && index
< last_visited_node
- 1)
694 /* If the partition is large enough, start looking for smallest boundary cost. */
695 if (partition
->insns
< partition_size
* 3 / 4
696 || best_cost
== INT_MAX
698 || (best_internal
* (HOST_WIDE_INT
) cost
699 > (internal
* (HOST_WIDE_INT
)best_cost
)))
700 && partition
->insns
< partition_size
* 5 / 4))
703 best_internal
= internal
;
705 best_n_nodes
= lto_symtab_encoder_size (partition
->encoder
);
706 best_total_size
= total_size
;
707 best_varpool_pos
= varpool_pos
;
709 if (symtab
->dump_file
)
710 fprintf (symtab
->dump_file
, "Step %i: added %s/%i, size %i, cost %i/%i "
711 "best %i/%i, step %i\n", i
,
712 order
[i
]->name (), order
[i
]->order
,
713 partition
->insns
, cost
, internal
,
714 best_cost
, best_internal
, best_i
);
715 /* Partition is too large, unwind into step when best cost was reached and
716 start new partition. */
717 if (partition
->insns
> 2 * partition_size
)
721 if (symtab
->dump_file
)
722 fprintf (symtab
->dump_file
, "Unwinding %i insertions to step %i\n",
724 undo_partition (partition
, best_n_nodes
);
725 varpool_pos
= best_varpool_pos
;
728 /* When we are finished, avoid creating empty partition. */
729 while (i
< n_nodes
- 1 && symbol_partitioned_p (order
[i
+ 1]))
731 if (i
== n_nodes
- 1)
733 partition
= new_partition ("");
734 last_visited_node
= 0;
735 total_size
= best_total_size
;
738 if (symtab
->dump_file
)
739 fprintf (symtab
->dump_file
, "New partition\n");
743 /* Since the size of partitions is just approximate, update the size after
744 we finished current one. */
745 if (npartitions
< n_lto_partitions
)
746 partition_size
= total_size
/ (n_lto_partitions
- npartitions
);
748 partition_size
= INT_MAX
;
750 if (partition_size
< PARAM_VALUE (MIN_PARTITION_SIZE
))
751 partition_size
= PARAM_VALUE (MIN_PARTITION_SIZE
);
756 next_nodes
.truncate (0);
758 /* Varables that are not reachable from the code go into last partition. */
759 if (flag_toplevel_reorder
)
761 FOR_EACH_VARIABLE (vnode
)
762 if (vnode
->get_partitioning_class () == SYMBOL_PARTITION
763 && !symbol_partitioned_p (vnode
)
764 && !vnode
->no_reorder
)
765 next_nodes
.safe_push (vnode
);
768 /* Output remaining ordered symbols. */
769 while (varpool_pos
< n_varpool_nodes
)
770 next_nodes
.safe_push (varpool_order
[varpool_pos
++]);
771 while (noreorder_pos
< (int)noreorder
.length ())
772 next_nodes
.safe_push (noreorder
[noreorder_pos
++]);
773 add_sorted_nodes (next_nodes
, partition
);
777 if (symtab
->dump_file
)
779 fprintf (symtab
->dump_file
, "\nPartition sizes:\n");
780 unsigned partitions
= ltrans_partitions
.length ();
782 for (unsigned i
= 0; i
< partitions
; i
++)
784 ltrans_partition p
= ltrans_partitions
[i
];
785 fprintf (symtab
->dump_file
, "partition %d contains %d (%2.2f%%)"
786 " symbols and %d (%2.2f%%) insns\n", i
, p
->symbols
,
787 100.0 * p
->symbols
/ n_nodes
, p
->insns
,
788 100.0 * p
->insns
/ original_total_size
);
791 fprintf (symtab
->dump_file
, "\n");
795 /* Return true if we must not change the name of the NODE. The name as
796 extracted from the corresponding decl should be passed in NAME. */
799 must_not_rename (symtab_node
*node
, const char *name
)
801 /* Our renaming machinery do not handle more than one change of assembler name.
802 We should not need more than one anyway. */
803 if (node
->lto_file_data
804 && lto_get_decl_name_mapping (node
->lto_file_data
, name
) != name
)
806 if (symtab
->dump_file
)
807 fprintf (symtab
->dump_file
,
808 "Not privatizing symbol name: %s. It privatized already.\n",
812 /* Avoid mangling of already mangled clones.
813 ??? should have a flag whether a symbol has a 'private' name already,
814 since we produce some symbols like that i.e. for global constructors
815 that are not really clones. */
816 if (node
->unique_name
)
818 if (symtab
->dump_file
)
819 fprintf (symtab
->dump_file
,
820 "Not privatizing symbol name: %s. Has unique name.\n",
827 /* If we are an offload compiler, we may have to rewrite symbols to be
828 valid on this target. Return either PTR or a modified version of it. */
831 maybe_rewrite_identifier (const char *ptr
)
833 #if defined ACCEL_COMPILER && (defined NO_DOT_IN_LABEL || defined NO_DOLLAR_IN_LABEL)
834 #ifndef NO_DOT_IN_LABEL
836 const char reject
[] = "$";
837 #elif !defined NO_DOLLAR_IN_LABEL
839 const char reject
[] = ".";
842 const char reject
[] = ".$";
846 const char *match
= ptr
;
849 size_t off
= strcspn (match
, reject
);
850 if (match
[off
] == '\0')
854 copy
= xstrdup (ptr
);
865 /* Ensure that the symbol in NODE is valid for the target, and if not,
869 validize_symbol_for_target (symtab_node
*node
)
871 tree decl
= node
->decl
;
872 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
874 if (must_not_rename (node
, name
))
877 const char *name2
= maybe_rewrite_identifier (name
);
880 symtab
->change_decl_assembler_name (decl
, get_identifier (name2
));
881 if (node
->lto_file_data
)
882 lto_record_renamed_decl (node
->lto_file_data
, name
,
884 (DECL_ASSEMBLER_NAME (decl
)));
888 /* Helper for privatize_symbol_name. Mangle NODE symbol name
889 represented by DECL. */
892 privatize_symbol_name_1 (symtab_node
*node
, tree decl
)
894 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
896 if (must_not_rename (node
, name
))
899 name
= maybe_rewrite_identifier (name
);
900 symtab
->change_decl_assembler_name (decl
,
901 clone_function_name_1 (name
,
904 if (node
->lto_file_data
)
905 lto_record_renamed_decl (node
->lto_file_data
, name
,
907 (DECL_ASSEMBLER_NAME (decl
)));
909 if (symtab
->dump_file
)
910 fprintf (symtab
->dump_file
,
911 "Privatizing symbol name: %s -> %s\n",
912 name
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
917 /* Mangle NODE symbol name into a local name.
918 This is necessary to do
919 1) if two or more static vars of same assembler name
920 are merged into single ltrans unit.
921 2) if previously static var was promoted hidden to avoid possible conflict
922 with symbols defined out of the LTO world. */
925 privatize_symbol_name (symtab_node
*node
)
927 if (!privatize_symbol_name_1 (node
, node
->decl
))
930 /* We could change name which is a target of transparent alias
931 chain of instrumented function name. Fix alias chain if so .*/
932 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
934 tree iname
= NULL_TREE
;
935 if (cnode
->instrumentation_clone
)
937 /* If we want to privatize instrumentation clone
938 then we also need to privatize original function. */
939 if (cnode
->instrumented_version
)
940 privatize_symbol_name (cnode
->instrumented_version
);
942 privatize_symbol_name_1 (cnode
, cnode
->orig_decl
);
943 iname
= DECL_ASSEMBLER_NAME (cnode
->decl
);
944 TREE_CHAIN (iname
) = DECL_ASSEMBLER_NAME (cnode
->orig_decl
);
946 else if (cnode
->instrumented_version
947 && cnode
->instrumented_version
->orig_decl
== cnode
->decl
)
949 iname
= DECL_ASSEMBLER_NAME (cnode
->instrumented_version
->decl
);
950 TREE_CHAIN (iname
) = DECL_ASSEMBLER_NAME (cnode
->decl
);
957 /* Promote variable VNODE to be static. */
960 promote_symbol (symtab_node
*node
)
962 /* We already promoted ... */
963 if (DECL_VISIBILITY (node
->decl
) == VISIBILITY_HIDDEN
964 && DECL_VISIBILITY_SPECIFIED (node
->decl
)
965 && TREE_PUBLIC (node
->decl
))
967 validize_symbol_for_target (node
);
971 gcc_checking_assert (!TREE_PUBLIC (node
->decl
)
972 && !DECL_EXTERNAL (node
->decl
));
973 /* Be sure that newly public symbol does not conflict with anything already
974 defined by the non-LTO part. */
975 privatize_symbol_name (node
);
976 TREE_PUBLIC (node
->decl
) = 1;
977 DECL_VISIBILITY (node
->decl
) = VISIBILITY_HIDDEN
;
978 DECL_VISIBILITY_SPECIFIED (node
->decl
) = true;
979 if (symtab
->dump_file
)
980 fprintf (symtab
->dump_file
,
981 "Promoting as hidden: %s\n", node
->name ());
984 /* Return true if NODE needs named section even if it won't land in the partition
986 FIXME: we should really not use named sections for inline clones and master clones. */
989 may_need_named_section_p (lto_symtab_encoder_t encoder
, symtab_node
*node
)
991 struct cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
994 if (node
->real_symbol_p ())
997 || (lto_symtab_encoder_lookup (encoder
, node
) != LCC_NOT_FOUND
998 && lto_symtab_encoder_encode_body_p (encoder
,
1002 /* If NODE represents a static variable. See if there are other variables
1003 of the same name in partition ENCODER (or in whole compilation unit if
1004 ENCODER is NULL) and if so, mangle the statics. Always mangle all
1005 conflicting statics, so we reduce changes of silently miscompiling
1006 asm statements referring to them by symbol name. */
1009 rename_statics (lto_symtab_encoder_t encoder
, symtab_node
*node
)
1011 tree decl
= node
->decl
;
1013 tree name
= DECL_ASSEMBLER_NAME (decl
);
1015 /* See if this is static symbol. */
1016 if ((node
->externally_visible
1017 /* FIXME: externally_visible is somewhat illogically not set for
1018 external symbols (i.e. those not defined). Remove this test
1019 once this is fixed. */
1020 || DECL_EXTERNAL (node
->decl
)
1021 || !node
->real_symbol_p ())
1022 && !may_need_named_section_p (encoder
, node
))
1025 /* Now walk symbols sharing the same name and see if there are any conflicts.
1026 (all types of symbols counts here, since we can not have static of the
1027 same name as external or public symbol.) */
1028 for (s
= symtab_node::get_for_asmname (name
);
1029 s
; s
= s
->next_sharing_asm_name
)
1030 if ((s
->real_symbol_p () || may_need_named_section_p (encoder
, s
))
1031 && s
->decl
!= node
->decl
1033 || lto_symtab_encoder_lookup (encoder
, s
) != LCC_NOT_FOUND
))
1036 /* OK, no confict, so we have nothing to do. */
1040 if (symtab
->dump_file
)
1041 fprintf (symtab
->dump_file
,
1042 "Renaming statics with asm name: %s\n", node
->name ());
1044 /* Assign every symbol in the set that shares the same ASM name an unique
1046 for (s
= symtab_node::get_for_asmname (name
); s
;)
1047 if (!s
->externally_visible
1048 && ((s
->real_symbol_p ()
1049 && !DECL_EXTERNAL (node
->decl
)
1050 && !TREE_PUBLIC (node
->decl
))
1051 || may_need_named_section_p (encoder
, s
))
1053 || lto_symtab_encoder_lookup (encoder
, s
) != LCC_NOT_FOUND
))
1055 if (privatize_symbol_name (s
))
1056 /* Re-start from beginning since we do not know how many symbols changed a name. */
1057 s
= symtab_node::get_for_asmname (name
);
1058 else s
= s
->next_sharing_asm_name
;
1060 else s
= s
->next_sharing_asm_name
;
1063 /* Find out all static decls that need to be promoted to global because
1064 of cross file sharing. This function must be run in the WPA mode after
1065 all inlinees are added. */
1068 lto_promote_cross_file_statics (void)
1072 gcc_assert (flag_wpa
);
1074 lto_stream_offload_p
= false;
1075 select_what_to_stream ();
1077 /* First compute boundaries. */
1078 n_sets
= ltrans_partitions
.length ();
1079 for (i
= 0; i
< n_sets
; i
++)
1081 ltrans_partition part
1082 = ltrans_partitions
[i
];
1083 part
->encoder
= compute_ltrans_boundary (part
->encoder
);
1086 /* Look at boundaries and promote symbols as needed. */
1087 for (i
= 0; i
< n_sets
; i
++)
1089 lto_symtab_encoder_iterator lsei
;
1090 lto_symtab_encoder_t encoder
= ltrans_partitions
[i
]->encoder
;
1092 for (lsei
= lsei_start (encoder
); !lsei_end_p (lsei
);
1095 symtab_node
*node
= lsei_node (lsei
);
1097 /* If symbol is static, rename it if its assembler name clash with
1098 anything else in this unit. */
1099 rename_statics (encoder
, node
);
1101 /* No need to promote if symbol already is externally visible ... */
1102 if (node
->externally_visible
1103 /* ... or if it is part of current partition ... */
1104 || lto_symtab_encoder_in_partition_p (encoder
, node
)
1105 /* ... or if we do not partition it. This mean that it will
1106 appear in every partition refernecing it. */
1107 || node
->get_partitioning_class () != SYMBOL_PARTITION
)
1109 validize_symbol_for_target (node
);
1113 promote_symbol (node
);
1118 /* Rename statics in the whole unit in the case that
1119 we do -flto-partition=none. */
1122 lto_promote_statics_nonwpa (void)
1125 FOR_EACH_SYMBOL (node
)
1127 rename_statics (NULL
, node
);
1128 validize_symbol_for_target (node
);