2 * Copyright © 2011 Intel Corporation
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:
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
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.
24 #include "main/core.h"
27 #include "ir_uniform.h"
28 #include "glsl_symbol_table.h"
30 #include "util/string_to_uint_map.h"
31 #include "ir_variable_refcount.h"
34 * \file link_uniforms.cpp
35 * Assign locations for GLSL uniforms.
37 * \author Ian Romanick <ian.d.romanick@intel.com>
41 * Used by linker to indicate uniforms that have no location set.
43 #define UNMAPPED_UNIFORM_LOC ~0u
46 * Count the backing storage requirements for a type
49 values_for_type(const glsl_type *type)
51 if (type->is_sampler()) {
53 } else if (type->is_array() && type->fields.array->is_sampler()) {
54 return type->array_size();
56 return type->component_slots();
61 program_resource_visitor::process(const glsl_type *type, const char *name)
63 assert(type->without_array()->is_record()
64 || type->without_array()->is_interface());
66 unsigned record_array_count = 1;
67 char *name_copy = ralloc_strdup(NULL, name);
68 enum glsl_interface_packing packing = type->get_interface_packing();
70 recursion(type, &name_copy, strlen(name), false, NULL, packing, false,
71 record_array_count, NULL);
72 ralloc_free(name_copy);
76 program_resource_visitor::process(ir_variable *var)
78 unsigned record_array_count = 1;
79 const bool row_major =
80 var->data.matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR;
82 const enum glsl_interface_packing packing = var->get_interface_type() ?
83 var->get_interface_type_packing() :
84 var->type->get_interface_packing();
87 var->data.from_named_ifc_block ? var->get_interface_type() : var->type;
88 const glsl_type *t_without_array = t->without_array();
90 /* false is always passed for the row_major parameter to the other
91 * processing functions because no information is available to do
92 * otherwise. See the warning in linker.h.
94 if (t_without_array->is_record() ||
95 (t->is_array() && t->fields.array->is_array())) {
96 char *name = ralloc_strdup(NULL, var->name);
97 recursion(var->type, &name, strlen(name), row_major, NULL, packing,
98 false, record_array_count, NULL);
100 } else if (t_without_array->is_interface()) {
101 char *name = ralloc_strdup(NULL, t_without_array->name);
102 const glsl_struct_field *ifc_member = var->data.from_named_ifc_block ?
104 fields.structure[t_without_array->field_index(var->name)] : NULL;
106 recursion(t, &name, strlen(name), row_major, NULL, packing,
107 false, record_array_count, ifc_member);
110 this->set_record_array_count(record_array_count);
111 this->visit_field(t, var->name, row_major, NULL, packing, false);
116 program_resource_visitor::recursion(const glsl_type *t, char **name,
117 size_t name_length, bool row_major,
118 const glsl_type *record_type,
119 const enum glsl_interface_packing packing,
121 unsigned record_array_count,
122 const glsl_struct_field *named_ifc_member)
124 /* Records need to have each field processed individually.
126 * Arrays of records need to have each array element processed
127 * individually, then each field of the resulting array elements processed
130 if (t->is_interface() && named_ifc_member) {
131 ralloc_asprintf_rewrite_tail(name, &name_length, ".%s",
132 named_ifc_member->name);
133 recursion(named_ifc_member->type, name, name_length, row_major, NULL,
134 packing, false, record_array_count, NULL);
135 } else if (t->is_record() || t->is_interface()) {
136 if (record_type == NULL && t->is_record())
140 this->enter_record(t, *name, row_major, packing);
142 for (unsigned i = 0; i < t->length; i++) {
143 const char *field = t->fields.structure[i].name;
144 size_t new_length = name_length;
146 if (t->fields.structure[i].type->is_record())
147 this->visit_field(&t->fields.structure[i]);
149 if (t->is_interface() && t->fields.structure[i].offset != -1)
150 this->set_buffer_offset(t->fields.structure[i].offset);
152 /* Append '.field' to the current variable name. */
153 if (name_length == 0) {
154 ralloc_asprintf_rewrite_tail(name, &new_length, "%s", field);
156 ralloc_asprintf_rewrite_tail(name, &new_length, ".%s", field);
159 /* The layout of structures at the top level of the block is set
160 * during parsing. For matrices contained in multiple levels of
161 * structures in the block, the inner structures have no layout.
162 * These cases must potentially inherit the layout from the outer
165 bool field_row_major = row_major;
166 const enum glsl_matrix_layout matrix_layout =
167 glsl_matrix_layout(t->fields.structure[i].matrix_layout);
168 if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
169 field_row_major = true;
170 } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
171 field_row_major = false;
174 recursion(t->fields.structure[i].type, name, new_length,
178 (i + 1) == t->length, record_array_count, NULL);
180 /* Only the first leaf-field of the record gets called with the
181 * record type pointer.
186 if (t->is_record()) {
187 (*name)[name_length] = '\0';
188 this->leave_record(t, *name, row_major, packing);
190 } else if (t->without_array()->is_record() ||
191 t->without_array()->is_interface() ||
192 (t->is_array() && t->fields.array->is_array())) {
193 if (record_type == NULL && t->fields.array->is_record())
194 record_type = t->fields.array;
196 unsigned length = t->length;
197 /* Shader storage block unsized arrays: add subscript [0] to variable
199 if (t->is_unsized_array())
202 record_array_count *= length;
204 for (unsigned i = 0; i < length; i++) {
205 size_t new_length = name_length;
207 /* Append the subscript to the current variable name */
208 ralloc_asprintf_rewrite_tail(name, &new_length, "[%u]", i);
210 recursion(t->fields.array, name, new_length, row_major,
213 (i + 1) == t->length, record_array_count,
216 /* Only the first leaf-field of the record gets called with the
217 * record type pointer.
222 this->set_record_array_count(record_array_count);
223 this->visit_field(t, *name, row_major, record_type, packing, last_field);
228 program_resource_visitor::visit_field(const glsl_struct_field *)
233 program_resource_visitor::enter_record(const glsl_type *, const char *, bool,
234 const enum glsl_interface_packing)
239 program_resource_visitor::leave_record(const glsl_type *, const char *, bool,
240 const enum glsl_interface_packing)
245 program_resource_visitor::set_buffer_offset(unsigned)
250 program_resource_visitor::set_record_array_count(unsigned)
257 * Class to help calculate the storage requirements for a set of uniforms
259 * As uniforms are added to the active set the number of active uniforms and
260 * the storage requirements for those uniforms are accumulated. The active
261 * uniforms are added to the hash table supplied to the constructor.
263 * If the same uniform is added multiple times (i.e., once for each shader
264 * target), it will only be accounted once.
266 class count_uniform_size : public program_resource_visitor {
268 count_uniform_size(struct string_to_uint_map *map,
269 struct string_to_uint_map *hidden_map)
270 : num_active_uniforms(0), num_hidden_uniforms(0), num_values(0),
271 num_shader_samplers(0), num_shader_images(0),
272 num_shader_uniform_components(0), num_shader_subroutines(0),
273 is_buffer_block(false), is_shader_storage(false), map(map),
274 hidden_map(hidden_map)
281 this->num_shader_samplers = 0;
282 this->num_shader_images = 0;
283 this->num_shader_uniform_components = 0;
284 this->num_shader_subroutines = 0;
287 void process(ir_variable *var)
289 this->current_var = var;
290 this->is_buffer_block = var->is_in_buffer_block();
291 this->is_shader_storage = var->is_in_shader_storage_block();
292 if (var->is_interface_instance())
293 program_resource_visitor::process(var->get_interface_type(),
294 var->get_interface_type()->name);
296 program_resource_visitor::process(var);
300 * Total number of active uniforms counted
302 unsigned num_active_uniforms;
304 unsigned num_hidden_uniforms;
307 * Number of data values required to back the storage for the active uniforms
312 * Number of samplers used
314 unsigned num_shader_samplers;
317 * Number of images used
319 unsigned num_shader_images;
322 * Number of uniforms used in the current shader
324 unsigned num_shader_uniform_components;
327 * Number of subroutine uniforms used
329 unsigned num_shader_subroutines;
331 bool is_buffer_block;
332 bool is_shader_storage;
334 struct string_to_uint_map *map;
337 virtual void visit_field(const glsl_type *type, const char *name,
338 bool /* row_major */,
339 const glsl_type * /* record_type */,
340 const enum glsl_interface_packing,
341 bool /* last_field */)
343 assert(!type->without_array()->is_record());
344 assert(!type->without_array()->is_interface());
345 assert(!(type->is_array() && type->fields.array->is_array()));
347 /* Count the number of samplers regardless of whether the uniform is
348 * already in the hash table. The hash table prevents adding the same
349 * uniform for multiple shader targets, but in this case we want to
350 * count it for each shader target.
352 const unsigned values = values_for_type(type);
353 if (type->contains_subroutine()) {
354 this->num_shader_subroutines += values;
355 } else if (type->contains_sampler()) {
356 this->num_shader_samplers += values;
357 } else if (type->contains_image()) {
358 this->num_shader_images += values;
360 /* As drivers are likely to represent image uniforms as
361 * scalar indices, count them against the limit of uniform
362 * components in the default block. The spec allows image
363 * uniforms to use up no more than one scalar slot.
365 if (!is_shader_storage)
366 this->num_shader_uniform_components += values;
368 /* Accumulate the total number of uniform slots used by this shader.
369 * Note that samplers do not count against this limit because they
370 * don't use any storage on current hardware.
372 if (!is_buffer_block)
373 this->num_shader_uniform_components += values;
376 /* If the uniform is already in the map, there's nothing more to do.
379 if (this->map->get(id, name))
382 if (this->current_var->data.how_declared == ir_var_hidden) {
383 this->hidden_map->put(this->num_hidden_uniforms, name);
384 this->num_hidden_uniforms++;
386 this->map->put(this->num_active_uniforms-this->num_hidden_uniforms,
390 /* Each leaf uniform occupies one entry in the list of active
393 this->num_active_uniforms++;
395 if(!is_gl_identifier(name) && !is_shader_storage && !is_buffer_block)
396 this->num_values += values;
399 struct string_to_uint_map *hidden_map;
402 * Current variable being processed.
404 ir_variable *current_var;
407 } /* anonymous namespace */
410 * Class to help parcel out pieces of backing storage to uniforms
412 * Each uniform processed has some range of the \c gl_constant_value
413 * structures associated with it. The association is done by finding
414 * the uniform in the \c string_to_uint_map and using the value from
415 * the map to connect that slot in the \c gl_uniform_storage table
416 * with the next available slot in the \c gl_constant_value array.
419 * This class assumes that every uniform that will be processed is
420 * already in the \c string_to_uint_map. In addition, it assumes that
421 * the \c gl_uniform_storage and \c gl_constant_value arrays are "big
424 class parcel_out_uniform_storage : public program_resource_visitor {
426 parcel_out_uniform_storage(struct gl_shader_program *prog,
427 struct string_to_uint_map *map,
428 struct gl_uniform_storage *uniforms,
429 union gl_constant_value *values)
430 : prog(prog), map(map), uniforms(uniforms), values(values)
434 void start_shader(gl_shader_stage shader_type)
436 assert(shader_type < MESA_SHADER_STAGES);
437 this->shader_type = shader_type;
439 this->shader_samplers_used = 0;
440 this->shader_shadow_samplers = 0;
441 this->next_sampler = 0;
442 this->next_image = 0;
443 this->next_subroutine = 0;
444 this->record_array_count = 1;
445 memset(this->targets, 0, sizeof(this->targets));
448 void set_and_process(ir_variable *var)
452 this->record_next_sampler = new string_to_uint_map;
454 buffer_block_index = -1;
455 if (var->is_in_buffer_block()) {
456 struct gl_uniform_block *blks = var->is_in_shader_storage_block() ?
457 prog->ShaderStorageBlocks : prog->UniformBlocks;
458 unsigned num_blks = var->is_in_shader_storage_block() ?
459 prog->NumShaderStorageBlocks : prog->NumUniformBlocks;
461 if (var->is_interface_instance() && var->type->is_array()) {
462 unsigned l = strlen(var->get_interface_type()->name);
464 for (unsigned i = 0; i < num_blks; i++) {
465 if (strncmp(var->get_interface_type()->name, blks[i].Name, l)
466 == 0 && blks[i].Name[l] == '[') {
467 buffer_block_index = i;
472 for (unsigned i = 0; i < num_blks; i++) {
473 if (strcmp(var->get_interface_type()->name, blks[i].Name) ==
475 buffer_block_index = i;
480 assert(buffer_block_index != -1);
482 /* Uniform blocks that were specified with an instance name must be
483 * handled a little bit differently. The name of the variable is the
484 * name used to reference the uniform block instead of being the name
485 * of a variable within the block. Therefore, searching for the name
486 * within the block will fail.
488 if (var->is_interface_instance()) {
490 process(var->get_interface_type(),
491 var->get_interface_type()->name);
493 const struct gl_uniform_block *const block =
494 &blks[buffer_block_index];
496 assert(var->data.location != -1);
498 const struct gl_uniform_buffer_variable *const ubo_var =
499 &block->Uniforms[var->data.location];
501 ubo_byte_offset = ubo_var->Offset;
505 /* Store any explicit location and reset data location so we can
506 * reuse this variable for storing the uniform slot number.
508 this->explicit_location = current_var->data.location;
509 current_var->data.location = -1;
513 delete this->record_next_sampler;
516 int buffer_block_index;
518 gl_shader_stage shader_type;
521 void handle_samplers(const glsl_type *base_type,
522 struct gl_uniform_storage *uniform, const char *name)
524 if (base_type->is_sampler()) {
525 uniform->opaque[shader_type].active = true;
527 /* Handle multiple samplers inside struct arrays */
528 if (this->record_array_count > 1) {
529 unsigned inner_array_size = MAX2(1, uniform->array_elements);
530 char *name_copy = ralloc_strdup(NULL, name);
532 /* Remove all array subscripts from the sampler name */
535 while((str_start = strchr(name_copy, '[')) &&
536 (str_end = strchr(name_copy, ']'))) {
537 memmove(str_start, str_end + 1, 1 + strlen(str_end));
541 if (this->record_next_sampler->get(index, name_copy)) {
542 /* In this case, we've already seen this uniform so we just use
543 * the next sampler index recorded the last time we visited.
545 uniform->opaque[shader_type].index = index;
546 index = inner_array_size + uniform->opaque[shader_type].index;
547 this->record_next_sampler->put(index, name_copy);
549 ralloc_free(name_copy);
550 /* Return as everything else has already been initialised in a
555 /* We've never seen this uniform before so we need to allocate
556 * enough indices to store it.
558 * Nested struct arrays behave like arrays of arrays so we need
559 * to increase the index by the total number of elements of the
560 * sampler in case there is more than one sampler inside the
561 * structs. This allows the offset to be easily calculated for
564 uniform->opaque[shader_type].index = this->next_sampler;
565 this->next_sampler +=
566 inner_array_size * this->record_array_count;
568 /* Store the next index for future passes over the struct array
570 index = uniform->opaque[shader_type].index + inner_array_size;
571 this->record_next_sampler->put(index, name_copy);
572 ralloc_free(name_copy);
575 /* Increment the sampler by 1 for non-arrays and by the number of
576 * array elements for arrays.
578 uniform->opaque[shader_type].index = this->next_sampler;
579 this->next_sampler += MAX2(1, uniform->array_elements);
582 const gl_texture_index target = base_type->sampler_index();
583 const unsigned shadow = base_type->sampler_shadow;
584 for (unsigned i = uniform->opaque[shader_type].index;
585 i < MIN2(this->next_sampler, MAX_SAMPLERS);
587 this->targets[i] = target;
588 this->shader_samplers_used |= 1U << i;
589 this->shader_shadow_samplers |= shadow << i;
594 void handle_images(const glsl_type *base_type,
595 struct gl_uniform_storage *uniform)
597 if (base_type->is_image()) {
598 uniform->opaque[shader_type].index = this->next_image;
599 uniform->opaque[shader_type].active = true;
601 /* Set image access qualifiers */
602 const GLenum access =
603 (current_var->data.image_read_only ? GL_READ_ONLY :
604 current_var->data.image_write_only ? GL_WRITE_ONLY :
607 const unsigned first = this->next_image;
609 /* Increment the image index by 1 for non-arrays and by the
610 * number of array elements for arrays.
612 this->next_image += MAX2(1, uniform->array_elements);
614 for (unsigned i = first; i < MIN2(next_image, MAX_IMAGE_UNIFORMS); i++)
615 prog->_LinkedShaders[shader_type]->ImageAccess[i] = access;
619 void handle_subroutines(const glsl_type *base_type,
620 struct gl_uniform_storage *uniform)
622 if (base_type->is_subroutine()) {
623 uniform->opaque[shader_type].index = this->next_subroutine;
624 uniform->opaque[shader_type].active = true;
626 /* Increment the subroutine index by 1 for non-arrays and by the
627 * number of array elements for arrays.
629 this->next_subroutine += MAX2(1, uniform->array_elements);
634 virtual void set_buffer_offset(unsigned offset)
636 this->ubo_byte_offset = offset;
639 virtual void set_record_array_count(unsigned record_array_count)
641 this->record_array_count = record_array_count;
644 virtual void enter_record(const glsl_type *type, const char *,
646 const enum glsl_interface_packing packing)
648 assert(type->is_record());
649 if (this->buffer_block_index == -1)
651 if (packing == GLSL_INTERFACE_PACKING_STD430)
652 this->ubo_byte_offset = glsl_align(
653 this->ubo_byte_offset, type->std430_base_alignment(row_major));
655 this->ubo_byte_offset = glsl_align(
656 this->ubo_byte_offset, type->std140_base_alignment(row_major));
659 virtual void leave_record(const glsl_type *type, const char *,
661 const enum glsl_interface_packing packing)
663 assert(type->is_record());
664 if (this->buffer_block_index == -1)
666 if (packing == GLSL_INTERFACE_PACKING_STD430)
667 this->ubo_byte_offset = glsl_align(
668 this->ubo_byte_offset, type->std430_base_alignment(row_major));
670 this->ubo_byte_offset = glsl_align(
671 this->ubo_byte_offset, type->std140_base_alignment(row_major));
674 virtual void visit_field(const glsl_type *type, const char *name,
675 bool row_major, const glsl_type * /* record_type */,
676 const enum glsl_interface_packing packing,
677 bool /* last_field */)
679 assert(!type->without_array()->is_record());
680 assert(!type->without_array()->is_interface());
681 assert(!(type->is_array() && type->fields.array->is_array()));
684 bool found = this->map->get(id, name);
690 const glsl_type *base_type;
691 if (type->is_array()) {
692 this->uniforms[id].array_elements = type->length;
693 base_type = type->fields.array;
695 this->uniforms[id].array_elements = 0;
699 /* Initialise opaque data */
700 this->uniforms[id].opaque[shader_type].index = ~0;
701 this->uniforms[id].opaque[shader_type].active = false;
703 /* This assigns uniform indices to sampler and image uniforms. */
704 handle_samplers(base_type, &this->uniforms[id], name);
705 handle_images(base_type, &this->uniforms[id]);
706 handle_subroutines(base_type, &this->uniforms[id]);
708 /* For array of arrays or struct arrays the base location may have
709 * already been set so don't set it again.
711 if (buffer_block_index == -1 && current_var->data.location == -1) {
712 current_var->data.location = id;
715 /* If there is already storage associated with this uniform or if the
716 * uniform is set as builtin, it means that it was set while processing
717 * an earlier shader stage. For example, we may be processing the
718 * uniform in the fragment shader, but the uniform was already processed
719 * in the vertex shader.
721 if (this->uniforms[id].storage != NULL || this->uniforms[id].builtin) {
725 /* Assign explicit locations. */
726 if (current_var->data.explicit_location) {
727 /* Set sequential locations for struct fields. */
728 if (current_var->type->without_array()->is_record() ||
729 current_var->type->is_array_of_arrays()) {
730 const unsigned entries = MAX2(1, this->uniforms[id].array_elements);
731 this->uniforms[id].remap_location =
732 this->explicit_location + field_counter;
733 field_counter += entries;
735 this->uniforms[id].remap_location = this->explicit_location;
738 /* Initialize to to indicate that no location is set */
739 this->uniforms[id].remap_location = UNMAPPED_UNIFORM_LOC;
742 this->uniforms[id].name = ralloc_strdup(this->uniforms, name);
743 this->uniforms[id].type = base_type;
744 this->uniforms[id].num_driver_storage = 0;
745 this->uniforms[id].driver_storage = NULL;
746 this->uniforms[id].atomic_buffer_index = -1;
747 this->uniforms[id].hidden =
748 current_var->data.how_declared == ir_var_hidden;
749 this->uniforms[id].builtin = is_gl_identifier(name);
751 this->uniforms[id].is_shader_storage =
752 current_var->is_in_shader_storage_block();
754 /* Do not assign storage if the uniform is a builtin or buffer object */
755 if (!this->uniforms[id].builtin &&
756 !this->uniforms[id].is_shader_storage &&
757 this->buffer_block_index == -1)
758 this->uniforms[id].storage = this->values;
760 if (this->buffer_block_index != -1) {
761 this->uniforms[id].block_index = this->buffer_block_index;
763 unsigned alignment = type->std140_base_alignment(row_major);
764 if (packing == GLSL_INTERFACE_PACKING_STD430)
765 alignment = type->std430_base_alignment(row_major);
766 this->ubo_byte_offset = glsl_align(this->ubo_byte_offset, alignment);
767 this->uniforms[id].offset = this->ubo_byte_offset;
768 if (packing == GLSL_INTERFACE_PACKING_STD430)
769 this->ubo_byte_offset += type->std430_size(row_major);
771 this->ubo_byte_offset += type->std140_size(row_major);
773 if (type->is_array()) {
774 if (packing == GLSL_INTERFACE_PACKING_STD430)
775 this->uniforms[id].array_stride =
776 type->without_array()->std430_array_stride(row_major);
778 this->uniforms[id].array_stride =
779 glsl_align(type->without_array()->std140_size(row_major),
782 this->uniforms[id].array_stride = 0;
785 if (type->without_array()->is_matrix()) {
786 const glsl_type *matrix = type->without_array();
787 const unsigned N = matrix->base_type == GLSL_TYPE_DOUBLE ? 8 : 4;
788 const unsigned items =
789 row_major ? matrix->matrix_columns : matrix->vector_elements;
792 if (packing == GLSL_INTERFACE_PACKING_STD430)
793 this->uniforms[id].matrix_stride = items < 3 ? items * N :
794 glsl_align(items * N, 16);
796 this->uniforms[id].matrix_stride = glsl_align(items * N, 16);
797 this->uniforms[id].row_major = row_major;
799 this->uniforms[id].matrix_stride = 0;
800 this->uniforms[id].row_major = false;
803 this->uniforms[id].block_index = -1;
804 this->uniforms[id].offset = -1;
805 this->uniforms[id].array_stride = -1;
806 this->uniforms[id].matrix_stride = -1;
807 this->uniforms[id].row_major = false;
810 if (!this->uniforms[id].builtin &&
811 !this->uniforms[id].is_shader_storage &&
812 this->buffer_block_index == -1)
813 this->values += values_for_type(type);
817 * Current program being processed.
819 struct gl_shader_program *prog;
821 struct string_to_uint_map *map;
823 struct gl_uniform_storage *uniforms;
824 unsigned next_sampler;
826 unsigned next_subroutine;
829 * Field counter is used to take care that uniform structures
830 * with explicit locations get sequential locations.
832 unsigned field_counter;
835 * Current variable being processed.
837 ir_variable *current_var;
839 /* Used to store the explicit location from current_var so that we can
840 * reuse the location field for storing the uniform slot id.
842 int explicit_location;
844 /* Stores total struct array elements including nested structs */
845 unsigned record_array_count;
847 /* Map for temporarily storing next sampler index when handling samplers in
850 struct string_to_uint_map *record_next_sampler;
853 union gl_constant_value *values;
855 gl_texture_index targets[MAX_SAMPLERS];
858 * Mask of samplers used by the current shader stage.
860 unsigned shader_samplers_used;
863 * Mask of samplers used by the current shader stage for shadows.
865 unsigned shader_shadow_samplers;
869 variable_is_referenced(ir_variable_refcount_visitor &v, ir_variable *var)
871 ir_variable_refcount_entry *const entry = v.get_variable_entry(var);
873 return entry->referenced_count > 0;
878 * Walks the IR and update the references to uniform blocks in the
879 * ir_variables to point at linked shader's list (previously, they
880 * would point at the uniform block list in one of the pre-linked
884 link_update_uniform_buffer_variables(struct gl_linked_shader *shader,
887 ir_variable_refcount_visitor v;
891 foreach_in_list(ir_instruction, node, shader->ir) {
892 ir_variable *const var = node->as_variable();
894 if (var == NULL || !var->is_in_buffer_block())
897 assert(var->data.mode == ir_var_uniform ||
898 var->data.mode == ir_var_shader_storage);
900 unsigned num_blocks = var->data.mode == ir_var_uniform ?
901 shader->NumUniformBlocks : shader->NumShaderStorageBlocks;
902 struct gl_uniform_block **blks = var->data.mode == ir_var_uniform ?
903 shader->UniformBlocks : shader->ShaderStorageBlocks;
905 if (var->is_interface_instance()) {
906 if (variable_is_referenced(v, var)) {
907 /* Since this is an interface instance, the instance type will be
908 * same as the array-stripped variable type. If the variable type
909 * is an array, then the block names will be suffixed with [0]
910 * through [n-1]. Unlike for non-interface instances, there will
911 * not be structure types here, so the only name sentinel that we
912 * have to worry about is [.
914 assert(var->type->without_array() == var->get_interface_type());
915 const char sentinel = var->type->is_array() ? '[' : '\0';
917 const ptrdiff_t len = strlen(var->get_interface_type()->name);
918 for (unsigned i = 0; i < num_blocks; i++) {
919 const char *const begin = blks[i]->Name;
920 const char *const end = strchr(begin, sentinel);
925 if (len != (end - begin))
928 /* Even when a match is found, do not "break" here. This could
929 * be an array of instances, and all elements of the array need
930 * to be marked as referenced.
932 if (strncmp(begin, var->get_interface_type()->name, len) == 0) {
933 blks[i]->stageref |= 1U << stage;
938 var->data.location = 0;
943 char sentinel = '\0';
945 if (var->type->is_record()) {
947 } else if (var->type->is_array() && (var->type->fields.array->is_array()
948 || var->type->without_array()->is_record())) {
952 const unsigned l = strlen(var->name);
953 for (unsigned i = 0; i < num_blocks; i++) {
954 for (unsigned j = 0; j < blks[i]->NumUniforms; j++) {
956 const char *begin = blks[i]->Uniforms[j].Name;
957 const char *end = strchr(begin, sentinel);
962 if ((ptrdiff_t) l != (end - begin))
965 found = strncmp(var->name, begin, l) == 0;
967 found = strcmp(var->name, blks[i]->Uniforms[j].Name) == 0;
971 var->data.location = j;
973 if (variable_is_referenced(v, var))
974 blks[i]->stageref |= 1U << stage;
988 * Combine the hidden uniform hash map with the uniform hash map so that the
989 * hidden uniforms will be given indicies at the end of the uniform storage
993 assign_hidden_uniform_slot_id(const char *name, unsigned hidden_id,
996 count_uniform_size *uniform_size = (count_uniform_size *) closure;
997 unsigned hidden_uniform_start = uniform_size->num_active_uniforms -
998 uniform_size->num_hidden_uniforms;
1000 uniform_size->map->put(hidden_uniform_start + hidden_id, name);
1004 * Search through the list of empty blocks to find one that fits the current
1008 find_empty_block(struct gl_shader_program *prog,
1009 struct gl_uniform_storage *uniform)
1011 const unsigned entries = MAX2(1, uniform->array_elements);
1013 foreach_list_typed(struct empty_uniform_block, block, link,
1014 &prog->EmptyUniformLocations) {
1015 /* Found a block with enough slots to fit the uniform */
1016 if (block->slots == entries) {
1017 unsigned start = block->start;
1018 exec_node_remove(&block->link);
1022 /* Found a block with more slots than needed. It can still be used. */
1023 } else if (block->slots > entries) {
1024 unsigned start = block->start;
1025 block->start += entries;
1026 block->slots -= entries;
1036 link_setup_uniform_remap_tables(struct gl_context *ctx,
1037 struct gl_shader_program *prog,
1038 unsigned num_explicit_uniform_locs)
1040 unsigned total_entries = num_explicit_uniform_locs;
1041 unsigned empty_locs =
1042 prog->NumUniformRemapTable - num_explicit_uniform_locs;
1044 /* Reserve all the explicit locations of the active uniforms. */
1045 for (unsigned i = 0; i < prog->NumUniformStorage; i++) {
1046 if (prog->UniformStorage[i].type->is_subroutine() ||
1047 prog->UniformStorage[i].is_shader_storage)
1050 if (prog->UniformStorage[i].remap_location != UNMAPPED_UNIFORM_LOC) {
1051 /* How many new entries for this uniform? */
1052 const unsigned entries =
1053 MAX2(1, prog->UniformStorage[i].array_elements);
1055 /* Set remap table entries point to correct gl_uniform_storage. */
1056 for (unsigned j = 0; j < entries; j++) {
1057 unsigned element_loc = prog->UniformStorage[i].remap_location + j;
1058 assert(prog->UniformRemapTable[element_loc] ==
1059 INACTIVE_UNIFORM_EXPLICIT_LOCATION);
1060 prog->UniformRemapTable[element_loc] = &prog->UniformStorage[i];
1065 /* Reserve locations for rest of the uniforms. */
1066 for (unsigned i = 0; i < prog->NumUniformStorage; i++) {
1068 if (prog->UniformStorage[i].type->is_subroutine() ||
1069 prog->UniformStorage[i].is_shader_storage)
1072 /* Built-in uniforms should not get any location. */
1073 if (prog->UniformStorage[i].builtin)
1076 /* Explicit ones have been set already. */
1077 if (prog->UniformStorage[i].remap_location != UNMAPPED_UNIFORM_LOC)
1080 /* how many new entries for this uniform? */
1081 const unsigned entries = MAX2(1, prog->UniformStorage[i].array_elements);
1083 /* Find UniformRemapTable for empty blocks where we can fit this uniform. */
1084 int chosen_location = -1;
1087 chosen_location = find_empty_block(prog, &prog->UniformStorage[i]);
1089 /* Add new entries to the total amount of entries. */
1090 total_entries += entries;
1092 if (chosen_location != -1) {
1093 empty_locs -= entries;
1095 chosen_location = prog->NumUniformRemapTable;
1097 /* resize remap table to fit new entries */
1098 prog->UniformRemapTable =
1100 prog->UniformRemapTable,
1101 gl_uniform_storage *,
1102 prog->NumUniformRemapTable + entries);
1103 prog->NumUniformRemapTable += entries;
1106 /* set pointers for this uniform */
1107 for (unsigned j = 0; j < entries; j++)
1108 prog->UniformRemapTable[chosen_location + j] =
1109 &prog->UniformStorage[i];
1111 /* set the base location in remap table for the uniform */
1112 prog->UniformStorage[i].remap_location = chosen_location;
1115 /* Verify that total amount of entries for explicit and implicit locations
1116 * is less than MAX_UNIFORM_LOCATIONS.
1119 if (total_entries > ctx->Const.MaxUserAssignableUniformLocations) {
1120 linker_error(prog, "count of uniform locations > MAX_UNIFORM_LOCATIONS"
1121 "(%u > %u)", total_entries,
1122 ctx->Const.MaxUserAssignableUniformLocations);
1125 /* Reserve all the explicit locations of the active subroutine uniforms. */
1126 for (unsigned i = 0; i < prog->NumUniformStorage; i++) {
1127 if (!prog->UniformStorage[i].type->is_subroutine())
1130 if (prog->UniformStorage[i].remap_location == UNMAPPED_UNIFORM_LOC)
1133 /* How many new entries for this uniform? */
1134 const unsigned entries =
1135 MAX2(1, prog->UniformStorage[i].array_elements);
1137 for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
1138 struct gl_linked_shader *sh = prog->_LinkedShaders[j];
1142 if (!prog->UniformStorage[i].opaque[j].active)
1145 /* Set remap table entries point to correct gl_uniform_storage. */
1146 for (unsigned k = 0; k < entries; k++) {
1147 unsigned element_loc = prog->UniformStorage[i].remap_location + k;
1148 assert(sh->SubroutineUniformRemapTable[element_loc] ==
1149 INACTIVE_UNIFORM_EXPLICIT_LOCATION);
1150 sh->SubroutineUniformRemapTable[element_loc] =
1151 &prog->UniformStorage[i];
1156 /* reserve subroutine locations */
1157 for (unsigned i = 0; i < prog->NumUniformStorage; i++) {
1158 if (!prog->UniformStorage[i].type->is_subroutine())
1161 if (prog->UniformStorage[i].remap_location != UNMAPPED_UNIFORM_LOC)
1164 const unsigned entries =
1165 MAX2(1, prog->UniformStorage[i].array_elements);
1167 for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
1168 struct gl_linked_shader *sh = prog->_LinkedShaders[j];
1172 if (!prog->UniformStorage[i].opaque[j].active)
1175 sh->SubroutineUniformRemapTable =
1177 sh->SubroutineUniformRemapTable,
1178 gl_uniform_storage *,
1179 sh->NumSubroutineUniformRemapTable + entries);
1181 for (unsigned k = 0; k < entries; k++) {
1182 sh->SubroutineUniformRemapTable[sh->NumSubroutineUniformRemapTable + k] =
1183 &prog->UniformStorage[i];
1185 prog->UniformStorage[i].remap_location =
1186 sh->NumSubroutineUniformRemapTable;
1187 sh->NumSubroutineUniformRemapTable += entries;
1193 link_assign_uniform_storage(struct gl_context *ctx,
1194 struct gl_shader_program *prog,
1195 const unsigned num_data_slots,
1196 unsigned num_explicit_uniform_locs)
1198 /* On the outside chance that there were no uniforms, bail out.
1200 if (prog->NumUniformStorage == 0)
1203 unsigned int boolean_true = ctx->Const.UniformBooleanTrue;
1205 prog->UniformStorage = rzalloc_array(prog, struct gl_uniform_storage,
1206 prog->NumUniformStorage);
1207 union gl_constant_value *data = rzalloc_array(prog->UniformStorage,
1208 union gl_constant_value,
1211 union gl_constant_value *data_end = &data[num_data_slots];
1214 parcel_out_uniform_storage parcel(prog, prog->UniformHash,
1215 prog->UniformStorage, data);
1217 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
1218 if (prog->_LinkedShaders[i] == NULL)
1221 parcel.start_shader((gl_shader_stage)i);
1223 foreach_in_list(ir_instruction, node, prog->_LinkedShaders[i]->ir) {
1224 ir_variable *const var = node->as_variable();
1226 if ((var == NULL) || (var->data.mode != ir_var_uniform &&
1227 var->data.mode != ir_var_shader_storage))
1230 parcel.set_and_process(var);
1233 prog->_LinkedShaders[i]->active_samplers = parcel.shader_samplers_used;
1234 prog->_LinkedShaders[i]->shadow_samplers = parcel.shader_shadow_samplers;
1236 STATIC_ASSERT(sizeof(prog->_LinkedShaders[i]->SamplerTargets) ==
1237 sizeof(parcel.targets));
1238 memcpy(prog->_LinkedShaders[i]->SamplerTargets, parcel.targets,
1239 sizeof(prog->_LinkedShaders[i]->SamplerTargets));
1243 for (unsigned i = 0; i < prog->NumUniformStorage; i++) {
1244 assert(prog->UniformStorage[i].storage != NULL ||
1245 prog->UniformStorage[i].builtin ||
1246 prog->UniformStorage[i].is_shader_storage ||
1247 prog->UniformStorage[i].block_index != -1);
1250 assert(parcel.values == data_end);
1253 link_setup_uniform_remap_tables(ctx, prog, num_explicit_uniform_locs);
1255 link_set_uniform_initializers(prog, boolean_true);
1259 link_assign_uniform_locations(struct gl_shader_program *prog,
1260 struct gl_context *ctx,
1261 unsigned int num_explicit_uniform_locs)
1263 ralloc_free(prog->UniformStorage);
1264 prog->UniformStorage = NULL;
1265 prog->NumUniformStorage = 0;
1267 if (prog->UniformHash != NULL) {
1268 prog->UniformHash->clear();
1270 prog->UniformHash = new string_to_uint_map;
1273 /* First pass: Count the uniform resources used by the user-defined
1274 * uniforms. While this happens, each active uniform will have an index
1277 * Note: this is *NOT* the index that is returned to the application by
1278 * glGetUniformLocation.
1280 struct string_to_uint_map *hiddenUniforms = new string_to_uint_map;
1281 count_uniform_size uniform_size(prog->UniformHash, hiddenUniforms);
1282 for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
1283 struct gl_linked_shader *sh = prog->_LinkedShaders[i];
1288 /* Uniforms that lack an initializer in the shader code have an initial
1289 * value of zero. This includes sampler uniforms.
1291 * Page 24 (page 30 of the PDF) of the GLSL 1.20 spec says:
1293 * "The link time initial value is either the value of the variable's
1294 * initializer, if present, or 0 if no initializer is present. Sampler
1295 * types cannot have initializers."
1297 memset(sh->SamplerUnits, 0, sizeof(sh->SamplerUnits));
1298 memset(sh->ImageUnits, 0, sizeof(sh->ImageUnits));
1300 link_update_uniform_buffer_variables(sh, i);
1302 /* Reset various per-shader target counts.
1304 uniform_size.start_shader();
1306 foreach_in_list(ir_instruction, node, sh->ir) {
1307 ir_variable *const var = node->as_variable();
1309 if ((var == NULL) || (var->data.mode != ir_var_uniform &&
1310 var->data.mode != ir_var_shader_storage))
1313 uniform_size.process(var);
1316 sh->num_samplers = uniform_size.num_shader_samplers;
1317 sh->NumImages = uniform_size.num_shader_images;
1318 sh->num_uniform_components = uniform_size.num_shader_uniform_components;
1319 sh->num_combined_uniform_components = sh->num_uniform_components;
1321 for (unsigned i = 0; i < sh->NumUniformBlocks; i++) {
1322 sh->num_combined_uniform_components +=
1323 sh->UniformBlocks[i]->UniformBufferSize / 4;
1327 prog->NumUniformStorage = uniform_size.num_active_uniforms;
1328 prog->NumHiddenUniforms = uniform_size.num_hidden_uniforms;
1330 /* assign hidden uniforms a slot id */
1331 hiddenUniforms->iterate(assign_hidden_uniform_slot_id, &uniform_size);
1332 delete hiddenUniforms;
1334 link_assign_uniform_storage(ctx, prog, uniform_size.num_values,
1335 num_explicit_uniform_locs);