1 /*
2 * Copyright © 2019 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 #include "compiler/nir/nir.h"
25 #include "compiler/nir/nir_builder.h"
26 #include "gl_nir.h"
27 #include "ir_uniform.h"
28
29 #include "util/compiler.h"
30 #include "main/mtypes.h"
31
32 static nir_ssa_def *
get_block_array_index(nir_builder * b,nir_deref_instr * deref,const struct gl_shader_program * shader_program)33 get_block_array_index(nir_builder *b, nir_deref_instr *deref,
34 const struct gl_shader_program *shader_program)
35 {
36 unsigned array_elements = 1;
37
38 /* Build a block name such as "block[2][0]" for finding in the list of
39 * blocks later on as well as an optional dynamic index which gets added
40 * to the block index later.
41 */
42 int binding = 0;
43 const char *block_name = "";
44 nir_ssa_def *nonconst_index = NULL;
45 while (deref->deref_type == nir_deref_type_array) {
46 nir_deref_instr *parent = nir_deref_instr_parent(deref);
47 assert(parent && glsl_type_is_array(parent->type));
48 unsigned arr_size = glsl_get_length(parent->type);
49
50 if (nir_src_is_const(deref->arr.index)) {
51 unsigned arr_index = nir_src_as_uint(deref->arr.index);
52
53 /* We're walking the deref from the tail so prepend the array index */
54 block_name = ralloc_asprintf(b->shader, "[%u]%s", arr_index,
55 block_name);
56
57 binding += arr_index * array_elements;
58 } else {
59 nir_ssa_def *arr_index = nir_ssa_for_src(b, deref->arr.index, 1);
60 arr_index = nir_umin(b, arr_index, nir_imm_int(b, arr_size - 1));
61 nir_ssa_def *arr_offset = nir_amul_imm(b, arr_index, array_elements);
62 if (nonconst_index)
63 nonconst_index = nir_iadd(b, nonconst_index, arr_offset);
64 else
65 nonconst_index = arr_offset;
66
67 /* We're walking the deref from the tail so prepend the array index */
68 block_name = ralloc_asprintf(b->shader, "[0]%s", block_name);
69 }
70
71 array_elements *= arr_size;
72 deref = parent;
73 }
74
75 assert(deref->deref_type == nir_deref_type_var);
76 binding += deref->var->data.binding;
77 block_name = ralloc_asprintf(b->shader, "%s%s",
78 glsl_get_type_name(deref->var->interface_type),
79 block_name);
80
81 struct gl_linked_shader *linked_shader =
82 shader_program->_LinkedShaders[b->shader->info.stage];
83
84 unsigned num_blocks;
85 struct gl_uniform_block **blocks;
86 if (nir_deref_mode_is(deref, nir_var_mem_ubo)) {
87 num_blocks = linked_shader->Program->info.num_ubos;
88 blocks = linked_shader->Program->sh.UniformBlocks;
89 } else {
90 assert(nir_deref_mode_is(deref, nir_var_mem_ssbo));
91 num_blocks = linked_shader->Program->info.num_ssbos;
92 blocks = linked_shader->Program->sh.ShaderStorageBlocks;
93 }
94
95 /* Block names are optional with ARB_gl_spirv so use the binding instead. */
96 bool use_bindings = shader_program->data->spirv;
97
98 for (unsigned i = 0; i < num_blocks; i++) {
99 if (( use_bindings && binding == blocks[i]->Binding) ||
100 (!use_bindings && strcmp(block_name, blocks[i]->Name) == 0)) {
101 if (nonconst_index)
102 return nir_iadd_imm(b, nonconst_index, i);
103 else
104 return nir_imm_int(b, i);
105 }
106 }
107
108 /* TODO: Investigate if we could change the code to assign Bindings to the
109 * blocks that were not explicitly assigned, so we can always compare
110 * bindings.
111 */
112
113 if (use_bindings)
114 unreachable("Failed to find the block by binding");
115 else
116 unreachable("Failed to find the block by name");
117 }
118
119 static void
get_block_index_offset(nir_variable * var,const struct gl_shader_program * shader_program,gl_shader_stage stage,unsigned * index,unsigned * offset)120 get_block_index_offset(nir_variable *var,
121 const struct gl_shader_program *shader_program,
122 gl_shader_stage stage,
123 unsigned *index, unsigned *offset)
124 {
125
126 struct gl_linked_shader *linked_shader =
127 shader_program->_LinkedShaders[stage];
128
129 unsigned num_blocks;
130 struct gl_uniform_block **blocks;
131 if (var->data.mode == nir_var_mem_ubo) {
132 num_blocks = linked_shader->Program->info.num_ubos;
133 blocks = linked_shader->Program->sh.UniformBlocks;
134 } else {
135 assert(var->data.mode == nir_var_mem_ssbo);
136 num_blocks = linked_shader->Program->info.num_ssbos;
137 blocks = linked_shader->Program->sh.ShaderStorageBlocks;
138 }
139
140 /* Block names are optional with ARB_gl_spirv so use the binding instead. */
141 bool use_bindings = shader_program->data->spirv;
142
143 for (unsigned i = 0; i < num_blocks; i++) {
144 const char *block_name = glsl_get_type_name(var->interface_type);
145 if (( use_bindings && blocks[i]->Binding == var->data.binding) ||
146 (!use_bindings && strcmp(block_name, blocks[i]->Name) == 0)) {
147 *index = i;
148 *offset = blocks[i]->Uniforms[var->data.location].Offset;
149 return;
150 }
151 }
152
153 if (use_bindings)
154 unreachable("Failed to find the block by binding");
155 else
156 unreachable("Failed to find the block by name");
157 }
158
159 static bool
lower_buffer_interface_derefs_impl(nir_function_impl * impl,const struct gl_shader_program * shader_program)160 lower_buffer_interface_derefs_impl(nir_function_impl *impl,
161 const struct gl_shader_program *shader_program)
162 {
163 bool progress = false;
164
165 nir_builder b;
166 nir_builder_init(&b, impl);
167
168 nir_foreach_block(block, impl) {
169 nir_foreach_instr_safe(instr, block) {
170 switch (instr->type) {
171 case nir_instr_type_deref: {
172 nir_deref_instr *deref = nir_instr_as_deref(instr);
173 if (!nir_deref_mode_is_one_of(deref, nir_var_mem_ubo |
174 nir_var_mem_ssbo))
175 break;
176
177 /* We use nir_address_format_32bit_index_offset */
178 assert(deref->dest.is_ssa);
179 assert(deref->dest.ssa.bit_size == 32);
180 deref->dest.ssa.num_components = 2;
181
182 progress = true;
183
184 b.cursor = nir_before_instr(&deref->instr);
185
186 unsigned offset = 0;
187 nir_ssa_def *ptr;
188 if (deref->deref_type == nir_deref_type_var &&
189 !glsl_type_is_interface(glsl_without_array(deref->var->type))) {
190 /* This variable is contained in an interface block rather than
191 * containing one. We need the block index and its offset
192 * inside that block
193 */
194 unsigned index;
195 get_block_index_offset(deref->var, shader_program,
196 b.shader->info.stage,
197 &index, &offset);
198 ptr = nir_imm_ivec2(&b, index, offset);
199 } else if (glsl_type_is_interface(deref->type)) {
200 /* This is the last deref before the block boundary.
201 * Everything after this point is a byte offset and will be
202 * handled by nir_lower_explicit_io().
203 */
204 nir_ssa_def *index = get_block_array_index(&b, deref,
205 shader_program);
206 ptr = nir_vec2(&b, index, nir_imm_int(&b, offset));
207 } else {
208 /* This will get handled by nir_lower_explicit_io(). */
209 break;
210 }
211
212 nir_deref_instr *cast = nir_build_deref_cast(&b, ptr, deref->modes,
213 deref->type, 0);
214 /* Set the alignment on the cast so that we get good alignment out
215 * of nir_lower_explicit_io. Our offset to the start of the UBO
216 * variable is always a constant, so we can use the maximum
217 * align_mul.
218 */
219 cast->cast.align_mul = NIR_ALIGN_MUL_MAX;
220 cast->cast.align_offset = offset % NIR_ALIGN_MUL_MAX;
221
222 nir_ssa_def_rewrite_uses(&deref->dest.ssa,
223 nir_src_for_ssa(&cast->dest.ssa));
224 nir_deref_instr_remove_if_unused(deref);
225 break;
226 }
227
228 case nir_instr_type_intrinsic: {
229 nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
230 switch (intrin->intrinsic) {
231 case nir_intrinsic_load_deref: {
232 nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
233 if (!nir_deref_mode_is_one_of(deref, nir_var_mem_ubo |
234 nir_var_mem_ssbo))
235 break;
236
237 /* UBO and SSBO Booleans are 32-bit integers where any non-zero
238 * value is considered true. NIR Booleans, on the other hand
239 * are 1-bit values until you get to a very late stage of the
240 * compilation process. We need to turn those 1-bit loads into
241 * a 32-bit load wrapped in an i2b to get a proper NIR boolean
242 * from the SSBO.
243 */
244 if (glsl_type_is_boolean(deref->type)) {
245 assert(intrin->dest.is_ssa);
246 b.cursor = nir_after_instr(&intrin->instr);
247 intrin->dest.ssa.bit_size = 32;
248 nir_ssa_def *bval = nir_i2b(&b, &intrin->dest.ssa);
249 nir_ssa_def_rewrite_uses_after(&intrin->dest.ssa,
250 nir_src_for_ssa(bval),
251 bval->parent_instr);
252 progress = true;
253 }
254 break;
255 }
256
257 case nir_intrinsic_store_deref: {
258 nir_deref_instr *deref = nir_src_as_deref(intrin->src[0]);
259 if (!nir_deref_mode_is_one_of(deref, nir_var_mem_ubo |
260 nir_var_mem_ssbo))
261 break;
262
263 /* SSBO Booleans are 32-bit integers where any non-zero value
264 * is considered true. NIR Booleans, on the other hand are
265 * 1-bit values until you get to a very late stage of the
266 * compilation process. We need to turn those 1-bit stores
267 * into a b2i32 followed by a 32-bit store. Technically the
268 * value we write doesn't have to be 0/1 so once Booleans are
269 * lowered to 32-bit values, we have an unneeded sanitation
270 * step but in practice it doesn't cost much.
271 */
272 if (glsl_type_is_boolean(deref->type)) {
273 assert(intrin->src[1].is_ssa);
274 b.cursor = nir_before_instr(&intrin->instr);
275 nir_ssa_def *ival = nir_b2i32(&b, intrin->src[1].ssa);
276 nir_instr_rewrite_src(&intrin->instr, &intrin->src[1],
277 nir_src_for_ssa(ival));
278 progress = true;
279 }
280 break;
281 }
282
283 case nir_intrinsic_copy_deref:
284 unreachable("copy_deref should be lowered by now");
285 break;
286
287 default:
288 /* Nothing to do */
289 break;
290 }
291 break;
292 }
293
294 default:
295 break; /* Nothing to do */
296 }
297 }
298 }
299
300 if (progress) {
301 nir_metadata_preserve(impl, nir_metadata_block_index |
302 nir_metadata_dominance);
303 }
304
305 return progress;
306 }
307
308 bool
gl_nir_lower_buffers(nir_shader * shader,const struct gl_shader_program * shader_program)309 gl_nir_lower_buffers(nir_shader *shader,
310 const struct gl_shader_program *shader_program)
311 {
312 bool progress = false;
313
314 /* First, we lower the derefs to turn block variable and array derefs into
315 * a nir_address_format_32bit_index_offset pointer. From there forward,
316 * we leave the derefs in place and let nir_lower_explicit_io handle them.
317 */
318 nir_foreach_function(function, shader) {
319 if (function->impl &&
320 lower_buffer_interface_derefs_impl(function->impl, shader_program))
321 progress = true;
322 }
323
324 /* If that did something, we validate and then call nir_lower_explicit_io
325 * to finish the process.
326 */
327 if (progress) {
328 nir_validate_shader(shader, "Lowering buffer interface derefs");
329 nir_lower_explicit_io(shader, nir_var_mem_ubo | nir_var_mem_ssbo,
330 nir_address_format_32bit_index_offset);
331 }
332
333 return progress;
334 }
335