Daily bump.
[official-gcc.git] / gcc / ipa-comdats.c
blobaf2aef8efad20cd19a6071267b5b43e4cb7b67ae
1 /* Localize comdats.
2 Copyright (C) 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
9 version.
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
14 for more details.
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/>. */
20 /* This is very simple pass that looks for static symbols that are used
21 exlusively by symbol within one comdat group. In this case it makes
22 sense to bring the symbol itself into the group to avoid dead code
23 that would arrise when the comdat group from current unit is replaced
24 by a different copy. Consider for example:
26 static int q(void)
28 ....
30 inline int t(void)
32 return q();
35 if Q is used only by T, it makes sense to put Q into T's comdat group.
37 The pass solve simple dataflow across the callgraph trying to prove what
38 symbols are used exclusively from a given comdat group.
40 The implementation maintains a queue linked by AUX pointer terminated by
41 pointer value 1. Lattice values are NULL for TOP, actual comdat group, or
42 ERROR_MARK_NODE for bottom.
44 TODO: When symbol is used only by comdat symbols, but from different groups,
45 it would make sense to produce a new comdat group for it with anonymous name.
47 TODO2: We can't mix variables and functions within one group. Currently
48 we just give up on references of symbols of different types. We also should
49 handle this by anonymous comdat group section. */
51 #include "config.h"
52 #include "system.h"
53 #include "coretypes.h"
54 #include "tm.h"
55 #include "tree.h"
56 #include "hash-map.h"
57 #include "is-a.h"
58 #include "plugin-api.h"
59 #include "vec.h"
60 #include "hashtab.h"
61 #include "hash-set.h"
62 #include "machmode.h"
63 #include "hard-reg-set.h"
64 #include "input.h"
65 #include "function.h"
66 #include "ipa-ref.h"
67 #include "cgraph.h"
68 #include "tree-pass.h"
70 /* Main dataflow loop propagating comdat groups across
71 the symbol table. All references to SYMBOL are examined
72 and NEWGROUP is updated accordingly. MAP holds current lattice
73 values for individual symbols. */
75 tree
76 propagate_comdat_group (struct symtab_node *symbol,
77 tree newgroup, hash_map<symtab_node *, tree> &map)
79 int i;
80 struct ipa_ref *ref;
82 /* Walk all references to SYMBOL, recursively dive into aliases. */
84 for (i = 0;
85 symbol->iterate_referring (i, ref)
86 && newgroup != error_mark_node; i++)
88 struct symtab_node *symbol2 = ref->referring;
90 if (ref->use == IPA_REF_ALIAS)
92 newgroup = propagate_comdat_group (symbol2, newgroup, map);
93 continue;
96 /* One COMDAT group can not hold both variables and functions at
97 a same time. For now we just go to BOTTOM, in future we may
98 invent special comdat groups for this case. */
100 if (symbol->type != symbol2->type)
102 newgroup = error_mark_node;
103 break;
106 /* If we see inline clone, its comdat group actually
107 corresponds to the comdat group of the function it is inlined
108 to. */
110 if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
112 if (cn->global.inlined_to)
113 symbol2 = cn->global.inlined_to;
116 /* The actual merge operation. */
118 tree *val2 = map.get (symbol2);
120 if (val2 && *val2 != newgroup)
122 if (!newgroup)
123 newgroup = *val2;
124 else
125 newgroup = error_mark_node;
129 /* If we analyze function, walk also callers. */
131 cgraph_node *cnode = dyn_cast <cgraph_node *> (symbol);
133 if (cnode)
134 for (struct cgraph_edge * edge = cnode->callers;
135 edge && newgroup != error_mark_node; edge = edge->next_caller)
137 struct symtab_node *symbol2 = edge->caller;
139 /* If we see inline clone, its comdat group actually
140 corresponds to the comdat group of the function it is inlined
141 to. */
143 if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
145 if (cn->global.inlined_to)
146 symbol2 = cn->global.inlined_to;
149 /* The actual merge operation. */
151 tree *val2 = map.get (symbol2);
153 if (val2 && *val2 != newgroup)
155 if (!newgroup)
156 newgroup = *val2;
157 else
158 newgroup = error_mark_node;
161 return newgroup;
165 /* Add all references of SYMBOL that are defined into queue started by FIRST
166 and linked by AUX pointer (unless they are already enqueued).
167 Walk recursively inlined functions. */
169 void
170 enqueue_references (symtab_node **first,
171 symtab_node *symbol)
173 int i;
174 struct ipa_ref *ref = NULL;
176 for (i = 0; symbol->iterate_reference (i, ref); i++)
178 symtab_node *node = ref->referred->ultimate_alias_target ();
179 if (!node->aux && node->definition)
181 node->aux = *first;
182 *first = node;
186 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (symbol))
188 struct cgraph_edge *edge;
190 for (edge = cnode->callees; edge; edge = edge->next_callee)
191 if (!edge->inline_failed)
192 enqueue_references (first, edge->callee);
193 else
195 symtab_node *node = edge->callee->ultimate_alias_target ();
196 if (!node->aux && node->definition)
198 node->aux = *first;
199 *first = node;
205 /* Set comdat group of SYMBOL to GROUP.
206 Callback for symtab_for_node_and_aliases. */
208 bool
209 set_comdat_group (symtab_node *symbol,
210 void *head_p)
212 symtab_node *head = (symtab_node *)head_p;
214 gcc_assert (!symbol->get_comdat_group ());
215 symbol->set_comdat_group (head->get_comdat_group ());
216 symbol->add_to_same_comdat_group (head);
217 return false;
220 /* The actual pass with the main dataflow loop. */
222 static unsigned int
223 ipa_comdats (void)
225 hash_map<symtab_node *, tree> map (251);
226 hash_map<tree, symtab_node *> comdat_head_map (251);
227 symtab_node *symbol;
228 bool comdat_group_seen = false;
229 symtab_node *first = (symtab_node *) (void *) 1;
230 tree group;
232 /* Start the dataflow by assigning comdat group to symbols that are in comdat
233 groups already. All other externally visible symbols must stay, we use
234 ERROR_MARK_NODE as bottom for the propagation. */
236 FOR_EACH_DEFINED_SYMBOL (symbol)
237 if (!symbol->real_symbol_p ())
239 else if ((group = symbol->get_comdat_group ()) != NULL)
241 map.put (symbol, group);
242 comdat_head_map.put (group, symbol);
243 comdat_group_seen = true;
245 /* Mark the symbol so we won't waste time visiting it for dataflow. */
246 symbol->aux = (symtab_node *) (void *) 1;
248 /* See symbols that can not be privatized to comdats; that is externally
249 visible symbols or otherwise used ones. We also do not want to mangle
250 user section names. */
251 else if (symbol->externally_visible
252 || symbol->force_output
253 || symbol->used_from_other_partition
254 || TREE_THIS_VOLATILE (symbol->decl)
255 || symbol->get_section ()
256 || (TREE_CODE (symbol->decl) == FUNCTION_DECL
257 && (DECL_STATIC_CONSTRUCTOR (symbol->decl)
258 || DECL_STATIC_DESTRUCTOR (symbol->decl))))
260 map.put (symbol->ultimate_alias_target (), error_mark_node);
262 /* Mark the symbol so we won't waste time visiting it for dataflow. */
263 symbol->aux = (symtab_node *) (void *) 1;
265 else
267 /* Enqueue symbol for dataflow. */
268 symbol->aux = first;
269 first = symbol;
272 if (!comdat_group_seen)
274 FOR_EACH_DEFINED_SYMBOL (symbol)
275 symbol->aux = NULL;
276 return 0;
279 /* The actual dataflow. */
281 while (first != (void *) 1)
283 tree group = NULL;
284 tree newgroup, *val;
286 symbol = first;
287 first = (symtab_node *)first->aux;
289 /* Get current lattice value of SYMBOL. */
290 val = map.get (symbol);
291 if (val)
292 group = *val;
294 /* If it is bottom, there is nothing to do; do not clear AUX
295 so we won't re-queue the symbol. */
296 if (group == error_mark_node)
297 continue;
299 newgroup = propagate_comdat_group (symbol, group, map);
301 /* If nothing changed, proceed to next symbol. */
302 if (newgroup == group)
304 symbol->aux = NULL;
305 continue;
308 /* Update lattice value and enqueue all references for re-visiting. */
309 gcc_assert (newgroup);
310 if (val)
311 *val = newgroup;
312 else
313 map.put (symbol, newgroup);
314 enqueue_references (&first, symbol);
316 /* We may need to revisit the symbol unless it is BOTTOM. */
317 if (newgroup != error_mark_node)
318 symbol->aux = NULL;
321 /* Finally assign symbols to the sections. */
323 FOR_EACH_DEFINED_SYMBOL (symbol)
325 symbol->aux = NULL;
326 if (!symbol->get_comdat_group ()
327 && !symbol->alias
328 && symbol->real_symbol_p ())
330 tree group = *map.get (symbol);
332 if (group == error_mark_node)
333 continue;
334 if (dump_file)
336 fprintf (dump_file, "Localizing symbol\n");
337 symbol->dump (dump_file);
338 fprintf (dump_file, "To group: %s\n", IDENTIFIER_POINTER (group));
340 symbol->call_for_symbol_and_aliases (set_comdat_group,
341 *comdat_head_map.get (group),
342 true);
345 return 0;
348 namespace {
350 const pass_data pass_data_ipa_comdats =
352 IPA_PASS, /* type */
353 "comdats", /* name */
354 OPTGROUP_NONE, /* optinfo_flags */
355 TV_IPA_COMDATS, /* tv_id */
356 0, /* properties_required */
357 0, /* properties_provided */
358 0, /* properties_destroyed */
359 0, /* todo_flags_start */
360 0, /* todo_flags_finish */
363 class pass_ipa_comdats : public ipa_opt_pass_d
365 public:
366 pass_ipa_comdats (gcc::context *ctxt)
367 : ipa_opt_pass_d (pass_data_ipa_comdats, ctxt,
368 NULL, /* generate_summary */
369 NULL, /* write_summary */
370 NULL, /* read_summary */
371 NULL, /* write_optimization_summary */
372 NULL, /* read_optimization_summary */
373 NULL, /* stmt_fixup */
374 0, /* function_transform_todo_flags_start */
375 NULL, /* function_transform */
376 NULL) /* variable_transform */
379 /* opt_pass methods: */
380 virtual bool gate (function *);
381 virtual unsigned int execute (function *) { return ipa_comdats (); }
383 }; // class pass_ipa_comdats
385 bool
386 pass_ipa_comdats::gate (function *)
388 return optimize;
391 } // anon namespace
393 ipa_opt_pass_d *
394 make_pass_ipa_comdats (gcc::context *ctxt)
396 return new pass_ipa_comdats (ctxt);