1 /*
2  * Copyright © 2018 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 DEALINGS
21  * IN THE SOFTWARE.
22  */
23 
24 #include "nir.h"
25 #include "gl_nir_linker.h"
26 #include "compiler/glsl/ir_uniform.h" /* for gl_uniform_storage */
27 #include "main/context.h"
28 #include "main/mtypes.h"
29 
30 struct set_opaque_binding_closure {
31    struct gl_shader_program *shader_prog;
32    struct gl_program *prog;
33    const nir_variable *var;
34    int binding;
35    int location;
36 };
37 
38 static void
set_opaque_binding(struct set_opaque_binding_closure * data,const struct glsl_type * type)39 set_opaque_binding(struct set_opaque_binding_closure *data,
40                    const struct glsl_type *type)
41 {
42    if (glsl_type_is_array(type) &&
43        glsl_type_is_array(glsl_get_array_element(type))) {
44       const struct glsl_type *element_type = glsl_get_array_element(type);
45 
46       for (unsigned int i = 0; i < glsl_get_length(type); i++)
47          set_opaque_binding(data, element_type);
48 
49       return;
50    }
51 
52    if (data->location < 0 ||
53        data->location >= data->prog->sh.data->NumUniformStorage)
54       return;
55 
56    struct gl_uniform_storage *storage =
57       data->prog->sh.data->UniformStorage + data->location++;
58 
59    const unsigned elements = MAX2(storage->array_elements, 1);
60 
61    for (unsigned int i = 0; i < elements; i++)
62       storage->storage[i].i = data->binding++;
63 
64    for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
65       struct gl_linked_shader *shader = data->shader_prog->_LinkedShaders[sh];
66 
67       if (!shader)
68          continue;
69       if (!storage->opaque[sh].active)
70          continue;
71 
72       if (glsl_type_is_sampler(storage->type)) {
73          for (unsigned i = 0; i < elements; i++) {
74             const unsigned index = storage->opaque[sh].index + i;
75 
76             if (storage->is_bindless) {
77                if (index >= shader->Program->sh.NumBindlessSamplers)
78                   break;
79                shader->Program->sh.BindlessSamplers[index].unit =
80                   storage->storage[i].i;
81                shader->Program->sh.BindlessSamplers[index].bound = true;
82                shader->Program->sh.HasBoundBindlessSampler = true;
83             } else {
84                if (index >= ARRAY_SIZE(shader->Program->SamplerUnits))
85                   break;
86                shader->Program->SamplerUnits[index] =
87                   storage->storage[i].i;
88             }
89          }
90       } else if (glsl_type_is_image(storage->type)) {
91          for (unsigned i = 0; i < elements; i++) {
92             const unsigned index = storage->opaque[sh].index + i;
93 
94             if (storage->is_bindless) {
95                if (index >= shader->Program->sh.NumBindlessImages)
96                   break;
97                shader->Program->sh.BindlessImages[index].unit =
98                   storage->storage[i].i;
99                shader->Program->sh.BindlessImages[index].bound = true;
100                shader->Program->sh.HasBoundBindlessImage = true;
101             } else {
102                if (index >= ARRAY_SIZE(shader->Program->sh.ImageUnits))
103                   break;
104                shader->Program->sh.ImageUnits[index] =
105                   storage->storage[i].i;
106             }
107          }
108       }
109    }
110 }
111 
112 static void
copy_constant_to_storage(union gl_constant_value * storage,const nir_constant * val,const struct glsl_type * type,unsigned int boolean_true)113 copy_constant_to_storage(union gl_constant_value *storage,
114                          const nir_constant *val,
115                          const struct glsl_type *type,
116                          unsigned int boolean_true)
117 {
118    const enum glsl_base_type base_type = glsl_get_base_type(type);
119    const unsigned n_columns = glsl_get_matrix_columns(type);
120    const unsigned n_rows = glsl_get_vector_elements(type);
121    unsigned dmul = glsl_base_type_is_64bit(base_type) ? 2 : 1;
122    int i = 0;
123 
124    if (n_columns > 1) {
125       const struct glsl_type *column_type = glsl_get_column_type(type);
126       for (unsigned int column = 0; column < n_columns; column++) {
127          copy_constant_to_storage(&storage[i], val->elements[column],
128                                   column_type, boolean_true);
129          i += n_rows * dmul;
130       }
131    } else {
132       for (unsigned int row = 0; row < n_rows; row++) {
133          switch (base_type) {
134          case GLSL_TYPE_UINT:
135             storage[i].u = val->values[row].u32;
136             break;
137          case GLSL_TYPE_INT:
138          case GLSL_TYPE_SAMPLER:
139             storage[i].i = val->values[row].i32;
140             break;
141          case GLSL_TYPE_FLOAT:
142             storage[i].f = val->values[row].f32;
143             break;
144          case GLSL_TYPE_DOUBLE:
145          case GLSL_TYPE_UINT64:
146          case GLSL_TYPE_INT64:
147             /* XXX need to check on big-endian */
148             memcpy(&storage[i].u, &val->values[row].f64, sizeof(double));
149             break;
150          case GLSL_TYPE_BOOL:
151             storage[i].b = val->values[row].u32 ? boolean_true : 0;
152             break;
153          case GLSL_TYPE_ARRAY:
154          case GLSL_TYPE_STRUCT:
155          case GLSL_TYPE_IMAGE:
156          case GLSL_TYPE_ATOMIC_UINT:
157          case GLSL_TYPE_INTERFACE:
158          case GLSL_TYPE_VOID:
159          case GLSL_TYPE_SUBROUTINE:
160          case GLSL_TYPE_FUNCTION:
161          case GLSL_TYPE_ERROR:
162          case GLSL_TYPE_UINT16:
163          case GLSL_TYPE_INT16:
164          case GLSL_TYPE_UINT8:
165          case GLSL_TYPE_INT8:
166          case GLSL_TYPE_FLOAT16:
167             /* All other types should have already been filtered by other
168              * paths in the caller.
169              */
170             assert(!"Should not get here.");
171             break;
172          }
173          i += dmul;
174       }
175    }
176 }
177 
178 struct set_uniform_initializer_closure {
179    struct gl_shader_program *shader_prog;
180    struct gl_program *prog;
181    const nir_variable *var;
182    int location;
183    unsigned int boolean_true;
184 };
185 
186 static void
set_uniform_initializer(struct set_uniform_initializer_closure * data,const struct glsl_type * type,const nir_constant * val)187 set_uniform_initializer(struct set_uniform_initializer_closure *data,
188                         const struct glsl_type *type,
189                         const nir_constant *val)
190 {
191    const struct glsl_type *t_without_array = glsl_without_array(type);
192 
193    if (glsl_type_is_struct_or_ifc(type)) {
194       for (unsigned int i = 0; i < glsl_get_length(type); i++) {
195          const struct glsl_type *field_type = glsl_get_struct_field(type, i);
196          set_uniform_initializer(data, field_type, val->elements[i]);
197       }
198       return;
199    }
200 
201    if (glsl_type_is_struct_or_ifc(t_without_array) ||
202        (glsl_type_is_array(type) &&
203         glsl_type_is_array(glsl_get_array_element(type)))) {
204       const struct glsl_type *element_type = glsl_get_array_element(type);
205 
206       for (unsigned int i = 0; i < glsl_get_length(type); i++)
207          set_uniform_initializer(data, element_type, val->elements[i]);
208 
209       return;
210    }
211 
212    if (data->location < 0 ||
213        data->location >= data->prog->sh.data->NumUniformStorage)
214       return;
215 
216    struct gl_uniform_storage *storage =
217       data->prog->sh.data->UniformStorage + data->location++;
218 
219    if (glsl_type_is_array(type)) {
220       const struct glsl_type *element_type = glsl_get_array_element(type);
221       const enum glsl_base_type base_type = glsl_get_base_type(element_type);
222       const unsigned int elements = glsl_get_components(element_type);
223       unsigned int idx = 0;
224       unsigned dmul = glsl_base_type_is_64bit(base_type) ? 2 : 1;
225 
226       assert(glsl_get_length(type) >= storage->array_elements);
227       for (unsigned int i = 0; i < storage->array_elements; i++) {
228          copy_constant_to_storage(&storage->storage[idx],
229                                   val->elements[i],
230                                   element_type,
231                                   data->boolean_true);
232 
233          idx += elements * dmul;
234       }
235    } else {
236       copy_constant_to_storage(storage->storage,
237                                val,
238                                type,
239                                data->boolean_true);
240 
241       if (glsl_type_is_sampler(storage->type)) {
242          for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
243             struct gl_linked_shader *shader =
244                data->shader_prog->_LinkedShaders[sh];
245 
246             if (shader && storage->opaque[sh].active) {
247                unsigned index = storage->opaque[sh].index;
248 
249                shader->Program->SamplerUnits[index] = storage->storage[0].i;
250             }
251          }
252       }
253    }
254 }
255 
256 void
gl_nir_set_uniform_initializers(struct gl_context * ctx,struct gl_shader_program * prog)257 gl_nir_set_uniform_initializers(struct gl_context *ctx,
258                                 struct gl_shader_program *prog)
259 {
260    for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
261       struct gl_linked_shader *sh = prog->_LinkedShaders[i];
262       if (!sh)
263          continue;
264 
265       nir_shader *nir = sh->Program->nir;
266       assert(nir);
267 
268       nir_foreach_gl_uniform_variable(var, nir) {
269          if (var->constant_initializer) {
270             struct set_uniform_initializer_closure data = {
271                .shader_prog = prog,
272                .prog = sh->Program,
273                .var = var,
274                .location = var->data.location,
275                .boolean_true = ctx->Const.UniformBooleanTrue
276             };
277             set_uniform_initializer(&data,
278                                     var->type,
279                                     var->constant_initializer);
280          } else if (var->data.explicit_binding) {
281 
282             if (nir_variable_is_in_block(var)) {
283                /* This case is handled by link_uniform_blocks */
284                continue;
285             }
286 
287             const struct glsl_type *without_array =
288                glsl_without_array(var->type);
289 
290             if (glsl_type_is_sampler(without_array) ||
291                 glsl_type_is_image(without_array)) {
292                struct set_opaque_binding_closure data = {
293                   .shader_prog = prog,
294                   .prog = sh->Program,
295                   .var = var,
296                   .binding = var->data.binding,
297                   .location = var->data.location
298                };
299                set_opaque_binding(&data, var->type);
300             }
301          }
302       }
303    }
304    memcpy(prog->data->UniformDataDefaults, prog->data->UniformDataSlots,
305           sizeof(union gl_constant_value) * prog->data->NumUniformDataSlots);
306 
307 }
308