1 /* OMP constructs' SIMD clone supporting code. 2 3 Copyright (C) 2005-2018 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "backend.h" 25 #include "target.h" 26 #include "tree.h" 27 #include "gimple.h" 28 #include "cfghooks.h" 29 #include "alloc-pool.h" 30 #include "tree-pass.h" 31 #include "ssa.h" 32 #include "cgraph.h" 33 #include "pretty-print.h" 34 #include "diagnostic-core.h" 35 #include "fold-const.h" 36 #include "stor-layout.h" 37 #include "cfganal.h" 38 #include "gimplify.h" 39 #include "gimple-iterator.h" 40 #include "gimplify-me.h" 41 #include "gimple-walk.h" 42 #include "langhooks.h" 43 #include "tree-cfg.h" 44 #include "tree-into-ssa.h" 45 #include "tree-dfa.h" 46 #include "cfgloop.h" 47 #include "symbol-summary.h" 48 #include "ipa-param-manipulation.h" 49 #include "tree-eh.h" 50 #include "varasm.h" 51 #include "stringpool.h" 52 #include "attribs.h" 53 #include "omp-simd-clone.h" 54 55 /* Return the number of elements in vector type VECTYPE, which is associated 56 with a SIMD clone. At present these always have a constant length. */ 57 58 static unsigned HOST_WIDE_INT 59 simd_clone_subparts (tree vectype) 60 { 61 return TYPE_VECTOR_SUBPARTS (vectype).to_constant (); 62 } 63 64 /* Allocate a fresh `simd_clone' and return it. NARGS is the number 65 of arguments to reserve space for. */ 66 67 static struct cgraph_simd_clone * 68 simd_clone_struct_alloc (int nargs) 69 { 70 struct cgraph_simd_clone *clone_info; 71 size_t len = (sizeof (struct cgraph_simd_clone) 72 + nargs * sizeof (struct cgraph_simd_clone_arg)); 73 clone_info = (struct cgraph_simd_clone *) 74 ggc_internal_cleared_alloc (len); 75 return clone_info; 76 } 77 78 /* Make a copy of the `struct cgraph_simd_clone' in FROM to TO. */ 79 80 static inline void 81 simd_clone_struct_copy (struct cgraph_simd_clone *to, 82 struct cgraph_simd_clone *from) 83 { 84 memcpy (to, from, (sizeof (struct cgraph_simd_clone) 85 + ((from->nargs - from->inbranch) 86 * sizeof (struct cgraph_simd_clone_arg)))); 87 } 88 89 /* Return vector of parameter types of function FNDECL. This uses 90 TYPE_ARG_TYPES if available, otherwise falls back to types of 91 DECL_ARGUMENTS types. */ 92 93 static vec<tree> 94 simd_clone_vector_of_formal_parm_types (tree fndecl) 95 { 96 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl))) 97 return ipa_get_vector_of_formal_parm_types (TREE_TYPE (fndecl)); 98 vec<tree> args = ipa_get_vector_of_formal_parms (fndecl); 99 unsigned int i; 100 tree arg; 101 FOR_EACH_VEC_ELT (args, i, arg) 102 args[i] = TREE_TYPE (args[i]); 103 return args; 104 } 105 106 /* Given a simd function in NODE, extract the simd specific 107 information from the OMP clauses passed in CLAUSES, and return 108 the struct cgraph_simd_clone * if it should be cloned. *INBRANCH_SPECIFIED 109 is set to TRUE if the `inbranch' or `notinbranch' clause specified, 110 otherwise set to FALSE. */ 111 112 static struct cgraph_simd_clone * 113 simd_clone_clauses_extract (struct cgraph_node *node, tree clauses, 114 bool *inbranch_specified) 115 { 116 vec<tree> args = simd_clone_vector_of_formal_parm_types (node->decl); 117 tree t; 118 int n; 119 *inbranch_specified = false; 120 121 n = args.length (); 122 if (n > 0 && args.last () == void_type_node) 123 n--; 124 125 /* Allocate one more than needed just in case this is an in-branch 126 clone which will require a mask argument. */ 127 struct cgraph_simd_clone *clone_info = simd_clone_struct_alloc (n + 1); 128 clone_info->nargs = n; 129 130 if (!clauses) 131 goto out; 132 133 clauses = TREE_VALUE (clauses); 134 if (!clauses || TREE_CODE (clauses) != OMP_CLAUSE) 135 goto out; 136 137 for (t = clauses; t; t = OMP_CLAUSE_CHAIN (t)) 138 { 139 switch (OMP_CLAUSE_CODE (t)) 140 { 141 case OMP_CLAUSE_INBRANCH: 142 clone_info->inbranch = 1; 143 *inbranch_specified = true; 144 break; 145 case OMP_CLAUSE_NOTINBRANCH: 146 clone_info->inbranch = 0; 147 *inbranch_specified = true; 148 break; 149 case OMP_CLAUSE_SIMDLEN: 150 clone_info->simdlen 151 = TREE_INT_CST_LOW (OMP_CLAUSE_SIMDLEN_EXPR (t)); 152 break; 153 case OMP_CLAUSE_LINEAR: 154 { 155 tree decl = OMP_CLAUSE_DECL (t); 156 tree step = OMP_CLAUSE_LINEAR_STEP (t); 157 int argno = TREE_INT_CST_LOW (decl); 158 if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (t)) 159 { 160 enum cgraph_simd_clone_arg_type arg_type; 161 if (TREE_CODE (args[argno]) == REFERENCE_TYPE) 162 switch (OMP_CLAUSE_LINEAR_KIND (t)) 163 { 164 case OMP_CLAUSE_LINEAR_REF: 165 arg_type 166 = SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP; 167 break; 168 case OMP_CLAUSE_LINEAR_UVAL: 169 arg_type 170 = SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP; 171 break; 172 case OMP_CLAUSE_LINEAR_VAL: 173 case OMP_CLAUSE_LINEAR_DEFAULT: 174 arg_type 175 = SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP; 176 break; 177 default: 178 gcc_unreachable (); 179 } 180 else 181 arg_type = SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP; 182 clone_info->args[argno].arg_type = arg_type; 183 clone_info->args[argno].linear_step = tree_to_shwi (step); 184 gcc_assert (clone_info->args[argno].linear_step >= 0 185 && clone_info->args[argno].linear_step < n); 186 } 187 else 188 { 189 if (POINTER_TYPE_P (args[argno])) 190 step = fold_convert (ssizetype, step); 191 if (!tree_fits_shwi_p (step)) 192 { 193 warning_at (OMP_CLAUSE_LOCATION (t), 0, 194 "ignoring large linear step"); 195 args.release (); 196 return NULL; 197 } 198 else if (integer_zerop (step)) 199 { 200 warning_at (OMP_CLAUSE_LOCATION (t), 0, 201 "ignoring zero linear step"); 202 args.release (); 203 return NULL; 204 } 205 else 206 { 207 enum cgraph_simd_clone_arg_type arg_type; 208 if (TREE_CODE (args[argno]) == REFERENCE_TYPE) 209 switch (OMP_CLAUSE_LINEAR_KIND (t)) 210 { 211 case OMP_CLAUSE_LINEAR_REF: 212 arg_type 213 = SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP; 214 break; 215 case OMP_CLAUSE_LINEAR_UVAL: 216 arg_type 217 = SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP; 218 break; 219 case OMP_CLAUSE_LINEAR_VAL: 220 case OMP_CLAUSE_LINEAR_DEFAULT: 221 arg_type 222 = SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP; 223 break; 224 default: 225 gcc_unreachable (); 226 } 227 else 228 arg_type = SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP; 229 clone_info->args[argno].arg_type = arg_type; 230 clone_info->args[argno].linear_step = tree_to_shwi (step); 231 } 232 } 233 break; 234 } 235 case OMP_CLAUSE_UNIFORM: 236 { 237 tree decl = OMP_CLAUSE_DECL (t); 238 int argno = tree_to_uhwi (decl); 239 clone_info->args[argno].arg_type 240 = SIMD_CLONE_ARG_TYPE_UNIFORM; 241 break; 242 } 243 case OMP_CLAUSE_ALIGNED: 244 { 245 tree decl = OMP_CLAUSE_DECL (t); 246 int argno = tree_to_uhwi (decl); 247 clone_info->args[argno].alignment 248 = TREE_INT_CST_LOW (OMP_CLAUSE_ALIGNED_ALIGNMENT (t)); 249 break; 250 } 251 default: 252 break; 253 } 254 } 255 256 out: 257 if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (node->decl)))) 258 { 259 warning_at (DECL_SOURCE_LOCATION (node->decl), 0, 260 "ignoring %<#pragma omp declare simd%> on function " 261 "with %<_Atomic%> qualified return type"); 262 args.release (); 263 return NULL; 264 } 265 266 for (unsigned int argno = 0; argno < clone_info->nargs; argno++) 267 if (TYPE_ATOMIC (args[argno]) 268 && clone_info->args[argno].arg_type != SIMD_CLONE_ARG_TYPE_UNIFORM) 269 { 270 warning_at (DECL_SOURCE_LOCATION (node->decl), 0, 271 "ignoring %<#pragma omp declare simd%> on function " 272 "with %<_Atomic%> qualified non-%<uniform%> argument"); 273 args.release (); 274 return NULL; 275 } 276 277 args.release (); 278 return clone_info; 279 } 280 281 /* Given a SIMD clone in NODE, calculate the characteristic data 282 type and return the coresponding type. The characteristic data 283 type is computed as described in the Intel Vector ABI. */ 284 285 static tree 286 simd_clone_compute_base_data_type (struct cgraph_node *node, 287 struct cgraph_simd_clone *clone_info) 288 { 289 tree type = integer_type_node; 290 tree fndecl = node->decl; 291 292 /* a) For non-void function, the characteristic data type is the 293 return type. */ 294 if (TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE) 295 type = TREE_TYPE (TREE_TYPE (fndecl)); 296 297 /* b) If the function has any non-uniform, non-linear parameters, 298 then the characteristic data type is the type of the first 299 such parameter. */ 300 else 301 { 302 vec<tree> map = simd_clone_vector_of_formal_parm_types (fndecl); 303 for (unsigned int i = 0; i < clone_info->nargs; ++i) 304 if (clone_info->args[i].arg_type == SIMD_CLONE_ARG_TYPE_VECTOR) 305 { 306 type = map[i]; 307 break; 308 } 309 map.release (); 310 } 311 312 /* c) If the characteristic data type determined by a) or b) above 313 is struct, union, or class type which is pass-by-value (except 314 for the type that maps to the built-in complex data type), the 315 characteristic data type is int. */ 316 if (RECORD_OR_UNION_TYPE_P (type) 317 && !aggregate_value_p (type, NULL) 318 && TREE_CODE (type) != COMPLEX_TYPE) 319 return integer_type_node; 320 321 /* d) If none of the above three classes is applicable, the 322 characteristic data type is int. */ 323 324 return type; 325 326 /* e) For Intel Xeon Phi native and offload compilation, if the 327 resulting characteristic data type is 8-bit or 16-bit integer 328 data type, the characteristic data type is int. */ 329 /* Well, we don't handle Xeon Phi yet. */ 330 } 331 332 static tree 333 simd_clone_mangle (struct cgraph_node *node, 334 struct cgraph_simd_clone *clone_info) 335 { 336 char vecsize_mangle = clone_info->vecsize_mangle; 337 char mask = clone_info->inbranch ? 'M' : 'N'; 338 unsigned int simdlen = clone_info->simdlen; 339 unsigned int n; 340 pretty_printer pp; 341 342 gcc_assert (vecsize_mangle && simdlen); 343 344 pp_string (&pp, "_ZGV"); 345 pp_character (&pp, vecsize_mangle); 346 pp_character (&pp, mask); 347 pp_decimal_int (&pp, simdlen); 348 349 for (n = 0; n < clone_info->nargs; ++n) 350 { 351 struct cgraph_simd_clone_arg arg = clone_info->args[n]; 352 353 switch (arg.arg_type) 354 { 355 case SIMD_CLONE_ARG_TYPE_UNIFORM: 356 pp_character (&pp, 'u'); 357 break; 358 case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP: 359 pp_character (&pp, 'l'); 360 goto mangle_linear; 361 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP: 362 pp_character (&pp, 'R'); 363 goto mangle_linear; 364 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP: 365 pp_character (&pp, 'L'); 366 goto mangle_linear; 367 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP: 368 pp_character (&pp, 'U'); 369 goto mangle_linear; 370 mangle_linear: 371 gcc_assert (arg.linear_step != 0); 372 if (arg.linear_step > 1) 373 pp_unsigned_wide_integer (&pp, arg.linear_step); 374 else if (arg.linear_step < 0) 375 { 376 pp_character (&pp, 'n'); 377 pp_unsigned_wide_integer (&pp, (-(unsigned HOST_WIDE_INT) 378 arg.linear_step)); 379 } 380 break; 381 case SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP: 382 pp_string (&pp, "ls"); 383 pp_unsigned_wide_integer (&pp, arg.linear_step); 384 break; 385 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP: 386 pp_string (&pp, "Rs"); 387 pp_unsigned_wide_integer (&pp, arg.linear_step); 388 break; 389 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP: 390 pp_string (&pp, "Ls"); 391 pp_unsigned_wide_integer (&pp, arg.linear_step); 392 break; 393 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP: 394 pp_string (&pp, "Us"); 395 pp_unsigned_wide_integer (&pp, arg.linear_step); 396 break; 397 default: 398 pp_character (&pp, 'v'); 399 } 400 if (arg.alignment) 401 { 402 pp_character (&pp, 'a'); 403 pp_decimal_int (&pp, arg.alignment); 404 } 405 } 406 407 pp_underscore (&pp); 408 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl)); 409 if (*str == '*') 410 ++str; 411 pp_string (&pp, str); 412 str = pp_formatted_text (&pp); 413 414 /* If there already is a SIMD clone with the same mangled name, don't 415 add another one. This can happen e.g. for 416 #pragma omp declare simd 417 #pragma omp declare simd simdlen(8) 418 int foo (int, int); 419 if the simdlen is assumed to be 8 for the first one, etc. */ 420 for (struct cgraph_node *clone = node->simd_clones; clone; 421 clone = clone->simdclone->next_clone) 422 if (id_equal (DECL_ASSEMBLER_NAME (clone->decl), str)) 423 return NULL_TREE; 424 425 return get_identifier (str); 426 } 427 428 /* Create a simd clone of OLD_NODE and return it. */ 429 430 static struct cgraph_node * 431 simd_clone_create (struct cgraph_node *old_node) 432 { 433 struct cgraph_node *new_node; 434 if (old_node->definition) 435 { 436 if (!old_node->has_gimple_body_p ()) 437 return NULL; 438 old_node->get_body (); 439 new_node = old_node->create_version_clone_with_body (vNULL, NULL, NULL, 440 false, NULL, NULL, 441 "simdclone"); 442 } 443 else 444 { 445 tree old_decl = old_node->decl; 446 tree new_decl = copy_node (old_node->decl); 447 DECL_NAME (new_decl) = clone_function_name (old_decl, "simdclone"); 448 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl)); 449 SET_DECL_RTL (new_decl, NULL); 450 DECL_STATIC_CONSTRUCTOR (new_decl) = 0; 451 DECL_STATIC_DESTRUCTOR (new_decl) = 0; 452 new_node = old_node->create_version_clone (new_decl, vNULL, NULL); 453 if (old_node->in_other_partition) 454 new_node->in_other_partition = 1; 455 } 456 if (new_node == NULL) 457 return new_node; 458 459 DECL_BUILT_IN_CLASS (new_node->decl) = NOT_BUILT_IN; 460 DECL_FUNCTION_CODE (new_node->decl) = (enum built_in_function) 0; 461 TREE_PUBLIC (new_node->decl) = TREE_PUBLIC (old_node->decl); 462 DECL_COMDAT (new_node->decl) = DECL_COMDAT (old_node->decl); 463 DECL_WEAK (new_node->decl) = DECL_WEAK (old_node->decl); 464 DECL_EXTERNAL (new_node->decl) = DECL_EXTERNAL (old_node->decl); 465 DECL_VISIBILITY_SPECIFIED (new_node->decl) 466 = DECL_VISIBILITY_SPECIFIED (old_node->decl); 467 DECL_VISIBILITY (new_node->decl) = DECL_VISIBILITY (old_node->decl); 468 DECL_DLLIMPORT_P (new_node->decl) = DECL_DLLIMPORT_P (old_node->decl); 469 if (DECL_ONE_ONLY (old_node->decl)) 470 make_decl_one_only (new_node->decl, DECL_ASSEMBLER_NAME (new_node->decl)); 471 472 /* The method cgraph_version_clone_with_body () will force the new 473 symbol local. Undo this, and inherit external visibility from 474 the old node. */ 475 new_node->local.local = old_node->local.local; 476 new_node->externally_visible = old_node->externally_visible; 477 478 return new_node; 479 } 480 481 /* Adjust the return type of the given function to its appropriate 482 vector counterpart. Returns a simd array to be used throughout the 483 function as a return value. */ 484 485 static tree 486 simd_clone_adjust_return_type (struct cgraph_node *node) 487 { 488 tree fndecl = node->decl; 489 tree orig_rettype = TREE_TYPE (TREE_TYPE (fndecl)); 490 unsigned int veclen; 491 tree t; 492 493 /* Adjust the function return type. */ 494 if (orig_rettype == void_type_node) 495 return NULL_TREE; 496 TREE_TYPE (fndecl) = build_distinct_type_copy (TREE_TYPE (fndecl)); 497 t = TREE_TYPE (TREE_TYPE (fndecl)); 498 if (INTEGRAL_TYPE_P (t) || POINTER_TYPE_P (t)) 499 veclen = node->simdclone->vecsize_int; 500 else 501 veclen = node->simdclone->vecsize_float; 502 veclen /= GET_MODE_BITSIZE (SCALAR_TYPE_MODE (t)); 503 if (veclen > node->simdclone->simdlen) 504 veclen = node->simdclone->simdlen; 505 if (POINTER_TYPE_P (t)) 506 t = pointer_sized_int_node; 507 if (veclen == node->simdclone->simdlen) 508 t = build_vector_type (t, node->simdclone->simdlen); 509 else 510 { 511 t = build_vector_type (t, veclen); 512 t = build_array_type_nelts (t, node->simdclone->simdlen / veclen); 513 } 514 TREE_TYPE (TREE_TYPE (fndecl)) = t; 515 if (!node->definition) 516 return NULL_TREE; 517 518 t = DECL_RESULT (fndecl); 519 /* Adjust the DECL_RESULT. */ 520 gcc_assert (TREE_TYPE (t) != void_type_node); 521 TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (fndecl)); 522 relayout_decl (t); 523 524 tree atype = build_array_type_nelts (orig_rettype, 525 node->simdclone->simdlen); 526 if (veclen != node->simdclone->simdlen) 527 return build1 (VIEW_CONVERT_EXPR, atype, t); 528 529 /* Set up a SIMD array to use as the return value. */ 530 tree retval = create_tmp_var_raw (atype, "retval"); 531 gimple_add_tmp_var (retval); 532 return retval; 533 } 534 535 /* Each vector argument has a corresponding array to be used locally 536 as part of the eventual loop. Create such temporary array and 537 return it. 538 539 PREFIX is the prefix to be used for the temporary. 540 541 TYPE is the inner element type. 542 543 SIMDLEN is the number of elements. */ 544 545 static tree 546 create_tmp_simd_array (const char *prefix, tree type, int simdlen) 547 { 548 tree atype = build_array_type_nelts (type, simdlen); 549 tree avar = create_tmp_var_raw (atype, prefix); 550 gimple_add_tmp_var (avar); 551 return avar; 552 } 553 554 /* Modify the function argument types to their corresponding vector 555 counterparts if appropriate. Also, create one array for each simd 556 argument to be used locally when using the function arguments as 557 part of the loop. 558 559 NODE is the function whose arguments are to be adjusted. 560 561 Returns an adjustment vector that will be filled describing how the 562 argument types will be adjusted. */ 563 564 static ipa_parm_adjustment_vec 565 simd_clone_adjust_argument_types (struct cgraph_node *node) 566 { 567 vec<tree> args; 568 ipa_parm_adjustment_vec adjustments; 569 570 if (node->definition) 571 args = ipa_get_vector_of_formal_parms (node->decl); 572 else 573 args = simd_clone_vector_of_formal_parm_types (node->decl); 574 adjustments.create (args.length ()); 575 unsigned i, j, veclen; 576 struct ipa_parm_adjustment adj; 577 struct cgraph_simd_clone *sc = node->simdclone; 578 579 for (i = 0; i < sc->nargs; ++i) 580 { 581 memset (&adj, 0, sizeof (adj)); 582 tree parm = args[i]; 583 tree parm_type = node->definition ? TREE_TYPE (parm) : parm; 584 adj.base_index = i; 585 adj.base = parm; 586 587 sc->args[i].orig_arg = node->definition ? parm : NULL_TREE; 588 sc->args[i].orig_type = parm_type; 589 590 switch (sc->args[i].arg_type) 591 { 592 default: 593 /* No adjustment necessary for scalar arguments. */ 594 adj.op = IPA_PARM_OP_COPY; 595 break; 596 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP: 597 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP: 598 if (node->definition) 599 sc->args[i].simd_array 600 = create_tmp_simd_array (IDENTIFIER_POINTER (DECL_NAME (parm)), 601 TREE_TYPE (parm_type), 602 sc->simdlen); 603 adj.op = IPA_PARM_OP_COPY; 604 break; 605 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP: 606 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP: 607 case SIMD_CLONE_ARG_TYPE_VECTOR: 608 if (INTEGRAL_TYPE_P (parm_type) || POINTER_TYPE_P (parm_type)) 609 veclen = sc->vecsize_int; 610 else 611 veclen = sc->vecsize_float; 612 veclen /= GET_MODE_BITSIZE (SCALAR_TYPE_MODE (parm_type)); 613 if (veclen > sc->simdlen) 614 veclen = sc->simdlen; 615 adj.arg_prefix = "simd"; 616 if (POINTER_TYPE_P (parm_type)) 617 adj.type = build_vector_type (pointer_sized_int_node, veclen); 618 else 619 adj.type = build_vector_type (parm_type, veclen); 620 sc->args[i].vector_type = adj.type; 621 for (j = veclen; j < sc->simdlen; j += veclen) 622 { 623 adjustments.safe_push (adj); 624 if (j == veclen) 625 { 626 memset (&adj, 0, sizeof (adj)); 627 adj.op = IPA_PARM_OP_NEW; 628 adj.arg_prefix = "simd"; 629 adj.base_index = i; 630 adj.type = sc->args[i].vector_type; 631 } 632 } 633 634 if (node->definition) 635 sc->args[i].simd_array 636 = create_tmp_simd_array (DECL_NAME (parm) 637 ? IDENTIFIER_POINTER (DECL_NAME (parm)) 638 : NULL, parm_type, sc->simdlen); 639 } 640 adjustments.safe_push (adj); 641 } 642 643 if (sc->inbranch) 644 { 645 tree base_type = simd_clone_compute_base_data_type (sc->origin, sc); 646 647 memset (&adj, 0, sizeof (adj)); 648 adj.op = IPA_PARM_OP_NEW; 649 adj.arg_prefix = "mask"; 650 651 adj.base_index = i; 652 if (INTEGRAL_TYPE_P (base_type) || POINTER_TYPE_P (base_type)) 653 veclen = sc->vecsize_int; 654 else 655 veclen = sc->vecsize_float; 656 veclen /= GET_MODE_BITSIZE (SCALAR_TYPE_MODE (base_type)); 657 if (veclen > sc->simdlen) 658 veclen = sc->simdlen; 659 if (sc->mask_mode != VOIDmode) 660 adj.type 661 = lang_hooks.types.type_for_mode (sc->mask_mode, 1); 662 else if (POINTER_TYPE_P (base_type)) 663 adj.type = build_vector_type (pointer_sized_int_node, veclen); 664 else 665 adj.type = build_vector_type (base_type, veclen); 666 adjustments.safe_push (adj); 667 668 for (j = veclen; j < sc->simdlen; j += veclen) 669 adjustments.safe_push (adj); 670 671 /* We have previously allocated one extra entry for the mask. Use 672 it and fill it. */ 673 sc->nargs++; 674 if (sc->mask_mode != VOIDmode) 675 base_type = boolean_type_node; 676 if (node->definition) 677 { 678 sc->args[i].orig_arg 679 = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL, base_type); 680 if (sc->mask_mode == VOIDmode) 681 sc->args[i].simd_array 682 = create_tmp_simd_array ("mask", base_type, sc->simdlen); 683 else if (veclen < sc->simdlen) 684 sc->args[i].simd_array 685 = create_tmp_simd_array ("mask", adj.type, sc->simdlen / veclen); 686 else 687 sc->args[i].simd_array = NULL_TREE; 688 } 689 sc->args[i].orig_type = base_type; 690 sc->args[i].arg_type = SIMD_CLONE_ARG_TYPE_MASK; 691 } 692 693 if (node->definition) 694 ipa_modify_formal_parameters (node->decl, adjustments); 695 else 696 { 697 tree new_arg_types = NULL_TREE, new_reversed; 698 bool last_parm_void = false; 699 if (args.length () > 0 && args.last () == void_type_node) 700 last_parm_void = true; 701 702 gcc_assert (TYPE_ARG_TYPES (TREE_TYPE (node->decl))); 703 j = adjustments.length (); 704 for (i = 0; i < j; i++) 705 { 706 struct ipa_parm_adjustment *adj = &adjustments[i]; 707 tree ptype; 708 if (adj->op == IPA_PARM_OP_COPY) 709 ptype = args[adj->base_index]; 710 else 711 ptype = adj->type; 712 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types); 713 } 714 new_reversed = nreverse (new_arg_types); 715 if (last_parm_void) 716 { 717 if (new_reversed) 718 TREE_CHAIN (new_arg_types) = void_list_node; 719 else 720 new_reversed = void_list_node; 721 } 722 723 tree new_type = build_distinct_type_copy (TREE_TYPE (node->decl)); 724 TYPE_ARG_TYPES (new_type) = new_reversed; 725 TREE_TYPE (node->decl) = new_type; 726 727 adjustments.release (); 728 } 729 args.release (); 730 return adjustments; 731 } 732 733 /* Initialize and copy the function arguments in NODE to their 734 corresponding local simd arrays. Returns a fresh gimple_seq with 735 the instruction sequence generated. */ 736 737 static gimple_seq 738 simd_clone_init_simd_arrays (struct cgraph_node *node, 739 ipa_parm_adjustment_vec adjustments) 740 { 741 gimple_seq seq = NULL; 742 unsigned i = 0, j = 0, k; 743 744 for (tree arg = DECL_ARGUMENTS (node->decl); 745 arg; 746 arg = DECL_CHAIN (arg), i++, j++) 747 { 748 if (adjustments[j].op == IPA_PARM_OP_COPY 749 || POINTER_TYPE_P (TREE_TYPE (arg))) 750 continue; 751 752 node->simdclone->args[i].vector_arg = arg; 753 754 tree array = node->simdclone->args[i].simd_array; 755 if (node->simdclone->mask_mode != VOIDmode 756 && node->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_MASK) 757 { 758 if (array == NULL_TREE) 759 continue; 760 unsigned int l 761 = tree_to_uhwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (array)))); 762 for (k = 0; k <= l; k++) 763 { 764 if (k) 765 { 766 arg = DECL_CHAIN (arg); 767 j++; 768 } 769 tree t = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (array)), 770 array, size_int (k), NULL, NULL); 771 t = build2 (MODIFY_EXPR, TREE_TYPE (t), t, arg); 772 gimplify_and_add (t, &seq); 773 } 774 continue; 775 } 776 if (simd_clone_subparts (TREE_TYPE (arg)) == node->simdclone->simdlen) 777 { 778 tree ptype = build_pointer_type (TREE_TYPE (TREE_TYPE (array))); 779 tree ptr = build_fold_addr_expr (array); 780 tree t = build2 (MEM_REF, TREE_TYPE (arg), ptr, 781 build_int_cst (ptype, 0)); 782 t = build2 (MODIFY_EXPR, TREE_TYPE (t), t, arg); 783 gimplify_and_add (t, &seq); 784 } 785 else 786 { 787 unsigned int simdlen = simd_clone_subparts (TREE_TYPE (arg)); 788 tree ptype = build_pointer_type (TREE_TYPE (TREE_TYPE (array))); 789 for (k = 0; k < node->simdclone->simdlen; k += simdlen) 790 { 791 tree ptr = build_fold_addr_expr (array); 792 int elemsize; 793 if (k) 794 { 795 arg = DECL_CHAIN (arg); 796 j++; 797 } 798 tree elemtype = TREE_TYPE (TREE_TYPE (arg)); 799 elemsize = GET_MODE_SIZE (SCALAR_TYPE_MODE (elemtype)); 800 tree t = build2 (MEM_REF, TREE_TYPE (arg), ptr, 801 build_int_cst (ptype, k * elemsize)); 802 t = build2 (MODIFY_EXPR, TREE_TYPE (t), t, arg); 803 gimplify_and_add (t, &seq); 804 } 805 } 806 } 807 return seq; 808 } 809 810 /* Callback info for ipa_simd_modify_stmt_ops below. */ 811 812 struct modify_stmt_info { 813 ipa_parm_adjustment_vec adjustments; 814 gimple *stmt; 815 /* True if the parent statement was modified by 816 ipa_simd_modify_stmt_ops. */ 817 bool modified; 818 }; 819 820 /* Callback for walk_gimple_op. 821 822 Adjust operands from a given statement as specified in the 823 adjustments vector in the callback data. */ 824 825 static tree 826 ipa_simd_modify_stmt_ops (tree *tp, int *walk_subtrees, void *data) 827 { 828 struct walk_stmt_info *wi = (struct walk_stmt_info *) data; 829 struct modify_stmt_info *info = (struct modify_stmt_info *) wi->info; 830 tree *orig_tp = tp; 831 if (TREE_CODE (*tp) == ADDR_EXPR) 832 tp = &TREE_OPERAND (*tp, 0); 833 struct ipa_parm_adjustment *cand = NULL; 834 if (TREE_CODE (*tp) == PARM_DECL) 835 cand = ipa_get_adjustment_candidate (&tp, NULL, info->adjustments, true); 836 else 837 { 838 if (TYPE_P (*tp)) 839 *walk_subtrees = 0; 840 } 841 842 tree repl = NULL_TREE; 843 if (cand) 844 repl = unshare_expr (cand->new_decl); 845 else 846 { 847 if (tp != orig_tp) 848 { 849 *walk_subtrees = 0; 850 bool modified = info->modified; 851 info->modified = false; 852 walk_tree (tp, ipa_simd_modify_stmt_ops, wi, wi->pset); 853 if (!info->modified) 854 { 855 info->modified = modified; 856 return NULL_TREE; 857 } 858 info->modified = modified; 859 repl = *tp; 860 } 861 else 862 return NULL_TREE; 863 } 864 865 if (tp != orig_tp) 866 { 867 repl = build_fold_addr_expr (repl); 868 gimple *stmt; 869 if (is_gimple_debug (info->stmt)) 870 { 871 tree vexpr = make_node (DEBUG_EXPR_DECL); 872 stmt = gimple_build_debug_source_bind (vexpr, repl, NULL); 873 DECL_ARTIFICIAL (vexpr) = 1; 874 TREE_TYPE (vexpr) = TREE_TYPE (repl); 875 SET_DECL_MODE (vexpr, TYPE_MODE (TREE_TYPE (repl))); 876 repl = vexpr; 877 } 878 else 879 { 880 stmt = gimple_build_assign (make_ssa_name (TREE_TYPE (repl)), repl); 881 repl = gimple_assign_lhs (stmt); 882 } 883 gimple_stmt_iterator gsi = gsi_for_stmt (info->stmt); 884 gsi_insert_before (&gsi, stmt, GSI_SAME_STMT); 885 *orig_tp = repl; 886 } 887 else if (!useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (repl))) 888 { 889 tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*tp), repl); 890 *tp = vce; 891 } 892 else 893 *tp = repl; 894 895 info->modified = true; 896 return NULL_TREE; 897 } 898 899 /* Traverse the function body and perform all modifications as 900 described in ADJUSTMENTS. At function return, ADJUSTMENTS will be 901 modified such that the replacement/reduction value will now be an 902 offset into the corresponding simd_array. 903 904 This function will replace all function argument uses with their 905 corresponding simd array elements, and ajust the return values 906 accordingly. */ 907 908 static void 909 ipa_simd_modify_function_body (struct cgraph_node *node, 910 ipa_parm_adjustment_vec adjustments, 911 tree retval_array, tree iter) 912 { 913 basic_block bb; 914 unsigned int i, j, l; 915 916 /* Re-use the adjustments array, but this time use it to replace 917 every function argument use to an offset into the corresponding 918 simd_array. */ 919 for (i = 0, j = 0; i < node->simdclone->nargs; ++i, ++j) 920 { 921 if (!node->simdclone->args[i].vector_arg) 922 continue; 923 924 tree basetype = TREE_TYPE (node->simdclone->args[i].orig_arg); 925 tree vectype = TREE_TYPE (node->simdclone->args[i].vector_arg); 926 adjustments[j].new_decl 927 = build4 (ARRAY_REF, 928 basetype, 929 node->simdclone->args[i].simd_array, 930 iter, 931 NULL_TREE, NULL_TREE); 932 if (adjustments[j].op == IPA_PARM_OP_NONE 933 && simd_clone_subparts (vectype) < node->simdclone->simdlen) 934 j += node->simdclone->simdlen / simd_clone_subparts (vectype) - 1; 935 } 936 937 l = adjustments.length (); 938 tree name; 939 940 FOR_EACH_SSA_NAME (i, name, cfun) 941 { 942 if (SSA_NAME_VAR (name) 943 && TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL) 944 { 945 for (j = 0; j < l; j++) 946 if (SSA_NAME_VAR (name) == adjustments[j].base 947 && adjustments[j].new_decl) 948 { 949 tree base_var; 950 if (adjustments[j].new_ssa_base == NULL_TREE) 951 { 952 base_var 953 = copy_var_decl (adjustments[j].base, 954 DECL_NAME (adjustments[j].base), 955 TREE_TYPE (adjustments[j].base)); 956 adjustments[j].new_ssa_base = base_var; 957 } 958 else 959 base_var = adjustments[j].new_ssa_base; 960 if (SSA_NAME_IS_DEFAULT_DEF (name)) 961 { 962 bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)); 963 gimple_stmt_iterator gsi = gsi_after_labels (bb); 964 tree new_decl = unshare_expr (adjustments[j].new_decl); 965 set_ssa_default_def (cfun, adjustments[j].base, NULL_TREE); 966 SET_SSA_NAME_VAR_OR_IDENTIFIER (name, base_var); 967 SSA_NAME_IS_DEFAULT_DEF (name) = 0; 968 gimple *stmt = gimple_build_assign (name, new_decl); 969 gsi_insert_before (&gsi, stmt, GSI_SAME_STMT); 970 } 971 else 972 SET_SSA_NAME_VAR_OR_IDENTIFIER (name, base_var); 973 } 974 } 975 } 976 977 struct modify_stmt_info info; 978 info.adjustments = adjustments; 979 980 FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl)) 981 { 982 gimple_stmt_iterator gsi; 983 984 gsi = gsi_start_bb (bb); 985 while (!gsi_end_p (gsi)) 986 { 987 gimple *stmt = gsi_stmt (gsi); 988 info.stmt = stmt; 989 struct walk_stmt_info wi; 990 991 memset (&wi, 0, sizeof (wi)); 992 info.modified = false; 993 wi.info = &info; 994 walk_gimple_op (stmt, ipa_simd_modify_stmt_ops, &wi); 995 996 if (greturn *return_stmt = dyn_cast <greturn *> (stmt)) 997 { 998 tree retval = gimple_return_retval (return_stmt); 999 if (!retval) 1000 { 1001 gsi_remove (&gsi, true); 1002 continue; 1003 } 1004 1005 /* Replace `return foo' with `retval_array[iter] = foo'. */ 1006 tree ref = build4 (ARRAY_REF, TREE_TYPE (retval), 1007 retval_array, iter, NULL, NULL); 1008 stmt = gimple_build_assign (ref, retval); 1009 gsi_replace (&gsi, stmt, true); 1010 info.modified = true; 1011 } 1012 1013 if (info.modified) 1014 { 1015 update_stmt (stmt); 1016 if (maybe_clean_eh_stmt (stmt)) 1017 gimple_purge_dead_eh_edges (gimple_bb (stmt)); 1018 } 1019 gsi_next (&gsi); 1020 } 1021 } 1022 } 1023 1024 /* Helper function of simd_clone_adjust, return linear step addend 1025 of Ith argument. */ 1026 1027 static tree 1028 simd_clone_linear_addend (struct cgraph_node *node, unsigned int i, 1029 tree addtype, basic_block entry_bb) 1030 { 1031 tree ptype = NULL_TREE; 1032 switch (node->simdclone->args[i].arg_type) 1033 { 1034 case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP: 1035 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP: 1036 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP: 1037 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP: 1038 return build_int_cst (addtype, node->simdclone->args[i].linear_step); 1039 case SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP: 1040 case SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP: 1041 ptype = TREE_TYPE (node->simdclone->args[i].orig_arg); 1042 break; 1043 case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP: 1044 case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP: 1045 ptype = TREE_TYPE (TREE_TYPE (node->simdclone->args[i].orig_arg)); 1046 break; 1047 default: 1048 gcc_unreachable (); 1049 } 1050 1051 unsigned int idx = node->simdclone->args[i].linear_step; 1052 tree arg = node->simdclone->args[idx].orig_arg; 1053 gcc_assert (is_gimple_reg_type (TREE_TYPE (arg))); 1054 gimple_stmt_iterator gsi = gsi_after_labels (entry_bb); 1055 gimple *g; 1056 tree ret; 1057 if (is_gimple_reg (arg)) 1058 ret = get_or_create_ssa_default_def (cfun, arg); 1059 else 1060 { 1061 g = gimple_build_assign (make_ssa_name (TREE_TYPE (arg)), arg); 1062 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1063 ret = gimple_assign_lhs (g); 1064 } 1065 if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE) 1066 { 1067 g = gimple_build_assign (make_ssa_name (TREE_TYPE (TREE_TYPE (arg))), 1068 build_simple_mem_ref (ret)); 1069 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1070 ret = gimple_assign_lhs (g); 1071 } 1072 if (!useless_type_conversion_p (addtype, TREE_TYPE (ret))) 1073 { 1074 g = gimple_build_assign (make_ssa_name (addtype), NOP_EXPR, ret); 1075 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1076 ret = gimple_assign_lhs (g); 1077 } 1078 if (POINTER_TYPE_P (ptype)) 1079 { 1080 tree size = TYPE_SIZE_UNIT (TREE_TYPE (ptype)); 1081 if (size && TREE_CODE (size) == INTEGER_CST) 1082 { 1083 g = gimple_build_assign (make_ssa_name (addtype), MULT_EXPR, 1084 ret, fold_convert (addtype, size)); 1085 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1086 ret = gimple_assign_lhs (g); 1087 } 1088 } 1089 return ret; 1090 } 1091 1092 /* Adjust the argument types in NODE to their appropriate vector 1093 counterparts. */ 1094 1095 static void 1096 simd_clone_adjust (struct cgraph_node *node) 1097 { 1098 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 1099 1100 targetm.simd_clone.adjust (node); 1101 1102 tree retval = simd_clone_adjust_return_type (node); 1103 ipa_parm_adjustment_vec adjustments 1104 = simd_clone_adjust_argument_types (node); 1105 1106 push_gimplify_context (); 1107 1108 gimple_seq seq = simd_clone_init_simd_arrays (node, adjustments); 1109 1110 /* Adjust all uses of vector arguments accordingly. Adjust all 1111 return values accordingly. */ 1112 tree iter = create_tmp_var (unsigned_type_node, "iter"); 1113 tree iter1 = make_ssa_name (iter); 1114 tree iter2 = NULL_TREE; 1115 ipa_simd_modify_function_body (node, adjustments, retval, iter1); 1116 adjustments.release (); 1117 1118 /* Initialize the iteration variable. */ 1119 basic_block entry_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)); 1120 basic_block body_bb = split_block_after_labels (entry_bb)->dest; 1121 gimple_stmt_iterator gsi = gsi_after_labels (entry_bb); 1122 /* Insert the SIMD array and iv initialization at function 1123 entry. */ 1124 gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT); 1125 1126 pop_gimplify_context (NULL); 1127 1128 gimple *g; 1129 basic_block incr_bb = NULL; 1130 struct loop *loop = NULL; 1131 1132 /* Create a new BB right before the original exit BB, to hold the 1133 iteration increment and the condition/branch. */ 1134 if (EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)) 1135 { 1136 basic_block orig_exit = EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun), 0)->src; 1137 incr_bb = create_empty_bb (orig_exit); 1138 incr_bb->count = profile_count::zero (); 1139 add_bb_to_loop (incr_bb, body_bb->loop_father); 1140 /* The succ of orig_exit was EXIT_BLOCK_PTR_FOR_FN (cfun), with an empty 1141 flag. Set it now to be a FALLTHRU_EDGE. */ 1142 gcc_assert (EDGE_COUNT (orig_exit->succs) == 1); 1143 EDGE_SUCC (orig_exit, 0)->flags |= EDGE_FALLTHRU; 1144 for (unsigned i = 0; 1145 i < EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds); ++i) 1146 { 1147 edge e = EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun), i); 1148 redirect_edge_succ (e, incr_bb); 1149 incr_bb->count += e->count (); 1150 } 1151 } 1152 else if (node->simdclone->inbranch) 1153 { 1154 incr_bb = create_empty_bb (entry_bb); 1155 incr_bb->count = profile_count::zero (); 1156 add_bb_to_loop (incr_bb, body_bb->loop_father); 1157 } 1158 1159 if (incr_bb) 1160 { 1161 make_single_succ_edge (incr_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0); 1162 gsi = gsi_last_bb (incr_bb); 1163 iter2 = make_ssa_name (iter); 1164 g = gimple_build_assign (iter2, PLUS_EXPR, iter1, 1165 build_int_cst (unsigned_type_node, 1)); 1166 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1167 1168 /* Mostly annotate the loop for the vectorizer (the rest is done 1169 below). */ 1170 loop = alloc_loop (); 1171 cfun->has_force_vectorize_loops = true; 1172 loop->safelen = node->simdclone->simdlen; 1173 loop->force_vectorize = true; 1174 loop->header = body_bb; 1175 } 1176 1177 /* Branch around the body if the mask applies. */ 1178 if (node->simdclone->inbranch) 1179 { 1180 gsi = gsi_last_bb (loop->header); 1181 tree mask_array 1182 = node->simdclone->args[node->simdclone->nargs - 1].simd_array; 1183 tree mask; 1184 if (node->simdclone->mask_mode != VOIDmode) 1185 { 1186 tree shift_cnt; 1187 if (mask_array == NULL_TREE) 1188 { 1189 tree arg = node->simdclone->args[node->simdclone->nargs 1190 - 1].vector_arg; 1191 mask = get_or_create_ssa_default_def (cfun, arg); 1192 shift_cnt = iter1; 1193 } 1194 else 1195 { 1196 tree maskt = TREE_TYPE (mask_array); 1197 int c = tree_to_uhwi (TYPE_MAX_VALUE (TYPE_DOMAIN (maskt))); 1198 c = node->simdclone->simdlen / (c + 1); 1199 int s = exact_log2 (c); 1200 gcc_assert (s > 0); 1201 c--; 1202 tree idx = make_ssa_name (TREE_TYPE (iter1)); 1203 g = gimple_build_assign (idx, RSHIFT_EXPR, iter1, 1204 build_int_cst (NULL_TREE, s)); 1205 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1206 mask = make_ssa_name (TREE_TYPE (TREE_TYPE (mask_array))); 1207 tree aref = build4 (ARRAY_REF, 1208 TREE_TYPE (TREE_TYPE (mask_array)), 1209 mask_array, idx, NULL, NULL); 1210 g = gimple_build_assign (mask, aref); 1211 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1212 shift_cnt = make_ssa_name (TREE_TYPE (iter1)); 1213 g = gimple_build_assign (shift_cnt, BIT_AND_EXPR, iter1, 1214 build_int_cst (TREE_TYPE (iter1), c)); 1215 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1216 } 1217 g = gimple_build_assign (make_ssa_name (TREE_TYPE (mask)), 1218 RSHIFT_EXPR, mask, shift_cnt); 1219 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1220 mask = gimple_assign_lhs (g); 1221 g = gimple_build_assign (make_ssa_name (TREE_TYPE (mask)), 1222 BIT_AND_EXPR, mask, 1223 build_int_cst (TREE_TYPE (mask), 1)); 1224 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1225 mask = gimple_assign_lhs (g); 1226 } 1227 else 1228 { 1229 mask = make_ssa_name (TREE_TYPE (TREE_TYPE (mask_array))); 1230 tree aref = build4 (ARRAY_REF, 1231 TREE_TYPE (TREE_TYPE (mask_array)), 1232 mask_array, iter1, NULL, NULL); 1233 g = gimple_build_assign (mask, aref); 1234 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1235 int bitsize = GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (aref))); 1236 if (!INTEGRAL_TYPE_P (TREE_TYPE (aref))) 1237 { 1238 aref = build1 (VIEW_CONVERT_EXPR, 1239 build_nonstandard_integer_type (bitsize, 0), 1240 mask); 1241 mask = make_ssa_name (TREE_TYPE (aref)); 1242 g = gimple_build_assign (mask, aref); 1243 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1244 } 1245 } 1246 1247 g = gimple_build_cond (EQ_EXPR, mask, build_zero_cst (TREE_TYPE (mask)), 1248 NULL, NULL); 1249 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1250 edge e = make_edge (loop->header, incr_bb, EDGE_TRUE_VALUE); 1251 e->probability = profile_probability::unlikely ().guessed (); 1252 incr_bb->count += e->count (); 1253 edge fallthru = FALLTHRU_EDGE (loop->header); 1254 fallthru->flags = EDGE_FALSE_VALUE; 1255 fallthru->probability = profile_probability::likely ().guessed (); 1256 } 1257 1258 basic_block latch_bb = NULL; 1259 basic_block new_exit_bb = NULL; 1260 1261 /* Generate the condition. */ 1262 if (incr_bb) 1263 { 1264 gsi = gsi_last_bb (incr_bb); 1265 g = gimple_build_cond (LT_EXPR, iter2, 1266 build_int_cst (unsigned_type_node, 1267 node->simdclone->simdlen), 1268 NULL, NULL); 1269 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1270 edge e = split_block (incr_bb, gsi_stmt (gsi)); 1271 latch_bb = e->dest; 1272 new_exit_bb = split_block_after_labels (latch_bb)->dest; 1273 loop->latch = latch_bb; 1274 1275 redirect_edge_succ (FALLTHRU_EDGE (latch_bb), body_bb); 1276 1277 edge new_e = make_edge (incr_bb, new_exit_bb, EDGE_FALSE_VALUE); 1278 1279 /* FIXME: Do we need to distribute probabilities for the conditional? */ 1280 new_e->probability = profile_probability::guessed_never (); 1281 /* The successor of incr_bb is already pointing to latch_bb; just 1282 change the flags. 1283 make_edge (incr_bb, latch_bb, EDGE_TRUE_VALUE); */ 1284 FALLTHRU_EDGE (incr_bb)->flags = EDGE_TRUE_VALUE; 1285 } 1286 1287 gphi *phi = create_phi_node (iter1, body_bb); 1288 edge preheader_edge = find_edge (entry_bb, body_bb); 1289 edge latch_edge = NULL; 1290 add_phi_arg (phi, build_zero_cst (unsigned_type_node), preheader_edge, 1291 UNKNOWN_LOCATION); 1292 if (incr_bb) 1293 { 1294 latch_edge = single_succ_edge (latch_bb); 1295 add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION); 1296 1297 /* Generate the new return. */ 1298 gsi = gsi_last_bb (new_exit_bb); 1299 if (retval 1300 && TREE_CODE (retval) == VIEW_CONVERT_EXPR 1301 && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL) 1302 retval = TREE_OPERAND (retval, 0); 1303 else if (retval) 1304 { 1305 retval = build1 (VIEW_CONVERT_EXPR, 1306 TREE_TYPE (TREE_TYPE (node->decl)), 1307 retval); 1308 retval = force_gimple_operand_gsi (&gsi, retval, true, NULL, 1309 false, GSI_CONTINUE_LINKING); 1310 } 1311 g = gimple_build_return (retval); 1312 gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING); 1313 } 1314 1315 /* Handle aligned clauses by replacing default defs of the aligned 1316 uniform args with __builtin_assume_aligned (arg_N(D), alignment) 1317 lhs. Handle linear by adding PHIs. */ 1318 for (unsigned i = 0; i < node->simdclone->nargs; i++) 1319 if (node->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_UNIFORM 1320 && (TREE_ADDRESSABLE (node->simdclone->args[i].orig_arg) 1321 || !is_gimple_reg_type 1322 (TREE_TYPE (node->simdclone->args[i].orig_arg)))) 1323 { 1324 tree orig_arg = node->simdclone->args[i].orig_arg; 1325 if (is_gimple_reg_type (TREE_TYPE (orig_arg))) 1326 iter1 = make_ssa_name (TREE_TYPE (orig_arg)); 1327 else 1328 { 1329 iter1 = create_tmp_var_raw (TREE_TYPE (orig_arg)); 1330 gimple_add_tmp_var (iter1); 1331 } 1332 gsi = gsi_after_labels (entry_bb); 1333 g = gimple_build_assign (iter1, orig_arg); 1334 gsi_insert_before (&gsi, g, GSI_NEW_STMT); 1335 gsi = gsi_after_labels (body_bb); 1336 g = gimple_build_assign (orig_arg, iter1); 1337 gsi_insert_before (&gsi, g, GSI_NEW_STMT); 1338 } 1339 else if (node->simdclone->args[i].arg_type == SIMD_CLONE_ARG_TYPE_UNIFORM 1340 && DECL_BY_REFERENCE (node->simdclone->args[i].orig_arg) 1341 && TREE_CODE (TREE_TYPE (node->simdclone->args[i].orig_arg)) 1342 == REFERENCE_TYPE 1343 && TREE_ADDRESSABLE 1344 (TREE_TYPE (TREE_TYPE (node->simdclone->args[i].orig_arg)))) 1345 { 1346 tree orig_arg = node->simdclone->args[i].orig_arg; 1347 tree def = ssa_default_def (cfun, orig_arg); 1348 if (def && !has_zero_uses (def)) 1349 { 1350 iter1 = create_tmp_var_raw (TREE_TYPE (TREE_TYPE (orig_arg))); 1351 gimple_add_tmp_var (iter1); 1352 gsi = gsi_after_labels (entry_bb); 1353 g = gimple_build_assign (iter1, build_simple_mem_ref (def)); 1354 gsi_insert_before (&gsi, g, GSI_NEW_STMT); 1355 gsi = gsi_after_labels (body_bb); 1356 g = gimple_build_assign (build_simple_mem_ref (def), iter1); 1357 gsi_insert_before (&gsi, g, GSI_NEW_STMT); 1358 } 1359 } 1360 else if (node->simdclone->args[i].alignment 1361 && node->simdclone->args[i].arg_type 1362 == SIMD_CLONE_ARG_TYPE_UNIFORM 1363 && (node->simdclone->args[i].alignment 1364 & (node->simdclone->args[i].alignment - 1)) == 0 1365 && TREE_CODE (TREE_TYPE (node->simdclone->args[i].orig_arg)) 1366 == POINTER_TYPE) 1367 { 1368 unsigned int alignment = node->simdclone->args[i].alignment; 1369 tree orig_arg = node->simdclone->args[i].orig_arg; 1370 tree def = ssa_default_def (cfun, orig_arg); 1371 if (def && !has_zero_uses (def)) 1372 { 1373 tree fn = builtin_decl_explicit (BUILT_IN_ASSUME_ALIGNED); 1374 gimple_seq seq = NULL; 1375 bool need_cvt = false; 1376 gcall *call 1377 = gimple_build_call (fn, 2, def, size_int (alignment)); 1378 g = call; 1379 if (!useless_type_conversion_p (TREE_TYPE (orig_arg), 1380 ptr_type_node)) 1381 need_cvt = true; 1382 tree t = make_ssa_name (need_cvt ? ptr_type_node : orig_arg); 1383 gimple_call_set_lhs (g, t); 1384 gimple_seq_add_stmt_without_update (&seq, g); 1385 if (need_cvt) 1386 { 1387 t = make_ssa_name (orig_arg); 1388 g = gimple_build_assign (t, NOP_EXPR, gimple_call_lhs (g)); 1389 gimple_seq_add_stmt_without_update (&seq, g); 1390 } 1391 gsi_insert_seq_on_edge_immediate 1392 (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)), seq); 1393 1394 entry_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)); 1395 node->create_edge (cgraph_node::get_create (fn), 1396 call, entry_bb->count); 1397 1398 imm_use_iterator iter; 1399 use_operand_p use_p; 1400 gimple *use_stmt; 1401 tree repl = gimple_get_lhs (g); 1402 FOR_EACH_IMM_USE_STMT (use_stmt, iter, def) 1403 if (is_gimple_debug (use_stmt) || use_stmt == call) 1404 continue; 1405 else 1406 FOR_EACH_IMM_USE_ON_STMT (use_p, iter) 1407 SET_USE (use_p, repl); 1408 } 1409 } 1410 else if ((node->simdclone->args[i].arg_type 1411 == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP) 1412 || (node->simdclone->args[i].arg_type 1413 == SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP) 1414 || (node->simdclone->args[i].arg_type 1415 == SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP) 1416 || (node->simdclone->args[i].arg_type 1417 == SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP)) 1418 { 1419 tree orig_arg = node->simdclone->args[i].orig_arg; 1420 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (orig_arg)) 1421 || POINTER_TYPE_P (TREE_TYPE (orig_arg))); 1422 tree def = NULL_TREE; 1423 if (TREE_ADDRESSABLE (orig_arg)) 1424 { 1425 def = make_ssa_name (TREE_TYPE (orig_arg)); 1426 iter1 = make_ssa_name (TREE_TYPE (orig_arg)); 1427 if (incr_bb) 1428 iter2 = make_ssa_name (TREE_TYPE (orig_arg)); 1429 gsi = gsi_after_labels (entry_bb); 1430 g = gimple_build_assign (def, orig_arg); 1431 gsi_insert_before (&gsi, g, GSI_NEW_STMT); 1432 } 1433 else 1434 { 1435 def = ssa_default_def (cfun, orig_arg); 1436 if (!def || has_zero_uses (def)) 1437 def = NULL_TREE; 1438 else 1439 { 1440 iter1 = make_ssa_name (orig_arg); 1441 if (incr_bb) 1442 iter2 = make_ssa_name (orig_arg); 1443 } 1444 } 1445 if (def) 1446 { 1447 phi = create_phi_node (iter1, body_bb); 1448 add_phi_arg (phi, def, preheader_edge, UNKNOWN_LOCATION); 1449 if (incr_bb) 1450 { 1451 add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION); 1452 enum tree_code code = INTEGRAL_TYPE_P (TREE_TYPE (orig_arg)) 1453 ? PLUS_EXPR : POINTER_PLUS_EXPR; 1454 tree addtype = INTEGRAL_TYPE_P (TREE_TYPE (orig_arg)) 1455 ? TREE_TYPE (orig_arg) : sizetype; 1456 tree addcst = simd_clone_linear_addend (node, i, addtype, 1457 entry_bb); 1458 gsi = gsi_last_bb (incr_bb); 1459 g = gimple_build_assign (iter2, code, iter1, addcst); 1460 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1461 } 1462 1463 imm_use_iterator iter; 1464 use_operand_p use_p; 1465 gimple *use_stmt; 1466 if (TREE_ADDRESSABLE (orig_arg)) 1467 { 1468 gsi = gsi_after_labels (body_bb); 1469 g = gimple_build_assign (orig_arg, iter1); 1470 gsi_insert_before (&gsi, g, GSI_NEW_STMT); 1471 } 1472 else 1473 FOR_EACH_IMM_USE_STMT (use_stmt, iter, def) 1474 if (use_stmt == phi) 1475 continue; 1476 else 1477 FOR_EACH_IMM_USE_ON_STMT (use_p, iter) 1478 SET_USE (use_p, iter1); 1479 } 1480 } 1481 else if (node->simdclone->args[i].arg_type 1482 == SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP 1483 || (node->simdclone->args[i].arg_type 1484 == SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP)) 1485 { 1486 tree orig_arg = node->simdclone->args[i].orig_arg; 1487 tree def = ssa_default_def (cfun, orig_arg); 1488 gcc_assert (!TREE_ADDRESSABLE (orig_arg) 1489 && TREE_CODE (TREE_TYPE (orig_arg)) == REFERENCE_TYPE); 1490 if (def && !has_zero_uses (def)) 1491 { 1492 tree rtype = TREE_TYPE (TREE_TYPE (orig_arg)); 1493 iter1 = make_ssa_name (orig_arg); 1494 if (incr_bb) 1495 iter2 = make_ssa_name (orig_arg); 1496 tree iter3 = make_ssa_name (rtype); 1497 tree iter4 = make_ssa_name (rtype); 1498 tree iter5 = incr_bb ? make_ssa_name (rtype) : NULL_TREE; 1499 gsi = gsi_after_labels (entry_bb); 1500 gimple *load 1501 = gimple_build_assign (iter3, build_simple_mem_ref (def)); 1502 gsi_insert_before (&gsi, load, GSI_NEW_STMT); 1503 1504 tree array = node->simdclone->args[i].simd_array; 1505 TREE_ADDRESSABLE (array) = 1; 1506 tree ptr = build_fold_addr_expr (array); 1507 phi = create_phi_node (iter1, body_bb); 1508 add_phi_arg (phi, ptr, preheader_edge, UNKNOWN_LOCATION); 1509 if (incr_bb) 1510 { 1511 add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION); 1512 g = gimple_build_assign (iter2, POINTER_PLUS_EXPR, iter1, 1513 TYPE_SIZE_UNIT (TREE_TYPE (iter3))); 1514 gsi = gsi_last_bb (incr_bb); 1515 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1516 } 1517 1518 phi = create_phi_node (iter4, body_bb); 1519 add_phi_arg (phi, iter3, preheader_edge, UNKNOWN_LOCATION); 1520 if (incr_bb) 1521 { 1522 add_phi_arg (phi, iter5, latch_edge, UNKNOWN_LOCATION); 1523 enum tree_code code = INTEGRAL_TYPE_P (TREE_TYPE (iter3)) 1524 ? PLUS_EXPR : POINTER_PLUS_EXPR; 1525 tree addtype = INTEGRAL_TYPE_P (TREE_TYPE (iter3)) 1526 ? TREE_TYPE (iter3) : sizetype; 1527 tree addcst = simd_clone_linear_addend (node, i, addtype, 1528 entry_bb); 1529 g = gimple_build_assign (iter5, code, iter4, addcst); 1530 gsi = gsi_last_bb (incr_bb); 1531 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1532 } 1533 1534 g = gimple_build_assign (build_simple_mem_ref (iter1), iter4); 1535 gsi = gsi_after_labels (body_bb); 1536 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1537 1538 imm_use_iterator iter; 1539 use_operand_p use_p; 1540 gimple *use_stmt; 1541 FOR_EACH_IMM_USE_STMT (use_stmt, iter, def) 1542 if (use_stmt == load) 1543 continue; 1544 else 1545 FOR_EACH_IMM_USE_ON_STMT (use_p, iter) 1546 SET_USE (use_p, iter1); 1547 1548 if (!TYPE_READONLY (rtype) && incr_bb) 1549 { 1550 tree v = make_ssa_name (rtype); 1551 tree aref = build4 (ARRAY_REF, rtype, array, 1552 size_zero_node, NULL_TREE, 1553 NULL_TREE); 1554 gsi = gsi_after_labels (new_exit_bb); 1555 g = gimple_build_assign (v, aref); 1556 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1557 g = gimple_build_assign (build_simple_mem_ref (def), v); 1558 gsi_insert_before (&gsi, g, GSI_SAME_STMT); 1559 } 1560 } 1561 } 1562 1563 calculate_dominance_info (CDI_DOMINATORS); 1564 if (loop) 1565 add_loop (loop, loop->header->loop_father); 1566 update_ssa (TODO_update_ssa); 1567 1568 pop_cfun (); 1569 } 1570 1571 /* If the function in NODE is tagged as an elemental SIMD function, 1572 create the appropriate SIMD clones. */ 1573 1574 void 1575 expand_simd_clones (struct cgraph_node *node) 1576 { 1577 tree attr = lookup_attribute ("omp declare simd", 1578 DECL_ATTRIBUTES (node->decl)); 1579 if (attr == NULL_TREE 1580 || node->global.inlined_to 1581 || lookup_attribute ("noclone", DECL_ATTRIBUTES (node->decl))) 1582 return; 1583 1584 /* Ignore 1585 #pragma omp declare simd 1586 extern int foo (); 1587 in C, there we don't know the argument types at all. */ 1588 if (!node->definition 1589 && TYPE_ARG_TYPES (TREE_TYPE (node->decl)) == NULL_TREE) 1590 return; 1591 1592 /* Call this before creating clone_info, as it might ggc_collect. */ 1593 if (node->definition && node->has_gimple_body_p ()) 1594 node->get_body (); 1595 1596 do 1597 { 1598 /* Start with parsing the "omp declare simd" attribute(s). */ 1599 bool inbranch_clause_specified; 1600 struct cgraph_simd_clone *clone_info 1601 = simd_clone_clauses_extract (node, TREE_VALUE (attr), 1602 &inbranch_clause_specified); 1603 if (clone_info == NULL) 1604 continue; 1605 1606 int orig_simdlen = clone_info->simdlen; 1607 tree base_type = simd_clone_compute_base_data_type (node, clone_info); 1608 /* The target can return 0 (no simd clones should be created), 1609 1 (just one ISA of simd clones should be created) or higher 1610 count of ISA variants. In that case, clone_info is initialized 1611 for the first ISA variant. */ 1612 int count 1613 = targetm.simd_clone.compute_vecsize_and_simdlen (node, clone_info, 1614 base_type, 0); 1615 if (count == 0) 1616 continue; 1617 1618 /* Loop over all COUNT ISA variants, and if !INBRANCH_CLAUSE_SPECIFIED, 1619 also create one inbranch and one !inbranch clone of it. */ 1620 for (int i = 0; i < count * 2; i++) 1621 { 1622 struct cgraph_simd_clone *clone = clone_info; 1623 if (inbranch_clause_specified && (i & 1) != 0) 1624 continue; 1625 1626 if (i != 0) 1627 { 1628 clone = simd_clone_struct_alloc (clone_info->nargs 1629 + ((i & 1) != 0)); 1630 simd_clone_struct_copy (clone, clone_info); 1631 /* Undo changes targetm.simd_clone.compute_vecsize_and_simdlen 1632 and simd_clone_adjust_argument_types did to the first 1633 clone's info. */ 1634 clone->nargs -= clone_info->inbranch; 1635 clone->simdlen = orig_simdlen; 1636 /* And call the target hook again to get the right ISA. */ 1637 targetm.simd_clone.compute_vecsize_and_simdlen (node, clone, 1638 base_type, 1639 i / 2); 1640 if ((i & 1) != 0) 1641 clone->inbranch = 1; 1642 } 1643 1644 /* simd_clone_mangle might fail if such a clone has been created 1645 already. */ 1646 tree id = simd_clone_mangle (node, clone); 1647 if (id == NULL_TREE) 1648 continue; 1649 1650 /* Only when we are sure we want to create the clone actually 1651 clone the function (or definitions) or create another 1652 extern FUNCTION_DECL (for prototypes without definitions). */ 1653 struct cgraph_node *n = simd_clone_create (node); 1654 if (n == NULL) 1655 continue; 1656 1657 n->simdclone = clone; 1658 clone->origin = node; 1659 clone->next_clone = NULL; 1660 if (node->simd_clones == NULL) 1661 { 1662 clone->prev_clone = n; 1663 node->simd_clones = n; 1664 } 1665 else 1666 { 1667 clone->prev_clone = node->simd_clones->simdclone->prev_clone; 1668 clone->prev_clone->simdclone->next_clone = n; 1669 node->simd_clones->simdclone->prev_clone = n; 1670 } 1671 symtab->change_decl_assembler_name (n->decl, id); 1672 /* And finally adjust the return type, parameters and for 1673 definitions also function body. */ 1674 if (node->definition) 1675 simd_clone_adjust (n); 1676 else 1677 { 1678 simd_clone_adjust_return_type (n); 1679 simd_clone_adjust_argument_types (n); 1680 } 1681 } 1682 } 1683 while ((attr = lookup_attribute ("omp declare simd", TREE_CHAIN (attr)))); 1684 } 1685 1686 /* Entry point for IPA simd clone creation pass. */ 1687 1688 static unsigned int 1689 ipa_omp_simd_clone (void) 1690 { 1691 struct cgraph_node *node; 1692 FOR_EACH_FUNCTION (node) 1693 expand_simd_clones (node); 1694 return 0; 1695 } 1696 1697 namespace { 1698 1699 const pass_data pass_data_omp_simd_clone = 1700 { 1701 SIMPLE_IPA_PASS, /* type */ 1702 "simdclone", /* name */ 1703 OPTGROUP_OMP, /* optinfo_flags */ 1704 TV_NONE, /* tv_id */ 1705 ( PROP_ssa | PROP_cfg ), /* properties_required */ 1706 0, /* properties_provided */ 1707 0, /* properties_destroyed */ 1708 0, /* todo_flags_start */ 1709 0, /* todo_flags_finish */ 1710 }; 1711 1712 class pass_omp_simd_clone : public simple_ipa_opt_pass 1713 { 1714 public: 1715 pass_omp_simd_clone(gcc::context *ctxt) 1716 : simple_ipa_opt_pass(pass_data_omp_simd_clone, ctxt) 1717 {} 1718 1719 /* opt_pass methods: */ 1720 virtual bool gate (function *); 1721 virtual unsigned int execute (function *) { return ipa_omp_simd_clone (); } 1722 }; 1723 1724 bool 1725 pass_omp_simd_clone::gate (function *) 1726 { 1727 return targetm.simd_clone.compute_vecsize_and_simdlen != NULL; 1728 } 1729 1730 } // anon namespace 1731 1732 simple_ipa_opt_pass * 1733 make_pass_omp_simd_clone (gcc::context *ctxt) 1734 { 1735 return new pass_omp_simd_clone (ctxt); 1736 } 1737