/* brig-variable-handler.cc -- brig variable directive handling Copyright (C) 2016-2020 Free Software Foundation, Inc. Contributed by Pekka Jaaskelainen 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 . */ #include "brig-code-entry-handler.h" #include "stringpool.h" #include "errors.h" #include "brig-machine.h" #include "brig-util.h" #include "print-tree.h" #include "diagnostic-core.h" #include "brig-to-generic.h" tree brig_directive_variable_handler::build_variable (const BrigDirectiveVariable *brigVar, tree_code var_decltype) { std::string var_name = m_parent.get_mangled_name (brigVar); bool is_definition = brigVar->modifier & BRIG_VARIABLE_DEFINITION; tree name_identifier = get_identifier (var_name.c_str ()); tree var_decl; tree t; if (brigVar->type & BRIG_TYPE_ARRAY) { tree element_type = gccbrig_tree_type_for_hsa_type (brigVar->type & ~BRIG_TYPE_ARRAY); uint64_t element_count = gccbrig_to_uint64_t (brigVar->dim); if (is_definition && element_count == 0) fatal_error (UNKNOWN_LOCATION, "Array definition with zero elements."); if (var_decltype == PARM_DECL) t = build_pointer_type (element_type); else t = build_array_type_nelts (element_type, element_count); } else { t = gccbrig_tree_type_for_hsa_type (brigVar->type); } size_t alignment = get_brig_var_alignment (brigVar); if (brigVar->segment == BRIG_SEGMENT_READONLY || brigVar->segment == BRIG_SEGMENT_KERNARG || (brigVar->modifier & BRIG_VARIABLE_CONST)) TYPE_READONLY (t) = 1; TYPE_ADDR_SPACE (t) = gccbrig_get_target_addr_space_id (brigVar->segment); var_decl = build_decl (UNKNOWN_LOCATION, var_decltype, name_identifier, t); SET_DECL_ALIGN (var_decl, alignment * BITS_PER_UNIT); /* Force the HSA alignments. */ DECL_USER_ALIGN (var_decl) = 1; TREE_USED (var_decl) = 1; TREE_PUBLIC (var_decl) = 1; if (is_definition) DECL_EXTERNAL (var_decl) = 0; else DECL_EXTERNAL (var_decl) = 1; /* The definition is elsewhere. */ if (brigVar->init != 0) { gcc_assert (brigVar->segment == BRIG_SEGMENT_READONLY || brigVar->segment == BRIG_SEGMENT_GLOBAL); const BrigBase *cst_operand_data = m_parent.get_brig_operand_entry (brigVar->init); tree initializer = NULL_TREE; if (cst_operand_data->kind == BRIG_KIND_OPERAND_CONSTANT_BYTES) initializer = get_tree_cst_for_hsa_operand ((const BrigOperandConstantBytes *) cst_operand_data, t); else error ("variable initializers of type %x not implemented", cst_operand_data->kind); gcc_assert (initializer != NULL_TREE); DECL_INITIAL (var_decl) = initializer; } if (var_decltype == PARM_DECL) { DECL_ARG_TYPE (var_decl) = TREE_TYPE (var_decl); DECL_EXTERNAL (var_decl) = 0; TREE_PUBLIC (var_decl) = 0; } TREE_ADDRESSABLE (var_decl) = 1; TREE_USED (var_decl) = 1; DECL_NONLOCAL (var_decl) = 1; DECL_ARTIFICIAL (var_decl) = 0; return var_decl; } size_t brig_directive_variable_handler::operator () (const BrigBase *base) { const BrigDirectiveVariable *brigVar = (const BrigDirectiveVariable *) base; bool is_definition = brigVar->modifier & BRIG_VARIABLE_DEFINITION; size_t var_size; tree var_type; if (brigVar->type & BRIG_TYPE_ARRAY) { tree element_type = gccbrig_tree_type_for_hsa_type (brigVar->type & ~BRIG_TYPE_ARRAY); uint64_t element_count = gccbrig_to_uint64_t (brigVar->dim); if (is_definition && element_count == 0) fatal_error (UNKNOWN_LOCATION, "Array definition with zero elements."); var_type = build_array_type_nelts (element_type, element_count); size_t element_size = tree_to_uhwi (TYPE_SIZE (element_type)); var_size = element_size * element_count / 8; } else { var_type = gccbrig_tree_type_for_hsa_type (brigVar->type); var_size = tree_to_uhwi (TYPE_SIZE (var_type)) / 8; } size_t alignment = get_brig_var_alignment (brigVar); bool function_scope = m_parent.m_cf != NULL; if (function_scope) m_parent.m_cf->m_function_scope_vars.insert (base); std::string var_name = m_parent.get_mangled_name (brigVar); if (brigVar->segment == BRIG_SEGMENT_GROUP) { /* Non-kernel scope group variables have been added at the 'analyze' stage. */ m_parent.add_group_variable (var_name, var_size, alignment, function_scope); return base->byteCount; } /* During analyze, handle only (module scope) group variables. */ if (m_parent.m_analyzing) return base->byteCount; if (brigVar->segment == BRIG_SEGMENT_KERNARG) { /* Do not create a real variable, but only a table of offsets to the kernarg segment buffer passed as the single argument by the kernel launcher for later reference. Ignore kernel declarations. */ if (m_parent.m_cf != NULL && m_parent.m_cf->m_func_decl != NULL_TREE) m_parent.m_cf->append_kernel_arg (brigVar, var_size, alignment); return base->byteCount; } else if (brigVar->segment == BRIG_SEGMENT_PRIVATE || brigVar->segment == BRIG_SEGMENT_SPILL) { /* Private variables are handled like group variables, except that their offsets are multiplied by the work-item flat id, when accessed. */ if (!m_parent.has_private_variable (var_name)) m_parent.append_private_variable (var_name, var_size, alignment); return base->byteCount; } else if (brigVar->segment == BRIG_SEGMENT_GLOBAL || brigVar->segment == BRIG_SEGMENT_READONLY) { tree def = is_definition ? NULL_TREE : m_parent.global_variable (var_name); if (!is_definition && def != NULL_TREE) { /* We have a definition already for this declaration. Use the definition instead of the declaration. */ } else if (gccbrig_might_be_host_defined_var_p (brigVar)) { tree var_decl = build_variable (brigVar); m_parent.add_host_def_var_ptr (var_name, var_decl); } else { tree var_decl = build_variable (brigVar); /* Make all global variables program scope for now so we can get their address from the Runtime API. */ DECL_CONTEXT (var_decl) = NULL_TREE; TREE_STATIC (var_decl) = 1; TREE_PUBLIC (var_decl) = 1; set_externally_visible (var_decl); m_parent.add_global_variable (var_name, var_decl); } } else if (brigVar->segment == BRIG_SEGMENT_ARG) { if (m_parent.m_cf->m_generating_arg_block) { tree var_decl = build_variable (brigVar); tree bind_expr = m_parent.m_cf->m_current_bind_expr; DECL_CONTEXT (var_decl) = m_parent.m_cf->m_func_decl; DECL_CHAIN (var_decl) = BIND_EXPR_VARS (bind_expr); BIND_EXPR_VARS (bind_expr) = var_decl; TREE_PUBLIC (var_decl) = 0; m_parent.m_cf->add_arg_variable (brigVar, var_decl); } else { /* Must be an incoming function argument which has been parsed in brig-function-handler.cc. No need to generate anything here. */ } } else gcc_unreachable (); return base->byteCount; } /* Returns the alignment for the given BRIG variable. In case the variable explicitly defines alignment and its larger than the natural alignment, returns it instead of the natural one. */ size_t brig_directive_variable_handler::get_brig_var_alignment (const BrigDirectiveVariable *brigVar) { size_t defined_alignment = brigVar->align == BRIG_ALIGNMENT_NONE ? 0 : 1 << (brigVar->align - 1); size_t natural_alignment; if (brigVar->type & BRIG_TYPE_ARRAY) { tree element_type = gccbrig_tree_type_for_hsa_type (brigVar->type & ~BRIG_TYPE_ARRAY); size_t element_size = tree_to_uhwi (TYPE_SIZE (element_type)); natural_alignment = element_size / BITS_PER_UNIT; } else { tree t = gccbrig_tree_type_for_hsa_type (brigVar->type); natural_alignment = tree_to_uhwi (TYPE_SIZE (t)) / BITS_PER_UNIT; } return natural_alignment > defined_alignment ? natural_alignment : defined_alignment; }