return len;
}
-void
-hsa_op_immed::emit_to_buffer (tree value)
+char *
+hsa_op_immed::emit_to_buffer (unsigned *brig_repr_size)
{
- unsigned total_len = m_brig_repr_size;
-
- /* As we can have a constructor with fewer elements, fill the memory
- with zeros. */
- m_brig_repr = XCNEWVEC (char, total_len);
- char *p = m_brig_repr;
+ char *brig_repr;
+ *brig_repr_size = hsa_get_imm_brig_type_len (m_type);
- if (TREE_CODE (value) == VECTOR_CST)
+ if (m_tree_value != NULL_TREE)
{
- int i, num = VECTOR_CST_NELTS (value);
- for (i = 0; i < num; i++)
+ /* Update brig_repr_size for special tree values. */
+ if (TREE_CODE (m_tree_value) == STRING_CST)
+ *brig_repr_size = TREE_STRING_LENGTH (m_tree_value);
+ else if (TREE_CODE (m_tree_value) == CONSTRUCTOR)
+ *brig_repr_size
+ = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (m_tree_value)));
+
+ unsigned total_len = *brig_repr_size;
+
+ /* As we can have a constructor with fewer elements, fill the memory
+ with zeros. */
+ brig_repr = XCNEWVEC (char, total_len);
+ char *p = brig_repr;
+
+ if (TREE_CODE (m_tree_value) == VECTOR_CST)
{
+ int i, num = VECTOR_CST_NELTS (m_tree_value);
+ for (i = 0; i < num; i++)
+ {
+ tree v = VECTOR_CST_ELT (m_tree_value, i);
+ unsigned actual = emit_immediate_scalar_to_buffer (v, p, 0);
+ total_len -= actual;
+ p += actual;
+ }
+ /* Vectors should have the exact size. */
+ gcc_assert (total_len == 0);
+ }
+ else if (TREE_CODE (m_tree_value) == STRING_CST)
+ memcpy (brig_repr, TREE_STRING_POINTER (m_tree_value),
+ TREE_STRING_LENGTH (m_tree_value));
+ else if (TREE_CODE (m_tree_value) == COMPLEX_CST)
+ {
+ gcc_assert (total_len % 2 == 0);
unsigned actual;
actual
- = emit_immediate_scalar_to_buffer (VECTOR_CST_ELT (value, i), p, 0);
- total_len -= actual;
+ = emit_immediate_scalar_to_buffer (TREE_REALPART (m_tree_value), p,
+ total_len / 2);
+
+ gcc_assert (actual == total_len / 2);
p += actual;
+
+ actual
+ = emit_immediate_scalar_to_buffer (TREE_IMAGPART (m_tree_value), p,
+ total_len / 2);
+ gcc_assert (actual == total_len / 2);
}
- /* Vectors should have the exact size. */
- gcc_assert (total_len == 0);
- }
- else if (TREE_CODE (value) == STRING_CST)
- memcpy (m_brig_repr, TREE_STRING_POINTER (value),
- TREE_STRING_LENGTH (value));
- else if (TREE_CODE (value) == COMPLEX_CST)
- {
- gcc_assert (total_len % 2 == 0);
- unsigned actual;
- actual
- = emit_immediate_scalar_to_buffer (TREE_REALPART (value), p,
- total_len / 2);
-
- gcc_assert (actual == total_len / 2);
- p += actual;
-
- actual
- = emit_immediate_scalar_to_buffer (TREE_IMAGPART (value), p,
- total_len / 2);
- gcc_assert (actual == total_len / 2);
+ else if (TREE_CODE (m_tree_value) == CONSTRUCTOR)
+ {
+ unsigned len = vec_safe_length (CONSTRUCTOR_ELTS (m_tree_value));
+ for (unsigned i = 0; i < len; i++)
+ {
+ tree v = CONSTRUCTOR_ELT (m_tree_value, i)->value;
+ unsigned actual = emit_immediate_scalar_to_buffer (v, p, 0);
+ total_len -= actual;
+ p += actual;
+ }
+ }
+ else
+ emit_immediate_scalar_to_buffer (m_tree_value, p, total_len);
}
- else if (TREE_CODE (value) == CONSTRUCTOR)
+ else
{
- unsigned len = vec_safe_length (CONSTRUCTOR_ELTS (value));
- for (unsigned i = 0; i < len; i++)
+ hsa_bytes bytes;
+
+ switch (*brig_repr_size)
{
- tree v = CONSTRUCTOR_ELT (value, i)->value;
- unsigned actual = emit_immediate_scalar_to_buffer (v, p, 0);
- total_len -= actual;
- p += actual;
+ case 1:
+ bytes.b8 = (uint8_t) m_int_value;
+ break;
+ case 2:
+ bytes.b16 = (uint16_t) m_int_value;
+ break;
+ case 4:
+ bytes.b32 = (uint32_t) m_int_value;
+ break;
+ case 8:
+ bytes.b64 = (uint64_t) m_int_value;
+ break;
+ default:
+ gcc_unreachable ();
}
+
+ brig_repr = XNEWVEC (char, *brig_repr_size);
+ memcpy (brig_repr, &bytes, *brig_repr_size);
}
- else
- emit_immediate_scalar_to_buffer (value, p, total_len);
+
+ return brig_repr;
}
/* Emit an immediate BRIG operand IMM. The BRIG type of the immediate might
static void
emit_immediate_operand (hsa_op_immed *imm)
{
+ unsigned brig_repr_size;
+ char *brig_repr = imm->emit_to_buffer (&brig_repr_size);
struct BrigOperandConstantBytes out;
memset (&out, 0, sizeof (out));
out.base.byteCount = lendian16 (sizeof (out));
out.base.kind = lendian16 (BRIG_KIND_OPERAND_CONSTANT_BYTES);
- uint32_t byteCount = lendian32 (imm->m_brig_repr_size);
+ uint32_t byteCount = lendian32 (brig_repr_size);
out.type = lendian16 (imm->m_type);
out.bytes = lendian32 (brig_data.add (&byteCount, sizeof (byteCount)));
brig_operand.add (&out, sizeof (out));
- brig_data.add (imm->m_brig_repr, imm->m_brig_repr_size);
+ brig_data.add (brig_repr, brig_repr_size);
brig_data.round_size_up (4);
+
+ free (brig_repr);
}
/* Emit a register BRIG operand REG. */
hsa_op_immed::hsa_op_immed (tree tree_val, bool min32int)
: hsa_op_with_type (BRIG_KIND_OPERAND_CONSTANT_BYTES,
hsa_type_for_tree_type (TREE_TYPE (tree_val), NULL,
- min32int)),
- m_brig_repr (NULL)
+ min32int))
{
if (hsa_seen_error ())
return;
|| TREE_CODE (tree_val) == INTEGER_CST))
|| TREE_CODE (tree_val) == CONSTRUCTOR);
m_tree_value = tree_val;
- m_brig_repr_size = hsa_get_imm_brig_type_len (m_type);
- if (TREE_CODE (m_tree_value) == STRING_CST)
- m_brig_repr_size = TREE_STRING_LENGTH (m_tree_value);
- else if (TREE_CODE (m_tree_value) == CONSTRUCTOR)
- {
- m_brig_repr_size
- = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (m_tree_value)));
-
- /* Verify that all elements of a constructor are constants. */
- for (unsigned i = 0;
- i < vec_safe_length (CONSTRUCTOR_ELTS (m_tree_value)); i++)
- {
- tree v = CONSTRUCTOR_ELT (m_tree_value, i)->value;
- if (!CONSTANT_CLASS_P (v))
- {
- HSA_SORRY_AT (EXPR_LOCATION (tree_val),
- "HSA ctor should have only constants");
- return;
- }
- }
- }
-
- emit_to_buffer (m_tree_value);
+ /* Verify that all elements of a constructor are constants. */
+ if (TREE_CODE (m_tree_value) == CONSTRUCTOR)
+ for (unsigned i = 0;
+ i < vec_safe_length (CONSTRUCTOR_ELTS (m_tree_value)); i++)
+ {
+ tree v = CONSTRUCTOR_ELT (m_tree_value, i)->value;
+ if (!CONSTANT_CLASS_P (v))
+ {
+ HSA_SORRY_AT (EXPR_LOCATION (tree_val),
+ "HSA ctor should have only constants");
+ return;
+ }
+ }
}
/* Constructor of class representing HSA immediate values. INTEGER_VALUE is the
hsa_op_immed::hsa_op_immed (HOST_WIDE_INT integer_value, BrigType16_t type)
: hsa_op_with_type (BRIG_KIND_OPERAND_CONSTANT_BYTES, type),
- m_tree_value (NULL), m_brig_repr (NULL)
+ m_tree_value (NULL)
{
gcc_assert (hsa_type_integer_p (type));
m_int_value = integer_value;
- m_brig_repr_size = hsa_type_bit_size (type) / BITS_PER_UNIT;
-
- hsa_bytes bytes;
-
- switch (m_brig_repr_size)
- {
- case 1:
- bytes.b8 = (uint8_t) m_int_value;
- break;
- case 2:
- bytes.b16 = (uint16_t) m_int_value;
- break;
- case 4:
- bytes.b32 = (uint32_t) m_int_value;
- break;
- case 8:
- bytes.b64 = (uint64_t) m_int_value;
- break;
- default:
- gcc_unreachable ();
- }
-
- m_brig_repr = XNEWVEC (char, m_brig_repr_size);
- memcpy (m_brig_repr, &bytes, m_brig_repr_size);
}
hsa_op_immed::hsa_op_immed ()
- : hsa_op_with_type (BRIG_KIND_NONE, BRIG_TYPE_NONE), m_brig_repr (NULL)
+ : hsa_op_with_type (BRIG_KIND_NONE, BRIG_TYPE_NONE)
{
}
hsa_op_immed::~hsa_op_immed ()
{
- free (m_brig_repr);
}
/* Change type of the immediate value to T. */
projects / gcc.git / commitdiff