[thirdparty/gcc.git] / gcc / brig / brigfrontend / brig-util.cc

/* brig-util.cc -- gccbrig utility functions
   Copyright (C) 2016-2020 Free Software Foundation, Inc.
   Contributed by Pekka Jaaskelainen <pekka.jaaskelainen@parmance.com>
   for General Processor Tech.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include <sstream>

#include "stdint.h"
#include "hsa-brig-format.h"
#include "brig-util.h"
#include "errors.h"
#include "diagnostic-core.h"
#include "print-tree.h"

bool
group_variable_offset_index::has_variable (const std::string &name) const
{
  varname_offset_table::const_iterator i = m_group_offsets.find (name);
  return i != m_group_offsets.end ();
}

/* Adds a new group segment variable.  */

void
group_variable_offset_index::add (const std::string &name, size_t size,
				  size_t alignment)
{
  size_t align_padding = m_next_group_offset % alignment == 0 ?
    0 : (alignment - m_next_group_offset % alignment);
  m_next_group_offset += align_padding;
  m_group_offsets[name] = m_next_group_offset;
  m_next_group_offset += size;
}

size_t
group_variable_offset_index::segment_offset (const std::string &name) const
{
  varname_offset_table::const_iterator i = m_group_offsets.find (name);
  gcc_assert (i != m_group_offsets.end ());
  return (*i).second;
}

/* Return true if operand number OPNUM of instruction with OPCODE is an output.
   False if it is an input.  Some code reused from Martin Jambor's gcc-hsa
   tree.  */

bool
gccbrig_hsa_opcode_op_output_p (BrigOpcode16_t opcode, int opnum)
{
  switch (opcode)
    {
    case BRIG_OPCODE_BR:
    case BRIG_OPCODE_SBR:
    case BRIG_OPCODE_CBR:
    case BRIG_OPCODE_ST:
    case BRIG_OPCODE_ATOMICNORET:
    case BRIG_OPCODE_SIGNALNORET:
    case BRIG_OPCODE_INITFBAR:
    case BRIG_OPCODE_JOINFBAR:
    case BRIG_OPCODE_WAITFBAR:
    case BRIG_OPCODE_ARRIVEFBAR:
    case BRIG_OPCODE_LEAVEFBAR:
    case BRIG_OPCODE_RELEASEFBAR:
    case BRIG_OPCODE_DEBUGTRAP:
      return false;
    default:
      return opnum == 0;
    }
}

unsigned
gccbrig_hsa_type_bit_size (BrigType16_t t)
{

  unsigned pack_type = t & ~BRIG_TYPE_BASE_MASK;

  if (pack_type == BRIG_TYPE_PACK_32)
    return 32;
  else if (pack_type == BRIG_TYPE_PACK_64)
    return 64;
  else if (pack_type == BRIG_TYPE_PACK_128)
    return 128;

  switch (t)
    {
    case BRIG_TYPE_NONE:
      return 0;

    case BRIG_TYPE_B1:
      return 1;

    case BRIG_TYPE_U8:
    case BRIG_TYPE_S8:
    case BRIG_TYPE_B8:
      return 8;

    case BRIG_TYPE_U16:
    case BRIG_TYPE_S16:
    case BRIG_TYPE_B16:
    case BRIG_TYPE_F16:
      return 16;

    case BRIG_TYPE_U32:
    case BRIG_TYPE_S32:
    case BRIG_TYPE_B32:
    case BRIG_TYPE_F32:
    case BRIG_TYPE_U8X4:
    case BRIG_TYPE_U16X2:
    case BRIG_TYPE_S8X4:
    case BRIG_TYPE_S16X2:
    case BRIG_TYPE_F16X2:
    case BRIG_TYPE_SIG32:
      return 32;

    case BRIG_TYPE_U64:
    case BRIG_TYPE_S64:
    case BRIG_TYPE_F64:
    case BRIG_TYPE_B64:
    case BRIG_TYPE_U8X8:
    case BRIG_TYPE_U16X4:
    case BRIG_TYPE_U32X2:
    case BRIG_TYPE_S8X8:
    case BRIG_TYPE_S16X4:
    case BRIG_TYPE_S32X2:
    case BRIG_TYPE_F16X4:
    case BRIG_TYPE_F32X2:
    case BRIG_TYPE_SIG64:
      return 64;

    case BRIG_TYPE_B128:
    case BRIG_TYPE_U8X16:
    case BRIG_TYPE_U16X8:
    case BRIG_TYPE_U32X4:
    case BRIG_TYPE_U64X2:
    case BRIG_TYPE_S8X16:
    case BRIG_TYPE_S16X8:
    case BRIG_TYPE_S32X4:
    case BRIG_TYPE_S64X2:
    case BRIG_TYPE_F16X8:
    case BRIG_TYPE_F32X4:
    case BRIG_TYPE_F64X2:
      return 128;

    default:
      printf ("HMM %d %x\n", t, t);
      gcc_unreachable ();
    }
}

/* gcc-hsa borrowed code ENDS.  */

uint64_t
gccbrig_to_uint64_t (const BrigUInt64 &brig_type)
{
  return (uint64_t (brig_type.hi) << 32) | uint64_t (brig_type.lo);
}

int
gccbrig_reg_size (const BrigOperandRegister *brig_reg)
{
  switch (brig_reg->regKind)
    {
    case BRIG_REGISTER_KIND_CONTROL:
      return 1;
    case BRIG_REGISTER_KIND_SINGLE:
      return 32;
    case BRIG_REGISTER_KIND_DOUBLE:
      return 64;
    case BRIG_REGISTER_KIND_QUAD:
      return 128;
    default:
      gcc_unreachable ();
      break;
    }
}

std::string
gccbrig_reg_name (const BrigOperandRegister *reg)
{
  std::ostringstream strstr;
  switch (reg->regKind)
    {
    case BRIG_REGISTER_KIND_CONTROL:
      strstr << 'c';
      break;
    case BRIG_REGISTER_KIND_SINGLE:
      strstr << 's';
      break;
    case BRIG_REGISTER_KIND_DOUBLE:
      strstr << 'd';
      break;
    case BRIG_REGISTER_KIND_QUAD:
      strstr << 'q';
      break;
    default:
      gcc_unreachable ();
      return "";
    }
  strstr << reg->regNum;
  return strstr.str ();
}

std::string
gccbrig_type_name (BrigType16_t type)
{
  switch (type)
    {
    case BRIG_TYPE_U8:
      return "u8";
    case BRIG_TYPE_U16:
      return "u16";
    case BRIG_TYPE_U32:
      return "u32";
    case BRIG_TYPE_U64:
      return "u64";
    case BRIG_TYPE_S8:
      return "s8";
    case BRIG_TYPE_S16:
      return "s16";
    case BRIG_TYPE_S32:
      return "s32";
    case BRIG_TYPE_S64:
      return "s64";
    default:
      gcc_unreachable ();
      break;
    }
}

std::string
gccbrig_segment_name (BrigSegment8_t segment)
{
  if (segment == BRIG_SEGMENT_GLOBAL)
    return "global";
  else if (segment == BRIG_SEGMENT_GROUP)
    return "group";
  else if (segment == BRIG_SEGMENT_PRIVATE)
    return "private";
  else
    gcc_unreachable ();
}

bool
gccbrig_is_float_type (BrigType16_t type)
{
  return (type == BRIG_TYPE_F32 || type == BRIG_TYPE_F64
	  || type == BRIG_TYPE_F16);
}

BrigType16_t
gccbrig_tree_type_to_hsa_type (tree tree_type)
{
  if (INTEGRAL_TYPE_P (tree_type))
    {
      if (TYPE_UNSIGNED (tree_type))
	{
	  switch (int_size_in_bytes (tree_type))
	    {
	    case 1:
	      return BRIG_TYPE_U8;
	    case 2:
	      return BRIG_TYPE_U16;
	    case 4:
	      return BRIG_TYPE_U32;
	    case 8:
	      return BRIG_TYPE_U64;
	    default:
	      break;
	    }
	}
      else
	{
	  switch (int_size_in_bytes (tree_type))
	    {
	    case 1:
	      return BRIG_TYPE_S8;
	    case 2:
	      return BRIG_TYPE_S16;
	    case 4:
	      return BRIG_TYPE_S32;
	    case 8:
	      return BRIG_TYPE_S64;
	    default:
	      break;
	    }
	}
    }
  else if (VECTOR_TYPE_P (tree_type))
    {
      tree element_type = TREE_TYPE (tree_type);
      size_t element_size = int_size_in_bytes (element_type) * 8;
      BrigType16_t brig_element_type;
      switch (element_size)
	{
	case 8:
	  brig_element_type
	    = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U8 : BRIG_TYPE_S8;
	  break;
	case 16:
	  brig_element_type
	    = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U16 : BRIG_TYPE_S16;
	  break;
	case 32:
	  brig_element_type
	    = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U32 : BRIG_TYPE_S32;
	  break;
	case 64:
	  brig_element_type
	    = TYPE_UNSIGNED (element_type) ? BRIG_TYPE_U64 : BRIG_TYPE_S64;
	  break;
	default:
	  gcc_unreachable ();
	}

      BrigType16_t pack_type;
      switch (int_size_in_bytes (tree_type) * 8)
	{
	case 32:
	  pack_type = BRIG_TYPE_PACK_32;
	  break;
	case 64:
	  pack_type = BRIG_TYPE_PACK_64;
	  break;
	case 128:
	  pack_type = BRIG_TYPE_PACK_128;
	  break;
	default:
	  gcc_unreachable ();
	}
      return brig_element_type | pack_type;
    }
  gcc_unreachable ();
}

/* Returns true in case the operation is a "bit level" operation,
   that is, not having operand type depending semantical differences.  */

bool
gccbrig_is_bit_operation (BrigOpcode16_t opcode)
{
  return opcode == BRIG_OPCODE_CMOV || opcode == BRIG_OPCODE_SHUFFLE
	 || opcode == BRIG_OPCODE_UNPACK || opcode == BRIG_OPCODE_UNPACKLO
	 || opcode == BRIG_OPCODE_UNPACKHI || opcode == BRIG_OPCODE_ST
	 || opcode == BRIG_OPCODE_PACK;
}

/* The program scope definition can be left external within the
   kernel binary which means it must be defined by the host via
   HSA runtime.  For these we have special treatment:
   Create additional pointer indirection when accessing the variable
   value from kernel code through a generated pointer
   __gccbrig_ptr_variable_name.  The pointer value then can be set either
   within the kernel binary (in case of a later linked in definition)
   or from the host.  */

bool
gccbrig_might_be_host_defined_var_p (const BrigDirectiveVariable *brigVar)
{
  bool is_definition = brigVar->modifier & BRIG_VARIABLE_DEFINITION;
  return (brigVar->segment == BRIG_SEGMENT_GLOBAL
	  || brigVar->segment == BRIG_SEGMENT_READONLY) && !is_definition
    && brigVar->linkage == BRIG_LINKAGE_PROGRAM
    && (brigVar->allocation == BRIG_ALLOCATION_PROGRAM
	|| brigVar->allocation == BRIG_ALLOCATION_AGENT);
}

/* Produce a GENERIC type for the given HSA/BRIG type.  Returns the element
   type in case of vector instructions.  */

tree
gccbrig_tree_type_for_hsa_type (BrigType16_t brig_type)
{
  tree tree_type = NULL_TREE;

  if (hsa_type_packed_p (brig_type))
    {
      /* The element type is encoded in the bottom 5 bits.  */
      BrigType16_t inner_brig_type = brig_type & BRIG_TYPE_BASE_MASK;

      unsigned full_size = gccbrig_hsa_type_bit_size (brig_type);

      if (inner_brig_type == BRIG_TYPE_F16)
	return build_vector_type (gccbrig_tree_type_for_hsa_type (BRIG_TYPE_U16),
				  full_size / 16);

      tree inner_type = gccbrig_tree_type_for_hsa_type (inner_brig_type);

      unsigned inner_size = gccbrig_hsa_type_bit_size (inner_brig_type);
      unsigned nunits = full_size / inner_size;
      tree_type = build_vector_type (inner_type, nunits);
    }
  else
    {
      switch (brig_type)
	{
	case BRIG_TYPE_NONE:
	  tree_type = void_type_node;
	  break;
	case BRIG_TYPE_B1:
	  tree_type = boolean_type_node;
	  break;
	case BRIG_TYPE_S8:
	case BRIG_TYPE_S16:
	case BRIG_TYPE_S32:
	case BRIG_TYPE_S64:
	  /* Ensure a fixed width integer.  */
	  tree_type
	    = build_nonstandard_integer_type
	    (gccbrig_hsa_type_bit_size (brig_type), false);
	  break;
	case BRIG_TYPE_U8:
	  return unsigned_char_type_node;
	case BRIG_TYPE_U16:
	case BRIG_TYPE_U32:
	case BRIG_TYPE_U64:
	case BRIG_TYPE_B8: /* Handle bit vectors as unsigned ints.  */
	case BRIG_TYPE_B16:
	case BRIG_TYPE_B32:
	case BRIG_TYPE_B64:
	case BRIG_TYPE_B128:
	case BRIG_TYPE_SIG32: /* Handle signals as integers for now.  */
	case BRIG_TYPE_SIG64:
	  tree_type = build_nonstandard_integer_type
	    (gccbrig_hsa_type_bit_size (brig_type), true);
	  break;
	case BRIG_TYPE_F16:
	  tree_type = uint16_type_node;
	  break;
	case BRIG_TYPE_F32:
	  /* TODO: make sure that the alignment of the float are at least as
	     strict than mandated by HSA, and conform to IEEE (like mandated
	     by HSA).  */
	  tree_type = float_type_node;
	  break;
	case BRIG_TYPE_F64:
	  tree_type = double_type_node;
	  break;
	case BRIG_TYPE_SAMP:
	case BRIG_TYPE_ROIMG:
	case BRIG_TYPE_WOIMG:
	case BRIG_TYPE_RWIMG:
	  {
	    /* Handle images and samplers as target-specific blobs of data
	       that should be allocated earlier on from the runtime side.
	       Create a void* that should be initialized to point to the blobs
	       by the kernel launcher.  Images and samplers are accessed
	       via builtins that take void* as the reference.  TODO: who and
	       how these arrays should be initialized?  */
	    tree void_ptr = build_pointer_type (void_type_node);
	    return void_ptr;
	  }
	default:
	  gcc_unreachable ();
	  break;
	}
    }

  /* Drop const qualifiers.  */
  return tree_type;
}

/* Calculates numeric identifier for the HSA register REG.

   Returned value is bound to [0, BRIG_2_TREE_HSAIL_TOTAL_REG_COUNT].  */

size_t
gccbrig_hsa_reg_id (const BrigOperandRegister &reg)
{
  size_t offset = reg.regNum;
  switch (reg.regKind)
    {
    case BRIG_REGISTER_KIND_QUAD:
      offset
	+= BRIG_2_TREE_HSAIL_D_REG_COUNT + BRIG_2_TREE_HSAIL_S_REG_COUNT
	+ BRIG_2_TREE_HSAIL_C_REG_COUNT;
      break;
    case BRIG_REGISTER_KIND_DOUBLE:
      offset += BRIG_2_TREE_HSAIL_S_REG_COUNT + BRIG_2_TREE_HSAIL_C_REG_COUNT;
      break;
    case BRIG_REGISTER_KIND_SINGLE:
      offset += BRIG_2_TREE_HSAIL_C_REG_COUNT;
    case BRIG_REGISTER_KIND_CONTROL:
      break;
    default:
      gcc_unreachable ();
      break;
    }
  return offset;
}

std::string
gccbrig_hsa_reg_name_from_id (size_t reg_id)
{
  char reg_name[32];
  long unsigned int reg_hash = (long unsigned int) reg_id;
  if (reg_hash < BRIG_2_TREE_HSAIL_C_REG_COUNT)
    {
      sprintf (reg_name, "$c%lu", reg_hash);
      return reg_name;
    }

  reg_hash -= BRIG_2_TREE_HSAIL_C_REG_COUNT;
  if (reg_hash < BRIG_2_TREE_HSAIL_S_REG_COUNT)
    {
      sprintf (reg_name, "$s%lu", reg_hash);
      return reg_name;
    }

  reg_hash -= BRIG_2_TREE_HSAIL_S_REG_COUNT;
  if (reg_hash < BRIG_2_TREE_HSAIL_D_REG_COUNT)
    {
      sprintf (reg_name, "$d%lu", reg_hash);
      return reg_name;
    }

   reg_hash -= BRIG_2_TREE_HSAIL_D_REG_COUNT;
   if (reg_hash < BRIG_2_TREE_HSAIL_Q_REG_COUNT)
    {
      sprintf (reg_name, "$q%lu", reg_hash);
      return reg_name;
    }

  gcc_unreachable ();
  return "$??";
}

/* Prints statistics of register usage to stdout.  */

void
gccbrig_print_reg_use_info (FILE *dump, const regs_use_index &info)
{
  regs_use_index::const_iterator begin_it = info.begin ();
  regs_use_index::const_iterator end_it = info.end ();
  for (regs_use_index::const_iterator it = begin_it; it != end_it; it++)
    {
      std::string hsa_reg = gccbrig_hsa_reg_name_from_id (it->first);
      printf ("%s:\n", hsa_reg.c_str ());
      const reg_use_info &info = it->second;
      typedef std::vector<std::pair<tree, size_t> >::const_iterator reg_use_it;
      reg_use_it begin_it2 = info.m_type_refs.begin ();
      reg_use_it end_it2 = info.m_type_refs.end ();
      for (reg_use_it it2 = begin_it2; it2 != end_it2; it2++)
	{
	  fprintf (dump, "(%lu) ", (long unsigned int) it2->second);
	  print_node_brief (dump, "", it2->first, 0);
	  fprintf (dump, "\n");
	}
    }
}
Commit	Line	Data
5fd1486c	1	/* brig-util.cc -- gccbrig utility functions
8d9254fc	2	Copyright (C) 2016-2020 Free Software Foundation, Inc.
5fd1486c PJ	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"
dc03239c	29	#include "print-tree.h"
5fd1486c	30
d4b7f2ee PJ	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
5fd1486c PJ	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	}
dc03239c HL	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
610f66a3	508	gccbrig_hsa_reg_name_from_id (size_t reg_id)
dc03239c HL	509	{
dc03239c HL	510	char reg_name[32];
610f66a3	511	long unsigned int reg_hash = (long unsigned int) reg_id;
dc03239c HL	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	{
610f66a3	560	fprintf (dump, "(%lu) ", (long unsigned int) it2->second);
dc03239c HL	561	print_node_brief (dump, "", it2->first, 0);
	562	fprintf (dump, "\n");
	563	}
	564	}
	565	}