gcc/hsa.c

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