1 /* brig-branch-inst-handler.cc -- brig branch instruction handling
2 Copyright (C) 2016-2020 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 "brig-code-entry-handler.h"
23
24 #include "errors.h"
25 #include "brig-util.h"
26 #include "tree-pretty-print.h"
27 #include "print-tree.h"
28 #include "vec.h"
29 #include "fold-const.h"
30
31 size_t
operator ()(const BrigBase * base)32 brig_branch_inst_handler::operator () (const BrigBase *base)
33 {
34 const BrigInstBase *brig_inst
35 = (const BrigInstBase *) &((const BrigInstBasic *) base)->base;
36
37 if (brig_inst->opcode == BRIG_OPCODE_CALL)
38 {
39 const BrigData *operand_entries
40 = m_parent.get_brig_data_entry (brig_inst->operands);
41 tree func_ref = NULL_TREE;
42 vec<tree, va_gc> *out_args;
43 vec_alloc (out_args, 1);
44 vec<tree, va_gc> *in_args;
45 /* Ten elem initially, more reserved if needed. */
46 vec_alloc (in_args, 10);
47
48 size_t operand_count = operand_entries->byteCount / 4;
49 gcc_assert (operand_count < 4);
50
51 for (size_t i = 0; i < operand_count; ++i)
52 {
53 uint32_t operand_offset
54 = ((const uint32_t *) &operand_entries->bytes)[i];
55 const BrigBase *operand_data
56 = m_parent.get_brig_operand_entry (operand_offset);
57 if (i == 1)
58 {
59 gcc_assert (operand_data->kind == BRIG_KIND_OPERAND_CODE_REF);
60 func_ref = build_tree_operand (*brig_inst, *operand_data);
61 continue;
62 }
63 gcc_assert (operand_data->kind == BRIG_KIND_OPERAND_CODE_LIST);
64 const BrigOperandCodeList *codelist
65 = (const BrigOperandCodeList *) operand_data;
66 const BrigData *data
67 = m_parent.get_brig_data_entry (codelist->elements);
68
69 size_t bytes = data->byteCount;
70 const BrigOperandOffset32_t *operand_ptr
71 = (const BrigOperandOffset32_t *) data->bytes;
72
73 bool out_args_p = i == 0;
74
75 while (bytes > 0)
76 {
77 BrigOperandOffset32_t offset = *operand_ptr;
78 const BrigBase *code_element
79 = m_parent.get_brig_code_entry (offset);
80 gcc_assert (code_element->kind == BRIG_KIND_DIRECTIVE_VARIABLE);
81 const BrigDirectiveVariable *brig_var
82 = (const BrigDirectiveVariable *) code_element;
83 tree var = m_parent.m_cf->arg_variable (brig_var);
84
85 if (brig_var->type & BRIG_TYPE_ARRAY)
86 {
87 /* Array return values are passed as the first argument. */
88 out_args_p = false;
89 /* Pass pointer to the element zero and use its element zero
90 as the base address. */
91 tree etype = TREE_TYPE (TREE_TYPE (var));
92 tree ptype = build_pointer_type (etype);
93 tree element_zero
94 = build4 (ARRAY_REF, etype, var, integer_zero_node,
95 NULL_TREE, NULL_TREE);
96 var = build1 (ADDR_EXPR, ptype, element_zero);
97 }
98
99 gcc_assert (var != NULL_TREE);
100 vec_safe_push (out_args_p ? out_args : in_args, var);
101 ++operand_ptr;
102 bytes -= 4;
103 }
104 }
105
106 gcc_assert (func_ref != NULL_TREE);
107 gcc_assert (out_args->length () == 0 || out_args->length () == 1);
108
109 tree ret_val_type = void_type_node;
110 tree ret_val = NULL_TREE;
111 if (out_args->length () == 1)
112 {
113 ret_val = (*out_args)[0];
114 ret_val_type = TREE_TYPE (ret_val);
115 }
116
117 /* Pass the hidden kernel arguments along to the called functions as
118 they might call builtins that need them or access group/private
119 memory. */
120
121 tree group_local_offset
122 = m_parent.m_cf->add_temp_var ("group_local_offset",
123 build_int_cst
124 (uint32_type_node,
125 m_parent.m_cf->
126 m_local_group_variables.size()));
127
128 /* TODO: ensure the callee's frame is aligned! */
129
130 vec_safe_reserve (in_args, 4);
131 vec_safe_push (in_args, m_parent.m_cf->m_context_arg);
132 vec_safe_push (in_args, m_parent.m_cf->m_group_base_arg);
133 vec_safe_push (in_args, group_local_offset);
134 vec_safe_push (in_args, m_parent.m_cf->m_private_base_arg);
135
136 tree call = build_call_vec (ret_val_type, build_fold_addr_expr (func_ref),
137 in_args);
138 TREE_NOTHROW (func_ref) = 1;
139 TREE_NOTHROW (call) = 1;
140
141 if (ret_val != NULL_TREE)
142 {
143 TREE_ADDRESSABLE (ret_val) = 1;
144 tree result_assign
145 = build2 (MODIFY_EXPR, TREE_TYPE (ret_val), ret_val, call);
146 m_parent.m_cf->append_statement (result_assign);
147 }
148 else
149 {
150 m_parent.m_cf->append_statement (call);
151 }
152
153 m_parent.m_cf->m_called_functions.push_back (func_ref);
154 if (DECL_EXTERNAL (func_ref))
155 m_parent.add_decl_call (call);
156 m_parent.m_cf->start_new_bb ();
157
158 return base->byteCount;
159 }
160
161 tree instr_type = gccbrig_tree_type_for_hsa_type (brig_inst->type);
162 tree_stl_vec operands = build_operands (*brig_inst);
163
164 if (brig_inst->opcode == BRIG_OPCODE_BR)
165 {
166 tree goto_stmt = build1 (GOTO_EXPR, instr_type, operands[0]);
167 m_parent.m_cf->append_statement (goto_stmt);
168 }
169 else if (brig_inst->opcode == BRIG_OPCODE_SBR)
170 {
171 tree select = operands[0];
172 tree cases = operands[1];
173
174 tree switch_expr = build2 (SWITCH_EXPR, TREE_TYPE (select), select,
175 NULL_TREE);
176
177 tree default_case
178 = build_case_label (NULL_TREE, NULL_TREE,
179 create_artificial_label (UNKNOWN_LOCATION));
180 append_to_statement_list (default_case, &SWITCH_BODY (switch_expr));
181
182 tree default_jump
183 = build1 (GOTO_EXPR, void_type_node, TREE_VEC_ELT (cases, 0));
184 append_to_statement_list (default_jump, &SWITCH_BODY (switch_expr));
185
186 for (int c = 0; c < TREE_VEC_LENGTH (cases); ++c)
187 {
188 tree case_label
189 = build_case_label (build_int_cst (integer_type_node, c), NULL_TREE,
190 create_artificial_label (UNKNOWN_LOCATION));
191
192 append_to_statement_list (case_label, &SWITCH_BODY (switch_expr));
193
194 tree jump
195 = build1 (GOTO_EXPR, void_type_node, TREE_VEC_ELT (cases, c));
196 append_to_statement_list (jump, &SWITCH_BODY (switch_expr));
197 }
198 m_parent.m_cf->append_statement (switch_expr);
199 }
200 else if (brig_inst->opcode == BRIG_OPCODE_CBR)
201 {
202 tree condition = operands[0];
203 tree target_goto = build1 (GOTO_EXPR, void_type_node, operands[1]);
204 /* Represents the if..else as (condition)?(goto foo):(goto bar). */
205 tree if_stmt
206 = build3 (COND_EXPR, void_type_node, condition, target_goto, NULL_TREE);
207 m_parent.m_cf->append_statement (if_stmt);
208 }
209 else if (brig_inst->opcode == BRIG_OPCODE_WAVEBARRIER)
210 {
211 /* WAVEBARRIER is a NOP when WAVESIZE = 1. */
212 }
213 else if (brig_inst->opcode == BRIG_OPCODE_BARRIER)
214 {
215 m_parent.m_cf->m_has_barriers = true;
216 tree_stl_vec call_operands;
217 /* FIXME. We should add attributes (are there suitable ones in gcc?) that
218 ensure the barrier won't be duplicated or moved out of loops etc.
219 Like the 'noduplicate' of LLVM. Same goes for fbarriers. */
220 m_parent.m_cf->append_statement
221 (m_parent.m_cf->expand_or_call_builtin (brig_inst->opcode,
222 BRIG_TYPE_NONE, NULL_TREE,
223 call_operands));
224 }
225 else if (brig_inst->opcode >= BRIG_OPCODE_ARRIVEFBAR
226 && brig_inst->opcode <= BRIG_OPCODE_WAITFBAR)
227 {
228 m_parent.m_cf->m_has_barriers = true;
229 m_parent.m_cf->append_statement
230 (m_parent.m_cf->expand_or_call_builtin (brig_inst->opcode,
231 BRIG_TYPE_NONE,
232 uint32_type_node, operands));
233 }
234 else
235 gcc_unreachable ();
236 m_parent.m_cf->start_new_bb ();
237 return base->byteCount;
238 }
239