1 /* Implementation of commonly needed HSAIL related functions and methods. 2 Copyright (C) 2013-2017 Free Software Foundation, Inc. 3 Contributed by Martin Jambor <mjambor@suse.cz> and 4 Martin Liska <mliska@suse.cz>. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GCC is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "is-a.h" 27 #include "hash-set.h" 28 #include "hash-map.h" 29 #include "vec.h" 30 #include "tree.h" 31 #include "dumpfile.h" 32 #include "gimple-pretty-print.h" 33 #include "diagnostic-core.h" 34 #include "alloc-pool.h" 35 #include "cgraph.h" 36 #include "print-tree.h" 37 #include "stringpool.h" 38 #include "symbol-summary.h" 39 #include "hsa-common.h" 40 #include "internal-fn.h" 41 #include "ctype.h" 42 #include "builtins.h" 43 44 /* Structure containing intermediate HSA representation of the generated 45 function. */ 46 class hsa_function_representation *hsa_cfun; 47 48 /* Element of the mapping vector between a host decl and an HSA kernel. */ 49 50 struct GTY(()) hsa_decl_kernel_map_element 51 { 52 /* The decl of the host function. */ 53 tree decl; 54 /* Name of the HSA kernel in BRIG. */ 55 char * GTY((skip)) name; 56 /* Size of OMP data, if the kernel contains a kernel dispatch. */ 57 unsigned omp_data_size; 58 /* True if the function is gridified kernel. */ 59 bool gridified_kernel_p; 60 }; 61 62 /* Mapping between decls and corresponding HSA kernels in this compilation 63 unit. */ 64 65 static GTY (()) vec<hsa_decl_kernel_map_element, va_gc> 66 *hsa_decl_kernel_mapping; 67 68 /* Mapping between decls and corresponding HSA kernels 69 called by the function. */ 70 hash_map <tree, vec <const char *> *> *hsa_decl_kernel_dependencies; 71 72 /* Hash function to lookup a symbol for a decl. */ 73 hash_table <hsa_noop_symbol_hasher> *hsa_global_variable_symbols; 74 75 /* HSA summaries. */ 76 hsa_summary_t *hsa_summaries = NULL; 77 78 /* HSA number of threads. */ 79 hsa_symbol *hsa_num_threads = NULL; 80 81 /* HSA function that cannot be expanded to HSAIL. */ 82 hash_set <tree> *hsa_failed_functions = NULL; 83 84 /* True if compilation unit-wide data are already allocated and initialized. */ 85 static bool compilation_unit_data_initialized; 86 87 /* Return true if FNDECL represents an HSA-callable function. */ 88 89 bool 90 hsa_callable_function_p (tree fndecl) 91 { 92 return (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl)) 93 && !lookup_attribute ("oacc function", DECL_ATTRIBUTES (fndecl))); 94 } 95 96 /* Allocate HSA structures that are are used when dealing with different 97 functions. */ 98 99 void 100 hsa_init_compilation_unit_data (void) 101 { 102 if (compilation_unit_data_initialized) 103 return; 104 105 compilation_unit_data_initialized = true; 106 107 hsa_global_variable_symbols = new hash_table <hsa_noop_symbol_hasher> (8); 108 hsa_failed_functions = new hash_set <tree> (); 109 hsa_emitted_internal_decls = new hash_table <hsa_internal_fn_hasher> (2); 110 } 111 112 /* Free data structures that are used when dealing with different 113 functions. */ 114 115 void 116 hsa_deinit_compilation_unit_data (void) 117 { 118 gcc_assert (compilation_unit_data_initialized); 119 120 delete hsa_failed_functions; 121 delete hsa_emitted_internal_decls; 122 123 for (hash_table <hsa_noop_symbol_hasher>::iterator it 124 = hsa_global_variable_symbols->begin (); 125 it != hsa_global_variable_symbols->end (); 126 ++it) 127 { 128 hsa_symbol *sym = *it; 129 delete sym; 130 } 131 132 delete hsa_global_variable_symbols; 133 134 if (hsa_num_threads) 135 { 136 delete hsa_num_threads; 137 hsa_num_threads = NULL; 138 } 139 140 compilation_unit_data_initialized = false; 141 } 142 143 /* Return true if we are generating large HSA machine model. */ 144 145 bool 146 hsa_machine_large_p (void) 147 { 148 /* FIXME: I suppose this is technically wrong but should work for me now. */ 149 return (GET_MODE_BITSIZE (Pmode) == 64); 150 } 151 152 /* Return the HSA profile we are using. */ 153 154 bool 155 hsa_full_profile_p (void) 156 { 157 return true; 158 } 159 160 /* Return true if a register in operand number OPNUM of instruction 161 is an output. False if it is an input. */ 162 163 bool 164 hsa_insn_basic::op_output_p (unsigned opnum) 165 { 166 switch (m_opcode) 167 { 168 case HSA_OPCODE_PHI: 169 case BRIG_OPCODE_CBR: 170 case BRIG_OPCODE_SBR: 171 case BRIG_OPCODE_ST: 172 case BRIG_OPCODE_SIGNALNORET: 173 case BRIG_OPCODE_DEBUGTRAP: 174 /* FIXME: There are probably missing cases here, double check. */ 175 return false; 176 case BRIG_OPCODE_EXPAND: 177 /* Example: expand_v4_b32_b128 (dest0, dest1, dest2, dest3), src0. */ 178 return opnum < operand_count () - 1; 179 default: 180 return opnum == 0; 181 } 182 } 183 184 /* Return true if OPCODE is an floating-point bit instruction opcode. */ 185 186 bool 187 hsa_opcode_floating_bit_insn_p (BrigOpcode16_t opcode) 188 { 189 switch (opcode) 190 { 191 case BRIG_OPCODE_NEG: 192 case BRIG_OPCODE_ABS: 193 case BRIG_OPCODE_CLASS: 194 case BRIG_OPCODE_COPYSIGN: 195 return true; 196 default: 197 return false; 198 } 199 } 200 201 /* Return the number of destination operands for this INSN. */ 202 203 unsigned 204 hsa_insn_basic::input_count () 205 { 206 switch (m_opcode) 207 { 208 default: 209 return 1; 210 211 case BRIG_OPCODE_NOP: 212 return 0; 213 214 case BRIG_OPCODE_EXPAND: 215 return 2; 216 217 case BRIG_OPCODE_LD: 218 /* ld_v[234] not yet handled. */ 219 return 1; 220 221 case BRIG_OPCODE_ST: 222 return 0; 223 224 case BRIG_OPCODE_ATOMICNORET: 225 return 0; 226 227 case BRIG_OPCODE_SIGNAL: 228 return 1; 229 230 case BRIG_OPCODE_SIGNALNORET: 231 return 0; 232 233 case BRIG_OPCODE_MEMFENCE: 234 return 0; 235 236 case BRIG_OPCODE_RDIMAGE: 237 case BRIG_OPCODE_LDIMAGE: 238 case BRIG_OPCODE_STIMAGE: 239 case BRIG_OPCODE_QUERYIMAGE: 240 case BRIG_OPCODE_QUERYSAMPLER: 241 sorry ("HSA image ops not handled"); 242 return 0; 243 244 case BRIG_OPCODE_CBR: 245 case BRIG_OPCODE_BR: 246 return 0; 247 248 case BRIG_OPCODE_SBR: 249 return 0; /* ??? */ 250 251 case BRIG_OPCODE_WAVEBARRIER: 252 return 0; /* ??? */ 253 254 case BRIG_OPCODE_BARRIER: 255 case BRIG_OPCODE_ARRIVEFBAR: 256 case BRIG_OPCODE_INITFBAR: 257 case BRIG_OPCODE_JOINFBAR: 258 case BRIG_OPCODE_LEAVEFBAR: 259 case BRIG_OPCODE_RELEASEFBAR: 260 case BRIG_OPCODE_WAITFBAR: 261 return 0; 262 263 case BRIG_OPCODE_LDF: 264 return 1; 265 266 case BRIG_OPCODE_ACTIVELANECOUNT: 267 case BRIG_OPCODE_ACTIVELANEID: 268 case BRIG_OPCODE_ACTIVELANEMASK: 269 case BRIG_OPCODE_ACTIVELANEPERMUTE: 270 return 1; /* ??? */ 271 272 case BRIG_OPCODE_CALL: 273 case BRIG_OPCODE_SCALL: 274 case BRIG_OPCODE_ICALL: 275 return 0; 276 277 case BRIG_OPCODE_RET: 278 return 0; 279 280 case BRIG_OPCODE_ALLOCA: 281 return 1; 282 283 case BRIG_OPCODE_CLEARDETECTEXCEPT: 284 return 0; 285 286 case BRIG_OPCODE_SETDETECTEXCEPT: 287 return 0; 288 289 case BRIG_OPCODE_PACKETCOMPLETIONSIG: 290 case BRIG_OPCODE_PACKETID: 291 case BRIG_OPCODE_CASQUEUEWRITEINDEX: 292 case BRIG_OPCODE_LDQUEUEREADINDEX: 293 case BRIG_OPCODE_LDQUEUEWRITEINDEX: 294 case BRIG_OPCODE_STQUEUEREADINDEX: 295 case BRIG_OPCODE_STQUEUEWRITEINDEX: 296 return 1; /* ??? */ 297 298 case BRIG_OPCODE_ADDQUEUEWRITEINDEX: 299 return 1; 300 301 case BRIG_OPCODE_DEBUGTRAP: 302 return 0; 303 304 case BRIG_OPCODE_GROUPBASEPTR: 305 case BRIG_OPCODE_KERNARGBASEPTR: 306 return 1; /* ??? */ 307 308 case HSA_OPCODE_ARG_BLOCK: 309 return 0; 310 311 case BRIG_KIND_DIRECTIVE_COMMENT: 312 return 0; 313 } 314 } 315 316 /* Return the number of source operands for this INSN. */ 317 318 unsigned 319 hsa_insn_basic::num_used_ops () 320 { 321 gcc_checking_assert (input_count () <= operand_count ()); 322 323 return operand_count () - input_count (); 324 } 325 326 /* Set alignment to VALUE. */ 327 328 void 329 hsa_insn_mem::set_align (BrigAlignment8_t value) 330 { 331 /* TODO: Perhaps remove this dump later on: */ 332 if (dump_file && (dump_flags & TDF_DETAILS) && value < m_align) 333 { 334 fprintf (dump_file, "Decreasing alignment to %u in instruction ", value); 335 dump_hsa_insn (dump_file, this); 336 } 337 m_align = value; 338 } 339 340 /* Return size of HSA type T in bits. */ 341 342 unsigned 343 hsa_type_bit_size (BrigType16_t t) 344 { 345 switch (t) 346 { 347 case BRIG_TYPE_B1: 348 return 1; 349 350 case BRIG_TYPE_U8: 351 case BRIG_TYPE_S8: 352 case BRIG_TYPE_B8: 353 return 8; 354 355 case BRIG_TYPE_U16: 356 case BRIG_TYPE_S16: 357 case BRIG_TYPE_B16: 358 case BRIG_TYPE_F16: 359 return 16; 360 361 case BRIG_TYPE_U32: 362 case BRIG_TYPE_S32: 363 case BRIG_TYPE_B32: 364 case BRIG_TYPE_F32: 365 case BRIG_TYPE_U8X4: 366 case BRIG_TYPE_U16X2: 367 case BRIG_TYPE_S8X4: 368 case BRIG_TYPE_S16X2: 369 case BRIG_TYPE_F16X2: 370 return 32; 371 372 case BRIG_TYPE_U64: 373 case BRIG_TYPE_S64: 374 case BRIG_TYPE_F64: 375 case BRIG_TYPE_B64: 376 case BRIG_TYPE_U8X8: 377 case BRIG_TYPE_U16X4: 378 case BRIG_TYPE_U32X2: 379 case BRIG_TYPE_S8X8: 380 case BRIG_TYPE_S16X4: 381 case BRIG_TYPE_S32X2: 382 case BRIG_TYPE_F16X4: 383 case BRIG_TYPE_F32X2: 384 385 return 64; 386 387 case BRIG_TYPE_B128: 388 case BRIG_TYPE_U8X16: 389 case BRIG_TYPE_U16X8: 390 case BRIG_TYPE_U32X4: 391 case BRIG_TYPE_U64X2: 392 case BRIG_TYPE_S8X16: 393 case BRIG_TYPE_S16X8: 394 case BRIG_TYPE_S32X4: 395 case BRIG_TYPE_S64X2: 396 case BRIG_TYPE_F16X8: 397 case BRIG_TYPE_F32X4: 398 case BRIG_TYPE_F64X2: 399 return 128; 400 401 default: 402 gcc_assert (hsa_seen_error ()); 403 return t; 404 } 405 } 406 407 /* Return BRIG bit-type with BITSIZE length. */ 408 409 BrigType16_t 410 hsa_bittype_for_bitsize (unsigned bitsize) 411 { 412 switch (bitsize) 413 { 414 case 1: 415 return BRIG_TYPE_B1; 416 case 8: 417 return BRIG_TYPE_B8; 418 case 16: 419 return BRIG_TYPE_B16; 420 case 32: 421 return BRIG_TYPE_B32; 422 case 64: 423 return BRIG_TYPE_B64; 424 case 128: 425 return BRIG_TYPE_B128; 426 default: 427 gcc_unreachable (); 428 } 429 } 430 431 /* Return BRIG unsigned int type with BITSIZE length. */ 432 433 BrigType16_t 434 hsa_uint_for_bitsize (unsigned bitsize) 435 { 436 switch (bitsize) 437 { 438 case 8: 439 return BRIG_TYPE_U8; 440 case 16: 441 return BRIG_TYPE_U16; 442 case 32: 443 return BRIG_TYPE_U32; 444 case 64: 445 return BRIG_TYPE_U64; 446 default: 447 gcc_unreachable (); 448 } 449 } 450 451 /* Return BRIG float type with BITSIZE length. */ 452 453 BrigType16_t 454 hsa_float_for_bitsize (unsigned bitsize) 455 { 456 switch (bitsize) 457 { 458 case 16: 459 return BRIG_TYPE_F16; 460 case 32: 461 return BRIG_TYPE_F32; 462 case 64: 463 return BRIG_TYPE_F64; 464 default: 465 gcc_unreachable (); 466 } 467 } 468 469 /* Return HSA bit-type with the same size as the type T. */ 470 471 BrigType16_t 472 hsa_bittype_for_type (BrigType16_t t) 473 { 474 return hsa_bittype_for_bitsize (hsa_type_bit_size (t)); 475 } 476 477 /* Return HSA unsigned integer type with the same size as the type T. */ 478 479 BrigType16_t 480 hsa_unsigned_type_for_type (BrigType16_t t) 481 { 482 return hsa_uint_for_bitsize (hsa_type_bit_size (t)); 483 } 484 485 /* Return true if TYPE is a packed HSA type. */ 486 487 bool 488 hsa_type_packed_p (BrigType16_t type) 489 { 490 return (type & BRIG_TYPE_PACK_MASK) != BRIG_TYPE_PACK_NONE; 491 } 492 493 /* Return true if and only if TYPE is a floating point number type. */ 494 495 bool 496 hsa_type_float_p (BrigType16_t type) 497 { 498 switch (type & BRIG_TYPE_BASE_MASK) 499 { 500 case BRIG_TYPE_F16: 501 case BRIG_TYPE_F32: 502 case BRIG_TYPE_F64: 503 return true; 504 default: 505 return false; 506 } 507 } 508 509 /* Return true if and only if TYPE is an integer number type. */ 510 511 bool 512 hsa_type_integer_p (BrigType16_t type) 513 { 514 switch (type & BRIG_TYPE_BASE_MASK) 515 { 516 case BRIG_TYPE_U8: 517 case BRIG_TYPE_U16: 518 case BRIG_TYPE_U32: 519 case BRIG_TYPE_U64: 520 case BRIG_TYPE_S8: 521 case BRIG_TYPE_S16: 522 case BRIG_TYPE_S32: 523 case BRIG_TYPE_S64: 524 return true; 525 default: 526 return false; 527 } 528 } 529 530 /* Return true if and only if TYPE is an bit-type. */ 531 532 bool 533 hsa_btype_p (BrigType16_t type) 534 { 535 switch (type & BRIG_TYPE_BASE_MASK) 536 { 537 case BRIG_TYPE_B8: 538 case BRIG_TYPE_B16: 539 case BRIG_TYPE_B32: 540 case BRIG_TYPE_B64: 541 case BRIG_TYPE_B128: 542 return true; 543 default: 544 return false; 545 } 546 } 547 548 549 /* Return HSA alignment encoding alignment to N bits. */ 550 551 BrigAlignment8_t 552 hsa_alignment_encoding (unsigned n) 553 { 554 gcc_assert (n >= 8 && !(n & (n - 1))); 555 if (n >= 256) 556 return BRIG_ALIGNMENT_32; 557 558 switch (n) 559 { 560 case 8: 561 return BRIG_ALIGNMENT_1; 562 case 16: 563 return BRIG_ALIGNMENT_2; 564 case 32: 565 return BRIG_ALIGNMENT_4; 566 case 64: 567 return BRIG_ALIGNMENT_8; 568 case 128: 569 return BRIG_ALIGNMENT_16; 570 default: 571 gcc_unreachable (); 572 } 573 } 574 575 /* Return HSA alignment encoding alignment of T got 576 by get_object_alignment. */ 577 578 BrigAlignment8_t 579 hsa_object_alignment (tree t) 580 { 581 return hsa_alignment_encoding (get_object_alignment (t)); 582 } 583 584 /* Return byte alignment for given BrigAlignment8_t value. */ 585 586 unsigned 587 hsa_byte_alignment (BrigAlignment8_t alignment) 588 { 589 gcc_assert (alignment != BRIG_ALIGNMENT_NONE); 590 591 return 1 << (alignment - 1); 592 } 593 594 /* Return natural alignment of HSA TYPE. */ 595 596 BrigAlignment8_t 597 hsa_natural_alignment (BrigType16_t type) 598 { 599 return hsa_alignment_encoding (hsa_type_bit_size (type & ~BRIG_TYPE_ARRAY)); 600 } 601 602 /* Call the correct destructor of a HSA instruction. */ 603 604 void 605 hsa_destroy_insn (hsa_insn_basic *insn) 606 { 607 if (hsa_insn_phi *phi = dyn_cast <hsa_insn_phi *> (insn)) 608 phi->~hsa_insn_phi (); 609 else if (hsa_insn_cbr *br = dyn_cast <hsa_insn_cbr *> (insn)) 610 br->~hsa_insn_cbr (); 611 else if (hsa_insn_cmp *cmp = dyn_cast <hsa_insn_cmp *> (insn)) 612 cmp->~hsa_insn_cmp (); 613 else if (hsa_insn_mem *mem = dyn_cast <hsa_insn_mem *> (insn)) 614 mem->~hsa_insn_mem (); 615 else if (hsa_insn_atomic *atomic = dyn_cast <hsa_insn_atomic *> (insn)) 616 atomic->~hsa_insn_atomic (); 617 else if (hsa_insn_seg *seg = dyn_cast <hsa_insn_seg *> (insn)) 618 seg->~hsa_insn_seg (); 619 else if (hsa_insn_call *call = dyn_cast <hsa_insn_call *> (insn)) 620 call->~hsa_insn_call (); 621 else if (hsa_insn_arg_block *block = dyn_cast <hsa_insn_arg_block *> (insn)) 622 block->~hsa_insn_arg_block (); 623 else if (hsa_insn_sbr *sbr = dyn_cast <hsa_insn_sbr *> (insn)) 624 sbr->~hsa_insn_sbr (); 625 else if (hsa_insn_br *br = dyn_cast <hsa_insn_br *> (insn)) 626 br->~hsa_insn_br (); 627 else if (hsa_insn_comment *comment = dyn_cast <hsa_insn_comment *> (insn)) 628 comment->~hsa_insn_comment (); 629 else 630 insn->~hsa_insn_basic (); 631 } 632 633 /* Call the correct destructor of a HSA operand. */ 634 635 void 636 hsa_destroy_operand (hsa_op_base *op) 637 { 638 if (hsa_op_code_list *list = dyn_cast <hsa_op_code_list *> (op)) 639 list->~hsa_op_code_list (); 640 else if (hsa_op_operand_list *list = dyn_cast <hsa_op_operand_list *> (op)) 641 list->~hsa_op_operand_list (); 642 else if (hsa_op_reg *reg = dyn_cast <hsa_op_reg *> (op)) 643 reg->~hsa_op_reg (); 644 else if (hsa_op_immed *immed = dyn_cast <hsa_op_immed *> (op)) 645 immed->~hsa_op_immed (); 646 else 647 op->~hsa_op_base (); 648 } 649 650 /* Create a mapping between the original function DECL and kernel name NAME. */ 651 652 void 653 hsa_add_kern_decl_mapping (tree decl, char *name, unsigned omp_data_size, 654 bool gridified_kernel_p) 655 { 656 hsa_decl_kernel_map_element dkm; 657 dkm.decl = decl; 658 dkm.name = name; 659 dkm.omp_data_size = omp_data_size; 660 dkm.gridified_kernel_p = gridified_kernel_p; 661 vec_safe_push (hsa_decl_kernel_mapping, dkm); 662 } 663 664 /* Return the number of kernel decl name mappings. */ 665 666 unsigned 667 hsa_get_number_decl_kernel_mappings (void) 668 { 669 return vec_safe_length (hsa_decl_kernel_mapping); 670 } 671 672 /* Return the decl in the Ith kernel decl name mapping. */ 673 674 tree 675 hsa_get_decl_kernel_mapping_decl (unsigned i) 676 { 677 return (*hsa_decl_kernel_mapping)[i].decl; 678 } 679 680 /* Return the name in the Ith kernel decl name mapping. */ 681 682 char * 683 hsa_get_decl_kernel_mapping_name (unsigned i) 684 { 685 return (*hsa_decl_kernel_mapping)[i].name; 686 } 687 688 /* Return maximum OMP size for kernel decl name mapping. */ 689 690 unsigned 691 hsa_get_decl_kernel_mapping_omp_size (unsigned i) 692 { 693 return (*hsa_decl_kernel_mapping)[i].omp_data_size; 694 } 695 696 /* Return if the function is gridified kernel in decl name mapping. */ 697 698 bool 699 hsa_get_decl_kernel_mapping_gridified (unsigned i) 700 { 701 return (*hsa_decl_kernel_mapping)[i].gridified_kernel_p; 702 } 703 704 /* Free the mapping between original decls and kernel names. */ 705 706 void 707 hsa_free_decl_kernel_mapping (void) 708 { 709 if (hsa_decl_kernel_mapping == NULL) 710 return; 711 712 for (unsigned i = 0; i < hsa_decl_kernel_mapping->length (); ++i) 713 free ((*hsa_decl_kernel_mapping)[i].name); 714 ggc_free (hsa_decl_kernel_mapping); 715 } 716 717 /* Add new kernel dependency. */ 718 719 void 720 hsa_add_kernel_dependency (tree caller, const char *called_function) 721 { 722 if (hsa_decl_kernel_dependencies == NULL) 723 hsa_decl_kernel_dependencies = new hash_map<tree, vec<const char *> *> (); 724 725 vec <const char *> *s = NULL; 726 vec <const char *> **slot = hsa_decl_kernel_dependencies->get (caller); 727 if (slot == NULL) 728 { 729 s = new vec <const char *> (); 730 hsa_decl_kernel_dependencies->put (caller, s); 731 } 732 else 733 s = *slot; 734 735 s->safe_push (called_function); 736 } 737 738 /* Expansion to HSA needs a few gc roots to hold types, constructors etc. In 739 order to minimize the number of GTY roots, we'll root them all in the 740 following array. The individual elements should only be accessed by the 741 very simple getters (of a pointer-to-tree) below. */ 742 743 static GTY(()) tree hsa_tree_gt_roots[3]; 744 745 tree * 746 hsa_get_ctor_statements (void) 747 { 748 return &hsa_tree_gt_roots[0]; 749 } 750 751 tree * 752 hsa_get_dtor_statements (void) 753 { 754 return &hsa_tree_gt_roots[1]; 755 } 756 757 tree * 758 hsa_get_kernel_dispatch_type (void) 759 { 760 return &hsa_tree_gt_roots[2]; 761 } 762 763 /* Modify the name P in-place so that it is a valid HSA identifier. */ 764 765 void 766 hsa_sanitize_name (char *p) 767 { 768 for (; *p; p++) 769 if (*p == '.' || *p == '-') 770 *p = '_'; 771 } 772 773 /* Clone the name P, set trailing ampersand and sanitize the name. */ 774 775 char * 776 hsa_brig_function_name (const char *p) 777 { 778 unsigned len = strlen (p); 779 char *buf = XNEWVEC (char, len + 2); 780 781 buf[0] = '&'; 782 buf[len + 1] = '\0'; 783 memcpy (buf + 1, p, len); 784 785 hsa_sanitize_name (buf); 786 return buf; 787 } 788 789 /* Add a flatten attribute and disable vectorization for gpu implementation 790 function decl GDECL. */ 791 792 void hsa_summary_t::process_gpu_implementation_attributes (tree gdecl) 793 { 794 DECL_ATTRIBUTES (gdecl) 795 = tree_cons (get_identifier ("flatten"), NULL_TREE, 796 DECL_ATTRIBUTES (gdecl)); 797 798 tree fn_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (gdecl); 799 if (fn_opts == NULL_TREE) 800 fn_opts = optimization_default_node; 801 fn_opts = copy_node (fn_opts); 802 TREE_OPTIMIZATION (fn_opts)->x_flag_tree_loop_vectorize = false; 803 TREE_OPTIMIZATION (fn_opts)->x_flag_tree_slp_vectorize = false; 804 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (gdecl) = fn_opts; 805 } 806 807 void 808 hsa_summary_t::link_functions (cgraph_node *gpu, cgraph_node *host, 809 hsa_function_kind kind, bool gridified_kernel_p) 810 { 811 hsa_function_summary *gpu_summary = get (gpu); 812 hsa_function_summary *host_summary = get (host); 813 814 gpu_summary->m_kind = kind; 815 host_summary->m_kind = kind; 816 817 gpu_summary->m_gpu_implementation_p = true; 818 host_summary->m_gpu_implementation_p = false; 819 820 gpu_summary->m_gridified_kernel_p = gridified_kernel_p; 821 host_summary->m_gridified_kernel_p = gridified_kernel_p; 822 823 gpu_summary->m_bound_function = host; 824 host_summary->m_bound_function = gpu; 825 826 process_gpu_implementation_attributes (gpu->decl); 827 828 /* Create reference between a kernel and a corresponding host implementation 829 to quarantee LTO streaming to a same LTRANS. */ 830 if (kind == HSA_KERNEL) 831 gpu->create_reference (host, IPA_REF_ADDR); 832 } 833 834 /* Add a HOST function to HSA summaries. */ 835 836 void 837 hsa_register_kernel (cgraph_node *host) 838 { 839 if (hsa_summaries == NULL) 840 hsa_summaries = new hsa_summary_t (symtab); 841 hsa_function_summary *s = hsa_summaries->get (host); 842 s->m_kind = HSA_KERNEL; 843 } 844 845 /* Add a pair of functions to HSA summaries. GPU is an HSA implementation of 846 a HOST function. */ 847 848 void 849 hsa_register_kernel (cgraph_node *gpu, cgraph_node *host) 850 { 851 if (hsa_summaries == NULL) 852 hsa_summaries = new hsa_summary_t (symtab); 853 hsa_summaries->link_functions (gpu, host, HSA_KERNEL, true); 854 } 855 856 /* Return true if expansion of the current HSA function has already failed. */ 857 858 bool 859 hsa_seen_error (void) 860 { 861 return hsa_cfun->m_seen_error; 862 } 863 864 /* Mark current HSA function as failed. */ 865 866 void 867 hsa_fail_cfun (void) 868 { 869 hsa_failed_functions->add (hsa_cfun->m_decl); 870 hsa_cfun->m_seen_error = true; 871 } 872 873 char * 874 hsa_internal_fn::name () 875 { 876 char *name = xstrdup (internal_fn_name (m_fn)); 877 for (char *ptr = name; *ptr; ptr++) 878 *ptr = TOLOWER (*ptr); 879 880 const char *suffix = NULL; 881 if (m_type_bit_size == 32) 882 suffix = "f"; 883 884 if (suffix) 885 { 886 char *name2 = concat (name, suffix, NULL); 887 free (name); 888 name = name2; 889 } 890 891 hsa_sanitize_name (name); 892 return name; 893 } 894 895 unsigned 896 hsa_internal_fn::get_arity () 897 { 898 switch (m_fn) 899 { 900 case IFN_ACOS: 901 case IFN_ASIN: 902 case IFN_ATAN: 903 case IFN_COS: 904 case IFN_EXP: 905 case IFN_EXP10: 906 case IFN_EXP2: 907 case IFN_EXPM1: 908 case IFN_LOG: 909 case IFN_LOG10: 910 case IFN_LOG1P: 911 case IFN_LOG2: 912 case IFN_LOGB: 913 case IFN_SIGNIFICAND: 914 case IFN_SIN: 915 case IFN_SQRT: 916 case IFN_TAN: 917 case IFN_CEIL: 918 case IFN_FLOOR: 919 case IFN_NEARBYINT: 920 case IFN_RINT: 921 case IFN_ROUND: 922 case IFN_TRUNC: 923 return 1; 924 case IFN_ATAN2: 925 case IFN_COPYSIGN: 926 case IFN_FMOD: 927 case IFN_POW: 928 case IFN_REMAINDER: 929 case IFN_SCALB: 930 case IFN_LDEXP: 931 return 2; 932 case IFN_CLRSB: 933 case IFN_CLZ: 934 case IFN_CTZ: 935 case IFN_FFS: 936 case IFN_PARITY: 937 case IFN_POPCOUNT: 938 default: 939 /* As we produce sorry message for unknown internal functions, 940 reaching this label is definitely a bug. */ 941 gcc_unreachable (); 942 } 943 } 944 945 BrigType16_t 946 hsa_internal_fn::get_argument_type (int n) 947 { 948 switch (m_fn) 949 { 950 case IFN_ACOS: 951 case IFN_ASIN: 952 case IFN_ATAN: 953 case IFN_COS: 954 case IFN_EXP: 955 case IFN_EXP10: 956 case IFN_EXP2: 957 case IFN_EXPM1: 958 case IFN_LOG: 959 case IFN_LOG10: 960 case IFN_LOG1P: 961 case IFN_LOG2: 962 case IFN_LOGB: 963 case IFN_SIGNIFICAND: 964 case IFN_SIN: 965 case IFN_SQRT: 966 case IFN_TAN: 967 case IFN_CEIL: 968 case IFN_FLOOR: 969 case IFN_NEARBYINT: 970 case IFN_RINT: 971 case IFN_ROUND: 972 case IFN_TRUNC: 973 case IFN_ATAN2: 974 case IFN_COPYSIGN: 975 case IFN_FMOD: 976 case IFN_POW: 977 case IFN_REMAINDER: 978 case IFN_SCALB: 979 return hsa_float_for_bitsize (m_type_bit_size); 980 case IFN_LDEXP: 981 { 982 if (n == -1 || n == 0) 983 return hsa_float_for_bitsize (m_type_bit_size); 984 else 985 return BRIG_TYPE_S32; 986 } 987 default: 988 /* As we produce sorry message for unknown internal functions, 989 reaching this label is definitely a bug. */ 990 gcc_unreachable (); 991 } 992 } 993 994 #include "gt-hsa-common.h" 995