gcc/ChangeLog:
2016-03-23 Martin Liska <mli...@suse.cz>
PR hsa/70391
* hsa-brig.c (emit_directive_variable): Emit alignment
according to hsa_symbol::m_align.
* hsa-dump.c (hsa_byte_alignment): Move the function to
another file.
(dump_hsa_symbol): Dump alignment of HSA symbols.
* hsa-gen.c (get_symbol_for_decl): Set-up alignment
of a symbol.
(gen_hsa_addr_with_align): New function.
(hsa_bitmemref_alignment): Use newly added function.
(gen_hsa_insns_for_load): Likewise.
(gen_hsa_insns_for_store): Likewise.
(gen_hsa_memory_copy): New argument added.
(gen_hsa_insns_for_single_assignment): Respect
alignment for assignments processed via
gen_hsa_memory_copy.
(gen_hsa_insns_for_direct_call): Likewise.
(gen_hsa_insns_for_return): Likewise.
(gen_function_def_parameters): Set default
alignment.
* hsa.c (hsa_object_alignment): New function.
(hsa_byte_alignment): Pasted function.
* hsa.h (hsa_symbol::m_align): New field.
---
gcc/hsa-brig.c | 5 +---
gcc/hsa-dump.c | 13 ++-------
gcc/hsa-gen.c | 88 +++++++++++++++++++++++++++++++++++++++++++++-------------
gcc/hsa.c | 20 +++++++++++++
gcc/hsa.h | 8 +++++-
5 files changed, 99 insertions(+), 35 deletions(-)
diff --git a/gcc/hsa-brig.c b/gcc/hsa-brig.c
index 9b6c0b8..ee587db 100644
--- a/gcc/hsa-brig.c
+++ b/gcc/hsa-brig.c
@@ -605,10 +605,7 @@ emit_directive_variable (struct hsa_symbol *symbol)
dirvar.init = 0;
dirvar.type = lendian16 (symbol->m_type);
dirvar.segment = symbol->m_segment;
- /* TODO: Once we are able to access global variables, we must copy their
- alignment. */
- dirvar.align = MAX (hsa_natural_alignment (dirvar.type),
- (BrigAlignment8_t) BRIG_ALIGNMENT_4);
+ dirvar.align = symbol->m_align;
dirvar.linkage = symbol->m_linkage;
dirvar.dim.lo = symbol->m_dim;
dirvar.dim.hi = symbol->m_dim >> 32;
diff --git a/gcc/hsa-dump.c b/gcc/hsa-dump.c
index b69b34d..d33ac4b 100644
--- a/gcc/hsa-dump.c
+++ b/gcc/hsa-dump.c
@@ -621,16 +621,6 @@ hsa_m_atomicop_name (enum BrigAtomicOperation op)
}
}
-/* Return byte alignment for given BrigAlignment8_t value. */
-
-static unsigned
-hsa_byte_alignment (BrigAlignment8_t alignment)
-{
- gcc_assert (alignment != BRIG_ALIGNMENT_NONE);
-
- return 1 << (alignment - 1);
-}
-
/* Dump textual representation of HSA IL register REG to file F. */
static void
@@ -716,7 +706,8 @@ dump_hsa_symbol (FILE *f, hsa_symbol *symbol)
name = buf;
}
- fprintf (f, "%s_%s %s", hsa_seg_name (symbol->m_segment),
+ fprintf (f, "align(%u) %s_%s %s", hsa_byte_alignment (symbol->m_align),
+ hsa_seg_name (symbol->m_segment),
hsa_type_name (symbol->m_type & ~BRIG_TYPE_ARRAY_MASK), name);
if (symbol->m_type & BRIG_TYPE_ARRAY_MASK)
diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c
index 72eecf9..db39813 100644
--- a/gcc/hsa-gen.c
+++ b/gcc/hsa-gen.c
@@ -169,12 +169,12 @@ hsa_symbol::hsa_symbol ()
hsa_symbol::hsa_symbol (BrigType16_t type, BrigSegment8_t segment,
BrigLinkage8_t linkage, bool global_scope_p,
- BrigAllocation allocation)
+ BrigAllocation allocation, BrigAlignment8_t align)
: m_decl (NULL_TREE), m_name (NULL), m_name_number (0),
m_directive_offset (0), m_type (type), m_segment (segment),
m_linkage (linkage), m_dim (0), m_cst_value (NULL),
m_global_scope_p (global_scope_p), m_seen_error (false),
- m_allocation (allocation), m_emitted_to_brig (false)
+ m_allocation (allocation), m_emitted_to_brig (false), m_align (align)
{
}
@@ -908,21 +908,29 @@ get_symbol_for_decl (tree decl)
{
hsa_symbol *sym;
gcc_assert (TREE_CODE (decl) == VAR_DECL);
+ BrigAlignment8_t align = hsa_object_alignment (decl);
if (is_in_global_vars)
{
sym = new hsa_symbol (BRIG_TYPE_NONE, BRIG_SEGMENT_GLOBAL,
BRIG_LINKAGE_PROGRAM, true,
- BRIG_ALLOCATION_PROGRAM);
+ BRIG_ALLOCATION_PROGRAM, align);
hsa_cfun->m_global_symbols.safe_push (sym);
}
else
{
+ /* As generation of memory copy instructions relies on alignment
+ greater or equal to 8 bytes, we need to increase alignment
+ of all aggregate types.. */
+ if (AGGREGATE_TYPE_P (TREE_TYPE (decl)))
+ align = MAX ((BrigAlignment8_t) BRIG_ALIGNMENT_8, align);
+
/* PARM_DECL and RESULT_DECL should be already in m_local_symbols. */
gcc_assert (TREE_CODE (decl) == VAR_DECL);
sym = new hsa_symbol (BRIG_TYPE_NONE, BRIG_SEGMENT_PRIVATE,
BRIG_LINKAGE_FUNCTION);
+ sym->m_align = align;
hsa_cfun->m_private_variables.safe_push (sym);
}
@@ -2192,6 +2200,30 @@ out:
return new hsa_op_address (symbol, reg, hwi_offset);
}
+/* Generate HSA address operand for a given tree memory reference REF. If
+ instructions need to be created to calculate the address, they will be added
+ to the end of HBB. OUTPUT_ALIGN is alignment of the created address. */
+
+static hsa_op_address *
+gen_hsa_addr_with_align (tree ref, hsa_bb *hbb, BrigAlignment8_t *output_align)
+{
+ hsa_op_address *addr = gen_hsa_addr (ref, hbb);
+ if (addr->m_reg || !addr->m_symbol)
+ *output_align = hsa_object_alignment (ref);
+ else
+ {
+ /* If the address consists only of a symbol and an offset, we
+ compute the alignment ourselves to take into account any alignment
+ promotions we might have done for the HSA symbol representation. */
+ unsigned align = hsa_byte_alignment (addr->m_symbol->m_align);
+ unsigned misalign = addr->m_imm_offset & (align - 1);
+ if (misalign)
+ align = (misalign & -misalign);
+ *output_align = hsa_alignment_encoding (BITS_PER_UNIT * align);
+ }
+ return addr;
+}
+
/* Generate HSA address for a function call argument of given TYPE.
INDEX is used to generate corresponding name of the arguments.
Special value -1 represents fact that result value is created. */
@@ -2398,7 +2430,7 @@ hsa_bitmemref_alignment (tree ref)
unsigned HOST_WIDE_INT bits = bit_offset % BITS_PER_UNIT;
unsigned HOST_WIDE_INT byte_bits = bit_offset - bits;
- BrigAlignment8_t base = hsa_alignment_encoding (get_object_alignment (ref));
+ BrigAlignment8_t base = hsa_object_alignment (ref);
if (byte_bits == 0)
return base;
return MIN (base, hsa_alignment_encoding (byte_bits & -byte_bits));
@@ -2537,7 +2569,7 @@ gen_hsa_insns_for_load (hsa_op_reg *dest, tree rhs, tree
type, hsa_bb *hbb)
false));
hsa_insn_mem *mem = new hsa_insn_mem (BRIG_OPCODE_LD, mtype, dest,
addr);
- mem->set_align (hsa_alignment_encoding (get_object_alignment (rhs)));
+ mem->set_align (hsa_object_alignment (rhs));
hbb->append_insn (mem);
}
}
@@ -2656,7 +2688,7 @@ gen_hsa_insns_for_store (tree lhs, hsa_op_base *src,
hsa_bb *hbb)
mtype = mem_type;
}
else
- req_align = hsa_alignment_encoding (get_object_alignment (lhs));
+ req_align = hsa_object_alignment (lhs);
hsa_insn_mem *mem = new hsa_insn_mem (BRIG_OPCODE_ST, mtype, src, addr);
mem->set_align (req_align);
@@ -2697,16 +2729,18 @@ gen_hsa_insns_for_store (tree lhs, hsa_op_base *src,
hsa_bb *hbb)
/* Generate memory copy instructions that are going to be used
for copying a HSA symbol SRC_SYMBOL (or SRC_REG) to TARGET memory,
- represented by pointer in a register. */
+ represented by pointer in a register. MIN_ALIGN is minimal alignment
+ of provided HSA addresses. */
static void
gen_hsa_memory_copy (hsa_bb *hbb, hsa_op_address *target, hsa_op_address *src,
- unsigned size)
+ unsigned size, BrigAlignment8_t min_align)
{
hsa_op_address *addr;
hsa_insn_mem *mem;
unsigned offset = 0;
+ unsigned min_byte_align = hsa_byte_alignment (min_align);
while (size)
{
@@ -2720,6 +2754,9 @@ gen_hsa_memory_copy (hsa_bb *hbb, hsa_op_address *target,
hsa_op_address *src,
else
s = 1;
+ if (s > min_byte_align)
+ s = min_byte_align;
+
BrigType16_t t = get_integer_type_by_bytes (s, false);
hsa_op_reg *tmp = new hsa_op_reg (t);
@@ -2837,16 +2874,21 @@ gen_hsa_insns_for_single_assignment (tree lhs, tree
rhs, hsa_bb *hbb)
}
else
{
- hsa_op_address *addr_lhs = gen_hsa_addr (lhs, hbb);
+ BrigAlignment8_t lhs_align;
+ hsa_op_address *addr_lhs = gen_hsa_addr_with_align (lhs, hbb,
+ &lhs_align);
if (TREE_CODE (rhs) == CONSTRUCTOR)
gen_hsa_ctor_assignment (addr_lhs, rhs, hbb);
else
{
- hsa_op_address *addr_rhs = gen_hsa_addr (rhs, hbb);
+ BrigAlignment8_t rhs_align;
+ hsa_op_address *addr_rhs = gen_hsa_addr_with_align (rhs, hbb,
+ &rhs_align);
unsigned size = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (rhs)));
- gen_hsa_memory_copy (hbb, addr_lhs, addr_rhs, size);
+ gen_hsa_memory_copy (hbb, addr_lhs, addr_rhs, size,
+ MIN (lhs_align, rhs_align));
}
}
}
@@ -3513,9 +3555,10 @@ gen_hsa_insns_for_direct_call (gimple *stmt, hsa_bb *hbb)
if (AGGREGATE_TYPE_P (TREE_TYPE (parm)))
{
addr = gen_hsa_addr_for_arg (TREE_TYPE (parm), i);
- hsa_op_address *src = gen_hsa_addr (parm, hbb);
+ BrigAlignment8_t align;
+ hsa_op_address *src = gen_hsa_addr_with_align (parm, hbb, &align);
gen_hsa_memory_copy (hbb, addr, src,
- addr->m_symbol->total_byte_size ());
+ addr->m_symbol->total_byte_size (), align);
}
else
{
@@ -3574,9 +3617,11 @@ gen_hsa_insns_for_direct_call (gimple *stmt, hsa_bb *hbb)
if (AGGREGATE_TYPE_P (lhs_type))
{
- hsa_op_address *result_addr = gen_hsa_addr (result, hbb);
+ BrigAlignment8_t align;
+ hsa_op_address *result_addr
+ = gen_hsa_addr_with_align (result, hbb, &align);
gen_hsa_memory_copy (hbb, result_addr, addr,
- addr->m_symbol->total_byte_size ());
+ addr->m_symbol->total_byte_size (), align);
}
else
{
@@ -3685,9 +3730,12 @@ gen_hsa_insns_for_return (greturn *stmt, hsa_bb *hbb)
if (AGGREGATE_TYPE_P (TREE_TYPE (retval)))
{
- hsa_op_address *retval_addr = gen_hsa_addr (retval, hbb);
+ BrigAlignment8_t align;
+ hsa_op_address *retval_addr = gen_hsa_addr_with_align (retval, hbb,
+ &align);
gen_hsa_memory_copy (hbb, addr, retval_addr,
- hsa_cfun->m_output_arg->total_byte_size ());
+ hsa_cfun->m_output_arg->total_byte_size (),
+ align);
}
else
{
@@ -5143,7 +5191,7 @@ gen_hsa_insns_for_call (gimple *stmt, hsa_bb *hbb)
hsa_op_address *dst_addr = get_address_from_value (dst, hbb);
hsa_op_address *src_addr = get_address_from_value (src, hbb);
- gen_hsa_memory_copy (hbb, dst_addr, src_addr, n);
+ gen_hsa_memory_copy (hbb, dst_addr, src_addr, n, BRIG_ALIGNMENT_1);
tree lhs = gimple_call_lhs (stmt);
if (lhs)
@@ -5597,9 +5645,11 @@ gen_function_def_parameters ()
private_arg = hsa_cfun->create_hsa_temporary (arg->m_type);
private_arg->fillup_for_decl (parm);
+ BrigAlignment8_t align = MIN (arg->m_align, private_arg->m_align);
+
hsa_op_address *private_arg_addr = new hsa_op_address (private_arg);
gen_hsa_memory_copy (prologue, private_arg_addr, parm_addr,
- arg->total_byte_size ());
+ arg->total_byte_size (), align);
}
else
private_arg = arg;
diff --git a/gcc/hsa.c b/gcc/hsa.c
index 9eacb59..ff97870 100644
--- a/gcc/hsa.c
+++ b/gcc/hsa.c
@@ -39,6 +39,7 @@ along with GCC; see the file COPYING3. If not see
#include "hsa.h"
#include "internal-fn.h"
#include "ctype.h"
+#include "builtins.h"
/* Structure containing intermediate HSA representation of the generated
function. */
@@ -570,6 +571,25 @@ hsa_alignment_encoding (unsigned n)
}
}
+/* Return HSA alignment encoding alignment of T got
+ by get_object_alignment. */
+
+BrigAlignment8_t
+hsa_object_alignment (tree t)
+{
+ return hsa_alignment_encoding (get_object_alignment (t));
+}
+
+/* Return byte alignment for given BrigAlignment8_t value. */
+
+unsigned
+hsa_byte_alignment (BrigAlignment8_t alignment)
+{
+ gcc_assert (alignment != BRIG_ALIGNMENT_NONE);
+
+ return 1 << (alignment - 1);
+}
+
/* Return natural alignment of HSA TYPE. */
BrigAlignment8_t
diff --git a/gcc/hsa.h b/gcc/hsa.h
index 1d6baab..ac692fb 100644
--- a/gcc/hsa.h
+++ b/gcc/hsa.h
@@ -60,7 +60,8 @@ struct hsa_symbol
/* Constructor. */
hsa_symbol (BrigType16_t type, BrigSegment8_t segment,
BrigLinkage8_t linkage, bool global_scope_p = false,
- BrigAllocation allocation = BRIG_ALLOCATION_AUTOMATIC);
+ BrigAllocation allocation = BRIG_ALLOCATION_AUTOMATIC,
+ BrigAlignment8_t align = BRIG_ALIGNMENT_8);
/* Return total size of the symbol. */
unsigned HOST_WIDE_INT total_byte_size ();
@@ -113,6 +114,9 @@ struct hsa_symbol
/* Flag used for global variables if a variable is already emitted or not.
*/
bool m_emitted_to_brig;
+ /* Alignment of the symbol. */
+ BrigAlignment8_t m_align;
+
private:
/* Default constructor. */
hsa_symbol ();
@@ -1347,6 +1351,8 @@ bool hsa_type_integer_p (BrigType16_t type);
bool hsa_btype_p (BrigType16_t type);
BrigAlignment8_t hsa_alignment_encoding (unsigned n);
BrigAlignment8_t hsa_natural_alignment (BrigType16_t type);
+BrigAlignment8_t hsa_object_alignment (tree t);
+unsigned hsa_byte_alignment (BrigAlignment8_t alignment);
void hsa_destroy_operand (hsa_op_base *op);
void hsa_destroy_insn (hsa_insn_basic *insn);
void hsa_add_kern_decl_mapping (tree decl, char *name, unsigned, bool);
--
2.7.1
