unsigned record_array_count = 1;
char *name_copy = ralloc_strdup(NULL, name);
- unsigned packing = type->interface_packing;
+ enum glsl_interface_packing packing = type->get_interface_packing();
recursion(type, &name_copy, strlen(name), false, NULL, packing, false,
- record_array_count);
+ record_array_count, NULL);
ralloc_free(name_copy);
}
program_resource_visitor::process(ir_variable *var)
{
unsigned record_array_count = 1;
- const glsl_type *t = var->type;
- const glsl_type *t_without_array = var->type->without_array();
const bool row_major =
var->data.matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR;
- const unsigned packing = var->get_interface_type() ?
- var->get_interface_type()->interface_packing :
- var->type->interface_packing;
+ const enum glsl_interface_packing packing = var->get_interface_type() ?
+ var->get_interface_type_packing() :
+ var->type->get_interface_packing();
+
+ const glsl_type *t =
+ var->data.from_named_ifc_block ? var->get_interface_type() : var->type;
+ const glsl_type *t_without_array = t->without_array();
/* false is always passed for the row_major parameter to the other
* processing functions because no information is available to do
* otherwise. See the warning in linker.h.
*/
-
- /* Only strdup the name if we actually will need to modify it. */
- if (var->data.from_named_ifc_block_array) {
- /* lower_named_interface_blocks created this variable by lowering an
- * interface block array to an array variable. For example if the
- * original source code was:
- *
- * out Blk { vec4 bar } foo[3];
- *
- * Then the variable is now:
- *
- * out vec4 bar[3];
- *
- * We need to visit each array element using the names constructed like
- * so:
- *
- * Blk[0].bar
- * Blk[1].bar
- * Blk[2].bar
- */
- assert(t->is_array());
- const glsl_type *ifc_type = var->get_interface_type();
- char *name = ralloc_strdup(NULL, ifc_type->name);
- size_t name_length = strlen(name);
- for (unsigned i = 0; i < t->length; i++) {
- size_t new_length = name_length;
- ralloc_asprintf_rewrite_tail(&name, &new_length, "[%u].%s", i,
- var->name);
- /* Note: row_major is only meaningful for uniform blocks, and
- * lowering is only applied to non-uniform interface blocks, so we
- * can safely pass false for row_major.
- */
- recursion(var->type, &name, new_length, row_major, NULL, packing,
- false, record_array_count);
- }
- ralloc_free(name);
- } else if (var->data.from_named_ifc_block_nonarray) {
- /* lower_named_interface_blocks created this variable by lowering a
- * named interface block (non-array) to an ordinary variable. For
- * example if the original source code was:
- *
- * out Blk { vec4 bar } foo;
- *
- * Then the variable is now:
- *
- * out vec4 bar;
- *
- * We need to visit this variable using the name:
- *
- * Blk.bar
- */
- const glsl_type *ifc_type = var->get_interface_type();
- char *name = ralloc_asprintf(NULL, "%s.%s", ifc_type->name, var->name);
- /* Note: row_major is only meaningful for uniform blocks, and lowering
- * is only applied to non-uniform interface blocks, so we can safely
- * pass false for row_major.
- */
- recursion(var->type, &name, strlen(name), row_major, NULL, packing,
- false, record_array_count);
- ralloc_free(name);
- } else if (t_without_array->is_record() ||
+ if (t_without_array->is_record() ||
(t->is_array() && t->fields.array->is_array())) {
char *name = ralloc_strdup(NULL, var->name);
recursion(var->type, &name, strlen(name), row_major, NULL, packing,
- false, record_array_count);
+ false, record_array_count, NULL);
ralloc_free(name);
} else if (t_without_array->is_interface()) {
char *name = ralloc_strdup(NULL, t_without_array->name);
- recursion(var->type, &name, strlen(name), row_major, NULL, packing,
- false, record_array_count);
+ const glsl_struct_field *ifc_member = var->data.from_named_ifc_block ?
+ &t_without_array->
+ fields.structure[t_without_array->field_index(var->name)] : NULL;
+
+ recursion(t, &name, strlen(name), row_major, NULL, packing,
+ false, record_array_count, ifc_member);
ralloc_free(name);
} else {
this->set_record_array_count(record_array_count);
program_resource_visitor::recursion(const glsl_type *t, char **name,
size_t name_length, bool row_major,
const glsl_type *record_type,
- const unsigned packing,
+ const enum glsl_interface_packing packing,
bool last_field,
- unsigned record_array_count)
+ unsigned record_array_count,
+ const glsl_struct_field *named_ifc_member)
{
/* Records need to have each field processed individually.
*
* individually, then each field of the resulting array elements processed
* individually.
*/
- if (t->is_record() || t->is_interface()) {
+ if (t->is_interface() && named_ifc_member) {
+ ralloc_asprintf_rewrite_tail(name, &name_length, ".%s",
+ named_ifc_member->name);
+ recursion(named_ifc_member->type, name, name_length, row_major, NULL,
+ packing, false, record_array_count, NULL);
+ } else if (t->is_record() || t->is_interface()) {
if (record_type == NULL && t->is_record())
record_type = t;
this->enter_record(t, *name, row_major, packing);
for (unsigned i = 0; i < t->length; i++) {
- const char *field = t->fields.structure[i].name;
- size_t new_length = name_length;
+ const char *field = t->fields.structure[i].name;
+ size_t new_length = name_length;
if (t->fields.structure[i].type->is_record())
this->visit_field(&t->fields.structure[i]);
+ if (t->is_interface() && t->fields.structure[i].offset != -1)
+ this->set_buffer_offset(t->fields.structure[i].offset);
+
/* Append '.field' to the current variable name. */
if (name_length == 0) {
ralloc_asprintf_rewrite_tail(name, &new_length, "%s", field);
field_row_major,
record_type,
packing,
- (i + 1) == t->length, record_array_count);
+ (i + 1) == t->length, record_array_count, NULL);
/* Only the first leaf-field of the record gets called with the
* record type pointer.
record_array_count *= length;
for (unsigned i = 0; i < length; i++) {
- size_t new_length = name_length;
+ size_t new_length = name_length;
- /* Append the subscript to the current variable name */
- ralloc_asprintf_rewrite_tail(name, &new_length, "[%u]", i);
+ /* Append the subscript to the current variable name */
+ ralloc_asprintf_rewrite_tail(name, &new_length, "[%u]", i);
recursion(t->fields.array, name, new_length, row_major,
record_type,
packing,
- (i + 1) == t->length, record_array_count);
+ (i + 1) == t->length, record_array_count,
+ named_ifc_member);
/* Only the first leaf-field of the record gets called with the
* record type pointer.
program_resource_visitor::visit_field(const glsl_type *type, const char *name,
bool row_major,
const glsl_type *,
- const unsigned,
+ const enum glsl_interface_packing,
bool /* last_field */)
{
visit_field(type, name, row_major);
void
program_resource_visitor::enter_record(const glsl_type *, const char *, bool,
- const unsigned)
+ const enum glsl_interface_packing)
{
}
void
program_resource_visitor::leave_record(const glsl_type *, const char *, bool,
- const unsigned)
+ const enum glsl_interface_packing)
+{
+}
+
+void
+program_resource_visitor::set_buffer_offset(unsigned)
{
}
: num_active_uniforms(0), num_hidden_uniforms(0), num_values(0),
num_shader_samplers(0), num_shader_images(0),
num_shader_uniform_components(0), num_shader_subroutines(0),
- is_ubo_var(false), is_shader_storage(false), map(map),
+ is_buffer_block(false), is_shader_storage(false), map(map),
hidden_map(hidden_map)
{
/* empty */
void process(ir_variable *var)
{
this->current_var = var;
- this->is_ubo_var = var->is_in_buffer_block();
+ this->is_buffer_block = var->is_in_buffer_block();
this->is_shader_storage = var->is_in_shader_storage_block();
if (var->is_interface_instance())
program_resource_visitor::process(var->get_interface_type(),
*/
unsigned num_shader_subroutines;
- bool is_ubo_var;
+ bool is_buffer_block;
bool is_shader_storage;
struct string_to_uint_map *map;
if(!is_shader_storage)
this->num_shader_uniform_components += values;
} else {
- /* Accumulate the total number of uniform slots used by this shader.
- * Note that samplers do not count against this limit because they
- * don't use any storage on current hardware.
- */
- if (!is_ubo_var && !is_shader_storage)
- this->num_shader_uniform_components += values;
+ /* Accumulate the total number of uniform slots used by this shader.
+ * Note that samplers do not count against this limit because they
+ * don't use any storage on current hardware.
+ */
+ if (!is_buffer_block)
+ this->num_shader_uniform_components += values;
}
/* If the uniform is already in the map, there's nothing more to do.
*/
unsigned id;
if (this->map->get(id, name))
- return;
+ return;
if (this->current_var->data.how_declared == ir_var_hidden) {
this->hidden_map->put(this->num_hidden_uniforms, name);
* uniforms.
*/
this->num_active_uniforms++;
- this->num_values += values;
+
+ if(!is_gl_identifier(name) && !is_shader_storage && !is_buffer_block)
+ this->num_values += values;
}
struct string_to_uint_map *hidden_map;
*/
class parcel_out_uniform_storage : public program_resource_visitor {
public:
- parcel_out_uniform_storage(struct string_to_uint_map *map,
- struct gl_uniform_storage *uniforms,
- union gl_constant_value *values)
- : map(map), uniforms(uniforms), values(values)
+ parcel_out_uniform_storage(struct gl_shader_program *prog,
+ struct string_to_uint_map *map,
+ struct gl_uniform_storage *uniforms,
+ union gl_constant_value *values)
+ : prog(prog), map(map), uniforms(uniforms), values(values)
{
}
memset(this->targets, 0, sizeof(this->targets));
}
- void set_and_process(struct gl_shader_program *prog,
- ir_variable *var)
+ void set_and_process(ir_variable *var)
{
current_var = var;
field_counter = 0;
this->record_next_sampler = new string_to_uint_map;
- ubo_block_index = -1;
+ buffer_block_index = -1;
if (var->is_in_buffer_block()) {
+ struct gl_uniform_block *blks = var->is_in_shader_storage_block() ?
+ prog->ShaderStorageBlocks : prog->UniformBlocks;
+ unsigned num_blks = var->is_in_shader_storage_block() ?
+ prog->NumShaderStorageBlocks : prog->NumUniformBlocks;
+
if (var->is_interface_instance() && var->type->is_array()) {
unsigned l = strlen(var->get_interface_type()->name);
- for (unsigned i = 0; i < prog->NumBufferInterfaceBlocks; i++) {
- if (strncmp(var->get_interface_type()->name,
- prog->BufferInterfaceBlocks[i].Name,
- l) == 0
- && prog->BufferInterfaceBlocks[i].Name[l] == '[') {
- ubo_block_index = i;
+ for (unsigned i = 0; i < num_blks; i++) {
+ if (strncmp(var->get_interface_type()->name, blks[i].Name, l)
+ == 0 && blks[i].Name[l] == '[') {
+ buffer_block_index = i;
break;
}
}
} else {
- for (unsigned i = 0; i < prog->NumBufferInterfaceBlocks; i++) {
- if (strcmp(var->get_interface_type()->name,
- prog->BufferInterfaceBlocks[i].Name) == 0) {
- ubo_block_index = i;
+ for (unsigned i = 0; i < num_blks; i++) {
+ if (strcmp(var->get_interface_type()->name, blks[i].Name) ==
+ 0) {
+ buffer_block_index = i;
break;
}
- }
- }
- assert(ubo_block_index != -1);
+ }
+ }
+ assert(buffer_block_index != -1);
/* Uniform blocks that were specified with an instance name must be
* handled a little bit differently. The name of the variable is the
var->get_interface_type()->name);
} else {
const struct gl_uniform_block *const block =
- &prog->BufferInterfaceBlocks[ubo_block_index];
+ &blks[buffer_block_index];
assert(var->data.location != -1);
delete this->record_next_sampler;
}
- int ubo_block_index;
+ int buffer_block_index;
int ubo_byte_offset;
gl_shader_stage shader_type;
uniform->opaque[shader_type].index = this->next_image;
uniform->opaque[shader_type].active = true;
+ /* Set image access qualifiers */
+ const GLenum access =
+ (current_var->data.image_read_only ? GL_READ_ONLY :
+ current_var->data.image_write_only ? GL_WRITE_ONLY :
+ GL_READ_WRITE);
+
+ const unsigned first = this->next_image;
+
/* Increment the image index by 1 for non-arrays and by the
* number of array elements for arrays.
*/
this->next_image += MAX2(1, uniform->array_elements);
+ for (unsigned i = first; i < MIN2(next_image, MAX_IMAGE_UNIFORMS); i++)
+ prog->_LinkedShaders[shader_type]->ImageAccess[i] = access;
}
}
}
}
+ virtual void set_buffer_offset(unsigned offset)
+ {
+ this->ubo_byte_offset = offset;
+ }
+
virtual void set_record_array_count(unsigned record_array_count)
{
this->record_array_count = record_array_count;
}
virtual void enter_record(const glsl_type *type, const char *,
- bool row_major, const unsigned packing) {
+ bool row_major, const enum glsl_interface_packing packing) {
assert(type->is_record());
- if (this->ubo_block_index == -1)
+ if (this->buffer_block_index == -1)
return;
if (packing == GLSL_INTERFACE_PACKING_STD430)
this->ubo_byte_offset = glsl_align(
}
virtual void leave_record(const glsl_type *type, const char *,
- bool row_major, const unsigned packing) {
+ bool row_major, const enum glsl_interface_packing packing) {
assert(type->is_record());
- if (this->ubo_block_index == -1)
+ if (this->buffer_block_index == -1)
return;
if (packing == GLSL_INTERFACE_PACKING_STD430)
this->ubo_byte_offset = glsl_align(
}
virtual void visit_field(const glsl_type *type, const char *name,
- bool row_major, const glsl_type *record_type,
- const unsigned packing,
+ bool row_major, const glsl_type * /* record_type */,
+ const enum glsl_interface_packing packing,
bool /* last_field */)
{
assert(!type->without_array()->is_record());
assert(found);
if (!found)
- return;
+ return;
const glsl_type *base_type;
if (type->is_array()) {
- this->uniforms[id].array_elements = type->length;
- base_type = type->fields.array;
+ this->uniforms[id].array_elements = type->length;
+ base_type = type->fields.array;
} else {
- this->uniforms[id].array_elements = 0;
- base_type = type;
+ this->uniforms[id].array_elements = 0;
+ base_type = type;
}
/* Initialise opaque data */
/* For array of arrays or struct arrays the base location may have
* already been set so don't set it again.
*/
- if (ubo_block_index == -1 && current_var->data.location == -1) {
+ if (buffer_block_index == -1 && current_var->data.location == -1) {
current_var->data.location = id;
}
this->uniforms[id].name = ralloc_strdup(this->uniforms, name);
this->uniforms[id].type = base_type;
- this->uniforms[id].initialized = 0;
this->uniforms[id].num_driver_storage = 0;
this->uniforms[id].driver_storage = NULL;
this->uniforms[id].atomic_buffer_index = -1;
current_var->data.how_declared == ir_var_hidden;
this->uniforms[id].builtin = is_gl_identifier(name);
- /* Do not assign storage if the uniform is builtin */
- if (!this->uniforms[id].builtin)
- this->uniforms[id].storage = this->values;
-
this->uniforms[id].is_shader_storage =
current_var->is_in_shader_storage_block();
- if (this->ubo_block_index != -1) {
- this->uniforms[id].block_index = this->ubo_block_index;
+ /* Do not assign storage if the uniform is a builtin or buffer object */
+ if (!this->uniforms[id].builtin &&
+ !this->uniforms[id].is_shader_storage &&
+ this->buffer_block_index == -1)
+ this->uniforms[id].storage = this->values;
+
+ if (this->buffer_block_index != -1) {
+ this->uniforms[id].block_index = this->buffer_block_index;
unsigned alignment = type->std140_base_alignment(row_major);
if (packing == GLSL_INTERFACE_PACKING_STD430)
this->uniforms[id].array_stride =
glsl_align(type->without_array()->std140_size(row_major),
16);
- } else {
- this->uniforms[id].array_stride = 0;
- }
+ } else {
+ this->uniforms[id].array_stride = 0;
+ }
- if (type->without_array()->is_matrix()) {
+ if (type->without_array()->is_matrix()) {
const glsl_type *matrix = type->without_array();
const unsigned N = matrix->base_type == GLSL_TYPE_DOUBLE ? 8 : 4;
const unsigned items =
glsl_align(items * N, 16);
else
this->uniforms[id].matrix_stride = glsl_align(items * N, 16);
- this->uniforms[id].row_major = row_major;
- } else {
- this->uniforms[id].matrix_stride = 0;
- this->uniforms[id].row_major = false;
- }
+ this->uniforms[id].row_major = row_major;
+ } else {
+ this->uniforms[id].matrix_stride = 0;
+ this->uniforms[id].row_major = false;
+ }
} else {
- this->uniforms[id].block_index = -1;
- this->uniforms[id].offset = -1;
- this->uniforms[id].array_stride = -1;
- this->uniforms[id].matrix_stride = -1;
- this->uniforms[id].row_major = false;
+ this->uniforms[id].block_index = -1;
+ this->uniforms[id].offset = -1;
+ this->uniforms[id].array_stride = -1;
+ this->uniforms[id].matrix_stride = -1;
+ this->uniforms[id].row_major = false;
}
- this->values += values_for_type(type);
+ if (!this->uniforms[id].builtin &&
+ !this->uniforms[id].is_shader_storage &&
+ this->buffer_block_index == -1)
+ this->values += values_for_type(type);
}
+ /**
+ * Current program being processed.
+ */
+ struct gl_shader_program *prog;
+
struct string_to_uint_map *map;
struct gl_uniform_storage *uniforms;
unsigned shader_shadow_samplers;
};
-/**
- * Merges a uniform block into an array of uniform blocks that may or
- * may not already contain a copy of it.
- *
- * Returns the index of the new block in the array.
- */
-int
-link_cross_validate_uniform_block(void *mem_ctx,
- struct gl_uniform_block **linked_blocks,
- unsigned int *num_linked_blocks,
- struct gl_uniform_block *new_block)
-{
- for (unsigned int i = 0; i < *num_linked_blocks; i++) {
- struct gl_uniform_block *old_block = &(*linked_blocks)[i];
-
- if (strcmp(old_block->Name, new_block->Name) == 0)
- return link_uniform_blocks_are_compatible(old_block, new_block)
- ? i : -1;
- }
-
- *linked_blocks = reralloc(mem_ctx, *linked_blocks,
- struct gl_uniform_block,
- *num_linked_blocks + 1);
- int linked_block_index = (*num_linked_blocks)++;
- struct gl_uniform_block *linked_block = &(*linked_blocks)[linked_block_index];
-
- memcpy(linked_block, new_block, sizeof(*new_block));
- linked_block->Uniforms = ralloc_array(*linked_blocks,
- struct gl_uniform_buffer_variable,
- linked_block->NumUniforms);
-
- memcpy(linked_block->Uniforms,
- new_block->Uniforms,
- sizeof(*linked_block->Uniforms) * linked_block->NumUniforms);
-
- for (unsigned int i = 0; i < linked_block->NumUniforms; i++) {
- struct gl_uniform_buffer_variable *ubo_var =
- &linked_block->Uniforms[i];
-
- if (ubo_var->Name == ubo_var->IndexName) {
- ubo_var->Name = ralloc_strdup(*linked_blocks, ubo_var->Name);
- ubo_var->IndexName = ubo_var->Name;
- } else {
- ubo_var->Name = ralloc_strdup(*linked_blocks, ubo_var->Name);
- ubo_var->IndexName = ralloc_strdup(*linked_blocks, ubo_var->IndexName);
- }
- }
-
- return linked_block_index;
-}
-
/**
* Walks the IR and update the references to uniform blocks in the
* ir_variables to point at linked shader's list (previously, they
* shaders).
*/
static void
-link_update_uniform_buffer_variables(struct gl_shader *shader)
+link_update_uniform_buffer_variables(struct gl_linked_shader *shader)
{
foreach_in_list(ir_instruction, node, shader->ir) {
ir_variable *const var = node->as_variable();
if ((var == NULL) || !var->is_in_buffer_block())
- continue;
+ continue;
assert(var->data.mode == ir_var_uniform ||
var->data.mode == ir_var_shader_storage);
sentinel = '[';
}
+ unsigned num_blocks = var->data.mode == ir_var_uniform ?
+ shader->NumUniformBlocks : shader->NumShaderStorageBlocks;
+ struct gl_uniform_block **blks = var->data.mode == ir_var_uniform ?
+ shader->UniformBlocks : shader->ShaderStorageBlocks;
+
const unsigned l = strlen(var->name);
- for (unsigned i = 0; i < shader->NumBufferInterfaceBlocks; i++) {
- for (unsigned j = 0; j < shader->BufferInterfaceBlocks[i].NumUniforms; j++) {
+ for (unsigned i = 0; i < num_blocks; i++) {
+ for (unsigned j = 0; j < blks[i]->NumUniforms; j++) {
if (sentinel) {
- const char *begin = shader->BufferInterfaceBlocks[i].Uniforms[j].Name;
+ const char *begin = blks[i]->Uniforms[j].Name;
const char *end = strchr(begin, sentinel);
if (end == NULL)
var->data.location = j;
break;
}
- } else if (!strcmp(var->name,
- shader->BufferInterfaceBlocks[i].Uniforms[j].Name)) {
- found = true;
- var->data.location = j;
- break;
- }
- }
- if (found)
- break;
- }
- assert(found);
- }
-}
-
-static void
-link_set_image_access_qualifiers(struct gl_shader_program *prog,
- gl_shader *sh, unsigned shader_stage,
- ir_variable *var, const glsl_type *type,
- char **name, size_t name_length)
-{
- /* Handle arrays of arrays */
- if (type->is_array() && type->fields.array->is_array()) {
- for (unsigned i = 0; i < type->length; i++) {
- size_t new_length = name_length;
-
- /* Append the subscript to the current variable name */
- ralloc_asprintf_rewrite_tail(name, &new_length, "[%u]", i);
-
- link_set_image_access_qualifiers(prog, sh, shader_stage, var,
- type->fields.array, name,
- new_length);
+ } else if (!strcmp(var->name, blks[i]->Uniforms[j].Name)) {
+ found = true;
+ var->data.location = j;
+ break;
+ }
+ }
+ if (found)
+ break;
}
- } else {
- unsigned id = 0;
- bool found = prog->UniformHash->get(id, *name);
assert(found);
- (void) found;
- const gl_uniform_storage *storage = &prog->UniformStorage[id];
- const unsigned index = storage->opaque[shader_stage].index;
- const GLenum access = (var->data.image_read_only ? GL_READ_ONLY :
- var->data.image_write_only ? GL_WRITE_ONLY :
- GL_READ_WRITE);
-
- for (unsigned j = 0; j < MAX2(1, storage->array_elements); ++j)
- sh->ImageAccess[index + j] = access;
}
}
uniform_size->map->put(hidden_uniform_start + hidden_id, name);
}
+/**
+ * Search through the list of empty blocks to find one that fits the current
+ * uniform.
+ */
+static int
+find_empty_block(struct gl_shader_program *prog,
+ struct gl_uniform_storage *uniform)
+{
+ const unsigned entries = MAX2(1, uniform->array_elements);
+
+ foreach_list_typed(struct empty_uniform_block, block, link,
+ &prog->EmptyUniformLocations) {
+ /* Found a block with enough slots to fit the uniform */
+ if (block->slots == entries) {
+ unsigned start = block->start;
+ exec_node_remove(&block->link);
+ ralloc_free(block);
+
+ return start;
+ /* Found a block with more slots than needed. It can still be used. */
+ } else if (block->slots > entries) {
+ unsigned start = block->start;
+ block->start += entries;
+ block->slots -= entries;
+
+ return start;
+ }
+ }
+
+ return -1;
+}
+
void
link_assign_uniform_locations(struct gl_shader_program *prog,
- unsigned int boolean_true)
+ unsigned int boolean_true,
+ unsigned int num_explicit_uniform_locs,
+ unsigned int max_uniform_locs)
{
ralloc_free(prog->UniformStorage);
prog->UniformStorage = NULL;
struct string_to_uint_map *hiddenUniforms = new string_to_uint_map;
count_uniform_size uniform_size(prog->UniformHash, hiddenUniforms);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
- continue;
+ continue;
/* Uniforms that lack an initializer in the shader code have an initial
* value of zero. This includes sampler uniforms.
uniform_size.start_shader();
foreach_in_list(ir_instruction, node, sh->ir) {
- ir_variable *const var = node->as_variable();
+ ir_variable *const var = node->as_variable();
- if ((var == NULL) || (var->data.mode != ir_var_uniform &&
- var->data.mode != ir_var_shader_storage))
- continue;
+ if ((var == NULL) || (var->data.mode != ir_var_uniform &&
+ var->data.mode != ir_var_shader_storage))
+ continue;
- uniform_size.process(var);
+ uniform_size.process(var);
}
sh->num_samplers = uniform_size.num_shader_samplers;
sh->num_uniform_components = uniform_size.num_shader_uniform_components;
sh->num_combined_uniform_components = sh->num_uniform_components;
- for (unsigned i = 0; i < sh->NumBufferInterfaceBlocks; i++) {
- if (!sh->BufferInterfaceBlocks[i].IsShaderStorage) {
- sh->num_combined_uniform_components +=
- sh->BufferInterfaceBlocks[i].UniformBufferSize / 4;
- }
+ for (unsigned i = 0; i < sh->NumUniformBlocks; i++) {
+ sh->num_combined_uniform_components +=
+ sh->UniformBlocks[i]->UniformBufferSize / 4;
}
}
union gl_constant_value *data_end = &data[num_data_slots];
#endif
- parcel_out_uniform_storage parcel(prog->UniformHash, uniforms, data);
+ parcel_out_uniform_storage parcel(prog, prog->UniformHash, uniforms, data);
+
+ unsigned total_entries = num_explicit_uniform_locs;
+ unsigned empty_locs = prog->NumUniformRemapTable - num_explicit_uniform_locs;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
- continue;
+ continue;
parcel.start_shader((gl_shader_stage)i);
foreach_in_list(ir_instruction, node, prog->_LinkedShaders[i]->ir) {
- ir_variable *const var = node->as_variable();
+ ir_variable *const var = node->as_variable();
if ((var == NULL) || (var->data.mode != ir_var_uniform &&
var->data.mode != ir_var_shader_storage))
- continue;
+ continue;
- parcel.set_and_process(prog, var);
+ parcel.set_and_process(var);
}
prog->_LinkedShaders[i]->active_samplers = parcel.shader_samplers_used;
/* how many new entries for this uniform? */
const unsigned entries = MAX2(1, uniforms[i].array_elements);
- /* resize remap table to fit new entries */
- prog->UniformRemapTable =
- reralloc(prog,
- prog->UniformRemapTable,
- gl_uniform_storage *,
- prog->NumUniformRemapTable + entries);
+ /* Find UniformRemapTable for empty blocks where we can fit this uniform. */
+ int chosen_location = -1;
+
+ if (empty_locs)
+ chosen_location = find_empty_block(prog, &uniforms[i]);
+
+ /* Add new entries to the total amount of entries. */
+ total_entries += entries;
+
+ if (chosen_location != -1) {
+ empty_locs -= entries;
+ } else {
+ chosen_location = prog->NumUniformRemapTable;
+
+ /* resize remap table to fit new entries */
+ prog->UniformRemapTable =
+ reralloc(prog,
+ prog->UniformRemapTable,
+ gl_uniform_storage *,
+ prog->NumUniformRemapTable + entries);
+ prog->NumUniformRemapTable += entries;
+ }
/* set pointers for this uniform */
for (unsigned j = 0; j < entries; j++)
- prog->UniformRemapTable[prog->NumUniformRemapTable+j] = &uniforms[i];
+ prog->UniformRemapTable[chosen_location + j] = &uniforms[i];
/* set the base location in remap table for the uniform */
- uniforms[i].remap_location = prog->NumUniformRemapTable;
+ uniforms[i].remap_location = chosen_location;
+ }
+
+ /* Verify that total amount of entries for explicit and implicit locations
+ * is less than MAX_UNIFORM_LOCATIONS.
+ */
- prog->NumUniformRemapTable += entries;
+ if (total_entries > max_uniform_locs) {
+ linker_error(prog, "count of uniform locations > MAX_UNIFORM_LOCATIONS"
+ "(%u > %u)", total_entries, max_uniform_locs);
}
/* Reserve all the explicit locations of the active subroutine uniforms. */
continue;
for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
- struct gl_shader *sh = prog->_LinkedShaders[j];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[j];
if (!sh)
continue;
if (uniforms[i].remap_location != UNMAPPED_UNIFORM_LOC)
continue;
for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
- struct gl_shader *sh = prog->_LinkedShaders[j];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[j];
if (!sh)
continue;
#ifndef NDEBUG
for (unsigned i = 0; i < num_uniforms; i++) {
- assert(uniforms[i].storage != NULL || uniforms[i].builtin);
+ assert(uniforms[i].storage != NULL || uniforms[i].builtin ||
+ uniforms[i].is_shader_storage ||
+ uniforms[i].block_index != -1);
}
assert(parcel.values == data_end);
prog->NumHiddenUniforms = hidden_uniforms;
prog->UniformStorage = uniforms;
- /**
- * Scan the program for image uniforms and store image unit access
- * information into the gl_shader data structure.
- */
- for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- gl_shader *sh = prog->_LinkedShaders[i];
-
- if (sh == NULL)
- continue;
-
- foreach_in_list(ir_instruction, node, sh->ir) {
- ir_variable *var = node->as_variable();
-
- if (var && var->data.mode == ir_var_uniform &&
- var->type->contains_image()) {
- char *name_copy = ralloc_strdup(NULL, var->name);
- link_set_image_access_qualifiers(prog, sh, i, var, var->type,
- &name_copy, strlen(var->name));
- ralloc_free(name_copy);
- }
- }
- }
-
link_set_uniform_initializers(prog, boolean_true);
return;