gcc/brig/brigfrontend/brig-util.cc

   1 /* brig-util.cc -- gccbrig utility functions
   2    Copyright (C) 2016-2018 Free Software Foundation, Inc.
   3    Contributed by Pekka Jaaskelainen <pekka.jaaskelainen@parmance.com>
   4    for General Processor Tech.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 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 <sstream>
  23
  24 #include "stdint.h"
  25 #include "hsa-brig-format.h"
  26 #include "brig-util.h"
  27 #include "errors.h"
  28 #include "diagnostic-core.h"
  29 #include "print-tree.h"
  30
  31 bool
  32 group_variable_offset_index::has_variable (const std::string &name) const
  33 {
  34   varname_offset_table::const_iterator i = m_group_offsets.find (name);
  35   return i != m_group_offsets.end ();
  36 }
  37
  38 /* Adds a new group segment variable.  */
  39
  40 void
  41 group_variable_offset_index::add (const std::string &name, size_t size,
  42                                   size_t alignment)
  43 {
  44   size_t align_padding = m_next_group_offset % alignment == 0 ?
  45     0 : (alignment - m_next_group_offset % alignment);
  46   m_next_group_offset += align_padding;
  47   m_group_offsets[name] = m_next_group_offset;
  48   m_next_group_offset += size;
  49 }
  50
  51 size_t
  52 group_variable_offset_index::segment_offset (const std::string &name) const
  53 {
  54   varname_offset_table::const_iterator i = m_group_offsets.find (name);
  55   gcc_assert (i != m_group_offsets.end ());
  56   return (*i).second;
  57 }
  58
  59 /* Return true if operand number OPNUM of instruction with OPCODE is an output.
  60    False if it is an input.  Some code reused from Martin Jambor's gcc-hsa
  61    tree.  */
  62
  63 bool
  64 gccbrig_hsa_opcode_op_output_p (BrigOpcode16_t opcode, int opnum)
  65 {
  66   switch (opcode)
  67     {
  68     case BRIG_OPCODE_BR:
  69     case BRIG_OPCODE_SBR:
  70     case BRIG_OPCODE_CBR:
  71     case BRIG_OPCODE_ST:
  72     case BRIG_OPCODE_ATOMICNORET:
  73     case BRIG_OPCODE_SIGNALNORET:
  74     case BRIG_OPCODE_INITFBAR:
  75     case BRIG_OPCODE_JOINFBAR:
  76     case BRIG_OPCODE_WAITFBAR:
  77     case BRIG_OPCODE_ARRIVEFBAR:
  78     case BRIG_OPCODE_LEAVEFBAR:
  79     case BRIG_OPCODE_RELEASEFBAR:
  80     case BRIG_OPCODE_DEBUGTRAP:
  81       return false;
  82     default:
  83       return opnum == 0;
  84     }
  85 }
  86
  87 unsigned
  88 gccbrig_hsa_type_bit_size (BrigType16_t t)
  89 {
  90
  91   unsigned pack_type = t & ~BRIG_TYPE_BASE_MASK;
  92
  93   if (pack_type == BRIG_TYPE_PACK_32)
  94     return 32;
  95   else if (pack_type == BRIG_TYPE_PACK_64)
  96     return 64;
  97   else if (pack_type == BRIG_TYPE_PACK_128)
  98     return 128;
  99
 100   switch (t)
 101     {
 102     case BRIG_TYPE_NONE:
 103       return 0;
 104
 105     case BRIG_TYPE_B1:
 106       return 1;
 107
 108     case BRIG_TYPE_U8:
 109     case BRIG_TYPE_S8:
 110     case BRIG_TYPE_B8:
 111       return 8;
 112
 113     case BRIG_TYPE_U16:
 114     case BRIG_TYPE_S16:
 115     case BRIG_TYPE_B16:
 116     case BRIG_TYPE_F16:
 117       return 16;
 118
 119     case BRIG_TYPE_U32:
 120     case BRIG_TYPE_S32:
 121     case BRIG_TYPE_B32:
 122     case BRIG_TYPE_F32:
 123     case BRIG_TYPE_U8X4:
 124     case BRIG_TYPE_U16X2:
 125     case BRIG_TYPE_S8X4:
 126     case BRIG_TYPE_S16X2:
 127     case BRIG_TYPE_F16X2:
 128     case BRIG_TYPE_SIG32:
 129       return 32;
 130
 131     case BRIG_TYPE_U64:
 132     case BRIG_TYPE_S64:
 133     case BRIG_TYPE_F64:
 134     case BRIG_TYPE_B64:
 135     case BRIG_TYPE_U8X8:
 136     case BRIG_TYPE_U16X4:
 137     case BRIG_TYPE_U32X2:
 138     case BRIG_TYPE_S8X8:
 139     case BRIG_TYPE_S16X4:
 140     case BRIG_TYPE_S32X2:
 141     case BRIG_TYPE_F16X4:
 142     case BRIG_TYPE_F32X2:
 143     case BRIG_TYPE_SIG64:
 144       return 64;
 145
 146     case BRIG_TYPE_B128:
 147     case BRIG_TYPE_U8X16:
 148     case BRIG_TYPE_U16X8:
 149     case BRIG_TYPE_U32X4:
 150     case BRIG_TYPE_U64X2:
 151     case BRIG_TYPE_S8X16:
 152     case BRIG_TYPE_S16X8:
 153     case BRIG_TYPE_S32X4:
 154     case BRIG_TYPE_S64X2:
 155     case BRIG_TYPE_F16X8:
 156     case BRIG_TYPE_F32X4:
 157     case BRIG_TYPE_F64X2:
 158       return 128;
 159
 160     default:
 161       printf ("HMM %d %x\n", t, t);
 162       gcc_unreachable ();
 163     }
 164 }
 165
 166 /* gcc-hsa borrowed code ENDS.  */
 167
 168 uint64_t
 169 gccbrig_to_uint64_t (const BrigUInt64 &brig_type)
 170 {
 171   return (uint64_t (brig_type.hi) << 32) | uint64_t (brig_type.lo);
 172 }
 173
 174 int
 175 gccbrig_reg_size (const BrigOperandRegister *brig_reg)
 176 {
 177   switch (brig_reg->regKind)
 178     {
 179     case BRIG_REGISTER_KIND_CONTROL:
 180       return 1;
 181     case BRIG_REGISTER_KIND_SINGLE:
 182       return 32;
 183     case BRIG_REGISTER_KIND_DOUBLE:
 184       return 64;
 185     case BRIG_REGISTER_KIND_QUAD:
 186       return 128;
 187     default:
 188       gcc_unreachable ();
 189       break;
 190     }
 191 }
 192
 193 std::string
 194 gccbrig_reg_name (const BrigOperandRegister *reg)
 195 {
 196   std::ostringstream strstr;
 197   switch (reg->regKind)
 198     {
 199     case BRIG_REGISTER_KIND_CONTROL:
 200       strstr << 'c';
 201       break;
 202     case BRIG_REGISTER_KIND_SINGLE:
 203       strstr << 's';
 204       break;
 205     case BRIG_REGISTER_KIND_DOUBLE:
 206       strstr << 'd';
 207       break;
 208     case BRIG_REGISTER_KIND_QUAD:
 209       strstr << 'q';
 210       break;
 211     default:
 212       gcc_unreachable ();
 213       return "";
 214     }
 215   strstr << reg->regNum;
 216   return strstr.str ();
 217 }
 218
 219 std::string
 220 gccbrig_type_name (BrigType16_t type)
 221 {
 222   switch (type)
 223     {
 224     case BRIG_TYPE_U8:
 225       return "u8";
 226     case BRIG_TYPE_U16:
 227       return "u16";
 228     case BRIG_TYPE_U32:
 229       return "u32";
 230     case BRIG_TYPE_U64:
 231       return "u64";
 232     case BRIG_TYPE_S8:
 233       return "s8";
 234     case BRIG_TYPE_S16:
 235       return "s16";
 236     case BRIG_TYPE_S32:
 237       return "s32";
 238     case BRIG_TYPE_S64:
 239       return "s64";
 240     default:
 241       gcc_unreachable ();
 242       break;
 243     }
 244 }
 245
 246 std::string
 247 gccbrig_segment_name (BrigSegment8_t segment)
 248 {
 249   if (segment == BRIG_SEGMENT_GLOBAL)
 250     return "global";
 251   else if (segment == BRIG_SEGMENT_GROUP)
 252     return "group";
 253   else if (segment == BRIG_SEGMENT_PRIVATE)
 254     return "private";
 255   else
 256     gcc_unreachable ();
 257 }
 258
 259 bool
 260 gccbrig_is_float_type (BrigType16_t type)
 261 {
 262   return (type == BRIG_TYPE_F32 || type == BRIG_TYPE_F64
 263           || type == BRIG_TYPE_F16);
 264 }
 265
 266 BrigType16_t
 267 gccbrig_tree_type_to_hsa_type (tree tree_type)
 268 {
 269   if (INTEGRAL_TYPE_P (tree_type))
 270     {
 271       if (TYPE_UNSIGNED (tree_type))
 272         {
 273           switch (int_size_in_bytes (tree_type))
 274             {
 275             case 1:
 276               return BRIG_TYPE_U8;
 277             case 2:
 278               return BRIG_TYPE_U16;
 279             case 4:
 280               return BRIG_TYPE_U32;
 281             case 8:
 282               return BRIG_TYPE_U64;
 283             default:
 284               break;
 285             }
 286         }
 287       else
 288         {
 289           switch (int_size_in_bytes (tree_type))
 290             {
 291             case 1:
 292               return BRIG_TYPE_S8;
 293             case 2:
 294               return BRIG_TYPE_S16;
 295             case 4:
 296               return BRIG_TYPE_S32;
 297             case 8:
 298               return BRIG_TYPE_S64;
 299             default:
 300               break;
 301             }
 302         }
 303     }
 304   else if (VECTOR_TYPE_P (tree_type))
 305     {
 306       tree element_type = TREE_TYPE (tree_type);
 307       size_t element_size = int_size_in_bytes (element_type) * 8;
 308       BrigType16_t brig_element_type;
 309       switch (element_size)
 310         {
 311         case 8:
 312           brig_element_type
 313             = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U8 : BRIG_TYPE_S8;
 314           break;
 315         case 16:
 316           brig_element_type
 317             = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U16 : BRIG_TYPE_S16;
 318           break;
 319         case 32:
 320           brig_element_type
 321             = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U32 : BRIG_TYPE_S32;
 322           break;
 323         case 64:
 324           brig_element_type
 325             = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U64 : BRIG_TYPE_S64;
 326           break;
 327         default:
 328           gcc_unreachable ();
 329         }
 330
 331       BrigType16_t pack_type;
 332       switch (int_size_in_bytes (tree_type) * 8)
 333         {
 334         case 32:
 335           pack_type = BRIG_TYPE_PACK_32;
 336           break;
 337         case 64:
 338           pack_type = BRIG_TYPE_PACK_64;
 339           break;
 340         case 128:
 341           pack_type = BRIG_TYPE_PACK_128;
 342           break;
 343         default:
 344           gcc_unreachable ();
 345         }
 346       return brig_element_type | pack_type;
 347     }
 348   gcc_unreachable ();
 349 }
 350
 351 /* Returns true in case the operation is a "bit level" operation,
 352    that is, not having operand type depending semantical differences.  */
 353
 354 bool
 355 gccbrig_is_bit_operation (BrigOpcode16_t opcode)
 356 {
 357   return opcode == BRIG_OPCODE_CMOV || opcode == BRIG_OPCODE_SHUFFLE
 358          || opcode == BRIG_OPCODE_UNPACK || opcode == BRIG_OPCODE_UNPACKLO
 359          || opcode == BRIG_OPCODE_UNPACKHI || opcode == BRIG_OPCODE_ST
 360          || opcode == BRIG_OPCODE_PACK;
 361 }
 362
 363 /* The program scope definition can be left external within the
 364    kernel binary which means it must be defined by the host via
 365    HSA runtime.  For these we have special treatment:
 366    Create additional pointer indirection when accessing the variable
 367    value from kernel code through a generated pointer
 368    __gccbrig_ptr_variable_name.  The pointer value then can be set either
 369    within the kernel binary (in case of a later linked in definition)
 370    or from the host.  */
 371
 372 bool
 373 gccbrig_might_be_host_defined_var_p (const BrigDirectiveVariable *brigVar)
 374 {
 375   bool is_definition = brigVar->modifier & BRIG_VARIABLE_DEFINITION;
 376   return (brigVar->segment == BRIG_SEGMENT_GLOBAL
 377           || brigVar->segment == BRIG_SEGMENT_READONLY) && !is_definition
 378     && brigVar->linkage == BRIG_LINKAGE_PROGRAM
 379     && (brigVar->allocation == BRIG_ALLOCATION_PROGRAM
 380         || brigVar->allocation == BRIG_ALLOCATION_AGENT);
 381 }
 382
 383 /* Produce a GENERIC type for the given HSA/BRIG type.  Returns the element
 384    type in case of vector instructions.  */
 385
 386 tree
 387 gccbrig_tree_type_for_hsa_type (BrigType16_t brig_type)
 388 {
 389   tree tree_type = NULL_TREE;
 390
 391   if (hsa_type_packed_p (brig_type))
 392     {
 393       /* The element type is encoded in the bottom 5 bits.  */
 394       BrigType16_t inner_brig_type = brig_type & BRIG_TYPE_BASE_MASK;
 395
 396       unsigned full_size = gccbrig_hsa_type_bit_size (brig_type);
 397
 398       if (inner_brig_type == BRIG_TYPE_F16)
 399         return build_vector_type (gccbrig_tree_type_for_hsa_type (BRIG_TYPE_U16),
 400                                   full_size / 16);
 401
 402       tree inner_type = gccbrig_tree_type_for_hsa_type (inner_brig_type);
 403
 404       unsigned inner_size = gccbrig_hsa_type_bit_size (inner_brig_type);
 405       unsigned nunits = full_size / inner_size;
 406       tree_type = build_vector_type (inner_type, nunits);
 407     }
 408   else
 409     {
 410       switch (brig_type)
 411         {
 412         case BRIG_TYPE_NONE:
 413           tree_type = void_type_node;
 414           break;
 415         case BRIG_TYPE_B1:
 416           tree_type = boolean_type_node;
 417           break;
 418         case BRIG_TYPE_S8:
 419         case BRIG_TYPE_S16:
 420         case BRIG_TYPE_S32:
 421         case BRIG_TYPE_S64:
 422           /* Ensure a fixed width integer.  */
 423           tree_type
 424             = build_nonstandard_integer_type
 425             (gccbrig_hsa_type_bit_size (brig_type), false);
 426           break;
 427         case BRIG_TYPE_U8:
 428           return unsigned_char_type_node;
 429         case BRIG_TYPE_U16:
 430         case BRIG_TYPE_U32:
 431         case BRIG_TYPE_U64:
 432         case BRIG_TYPE_B8: /* Handle bit vectors as unsigned ints.  */
 433         case BRIG_TYPE_B16:
 434         case BRIG_TYPE_B32:
 435         case BRIG_TYPE_B64:
 436         case BRIG_TYPE_B128:
 437         case BRIG_TYPE_SIG32: /* Handle signals as integers for now.  */
 438         case BRIG_TYPE_SIG64:
 439           tree_type = build_nonstandard_integer_type
 440             (gccbrig_hsa_type_bit_size (brig_type), true);
 441           break;
 442         case BRIG_TYPE_F16:
 443           tree_type = uint16_type_node;
 444           break;
 445         case BRIG_TYPE_F32:
 446           /* TODO: make sure that the alignment of the float are at least as
 447              strict than mandated by HSA, and conform to IEEE (like mandated
 448              by HSA).  */
 449           tree_type = float_type_node;
 450           break;
 451         case BRIG_TYPE_F64:
 452           tree_type = double_type_node;
 453           break;
 454         case BRIG_TYPE_SAMP:
 455         case BRIG_TYPE_ROIMG:
 456         case BRIG_TYPE_WOIMG:
 457         case BRIG_TYPE_RWIMG:
 458           {
 459             /* Handle images and samplers as target-specific blobs of data
 460                that should be allocated earlier on from the runtime side.
 461                Create a void* that should be initialized to point to the blobs
 462                by the kernel launcher.  Images and samplers are accessed
 463                via builtins that take void* as the reference.  TODO: who and
 464                how these arrays should be initialized?  */
 465             tree void_ptr = build_pointer_type (void_type_node);
 466             return void_ptr;
 467           }
 468         default:
 469           gcc_unreachable ();
 470           break;
 471         }
 472     }
 473
 474   /* Drop const qualifiers.  */
 475   return tree_type;
 476 }
 477
 478 /* Calculates numeric identifier for the HSA register REG.
 479
 480    Returned value is bound to [0, BRIG_2_TREE_HSAIL_TOTAL_REG_COUNT].  */
 481
 482 size_t
 483 gccbrig_hsa_reg_id (const BrigOperandRegister &reg)
 484 {
 485   size_t offset = reg.regNum;
 486   switch (reg.regKind)
 487     {
 488     case BRIG_REGISTER_KIND_QUAD:
 489       offset
 490         += BRIG_2_TREE_HSAIL_D_REG_COUNT + BRIG_2_TREE_HSAIL_S_REG_COUNT
 491         + BRIG_2_TREE_HSAIL_C_REG_COUNT;
 492       break;
 493     case BRIG_REGISTER_KIND_DOUBLE:
 494       offset += BRIG_2_TREE_HSAIL_S_REG_COUNT + BRIG_2_TREE_HSAIL_C_REG_COUNT;
 495       break;
 496     case BRIG_REGISTER_KIND_SINGLE:
 497       offset += BRIG_2_TREE_HSAIL_C_REG_COUNT;
 498     case BRIG_REGISTER_KIND_CONTROL:
 499       break;
 500     default:
 501       gcc_unreachable ();
 502       break;
 503     }
 504   return offset;
 505 }
 506
 507 std::string
 508 gccbrig_hsa_reg_name_from_id (size_t reg_id)
 509 {
 510   char reg_name[32];
 511   long unsigned int reg_hash = (long unsigned int) reg_id;
 512   if (reg_hash < BRIG_2_TREE_HSAIL_C_REG_COUNT)
 513     {
 514       sprintf (reg_name, "$c%lu", reg_hash);
 515       return reg_name;
 516     }
 517
 518   reg_hash -= BRIG_2_TREE_HSAIL_C_REG_COUNT;
 519   if (reg_hash < BRIG_2_TREE_HSAIL_S_REG_COUNT)
 520     {
 521       sprintf (reg_name, "$s%lu", reg_hash);
 522       return reg_name;
 523     }
 524
 525   reg_hash -= BRIG_2_TREE_HSAIL_S_REG_COUNT;
 526   if (reg_hash < BRIG_2_TREE_HSAIL_D_REG_COUNT)
 527     {
 528       sprintf (reg_name, "$d%lu", reg_hash);
 529       return reg_name;
 530     }
 531
 532    reg_hash -= BRIG_2_TREE_HSAIL_D_REG_COUNT;
 533    if (reg_hash < BRIG_2_TREE_HSAIL_Q_REG_COUNT)
 534     {
 535       sprintf (reg_name, "$q%lu", reg_hash);
 536       return reg_name;
 537     }
 538
 539   gcc_unreachable ();
 540   return "$??";
 541 }
 542
 543 /* Prints statistics of register usage to stdout.  */
 544
 545 void
 546 gccbrig_print_reg_use_info (FILE *dump, const regs_use_index &info)
 547 {
 548   regs_use_index::const_iterator begin_it = info.begin ();
 549   regs_use_index::const_iterator end_it = info.end ();
 550   for (regs_use_index::const_iterator it = begin_it; it != end_it; it++)
 551     {
 552       std::string hsa_reg = gccbrig_hsa_reg_name_from_id (it->first);
 553       printf ("%s:\n", hsa_reg.c_str ());
 554       const reg_use_info &info = it->second;
 555       typedef std::vector<std::pair<tree, size_t> >::const_iterator reg_use_it;
 556       reg_use_it begin_it2 = info.m_type_refs.begin ();
 557       reg_use_it end_it2 = info.m_type_refs.end ();
 558       for (reg_use_it it2 = begin_it2; it2 != end_it2; it2++)
 559         {
 560           fprintf (dump, "(%lu) ", (long unsigned int) it2->second);
 561           print_node_brief (dump, "", it2->first, 0);
 562           fprintf (dump, "\n");
 563         }
 564     }
 565 }