1 /* Localize comdats. 2 Copyright (C) 2014-2017 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 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. 10 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. 15 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/>. */ 19 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: 25 26 static int q(void) 27 { 28 .... 29 } 30 inline int t(void) 31 { 32 return q(); 33 } 34 35 if Q is used only by T, it makes sense to put Q into T's comdat group. 36 37 The pass solve simple dataflow across the callgraph trying to prove what 38 symbols are used exclusively from a given comdat group. 39 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. 43 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. 46 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. */ 50 51 #include "config.h" 52 #include "system.h" 53 #include "coretypes.h" 54 #include "tm.h" 55 #include "tree.h" 56 #include "tree-pass.h" 57 #include "cgraph.h" 58 59 /* Main dataflow loop propagating comdat groups across 60 the symbol table. All references to SYMBOL are examined 61 and NEWGROUP is updated accordingly. MAP holds current lattice 62 values for individual symbols. */ 63 64 tree 65 propagate_comdat_group (struct symtab_node *symbol, 66 tree newgroup, hash_map<symtab_node *, tree> &map) 67 { 68 int i; 69 struct ipa_ref *ref; 70 71 /* Walk all references to SYMBOL, recursively dive into aliases. */ 72 73 for (i = 0; 74 symbol->iterate_referring (i, ref) 75 && newgroup != error_mark_node; i++) 76 { 77 struct symtab_node *symbol2 = ref->referring; 78 79 if (ref->use == IPA_REF_ALIAS) 80 { 81 newgroup = propagate_comdat_group (symbol2, newgroup, map); 82 continue; 83 } 84 85 /* One COMDAT group can not hold both variables and functions at 86 a same time. For now we just go to BOTTOM, in future we may 87 invent special comdat groups for this case. */ 88 89 if (symbol->type != symbol2->type) 90 { 91 newgroup = error_mark_node; 92 break; 93 } 94 95 /* If we see inline clone, its comdat group actually 96 corresponds to the comdat group of the function it is inlined 97 to. */ 98 99 if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2)) 100 { 101 if (cn->global.inlined_to) 102 symbol2 = cn->global.inlined_to; 103 } 104 105 /* The actual merge operation. */ 106 107 tree *val2 = map.get (symbol2); 108 109 if (val2 && *val2 != newgroup) 110 { 111 if (!newgroup) 112 newgroup = *val2; 113 else 114 newgroup = error_mark_node; 115 } 116 } 117 118 /* If we analyze function, walk also callers. */ 119 120 cgraph_node *cnode = dyn_cast <cgraph_node *> (symbol); 121 122 if (cnode) 123 for (struct cgraph_edge * edge = cnode->callers; 124 edge && newgroup != error_mark_node; edge = edge->next_caller) 125 { 126 struct symtab_node *symbol2 = edge->caller; 127 128 if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2)) 129 { 130 /* Thunks can not call across section boundary. */ 131 if (cn->thunk.thunk_p) 132 newgroup = propagate_comdat_group (symbol2, newgroup, map); 133 /* If we see inline clone, its comdat group actually 134 corresponds to the comdat group of the function it 135 is inlined to. */ 136 if (cn->global.inlined_to) 137 symbol2 = cn->global.inlined_to; 138 } 139 140 /* The actual merge operation. */ 141 142 tree *val2 = map.get (symbol2); 143 144 if (val2 && *val2 != newgroup) 145 { 146 if (!newgroup) 147 newgroup = *val2; 148 else 149 newgroup = error_mark_node; 150 } 151 } 152 return newgroup; 153 } 154 155 156 /* Add all references of SYMBOL that are defined into queue started by FIRST 157 and linked by AUX pointer (unless they are already enqueued). 158 Walk recursively inlined functions. */ 159 160 void 161 enqueue_references (symtab_node **first, 162 symtab_node *symbol) 163 { 164 int i; 165 struct ipa_ref *ref = NULL; 166 167 for (i = 0; symbol->iterate_reference (i, ref); i++) 168 { 169 symtab_node *node = ref->referred->ultimate_alias_target (); 170 171 /* Always keep thunks in same sections as target function. */ 172 if (is_a <cgraph_node *>(node)) 173 node = dyn_cast <cgraph_node *> (node)->function_symbol (); 174 if (!node->aux && node->definition) 175 { 176 node->aux = *first; 177 *first = node; 178 } 179 } 180 181 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (symbol)) 182 { 183 struct cgraph_edge *edge; 184 185 for (edge = cnode->callees; edge; edge = edge->next_callee) 186 if (!edge->inline_failed) 187 enqueue_references (first, edge->callee); 188 else 189 { 190 symtab_node *node = edge->callee->ultimate_alias_target (); 191 192 /* Always keep thunks in same sections as target function. */ 193 if (is_a <cgraph_node *>(node)) 194 node = dyn_cast <cgraph_node *> (node)->function_symbol (); 195 if (!node->aux && node->definition) 196 { 197 node->aux = *first; 198 *first = node; 199 } 200 } 201 } 202 } 203 204 /* Set comdat group of SYMBOL to GROUP. 205 Callback for for_node_and_aliases. */ 206 207 bool 208 set_comdat_group (symtab_node *symbol, 209 void *head_p) 210 { 211 symtab_node *head = (symtab_node *)head_p; 212 213 gcc_assert (!symbol->get_comdat_group ()); 214 symbol->set_comdat_group (head->get_comdat_group ()); 215 symbol->add_to_same_comdat_group (head); 216 return false; 217 } 218 219 /* Set comdat group of SYMBOL to GROUP. 220 Callback for for_node_thunks_and_aliases. */ 221 222 bool 223 set_comdat_group_1 (cgraph_node *symbol, 224 void *head_p) 225 { 226 return set_comdat_group (symbol, head_p); 227 } 228 229 /* The actual pass with the main dataflow loop. */ 230 231 static unsigned int 232 ipa_comdats (void) 233 { 234 hash_map<symtab_node *, tree> map (251); 235 hash_map<tree, symtab_node *> comdat_head_map (251); 236 symtab_node *symbol; 237 bool comdat_group_seen = false; 238 symtab_node *first = (symtab_node *) (void *) 1; 239 tree group; 240 241 /* Start the dataflow by assigning comdat group to symbols that are in comdat 242 groups already. All other externally visible symbols must stay, we use 243 ERROR_MARK_NODE as bottom for the propagation. */ 244 245 FOR_EACH_DEFINED_SYMBOL (symbol) 246 if (!symbol->real_symbol_p ()) 247 ; 248 else if ((group = symbol->get_comdat_group ()) != NULL) 249 { 250 map.put (symbol, group); 251 comdat_head_map.put (group, symbol); 252 comdat_group_seen = true; 253 254 /* Mark the symbol so we won't waste time visiting it for dataflow. */ 255 symbol->aux = (symtab_node *) (void *) 1; 256 } 257 /* See symbols that can not be privatized to comdats; that is externally 258 visible symbols or otherwise used ones. We also do not want to mangle 259 user section names. */ 260 else if (symbol->externally_visible 261 || symbol->force_output 262 || symbol->used_from_other_partition 263 || TREE_THIS_VOLATILE (symbol->decl) 264 || symbol->get_section () 265 || (TREE_CODE (symbol->decl) == FUNCTION_DECL 266 && (DECL_STATIC_CONSTRUCTOR (symbol->decl) 267 || DECL_STATIC_DESTRUCTOR (symbol->decl)))) 268 { 269 symtab_node *target = symbol->ultimate_alias_target (); 270 271 /* Always keep thunks in same sections as target function. */ 272 if (is_a <cgraph_node *>(target)) 273 target = dyn_cast <cgraph_node *> (target)->function_symbol (); 274 map.put (target, error_mark_node); 275 276 /* Mark the symbol so we won't waste time visiting it for dataflow. */ 277 symbol->aux = (symtab_node *) (void *) 1; 278 } 279 else 280 { 281 /* Enqueue symbol for dataflow. */ 282 symbol->aux = first; 283 first = symbol; 284 } 285 286 if (!comdat_group_seen) 287 { 288 FOR_EACH_DEFINED_SYMBOL (symbol) 289 symbol->aux = NULL; 290 return 0; 291 } 292 293 /* The actual dataflow. */ 294 295 while (first != (void *) 1) 296 { 297 tree group = NULL; 298 tree newgroup, *val; 299 300 symbol = first; 301 first = (symtab_node *)first->aux; 302 303 /* Get current lattice value of SYMBOL. */ 304 val = map.get (symbol); 305 if (val) 306 group = *val; 307 308 /* If it is bottom, there is nothing to do; do not clear AUX 309 so we won't re-queue the symbol. */ 310 if (group == error_mark_node) 311 continue; 312 313 newgroup = propagate_comdat_group (symbol, group, map); 314 315 /* If nothing changed, proceed to next symbol. */ 316 if (newgroup == group) 317 { 318 symbol->aux = NULL; 319 continue; 320 } 321 322 /* Update lattice value and enqueue all references for re-visiting. */ 323 gcc_assert (newgroup); 324 if (val) 325 *val = newgroup; 326 else 327 map.put (symbol, newgroup); 328 enqueue_references (&first, symbol); 329 330 /* We may need to revisit the symbol unless it is BOTTOM. */ 331 if (newgroup != error_mark_node) 332 symbol->aux = NULL; 333 } 334 335 /* Finally assign symbols to the sections. */ 336 337 FOR_EACH_DEFINED_SYMBOL (symbol) 338 { 339 struct cgraph_node *fun; 340 symbol->aux = NULL; 341 if (!symbol->get_comdat_group () 342 && !symbol->alias 343 && (!(fun = dyn_cast <cgraph_node *> (symbol)) 344 || !fun->thunk.thunk_p) 345 && symbol->real_symbol_p ()) 346 { 347 tree *val = map.get (symbol); 348 349 /* A NULL here means that SYMBOL is unreachable in the definition 350 of ipa-comdats. Either ipa-comdats is wrong about this or someone 351 forgot to cleanup and remove unreachable functions earlier. */ 352 gcc_assert (val); 353 354 tree group = *val; 355 356 if (group == error_mark_node) 357 continue; 358 if (dump_file) 359 { 360 fprintf (dump_file, "Localizing symbol\n"); 361 symbol->dump (dump_file); 362 fprintf (dump_file, "To group: %s\n", IDENTIFIER_POINTER (group)); 363 } 364 if (is_a <cgraph_node *> (symbol)) 365 dyn_cast <cgraph_node *>(symbol)->call_for_symbol_thunks_and_aliases 366 (set_comdat_group_1, 367 *comdat_head_map.get (group), 368 true); 369 else 370 symbol->call_for_symbol_and_aliases 371 (set_comdat_group, 372 *comdat_head_map.get (group), 373 true); 374 } 375 } 376 return 0; 377 } 378 379 namespace { 380 381 const pass_data pass_data_ipa_comdats = 382 { 383 IPA_PASS, /* type */ 384 "comdats", /* name */ 385 OPTGROUP_NONE, /* optinfo_flags */ 386 TV_IPA_COMDATS, /* tv_id */ 387 0, /* properties_required */ 388 0, /* properties_provided */ 389 0, /* properties_destroyed */ 390 0, /* todo_flags_start */ 391 0, /* todo_flags_finish */ 392 }; 393 394 class pass_ipa_comdats : public ipa_opt_pass_d 395 { 396 public: 397 pass_ipa_comdats (gcc::context *ctxt) 398 : ipa_opt_pass_d (pass_data_ipa_comdats, ctxt, 399 NULL, /* generate_summary */ 400 NULL, /* write_summary */ 401 NULL, /* read_summary */ 402 NULL, /* write_optimization_summary */ 403 NULL, /* read_optimization_summary */ 404 NULL, /* stmt_fixup */ 405 0, /* function_transform_todo_flags_start */ 406 NULL, /* function_transform */ 407 NULL) /* variable_transform */ 408 {} 409 410 /* opt_pass methods: */ 411 virtual bool gate (function *); 412 virtual unsigned int execute (function *) { return ipa_comdats (); } 413 414 }; // class pass_ipa_comdats 415 416 bool 417 pass_ipa_comdats::gate (function *) 418 { 419 return HAVE_COMDAT_GROUP && optimize; 420 } 421 422 } // anon namespace 423 424 ipa_opt_pass_d * 425 make_pass_ipa_comdats (gcc::context *ctxt) 426 { 427 return new pass_ipa_comdats (ctxt); 428 } 429