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 { 299 cgraph_node *new_node; 300 301 if (definition) 302 { 303 new_node = node->create_version_clone_with_body (vNULL, NULL, 304 NULL, false, 305 NULL, NULL, 306 name); 307 new_node->force_output = true; 308 } 309 else 310 { 311 tree new_decl = copy_node (node->decl); 312 new_node = cgraph_node::get_create (new_decl); 313 /* Generate a new name for the new version. */ 314 symtab->change_decl_assembler_name (new_node->decl, 315 clone_function_name (node->decl, 316 name)); 317 } 318 return new_node; 319 } 320 321 /* If the function in NODE has multiple target attributes 322 create the appropriate clone for each valid target attribute. */ 323 324 static bool 325 expand_target_clones (struct cgraph_node *node, bool definition) 326 { 327 int i; 328 /* Parsing target attributes separated by comma. */ 329 tree attr_target = lookup_attribute ("target_clones", 330 DECL_ATTRIBUTES (node->decl)); 331 /* No targets specified. */ 332 if (!attr_target) 333 return false; 334 335 tree arglist = TREE_VALUE (attr_target); 336 int attr_len = get_attr_len (arglist); 337 338 /* No need to clone for 1 target attribute. */ 339 if (attr_len == -1) 340 { 341 warning_at (DECL_SOURCE_LOCATION (node->decl), 342 0, 343 "single %<target_clones%> attribute is ignored"); 344 return false; 345 } 346 347 if (node->definition 348 && !tree_versionable_function_p (node->decl)) 349 { 350 error_at (DECL_SOURCE_LOCATION (node->decl), 351 "clones for %<target_clones%> attribute cannot be created"); 352 const char *reason = NULL; 353 if (lookup_attribute ("noclone", DECL_ATTRIBUTES (node->decl))) 354 reason = G_("function %q+F can never be copied " 355 "because it has %<noclone%> attribute"); 356 else 357 reason = copy_forbidden (DECL_STRUCT_FUNCTION (node->decl)); 358 if (reason) 359 inform (DECL_SOURCE_LOCATION (node->decl), reason, node->decl); 360 return false; 361 } 362 363 char *attr_str = XNEWVEC (char, attr_len); 364 int attrnum = get_attr_str (arglist, attr_str); 365 char **attrs = XNEWVEC (char *, attrnum); 366 367 attrnum = separate_attrs (attr_str, attrs, attrnum); 368 if (attrnum == -1) 369 { 370 error_at (DECL_SOURCE_LOCATION (node->decl), 371 "default target was not set"); 372 XDELETEVEC (attrs); 373 XDELETEVEC (attr_str); 374 return false; 375 } 376 else if (attrnum == -2) 377 { 378 error_at (DECL_SOURCE_LOCATION (node->decl), 379 "an empty string cannot be in %<target_clones%> attribute"); 380 XDELETEVEC (attrs); 381 XDELETEVEC (attr_str); 382 return false; 383 } 384 385 cgraph_function_version_info *decl1_v = NULL; 386 cgraph_function_version_info *decl2_v = NULL; 387 cgraph_function_version_info *before = NULL; 388 cgraph_function_version_info *after = NULL; 389 decl1_v = node->function_version (); 390 if (decl1_v == NULL) 391 decl1_v = node->insert_new_function_version (); 392 before = decl1_v; 393 DECL_FUNCTION_VERSIONED (node->decl) = 1; 394 395 for (i = 0; i < attrnum; i++) 396 { 397 char *attr = attrs[i]; 398 char *suffix = XNEWVEC (char, strlen (attr) + 1); 399 400 create_new_asm_name (attr, suffix); 401 /* Create new target clone. */ 402 cgraph_node *new_node = create_target_clone (node, definition, suffix); 403 new_node->local.local = false; 404 XDELETEVEC (suffix); 405 406 /* Set new attribute for the clone. */ 407 tree attributes = make_attribute ("target", attr, 408 DECL_ATTRIBUTES (new_node->decl)); 409 DECL_ATTRIBUTES (new_node->decl) = attributes; 410 location_t saved_loc = input_location; 411 input_location = DECL_SOURCE_LOCATION (node->decl); 412 if (!targetm.target_option.valid_attribute_p (new_node->decl, NULL, 413 TREE_VALUE (attributes), 414 0)) 415 return false; 416 417 input_location = saved_loc; 418 decl2_v = new_node->function_version (); 419 if (decl2_v != NULL) 420 continue; 421 decl2_v = new_node->insert_new_function_version (); 422 423 /* Chain decl2_v and decl1_v. All semantically identical versions 424 will be chained together. */ 425 after = decl2_v; 426 while (before->next != NULL) 427 before = before->next; 428 while (after->prev != NULL) 429 after = after->prev; 430 431 before->next = after; 432 after->prev = before; 433 DECL_FUNCTION_VERSIONED (new_node->decl) = 1; 434 } 435 436 XDELETEVEC (attrs); 437 XDELETEVEC (attr_str); 438 439 /* Setting new attribute to initial function. */ 440 tree attributes = make_attribute ("target", "default", 441 DECL_ATTRIBUTES (node->decl)); 442 DECL_ATTRIBUTES (node->decl) = attributes; 443 node->local.local = false; 444 location_t saved_loc = input_location; 445 input_location = DECL_SOURCE_LOCATION (node->decl); 446 bool ret 447 = targetm.target_option.valid_attribute_p (node->decl, NULL, 448 TREE_VALUE (attributes), 0); 449 input_location = saved_loc; 450 return ret; 451 } 452 453 static unsigned int 454 ipa_target_clone (void) 455 { 456 struct cgraph_node *node; 457 auto_vec<cgraph_node *> to_dispatch; 458 459 FOR_EACH_FUNCTION (node) 460 if (expand_target_clones (node, node->definition)) 461 to_dispatch.safe_push (node); 462 463 for (unsigned i = 0; i < to_dispatch.length (); i++) 464 create_dispatcher_calls (to_dispatch[i]); 465 466 return 0; 467 } 468 469 namespace { 470 471 const pass_data pass_data_target_clone = 472 { 473 SIMPLE_IPA_PASS, /* type */ 474 "targetclone", /* name */ 475 OPTGROUP_NONE, /* optinfo_flags */ 476 TV_NONE, /* tv_id */ 477 ( PROP_ssa | PROP_cfg ), /* properties_required */ 478 0, /* properties_provided */ 479 0, /* properties_destroyed */ 480 0, /* todo_flags_start */ 481 TODO_update_ssa /* todo_flags_finish */ 482 }; 483 484 class pass_target_clone : public simple_ipa_opt_pass 485 { 486 public: 487 pass_target_clone (gcc::context *ctxt) 488 : simple_ipa_opt_pass (pass_data_target_clone, ctxt) 489 {} 490 491 /* opt_pass methods: */ 492 virtual bool gate (function *); 493 virtual unsigned int execute (function *) { return ipa_target_clone (); } 494 }; 495 496 bool 497 pass_target_clone::gate (function *) 498 { 499 return true; 500 } 501 502 } // anon namespace 503 504 simple_ipa_opt_pass * 505 make_pass_target_clone (gcc::context *ctxt) 506 { 507 return new pass_target_clone (ctxt); 508 } 509