1 /* Pass for parsing functions with multiple target attributes. 2 3 Contributed by Evgeny Stupachenko <evstupac@gmail.com> 4 5 Copyright (C) 2015-2018 Free Software Foundation, Inc. 6 7 This file is part of GCC. 8 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 12 version. 13 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 17 for more details. 18 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/>. */ 22 23 #include "config.h" 24 #include "system.h" 25 #include "coretypes.h" 26 #include "backend.h" 27 #include "tree.h" 28 #include "stringpool.h" 29 #include "gimple.h" 30 #include "diagnostic-core.h" 31 #include "gimple-ssa.h" 32 #include "cgraph.h" 33 #include "tree-pass.h" 34 #include "target.h" 35 #include "attribs.h" 36 #include "pretty-print.h" 37 #include "gimple-iterator.h" 38 #include "gimple-walk.h" 39 #include "tree-inline.h" 40 #include "intl.h" 41 42 /* Walker callback that replaces all FUNCTION_DECL of a function that's 43 going to be versioned. */ 44 45 static tree 46 replace_function_decl (tree *op, int *walk_subtrees, void *data) 47 { 48 struct walk_stmt_info *wi = (struct walk_stmt_info *) data; 49 cgraph_function_version_info *info = (cgraph_function_version_info *)wi->info; 50 51 if (TREE_CODE (*op) == FUNCTION_DECL 52 && info->this_node->decl == *op) 53 { 54 *op = info->dispatcher_resolver; 55 *walk_subtrees = 0; 56 } 57 58 return NULL; 59 } 60 61 /* If the call in NODE has multiple target attribute with multiple fields, 62 replace it with dispatcher call and create dispatcher (once). */ 63 64 static void 65 create_dispatcher_calls (struct cgraph_node *node) 66 { 67 ipa_ref *ref; 68 69 if (!DECL_FUNCTION_VERSIONED (node->decl) 70 || !is_function_default_version (node->decl)) 71 return; 72 73 if (!targetm.has_ifunc_p ()) 74 { 75 error_at (DECL_SOURCE_LOCATION (node->decl), 76 "the call requires ifunc, which is not" 77 " supported by this target"); 78 return; 79 } 80 else if (!targetm.get_function_versions_dispatcher) 81 { 82 error_at (DECL_SOURCE_LOCATION (node->decl), 83 "target does not support function version dispatcher"); 84 return; 85 } 86 87 tree idecl = targetm.get_function_versions_dispatcher (node->decl); 88 if (!idecl) 89 { 90 error_at (DECL_SOURCE_LOCATION (node->decl), 91 "default %<target_clones%> attribute was not set"); 92 return; 93 } 94 95 cgraph_node *inode = cgraph_node::get (idecl); 96 gcc_assert (inode); 97 tree resolver_decl = targetm.generate_version_dispatcher_body (inode); 98 99 /* Update aliases. */ 100 inode->alias = true; 101 inode->alias_target = resolver_decl; 102 if (!inode->analyzed) 103 inode->resolve_alias (cgraph_node::get (resolver_decl)); 104 105 auto_vec<cgraph_edge *> edges_to_redirect; 106 auto_vec<ipa_ref *> references_to_redirect; 107 108 for (unsigned i = 0; node->iterate_referring (i, ref); i++) 109 references_to_redirect.safe_push (ref); 110 111 /* We need to remember NEXT_CALLER as it could be modified in the loop. */ 112 for (cgraph_edge *e = node->callers; e ; e = e->next_caller) 113 edges_to_redirect.safe_push (e); 114 115 if (!edges_to_redirect.is_empty () || !references_to_redirect.is_empty ()) 116 { 117 /* Redirect edges. */ 118 unsigned i; 119 cgraph_edge *e; 120 FOR_EACH_VEC_ELT (edges_to_redirect, i, e) 121 { 122 e->redirect_callee (inode); 123 e->redirect_call_stmt_to_callee (); 124 } 125 126 /* Redirect references. */ 127 FOR_EACH_VEC_ELT (references_to_redirect, i, ref) 128 { 129 if (ref->use == IPA_REF_ADDR) 130 { 131 struct walk_stmt_info wi; 132 memset (&wi, 0, sizeof (wi)); 133 wi.info = (void *)node->function_version (); 134 135 if (dyn_cast<varpool_node *> (ref->referring)) 136 { 137 hash_set<tree> visited_nodes; 138 walk_tree (&DECL_INITIAL (ref->referring->decl), 139 replace_function_decl, &wi, &visited_nodes); 140 } 141 else 142 { 143 gimple_stmt_iterator it = gsi_for_stmt (ref->stmt); 144 if (ref->referring->decl != resolver_decl) 145 walk_gimple_stmt (&it, NULL, replace_function_decl, &wi); 146 } 147 148 symtab_node *source = ref->referring; 149 ref->remove_reference (); 150 source->create_reference (inode, IPA_REF_ADDR); 151 } 152 else if (ref->use == IPA_REF_ALIAS) 153 { 154 symtab_node *source = ref->referring; 155 ref->remove_reference (); 156 source->create_reference (inode, IPA_REF_ALIAS); 157 source->add_to_same_comdat_group (inode); 158 } 159 else 160 gcc_unreachable (); 161 } 162 } 163 164 symtab->change_decl_assembler_name (node->decl, 165 clone_function_name (node->decl, 166 "default")); 167 168 /* FIXME: copy of cgraph_node::make_local that should be cleaned up 169 in next stage1. */ 170 node->make_decl_local (); 171 node->set_section (NULL); 172 node->set_comdat_group (NULL); 173 node->externally_visible = false; 174 node->forced_by_abi = false; 175 node->set_section (NULL); 176 node->unique_name = ((node->resolution == LDPR_PREVAILING_DEF_IRONLY 177 || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP) 178 && !flag_incremental_link); 179 node->resolution = LDPR_PREVAILING_DEF_IRONLY; 180 181 DECL_ARTIFICIAL (node->decl) = 1; 182 node->force_output = true; 183 } 184 185 /* Return length of attribute names string, 186 if arglist chain > 1, -1 otherwise. */ 187 188 static int 189 get_attr_len (tree arglist) 190 { 191 tree arg; 192 int str_len_sum = 0; 193 int argnum = 0; 194 195 for (arg = arglist; arg; arg = TREE_CHAIN (arg)) 196 { 197 const char *str = TREE_STRING_POINTER (TREE_VALUE (arg)); 198 size_t len = strlen (str); 199 str_len_sum += len + 1; 200 for (const char *p = strchr (str, ','); p; p = strchr (p + 1, ',')) 201 argnum++; 202 argnum++; 203 } 204 if (argnum <= 1) 205 return -1; 206 return str_len_sum; 207 } 208 209 /* Create string with attributes separated by comma. 210 Return number of attributes. */ 211 212 static int 213 get_attr_str (tree arglist, char *attr_str) 214 { 215 tree arg; 216 size_t str_len_sum = 0; 217 int argnum = 0; 218 219 for (arg = arglist; arg; arg = TREE_CHAIN (arg)) 220 { 221 const char *str = TREE_STRING_POINTER (TREE_VALUE (arg)); 222 size_t len = strlen (str); 223 for (const char *p = strchr (str, ','); p; p = strchr (p + 1, ',')) 224 argnum++; 225 memcpy (attr_str + str_len_sum, str, len); 226 attr_str[str_len_sum + len] = TREE_CHAIN (arg) ? ',' : '\0'; 227 str_len_sum += len + 1; 228 argnum++; 229 } 230 return argnum; 231 } 232 233 /* Return number of attributes separated by comma and put them into ARGS. 234 If there is no DEFAULT attribute return -1. If there is an empty 235 string in attribute return -2. */ 236 237 static int 238 separate_attrs (char *attr_str, char **attrs, int attrnum) 239 { 240 int i = 0; 241 int default_count = 0; 242 243 for (char *attr = strtok (attr_str, ","); 244 attr != NULL; attr = strtok (NULL, ",")) 245 { 246 if (strcmp (attr, "default") == 0) 247 { 248 default_count++; 249 continue; 250 } 251 attrs[i++] = attr; 252 } 253 if (default_count == 0) 254 return -1; 255 else if (i + default_count < attrnum) 256 return -2; 257 258 return i; 259 } 260 261 /* Return true if symbol is valid in assembler name. */ 262 263 static bool 264 is_valid_asm_symbol (char c) 265 { 266 if ('a' <= c && c <= 'z') 267 return true; 268 if ('A' <= c && c <= 'Z') 269 return true; 270 if ('0' <= c && c <= '9') 271 return true; 272 if (c == '_') 273 return true; 274 return false; 275 } 276 277 /* Replace all not valid assembler symbols with '_'. */ 278 279 static void 280 create_new_asm_name (char *old_asm_name, char *new_asm_name) 281 { 282 int i; 283 int old_name_len = strlen (old_asm_name); 284 285 /* Replace all not valid assembler symbols with '_'. */ 286 for (i = 0; i < old_name_len; i++) 287 if (!is_valid_asm_symbol (old_asm_name[i])) 288 new_asm_name[i] = '_'; 289 else 290 new_asm_name[i] = old_asm_name[i]; 291 new_asm_name[old_name_len] = '\0'; 292 } 293 294 /* Creates target clone of NODE. */ 295 296 static cgraph_node * 297 create_target_clone (cgraph_node *node, bool definition, char *name, 298 tree attributes) 299 { 300 cgraph_node *new_node; 301 302 if (definition) 303 { 304 new_node = node->create_version_clone_with_body (vNULL, NULL, 305 NULL, false, 306 NULL, NULL, 307 name, attributes); 308 if (new_node == NULL) 309 return NULL; 310 new_node->force_output = true; 311 } 312 else 313 { 314 tree new_decl = copy_node (node->decl); 315 new_node = cgraph_node::get_create (new_decl); 316 DECL_ATTRIBUTES (new_decl) = attributes; 317 /* Generate a new name for the new version. */ 318 symtab->change_decl_assembler_name (new_node->decl, 319 clone_function_name (node->decl, 320 name)); 321 } 322 return new_node; 323 } 324 325 /* If the function in NODE has multiple target attributes 326 create the appropriate clone for each valid target attribute. */ 327 328 static bool 329 expand_target_clones (struct cgraph_node *node, bool definition) 330 { 331 int i; 332 /* Parsing target attributes separated by comma. */ 333 tree attr_target = lookup_attribute ("target_clones", 334 DECL_ATTRIBUTES (node->decl)); 335 /* No targets specified. */ 336 if (!attr_target) 337 return false; 338 339 tree arglist = TREE_VALUE (attr_target); 340 int attr_len = get_attr_len (arglist); 341 342 /* No need to clone for 1 target attribute. */ 343 if (attr_len == -1) 344 { 345 warning_at (DECL_SOURCE_LOCATION (node->decl), 346 0, 347 "single %<target_clones%> attribute is ignored"); 348 return false; 349 } 350 351 if (node->definition 352 && !tree_versionable_function_p (node->decl)) 353 { 354 error_at (DECL_SOURCE_LOCATION (node->decl), 355 "clones for %<target_clones%> attribute cannot be created"); 356 const char *reason = NULL; 357 if (lookup_attribute ("noclone", DECL_ATTRIBUTES (node->decl))) 358 reason = G_("function %q+F can never be copied " 359 "because it has %<noclone%> attribute"); 360 else 361 reason = copy_forbidden (DECL_STRUCT_FUNCTION (node->decl)); 362 if (reason) 363 inform (DECL_SOURCE_LOCATION (node->decl), reason, node->decl); 364 return false; 365 } 366 367 char *attr_str = XNEWVEC (char, attr_len); 368 int attrnum = get_attr_str (arglist, attr_str); 369 char **attrs = XNEWVEC (char *, attrnum); 370 371 attrnum = separate_attrs (attr_str, attrs, attrnum); 372 if (attrnum == -1) 373 { 374 error_at (DECL_SOURCE_LOCATION (node->decl), 375 "default target was not set"); 376 XDELETEVEC (attrs); 377 XDELETEVEC (attr_str); 378 return false; 379 } 380 else if (attrnum == -2) 381 { 382 error_at (DECL_SOURCE_LOCATION (node->decl), 383 "an empty string cannot be in %<target_clones%> attribute"); 384 XDELETEVEC (attrs); 385 XDELETEVEC (attr_str); 386 return false; 387 } 388 389 cgraph_function_version_info *decl1_v = NULL; 390 cgraph_function_version_info *decl2_v = NULL; 391 cgraph_function_version_info *before = NULL; 392 cgraph_function_version_info *after = NULL; 393 decl1_v = node->function_version (); 394 if (decl1_v == NULL) 395 decl1_v = node->insert_new_function_version (); 396 before = decl1_v; 397 DECL_FUNCTION_VERSIONED (node->decl) = 1; 398 399 for (i = 0; i < attrnum; i++) 400 { 401 char *attr = attrs[i]; 402 char *suffix = XNEWVEC (char, strlen (attr) + 1); 403 404 create_new_asm_name (attr, suffix); 405 /* Create new target clone. */ 406 tree attributes = make_attribute ("target", attr, 407 DECL_ATTRIBUTES (node->decl)); 408 409 cgraph_node *new_node = create_target_clone (node, definition, suffix, 410 attributes); 411 if (new_node == NULL) 412 return false; 413 new_node->local.local = false; 414 XDELETEVEC (suffix); 415 416 decl2_v = new_node->function_version (); 417 if (decl2_v != NULL) 418 continue; 419 decl2_v = new_node->insert_new_function_version (); 420 421 /* Chain decl2_v and decl1_v. All semantically identical versions 422 will be chained together. */ 423 after = decl2_v; 424 while (before->next != NULL) 425 before = before->next; 426 while (after->prev != NULL) 427 after = after->prev; 428 429 before->next = after; 430 after->prev = before; 431 DECL_FUNCTION_VERSIONED (new_node->decl) = 1; 432 } 433 434 XDELETEVEC (attrs); 435 XDELETEVEC (attr_str); 436 437 /* Setting new attribute to initial function. */ 438 tree attributes = make_attribute ("target", "default", 439 DECL_ATTRIBUTES (node->decl)); 440 DECL_ATTRIBUTES (node->decl) = attributes; 441 node->local.local = false; 442 return true; 443 } 444 445 static unsigned int 446 ipa_target_clone (void) 447 { 448 struct cgraph_node *node; 449 auto_vec<cgraph_node *> to_dispatch; 450 451 FOR_EACH_FUNCTION (node) 452 if (expand_target_clones (node, node->definition)) 453 to_dispatch.safe_push (node); 454 455 for (unsigned i = 0; i < to_dispatch.length (); i++) 456 create_dispatcher_calls (to_dispatch[i]); 457 458 return 0; 459 } 460 461 namespace { 462 463 const pass_data pass_data_target_clone = 464 { 465 SIMPLE_IPA_PASS, /* type */ 466 "targetclone", /* name */ 467 OPTGROUP_NONE, /* optinfo_flags */ 468 TV_NONE, /* tv_id */ 469 ( PROP_ssa | PROP_cfg ), /* properties_required */ 470 0, /* properties_provided */ 471 0, /* properties_destroyed */ 472 0, /* todo_flags_start */ 473 TODO_update_ssa /* todo_flags_finish */ 474 }; 475 476 class pass_target_clone : public simple_ipa_opt_pass 477 { 478 public: 479 pass_target_clone (gcc::context *ctxt) 480 : simple_ipa_opt_pass (pass_data_target_clone, ctxt) 481 {} 482 483 /* opt_pass methods: */ 484 virtual bool gate (function *); 485 virtual unsigned int execute (function *) { return ipa_target_clone (); } 486 }; 487 488 bool 489 pass_target_clone::gate (function *) 490 { 491 return true; 492 } 493 494 } // anon namespace 495 496 simple_ipa_opt_pass * 497 make_pass_target_clone (gcc::context *ctxt) 498 { 499 return new pass_target_clone (ctxt); 500 } 501