• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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