* DEALINGS IN THE SOFTWARE.
*/
-#include "main/core.h"
#include "ir.h"
#include "linker.h"
#include "ir_uniform.h"
#include "glsl_symbol_table.h"
-#include "program/hash_table.h"
#include "program.h"
-#include "util/hash_table.h"
+#include "string_to_uint_map.h"
+#include "ir_array_refcount.h"
+
+#include "main/mtypes.h"
+#include "util/strndup.h"
/**
* \file link_uniforms.cpp
*/
#define UNMAPPED_UNIFORM_LOC ~0u
-/**
- * Count the backing storage requirements for a type
- */
-static unsigned
-values_for_type(const glsl_type *type)
+static char*
+get_top_level_name(const char *name)
{
- if (type->is_sampler()) {
- return 1;
- } else if (type->is_array() && type->fields.array->is_sampler()) {
- return type->array_size();
- } else {
- return type->component_slots();
+ const char *first_dot = strchr(name, '.');
+ const char *first_square_bracket = strchr(name, '[');
+ int name_size = 0;
+
+ /* The ARB_program_interface_query spec says:
+ *
+ * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer identifying
+ * the number of active array elements of the top-level shader storage
+ * block member containing to the active variable is written to
+ * <params>. If the top-level block member is not declared as an
+ * array, the value one is written to <params>. If the top-level block
+ * member is an array with no declared size, the value zero is written
+ * to <params>."
+ */
+
+ /* The buffer variable is on top level.*/
+ if (!first_square_bracket && !first_dot)
+ name_size = strlen(name);
+ else if ((!first_square_bracket ||
+ (first_dot && first_dot < first_square_bracket)))
+ name_size = first_dot - name;
+ else
+ name_size = first_square_bracket - name;
+
+ return strndup(name, name_size);
+}
+
+static char*
+get_var_name(const char *name)
+{
+ const char *first_dot = strchr(name, '.');
+
+ if (!first_dot)
+ return strdup(name);
+
+ return strndup(first_dot+1, strlen(first_dot) - 1);
+}
+
+static bool
+is_top_level_shader_storage_block_member(const char* name,
+ const char* interface_name,
+ const char* field_name)
+{
+ bool result = false;
+
+ /* If the given variable is already a top-level shader storage
+ * block member, then return array_size = 1.
+ * We could have two possibilities: if we have an instanced
+ * shader storage block or not instanced.
+ *
+ * For the first, we check create a name as it was in top level and
+ * compare it with the real name. If they are the same, then
+ * the variable is already at top-level.
+ *
+ * Full instanced name is: interface name + '.' + var name +
+ * NULL character
+ */
+ int name_length = strlen(interface_name) + 1 + strlen(field_name) + 1;
+ char *full_instanced_name = (char *) calloc(name_length, sizeof(char));
+ if (!full_instanced_name) {
+ fprintf(stderr, "%s: Cannot allocate space for name\n", __func__);
+ return false;
+ }
+
+ snprintf(full_instanced_name, name_length, "%s.%s",
+ interface_name, field_name);
+
+ /* Check if its top-level shader storage block member of an
+ * instanced interface block, or of a unnamed interface block.
+ */
+ if (strcmp(name, full_instanced_name) == 0 ||
+ strcmp(name, field_name) == 0)
+ result = true;
+
+ free(full_instanced_name);
+ return result;
+}
+
+static int
+get_array_size(struct gl_uniform_storage *uni, const glsl_struct_field *field,
+ char *interface_name, char *var_name)
+{
+ /* The ARB_program_interface_query spec says:
+ *
+ * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer identifying
+ * the number of active array elements of the top-level shader storage
+ * block member containing to the active variable is written to
+ * <params>. If the top-level block member is not declared as an
+ * array, the value one is written to <params>. If the top-level block
+ * member is an array with no declared size, the value zero is written
+ * to <params>."
+ */
+ if (is_top_level_shader_storage_block_member(uni->name,
+ interface_name,
+ var_name))
+ return 1;
+ else if (field->type->is_array())
+ return field->type->length;
+
+ return 1;
+}
+
+static int
+get_array_stride(struct gl_uniform_storage *uni, const glsl_type *iface,
+ const glsl_struct_field *field, char *interface_name,
+ char *var_name, bool use_std430_as_default)
+{
+ /* The ARB_program_interface_query spec says:
+ *
+ * "For the property TOP_LEVEL_ARRAY_STRIDE, a single integer
+ * identifying the stride between array elements of the top-level
+ * shader storage block member containing the active variable is
+ * written to <params>. For top-level block members declared as
+ * arrays, the value written is the difference, in basic machine units,
+ * between the offsets of the active variable for consecutive elements
+ * in the top-level array. For top-level block members not declared as
+ * an array, zero is written to <params>."
+ */
+ if (field->type->is_array()) {
+ const enum glsl_matrix_layout matrix_layout =
+ glsl_matrix_layout(field->matrix_layout);
+ bool row_major = matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR;
+ const glsl_type *array_type = field->type->fields.array;
+
+ if (is_top_level_shader_storage_block_member(uni->name,
+ interface_name,
+ var_name))
+ return 0;
+
+ if (GLSL_INTERFACE_PACKING_STD140 ==
+ iface->get_internal_ifc_packing(use_std430_as_default)) {
+ if (array_type->is_struct() || array_type->is_array())
+ return glsl_align(array_type->std140_size(row_major), 16);
+ else
+ return MAX2(array_type->std140_base_alignment(row_major), 16);
+ } else {
+ return array_type->std430_array_stride(row_major);
+ }
+ }
+ return 0;
+}
+
+static void
+calculate_array_size_and_stride(struct gl_shader_program *shProg,
+ struct gl_uniform_storage *uni,
+ bool use_std430_as_default)
+{
+ if (!uni->is_shader_storage)
+ return;
+
+ int block_index = uni->block_index;
+ int array_size = -1;
+ int array_stride = -1;
+ char *var_name = get_top_level_name(uni->name);
+ char *interface_name =
+ get_top_level_name(uni->is_shader_storage ?
+ shProg->data->ShaderStorageBlocks[block_index].Name :
+ shProg->data->UniformBlocks[block_index].Name);
+
+ if (strcmp(var_name, interface_name) == 0) {
+ /* Deal with instanced array of SSBOs */
+ char *temp_name = get_var_name(uni->name);
+ if (!temp_name) {
+ linker_error(shProg, "Out of memory during linking.\n");
+ goto write_top_level_array_size_and_stride;
+ }
+ free(var_name);
+ var_name = get_top_level_name(temp_name);
+ free(temp_name);
+ if (!var_name) {
+ linker_error(shProg, "Out of memory during linking.\n");
+ goto write_top_level_array_size_and_stride;
+ }
+ }
+
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
+ const gl_linked_shader *sh = shProg->_LinkedShaders[i];
+ if (sh == NULL)
+ continue;
+
+ foreach_in_list(ir_instruction, node, sh->ir) {
+ ir_variable *var = node->as_variable();
+ if (!var || !var->get_interface_type() ||
+ var->data.mode != ir_var_shader_storage)
+ continue;
+
+ const glsl_type *iface = var->get_interface_type();
+
+ if (strcmp(interface_name, iface->name) != 0)
+ continue;
+
+ for (unsigned i = 0; i < iface->length; i++) {
+ const glsl_struct_field *field = &iface->fields.structure[i];
+ if (strcmp(field->name, var_name) != 0)
+ continue;
+
+ array_stride = get_array_stride(uni, iface, field, interface_name,
+ var_name, use_std430_as_default);
+ array_size = get_array_size(uni, field, interface_name, var_name);
+ goto write_top_level_array_size_and_stride;
+ }
+ }
}
+write_top_level_array_size_and_stride:
+ free(interface_name);
+ free(var_name);
+ uni->top_level_array_stride = array_stride;
+ uni->top_level_array_size = array_size;
}
void
-program_resource_visitor::process(const glsl_type *type, const char *name)
+program_resource_visitor::process(const glsl_type *type, const char *name,
+ bool use_std430_as_default)
{
- assert(type->without_array()->is_record()
+ assert(type->without_array()->is_struct()
|| type->without_array()->is_interface());
unsigned record_array_count = 1;
char *name_copy = ralloc_strdup(NULL, name);
- unsigned packing = type->interface_packing;
+
+ enum glsl_interface_packing packing =
+ type->get_internal_ifc_packing(use_std430_as_default);
recursion(type, &name_copy, strlen(name), false, NULL, packing, false,
- record_array_count);
+ record_array_count, NULL);
ralloc_free(name_copy);
}
void
-program_resource_visitor::process(ir_variable *var)
+program_resource_visitor::process(ir_variable *var, bool use_std430_as_default)
+{
+ const glsl_type *t =
+ var->data.from_named_ifc_block ? var->get_interface_type() : var->type;
+ process(var, t, use_std430_as_default);
+}
+
+void
+program_resource_visitor::process(ir_variable *var, const glsl_type *var_type,
+ bool use_std430_as_default)
{
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;
+ enum glsl_interface_packing packing = var->get_interface_type() ?
+ var->get_interface_type()->
+ get_internal_ifc_packing(use_std430_as_default) :
+ var->type->get_internal_ifc_packing(use_std430_as_default);
+
+ const glsl_type *t = 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_struct() ||
(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 (record_type == NULL && t->is_record())
+ 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_struct() || t->is_interface()) {
+ if (record_type == NULL && t->is_struct())
record_type = t;
- if (t->is_record())
+ if (t->is_struct())
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) {
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_type = NULL;
}
- if (t->is_record()) {
+ if (t->is_struct()) {
(*name)[name_length] = '\0';
this->leave_record(t, *name, row_major, packing);
}
- } else if (t->without_array()->is_record() ||
+ } else if (t->without_array()->is_struct() ||
t->without_array()->is_interface() ||
(t->is_array() && t->fields.array->is_array())) {
- if (record_type == NULL && t->fields.array->is_record())
+ if (record_type == NULL && t->fields.array->is_struct())
record_type = t->fields.array;
unsigned length = t->length;
+
/* Shader storage block unsized arrays: add subscript [0] to variable
- * names */
+ * names.
+ */
if (t->is_unsized_array())
length = 1;
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.
}
void
-program_resource_visitor::visit_field(const glsl_type *type, const char *name,
- bool row_major,
- const glsl_type *,
- const unsigned,
- bool /* last_field */)
-{
- visit_field(type, name, row_major);
-}
-
-void
-program_resource_visitor::visit_field(const glsl_struct_field *field)
+program_resource_visitor::enter_record(const glsl_type *, const char *, bool,
+ const enum glsl_interface_packing)
{
- (void) field;
- /* empty */
}
void
-program_resource_visitor::enter_record(const glsl_type *, const char *, bool,
- const unsigned)
+program_resource_visitor::leave_record(const glsl_type *, const char *, bool,
+ const enum glsl_interface_packing)
{
}
void
-program_resource_visitor::leave_record(const glsl_type *, const char *, bool,
- const unsigned)
+program_resource_visitor::set_buffer_offset(unsigned)
{
}
class count_uniform_size : public program_resource_visitor {
public:
count_uniform_size(struct string_to_uint_map *map,
- struct string_to_uint_map *hidden_map)
+ struct string_to_uint_map *hidden_map,
+ bool use_std430_as_default)
: 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),
- hidden_map(hidden_map)
+ is_buffer_block(false), is_shader_storage(false), map(map),
+ hidden_map(hidden_map), current_var(NULL),
+ use_std430_as_default(use_std430_as_default)
{
/* 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(),
- var->get_interface_type()->name);
+ var->get_interface_type()->name,
+ use_std430_as_default);
else
- program_resource_visitor::process(var);
+ program_resource_visitor::process(var, use_std430_as_default);
}
/**
*/
unsigned num_shader_subroutines;
- bool is_ubo_var;
+ bool is_buffer_block;
bool is_shader_storage;
struct string_to_uint_map *map;
private:
virtual void visit_field(const glsl_type *type, const char *name,
- bool row_major)
+ bool /* row_major */,
+ const glsl_type * /* record_type */,
+ const enum glsl_interface_packing,
+ bool /* last_field */)
{
- assert(!type->without_array()->is_record());
+ assert(!type->without_array()->is_struct());
assert(!type->without_array()->is_interface());
assert(!(type->is_array() && type->fields.array->is_array()));
- (void) row_major;
-
/* Count the number of samplers regardless of whether the uniform is
* already in the hash table. The hash table prevents adding the same
* uniform for multiple shader targets, but in this case we want to
* count it for each shader target.
*/
- const unsigned values = values_for_type(type);
+ const unsigned values = type->component_slots();
if (type->contains_subroutine()) {
this->num_shader_subroutines += values;
- } else if (type->contains_sampler()) {
- this->num_shader_samplers += values;
- } else if (type->contains_image()) {
- this->num_shader_images += values;
+ } else if (type->contains_sampler() && !current_var->data.bindless) {
+ /* Samplers (bound or bindless) are counted as two components as
+ * specified by ARB_bindless_texture. */
+ this->num_shader_samplers += values / 2;
+ } else if (type->contains_image() && !current_var->data.bindless) {
+ /* Images (bound or bindless) are counted as two components as
+ * specified by ARB_bindless_texture. */
+ this->num_shader_images += values / 2;
/* As drivers are likely to represent image uniforms as
* scalar indices, count them against the limit of uniform
* components in the default block. The spec allows image
* uniforms to use up no more than one scalar slot.
*/
- if(!is_shader_storage)
+ 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;
* Current variable being processed.
*/
ir_variable *current_var;
+
+ bool use_std430_as_default;
};
} /* anonymous namespace */
+unsigned
+link_calculate_matrix_stride(const glsl_type *matrix, bool row_major,
+ enum glsl_interface_packing packing)
+{
+ const unsigned N = matrix->is_double() ? 8 : 4;
+ const unsigned items =
+ row_major ? matrix->matrix_columns : matrix->vector_elements;
+
+ assert(items <= 4);
+
+ /* Matrix stride for std430 mat2xY matrices are not rounded up to
+ * vec4 size.
+ *
+ * Section 7.6.2.2 "Standard Uniform Block Layout" of the OpenGL 4.3 spec
+ * says:
+ *
+ * 2. If the member is a two- or four-component vector with components
+ * consuming N basic machine units, the base alignment is 2N or 4N,
+ * respectively.
+ * ...
+ * 4. If the member is an array of scalars or vectors, the base
+ * alignment and array stride are set to match the base alignment of
+ * a single array element, according to rules (1), (2), and (3), and
+ * rounded up to the base alignment of a vec4.
+ * ...
+ * 7. If the member is a row-major matrix with C columns and R rows, the
+ * matrix is stored identically to an array of R row vectors with C
+ * components each, according to rule (4).
+ * ...
+ *
+ * When using the std430 storage layout, shader storage blocks will be
+ * laid out in buffer storage identically to uniform and shader storage
+ * blocks using the std140 layout, except that the base alignment and
+ * stride of arrays of scalars and vectors in rule 4 and of structures
+ * in rule 9 are not rounded up a multiple of the base alignment of a
+ * vec4.
+ */
+ return packing == GLSL_INTERFACE_PACKING_STD430
+ ? (items < 3 ? items * N : glsl_align(items * N, 16))
+ : glsl_align(items * N, 16);
+}
+
/**
* Class to help parcel out pieces of backing storage to uniforms
*
*/
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,
+ bool use_std430_as_default)
+ : prog(prog), map(map), uniforms(uniforms),
+ use_std430_as_default(use_std430_as_default), values(values),
+ bindless_targets(NULL), bindless_access(NULL),
+ shader_storage_blocks_write_access(0)
{
}
+ virtual ~parcel_out_uniform_storage()
+ {
+ free(this->bindless_targets);
+ free(this->bindless_access);
+ }
+
void start_shader(gl_shader_stage shader_type)
{
assert(shader_type < MESA_SHADER_STAGES);
this->next_subroutine = 0;
this->record_array_count = 1;
memset(this->targets, 0, sizeof(this->targets));
+
+ this->num_bindless_samplers = 0;
+ this->next_bindless_sampler = 0;
+ free(this->bindless_targets);
+ this->bindless_targets = NULL;
+
+ this->num_bindless_images = 0;
+ this->next_bindless_image = 0;
+ free(this->bindless_access);
+ this->bindless_access = NULL;
+ this->shader_storage_blocks_write_access = 0;
}
- 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;
+ this->record_next_bindless_sampler = new string_to_uint_map;
+ this->record_next_image = new string_to_uint_map;
+ this->record_next_bindless_image = new string_to_uint_map;
- ubo_block_index = -1;
+ buffer_block_index = -1;
if (var->is_in_buffer_block()) {
- if (var->is_interface_instance() && var->type->is_array()) {
+ struct gl_uniform_block *blks = var->is_in_shader_storage_block() ?
+ prog->data->ShaderStorageBlocks : prog->data->UniformBlocks;
+ unsigned num_blks = var->is_in_shader_storage_block() ?
+ prog->data->NumShaderStorageBlocks : prog->data->NumUniformBlocks;
+ bool is_interface_array =
+ var->is_interface_instance() && var->type->is_array();
+
+ if (is_interface_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);
+
+ if (var->is_in_shader_storage_block() &&
+ !var->data.memory_read_only) {
+ unsigned array_size = is_interface_array ?
+ var->type->array_size() : 1;
+
+ STATIC_ASSERT(MAX_SHADER_STORAGE_BUFFERS <= 32);
+
+ /* Shaders that use too many SSBOs will fail to compile, which
+ * we don't care about.
+ *
+ * This is true for shaders that do not use too many SSBOs:
+ */
+ if (buffer_block_index + array_size <= 32) {
+ shader_storage_blocks_write_access |=
+ u_bit_consecutive(buffer_block_index, array_size);
+ }
+ }
/* Uniform blocks that were specified with an instance name must be
* handled a little bit differently. The name of the variable is the
if (var->is_interface_instance()) {
ubo_byte_offset = 0;
process(var->get_interface_type(),
- var->get_interface_type()->name);
+ var->get_interface_type()->name,
+ use_std430_as_default);
} else {
const struct gl_uniform_block *const block =
- &prog->BufferInterfaceBlocks[ubo_block_index];
+ &blks[buffer_block_index];
assert(var->data.location != -1);
&block->Uniforms[var->data.location];
ubo_byte_offset = ubo_var->Offset;
- process(var);
+ process(var, use_std430_as_default);
}
} else {
/* Store any explicit location and reset data location so we can
this->explicit_location = current_var->data.location;
current_var->data.location = -1;
- process(var);
+ process(var, use_std430_as_default);
}
delete this->record_next_sampler;
+ delete this->record_next_bindless_sampler;
+ delete this->record_next_image;
+ delete this->record_next_bindless_image;
}
- int ubo_block_index;
+ int buffer_block_index;
int ubo_byte_offset;
gl_shader_stage shader_type;
private:
+ bool set_opaque_indices(const glsl_type *base_type,
+ struct gl_uniform_storage *uniform,
+ const char *name, unsigned &next_index,
+ struct string_to_uint_map *record_next_index)
+ {
+ assert(base_type->is_sampler() || base_type->is_image());
+
+ if (this->record_array_count > 1) {
+ unsigned inner_array_size = MAX2(1, uniform->array_elements);
+ char *name_copy = ralloc_strdup(NULL, name);
+
+ /* Remove all array subscripts from the sampler/image name */
+ char *str_start;
+ const char *str_end;
+ while((str_start = strchr(name_copy, '[')) &&
+ (str_end = strchr(name_copy, ']'))) {
+ memmove(str_start, str_end + 1, 1 + strlen(str_end + 1));
+ }
+
+ unsigned index = 0;
+ if (record_next_index->get(index, name_copy)) {
+ /* In this case, we've already seen this uniform so we just use the
+ * next sampler/image index recorded the last time we visited.
+ */
+ uniform->opaque[shader_type].index = index;
+ index = inner_array_size + uniform->opaque[shader_type].index;
+ record_next_index->put(index, name_copy);
+
+ ralloc_free(name_copy);
+ /* Return as everything else has already been initialised in a
+ * previous pass.
+ */
+ return false;
+ } else {
+ /* We've never seen this uniform before so we need to allocate
+ * enough indices to store it.
+ *
+ * Nested struct arrays behave like arrays of arrays so we need to
+ * increase the index by the total number of elements of the
+ * sampler/image in case there is more than one sampler/image
+ * inside the structs. This allows the offset to be easily
+ * calculated for indirect indexing.
+ */
+ uniform->opaque[shader_type].index = next_index;
+ next_index += inner_array_size * this->record_array_count;
+
+ /* Store the next index for future passes over the struct array
+ */
+ index = uniform->opaque[shader_type].index + inner_array_size;
+ record_next_index->put(index, name_copy);
+ ralloc_free(name_copy);
+ }
+ } else {
+ /* Increment the sampler/image by 1 for non-arrays and by the number
+ * of array elements for arrays.
+ */
+ uniform->opaque[shader_type].index = next_index;
+ next_index += MAX2(1, uniform->array_elements);
+ }
+ return true;
+ }
+
void handle_samplers(const glsl_type *base_type,
struct gl_uniform_storage *uniform, const char *name)
{
if (base_type->is_sampler()) {
uniform->opaque[shader_type].active = true;
- /* Handle multiple samplers inside struct arrays */
- if (this->record_array_count > 1) {
- unsigned inner_array_size = MAX2(1, uniform->array_elements);
- char *name_copy = ralloc_strdup(NULL, name);
-
- /* Remove all array subscripts from the sampler name */
- char *str_start;
- const char *str_end;
- while((str_start = strchr(name_copy, '[')) &&
- (str_end = strchr(name_copy, ']'))) {
- memmove(str_start, str_end + 1, 1 + strlen(str_end));
- }
-
- unsigned index = 0;
- if (this->record_next_sampler->get(index, name_copy)) {
- /* In this case, we've already seen this uniform so we just use
- * the next sampler index recorded the last time we visited.
- */
- uniform->opaque[shader_type].index = index;
- index = inner_array_size + uniform->opaque[shader_type].index;
- this->record_next_sampler->put(index, name_copy);
+ const gl_texture_index target = base_type->sampler_index();
+ const unsigned shadow = base_type->sampler_shadow;
- ralloc_free(name_copy);
- /* Return as everything else has already been initialised in a
- * previous pass.
- */
+ if (current_var->data.bindless) {
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_bindless_sampler,
+ this->record_next_bindless_sampler))
return;
- } else {
- /* We've never seen this uniform before so we need to allocate
- * enough indices to store it.
- *
- * Nested struct arrays behave like arrays of arrays so we need
- * to increase the index by the total number of elements of the
- * sampler in case there is more than one sampler inside the
- * structs. This allows the offset to be easily calculated for
- * indirect indexing.
- */
- uniform->opaque[shader_type].index = this->next_sampler;
- this->next_sampler +=
- inner_array_size * this->record_array_count;
- /* Store the next index for future passes over the struct array
- */
- index = uniform->opaque[shader_type].index + inner_array_size;
- this->record_next_sampler->put(index, name_copy);
- ralloc_free(name_copy);
+ this->num_bindless_samplers = this->next_bindless_sampler;
+
+ this->bindless_targets = (gl_texture_index *)
+ realloc(this->bindless_targets,
+ this->num_bindless_samplers * sizeof(gl_texture_index));
+
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < this->num_bindless_samplers;
+ i++) {
+ this->bindless_targets[i] = target;
}
} else {
- /* Increment the sampler by 1 for non-arrays and by the number of
- * array elements for arrays.
- */
- uniform->opaque[shader_type].index = this->next_sampler;
- this->next_sampler += MAX2(1, uniform->array_elements);
- }
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_sampler,
+ this->record_next_sampler))
+ return;
- const gl_texture_index target = base_type->sampler_index();
- const unsigned shadow = base_type->sampler_shadow;
- for (unsigned i = uniform->opaque[shader_type].index;
- i < MIN2(this->next_sampler, MAX_SAMPLERS);
- i++) {
- this->targets[i] = target;
- this->shader_samplers_used |= 1U << i;
- this->shader_shadow_samplers |= shadow << i;
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < MIN2(this->next_sampler, MAX_SAMPLERS);
+ i++) {
+ this->targets[i] = target;
+ this->shader_samplers_used |= 1U << i;
+ this->shader_shadow_samplers |= shadow << i;
+ }
}
}
}
void handle_images(const glsl_type *base_type,
- struct gl_uniform_storage *uniform)
+ struct gl_uniform_storage *uniform, const char *name)
{
if (base_type->is_image()) {
- uniform->opaque[shader_type].index = this->next_image;
uniform->opaque[shader_type].active = true;
- /* 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);
+ /* Set image access qualifiers */
+ const GLenum access =
+ current_var->data.memory_read_only ?
+ (current_var->data.memory_write_only ? GL_NONE :
+ GL_READ_ONLY) :
+ (current_var->data.memory_write_only ? GL_WRITE_ONLY :
+ GL_READ_WRITE);
+
+ if (current_var->data.bindless) {
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_bindless_image,
+ this->record_next_bindless_image))
+ return;
+
+ this->num_bindless_images = this->next_bindless_image;
+ this->bindless_access = (GLenum *)
+ realloc(this->bindless_access,
+ this->num_bindless_images * sizeof(GLenum));
+
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < this->num_bindless_images;
+ i++) {
+ this->bindless_access[i] = access;
+ }
+ } else {
+ if (!set_opaque_indices(base_type, uniform, name,
+ this->next_image,
+ this->record_next_image))
+ return;
+
+ for (unsigned i = uniform->opaque[shader_type].index;
+ i < MIN2(this->next_image, MAX_IMAGE_UNIFORMS);
+ i++) {
+ prog->_LinkedShaders[shader_type]->Program->sh.ImageAccess[i] = access;
+ }
+ }
}
}
uniform->opaque[shader_type].index = this->next_subroutine;
uniform->opaque[shader_type].active = true;
+ prog->_LinkedShaders[shader_type]->Program->sh.NumSubroutineUniforms++;
+
/* Increment the subroutine index by 1 for non-arrays and by the
* number of array elements for arrays.
*/
}
}
- virtual void set_record_array_count(unsigned record_array_count)
+ virtual void set_buffer_offset(unsigned offset)
{
- this->record_array_count = record_array_count;
+ this->ubo_byte_offset = offset;
}
- virtual void visit_field(const glsl_type *type, const char *name,
- bool row_major)
+ virtual void set_record_array_count(unsigned record_array_count)
{
- (void) type;
- (void) name;
- (void) row_major;
- assert(!"Should not get here.");
+ this->record_array_count = record_array_count;
}
virtual void enter_record(const glsl_type *type, const char *,
- bool row_major, const unsigned packing) {
- assert(type->is_record());
- if (this->ubo_block_index == -1)
+ bool row_major,
+ const enum glsl_interface_packing packing)
+ {
+ assert(type->is_struct());
+ 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) {
- assert(type->is_record());
- if (this->ubo_block_index == -1)
+ bool row_major,
+ const enum glsl_interface_packing packing)
+ {
+ assert(type->is_struct());
+ 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(!type->without_array()->is_struct());
assert(!type->without_array()->is_interface());
assert(!(type->is_array() && type->fields.array->is_array()));
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 */
this->uniforms[id].opaque[shader_type].index = ~0;
this->uniforms[id].opaque[shader_type].active = false;
+ if (current_var->data.used || base_type->is_subroutine())
+ this->uniforms[id].active_shader_mask |= 1 << shader_type;
+
/* This assigns uniform indices to sampler and image uniforms. */
handle_samplers(base_type, &this->uniforms[id], name);
- handle_images(base_type, &this->uniforms[id]);
+ handle_images(base_type, &this->uniforms[id], name);
handle_subroutines(base_type, &this->uniforms[id]);
/* 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;
}
/* Assign explicit locations. */
if (current_var->data.explicit_location) {
/* Set sequential locations for struct fields. */
- if (current_var->type->without_array()->is_record() ||
+ if (current_var->type->without_array()->is_struct() ||
current_var->type->is_array_of_arrays()) {
const unsigned entries = MAX2(1, this->uniforms[id].array_elements);
this->uniforms[id].remap_location =
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();
+ this->uniforms[id].is_bindless = current_var->data.bindless;
+
+ /* 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->ubo_block_index != -1) {
- this->uniforms[id].block_index = this->ubo_block_index;
+ 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;
- }
-
- 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 =
- row_major ? matrix->matrix_columns : matrix->vector_elements;
+ } else {
+ this->uniforms[id].array_stride = 0;
+ }
- assert(items <= 4);
- if (packing == GLSL_INTERFACE_PACKING_STD430)
- this->uniforms[id].matrix_stride = items < 3 ? items * N :
- 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;
- }
+ if (type->without_array()->is_matrix()) {
+ this->uniforms[id].matrix_stride =
+ link_calculate_matrix_stride(type->without_array(),
+ row_major,
+ packing);
+ 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 += type->component_slots();
+
+ calculate_array_size_and_stride(prog, &this->uniforms[id],
+ use_std430_as_default);
}
+ /**
+ * Current program being processed.
+ */
+ struct gl_shader_program *prog;
+
struct string_to_uint_map *map;
struct gl_uniform_storage *uniforms;
unsigned next_sampler;
+ unsigned next_bindless_sampler;
unsigned next_image;
+ unsigned next_bindless_image;
unsigned next_subroutine;
+ bool use_std430_as_default;
+
/**
* Field counter is used to take care that uniform structures
* with explicit locations get sequential locations.
*/
struct string_to_uint_map *record_next_sampler;
+ /* Map for temporarily storing next imager index when handling images in
+ * struct arrays.
+ */
+ struct string_to_uint_map *record_next_image;
+
+ /* Map for temporarily storing next bindless sampler index when handling
+ * bindless samplers in struct arrays.
+ */
+ struct string_to_uint_map *record_next_bindless_sampler;
+
+ /* Map for temporarily storing next bindless image index when handling
+ * bindless images in struct arrays.
+ */
+ struct string_to_uint_map *record_next_bindless_image;
+
public:
union gl_constant_value *values;
* Mask of samplers used by the current shader stage for shadows.
*/
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];
+ /**
+ * Number of bindless samplers used by the current shader stage.
+ */
+ unsigned num_bindless_samplers;
- if (strcmp(old_block->Name, new_block->Name) == 0)
- return link_uniform_blocks_are_compatible(old_block, new_block)
- ? i : -1;
- }
+ /**
+ * Texture targets for bindless samplers used by the current stage.
+ */
+ gl_texture_index *bindless_targets;
- *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];
+ /**
+ * Number of bindless images used by the current shader stage.
+ */
+ unsigned num_bindless_images;
- memcpy(linked_block, new_block, sizeof(*new_block));
- linked_block->Uniforms = ralloc_array(*linked_blocks,
- struct gl_uniform_buffer_variable,
- linked_block->NumUniforms);
+ /**
+ * Access types for bindless images used by the current stage.
+ */
+ GLenum *bindless_access;
- memcpy(linked_block->Uniforms,
- new_block->Uniforms,
- sizeof(*linked_block->Uniforms) * linked_block->NumUniforms);
+ /**
+ * Bitmask of shader storage blocks not declared as read-only.
+ */
+ unsigned shader_storage_blocks_write_access;
+};
- for (unsigned int i = 0; i < linked_block->NumUniforms; i++) {
- struct gl_uniform_buffer_variable *ubo_var =
- &linked_block->Uniforms[i];
+static bool
+variable_is_referenced(ir_array_refcount_visitor &v, ir_variable *var)
+{
+ ir_array_refcount_entry *const entry = v.get_variable_entry(var);
- 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 entry->is_referenced;
- return linked_block_index;
}
/**
* shaders).
*/
static void
-link_update_uniform_buffer_variables(struct gl_shader *shader)
+link_update_uniform_buffer_variables(struct gl_linked_shader *shader,
+ unsigned stage)
{
+ ir_array_refcount_visitor v;
+
+ v.run(shader->ir);
+
foreach_in_list(ir_instruction, node, shader->ir) {
ir_variable *const var = node->as_variable();
- if ((var == NULL) || !var->is_in_buffer_block())
- continue;
+ if (var == NULL || !var->is_in_buffer_block())
+ continue;
assert(var->data.mode == ir_var_uniform ||
var->data.mode == ir_var_shader_storage);
+ unsigned num_blocks = var->data.mode == ir_var_uniform ?
+ shader->Program->info.num_ubos : shader->Program->info.num_ssbos;
+ struct gl_uniform_block **blks = var->data.mode == ir_var_uniform ?
+ shader->Program->sh.UniformBlocks :
+ shader->Program->sh.ShaderStorageBlocks;
+
if (var->is_interface_instance()) {
+ const ir_array_refcount_entry *const entry = v.get_variable_entry(var);
+
+ if (entry->is_referenced) {
+ /* Since this is an interface instance, the instance type will be
+ * same as the array-stripped variable type. If the variable type
+ * is an array, then the block names will be suffixed with [0]
+ * through [n-1]. Unlike for non-interface instances, there will
+ * not be structure types here, so the only name sentinel that we
+ * have to worry about is [.
+ */
+ assert(var->type->without_array() == var->get_interface_type());
+ const char sentinel = var->type->is_array() ? '[' : '\0';
+
+ const ptrdiff_t len = strlen(var->get_interface_type()->name);
+ for (unsigned i = 0; i < num_blocks; i++) {
+ const char *const begin = blks[i]->Name;
+ const char *const end = strchr(begin, sentinel);
+
+ if (end == NULL)
+ continue;
+
+ if (len != (end - begin))
+ continue;
+
+ /* Even when a match is found, do not "break" here. This could
+ * be an array of instances, and all elements of the array need
+ * to be marked as referenced.
+ */
+ if (strncmp(begin, var->get_interface_type()->name, len) == 0 &&
+ (!var->type->is_array() ||
+ entry->is_linearized_index_referenced(blks[i]->linearized_array_index))) {
+ blks[i]->stageref |= 1U << stage;
+ }
+ }
+ }
+
var->data.location = 0;
continue;
}
bool found = false;
char sentinel = '\0';
- if (var->type->is_record()) {
+ if (var->type->is_struct()) {
sentinel = '.';
} else if (var->type->is_array() && (var->type->fields.array->is_array()
- || var->type->without_array()->is_record())) {
+ || var->type->without_array()->is_struct())) {
sentinel = '[';
}
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)
if ((ptrdiff_t) l != (end - begin))
continue;
- if (strncmp(var->name, begin, l) == 0) {
- found = true;
- 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);
- }
-}
+ found = strncmp(var->name, begin, l) == 0;
+ } else {
+ found = strcmp(var->name, blks[i]->Uniforms[j].Name) == 0;
+ }
-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;
+ if (found) {
+ var->data.location = j;
+
+ if (variable_is_referenced(v, var))
+ blks[i]->stageref |= 1U << stage;
- /* Append the subscript to the current variable name */
- ralloc_asprintf_rewrite_tail(name, &new_length, "[%u]", i);
+ break;
+ }
+ }
- link_set_image_access_qualifiers(prog, sh, shader_stage, var,
- type->fields.array, name,
- new_length);
+ 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);
}
-void
-link_assign_uniform_locations(struct gl_shader_program *prog,
- unsigned int boolean_true)
+static void
+link_setup_uniform_remap_tables(struct gl_context *ctx,
+ struct gl_shader_program *prog)
{
- ralloc_free(prog->UniformStorage);
- prog->UniformStorage = NULL;
- prog->NumUniformStorage = 0;
-
- if (prog->UniformHash != NULL) {
- prog->UniformHash->clear();
- } else {
- prog->UniformHash = new string_to_uint_map;
- }
-
- /* First pass: Count the uniform resources used by the user-defined
- * uniforms. While this happens, each active uniform will have an index
- * assigned to it.
- *
- * Note: this is *NOT* the index that is returned to the application by
- * glGetUniformLocation.
- */
- 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];
-
- if (sh == NULL)
- continue;
-
- /* Uniforms that lack an initializer in the shader code have an initial
- * value of zero. This includes sampler uniforms.
- *
- * Page 24 (page 30 of the PDF) of the GLSL 1.20 spec says:
- *
- * "The link time initial value is either the value of the variable's
- * initializer, if present, or 0 if no initializer is present. Sampler
- * types cannot have initializers."
- */
- memset(sh->SamplerUnits, 0, sizeof(sh->SamplerUnits));
- memset(sh->ImageUnits, 0, sizeof(sh->ImageUnits));
-
- link_update_uniform_buffer_variables(sh);
-
- /* Reset various per-shader target counts.
- */
- uniform_size.start_shader();
-
- foreach_in_list(ir_instruction, node, sh->ir) {
- ir_variable *const var = node->as_variable();
-
- if ((var == NULL) || (var->data.mode != ir_var_uniform &&
- var->data.mode != ir_var_shader_storage))
- continue;
-
- uniform_size.process(var);
- }
-
- sh->num_samplers = uniform_size.num_shader_samplers;
- sh->NumImages = uniform_size.num_shader_images;
- 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;
- }
- }
- }
-
- const unsigned num_uniforms = uniform_size.num_active_uniforms;
- const unsigned num_data_slots = uniform_size.num_values;
- const unsigned hidden_uniforms = uniform_size.num_hidden_uniforms;
-
- /* assign hidden uniforms a slot id */
- hiddenUniforms->iterate(assign_hidden_uniform_slot_id, &uniform_size);
- delete hiddenUniforms;
-
- /* On the outside chance that there were no uniforms, bail out.
- */
- if (num_uniforms == 0)
- return;
-
- struct gl_uniform_storage *uniforms =
- rzalloc_array(prog, struct gl_uniform_storage, num_uniforms);
- union gl_constant_value *data =
- rzalloc_array(uniforms, union gl_constant_value, num_data_slots);
-#ifndef NDEBUG
- union gl_constant_value *data_end = &data[num_data_slots];
-#endif
-
- parcel_out_uniform_storage parcel(prog->UniformHash, uniforms, data);
-
- for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- if (prog->_LinkedShaders[i] == NULL)
- 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();
-
- if ((var == NULL) || (var->data.mode != ir_var_uniform &&
- var->data.mode != ir_var_shader_storage))
- continue;
-
- parcel.set_and_process(prog, var);
- }
-
- prog->_LinkedShaders[i]->active_samplers = parcel.shader_samplers_used;
- prog->_LinkedShaders[i]->shadow_samplers = parcel.shader_shadow_samplers;
-
- STATIC_ASSERT(sizeof(prog->_LinkedShaders[i]->SamplerTargets) ==
- sizeof(parcel.targets));
- memcpy(prog->_LinkedShaders[i]->SamplerTargets, parcel.targets,
- sizeof(prog->_LinkedShaders[i]->SamplerTargets));
- }
+ unsigned total_entries = prog->NumExplicitUniformLocations;
+ unsigned empty_locs = prog->NumUniformRemapTable - total_entries;
/* Reserve all the explicit locations of the active uniforms. */
- for (unsigned i = 0; i < num_uniforms; i++) {
- if (uniforms[i].type->is_subroutine() ||
- uniforms[i].is_shader_storage)
+ for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
+ if (prog->data->UniformStorage[i].type->is_subroutine() ||
+ prog->data->UniformStorage[i].is_shader_storage)
continue;
- if (uniforms[i].remap_location != UNMAPPED_UNIFORM_LOC) {
+ if (prog->data->UniformStorage[i].remap_location !=
+ UNMAPPED_UNIFORM_LOC) {
/* How many new entries for this uniform? */
- const unsigned entries = MAX2(1, uniforms[i].array_elements);
+ const unsigned entries =
+ MAX2(1, prog->data->UniformStorage[i].array_elements);
/* Set remap table entries point to correct gl_uniform_storage. */
for (unsigned j = 0; j < entries; j++) {
- unsigned element_loc = uniforms[i].remap_location + j;
+ unsigned element_loc =
+ prog->data->UniformStorage[i].remap_location + j;
assert(prog->UniformRemapTable[element_loc] ==
INACTIVE_UNIFORM_EXPLICIT_LOCATION);
- prog->UniformRemapTable[element_loc] = &uniforms[i];
+ prog->UniformRemapTable[element_loc] =
+ &prog->data->UniformStorage[i];
}
}
}
/* Reserve locations for rest of the uniforms. */
- for (unsigned i = 0; i < num_uniforms; i++) {
+ for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
- if (uniforms[i].type->is_subroutine() ||
- uniforms[i].is_shader_storage)
+ if (prog->data->UniformStorage[i].type->is_subroutine() ||
+ prog->data->UniformStorage[i].is_shader_storage)
continue;
/* Built-in uniforms should not get any location. */
- if (uniforms[i].builtin)
+ if (prog->data->UniformStorage[i].builtin)
continue;
/* Explicit ones have been set already. */
- if (uniforms[i].remap_location != UNMAPPED_UNIFORM_LOC)
+ if (prog->data->UniformStorage[i].remap_location != UNMAPPED_UNIFORM_LOC)
continue;
/* how many new entries for this uniform? */
- const unsigned entries = MAX2(1, uniforms[i].array_elements);
+ const unsigned entries =
+ MAX2(1, prog->data->UniformStorage[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 = link_util_find_empty_block(prog, &prog->data->UniformStorage[i]);
+
+ /* Add new entries to the total amount for checking against MAX_UNIFORM-
+ * _LOCATIONS. This only applies to the default uniform block (-1),
+ * because locations of uniform block entries are not assignable.
+ */
+ if (prog->data->UniformStorage[i].block_index == -1)
+ 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] =
+ &prog->data->UniformStorage[i];
/* set the base location in remap table for the uniform */
- uniforms[i].remap_location = prog->NumUniformRemapTable;
+ prog->data->UniformStorage[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 > ctx->Const.MaxUserAssignableUniformLocations) {
+ linker_error(prog, "count of uniform locations > MAX_UNIFORM_LOCATIONS"
+ "(%u > %u)", total_entries,
+ ctx->Const.MaxUserAssignableUniformLocations);
}
/* Reserve all the explicit locations of the active subroutine uniforms. */
- for (unsigned i = 0; i < num_uniforms; i++) {
- if (!uniforms[i].type->is_subroutine())
+ for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
+ if (!prog->data->UniformStorage[i].type->is_subroutine())
continue;
- if (uniforms[i].remap_location == UNMAPPED_UNIFORM_LOC)
+ if (prog->data->UniformStorage[i].remap_location == UNMAPPED_UNIFORM_LOC)
continue;
- for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
- struct gl_shader *sh = prog->_LinkedShaders[j];
- if (!sh)
- continue;
+ /* How many new entries for this uniform? */
+ const unsigned entries =
+ MAX2(1, prog->data->UniformStorage[i].array_elements);
- if (!uniforms[i].opaque[j].active)
- continue;
+ unsigned mask = prog->data->linked_stages;
+ while (mask) {
+ const int j = u_bit_scan(&mask);
+ struct gl_program *p = prog->_LinkedShaders[j]->Program;
- /* How many new entries for this uniform? */
- const unsigned entries = MAX2(1, uniforms[i].array_elements);
+ if (!prog->data->UniformStorage[i].opaque[j].active)
+ continue;
/* Set remap table entries point to correct gl_uniform_storage. */
for (unsigned k = 0; k < entries; k++) {
- unsigned element_loc = uniforms[i].remap_location + k;
- assert(sh->SubroutineUniformRemapTable[element_loc] ==
+ unsigned element_loc =
+ prog->data->UniformStorage[i].remap_location + k;
+ assert(p->sh.SubroutineUniformRemapTable[element_loc] ==
INACTIVE_UNIFORM_EXPLICIT_LOCATION);
- sh->SubroutineUniformRemapTable[element_loc] = &uniforms[i];
+ p->sh.SubroutineUniformRemapTable[element_loc] =
+ &prog->data->UniformStorage[i];
}
}
}
/* reserve subroutine locations */
- for (unsigned i = 0; i < num_uniforms; i++) {
-
- if (!uniforms[i].type->is_subroutine())
+ for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
+ if (!prog->data->UniformStorage[i].type->is_subroutine())
continue;
- const unsigned entries = MAX2(1, uniforms[i].array_elements);
- if (uniforms[i].remap_location != UNMAPPED_UNIFORM_LOC)
+ if (prog->data->UniformStorage[i].remap_location !=
+ UNMAPPED_UNIFORM_LOC)
continue;
- for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
- struct gl_shader *sh = prog->_LinkedShaders[j];
- if (!sh)
- continue;
- if (!uniforms[i].opaque[j].active)
+ const unsigned entries =
+ MAX2(1, prog->data->UniformStorage[i].array_elements);
+
+ unsigned mask = prog->data->linked_stages;
+ while (mask) {
+ const int j = u_bit_scan(&mask);
+ struct gl_program *p = prog->_LinkedShaders[j]->Program;
+
+ if (!prog->data->UniformStorage[i].opaque[j].active)
continue;
- sh->SubroutineUniformRemapTable =
- reralloc(sh,
- sh->SubroutineUniformRemapTable,
+ p->sh.SubroutineUniformRemapTable =
+ reralloc(p,
+ p->sh.SubroutineUniformRemapTable,
gl_uniform_storage *,
- sh->NumSubroutineUniformRemapTable + entries);
+ p->sh.NumSubroutineUniformRemapTable + entries);
+
+ for (unsigned k = 0; k < entries; k++) {
+ p->sh.SubroutineUniformRemapTable[p->sh.NumSubroutineUniformRemapTable + k] =
+ &prog->data->UniformStorage[i];
+ }
+ prog->data->UniformStorage[i].remap_location =
+ p->sh.NumSubroutineUniformRemapTable;
+ p->sh.NumSubroutineUniformRemapTable += entries;
+ }
+ }
+}
+
+static void
+link_assign_uniform_storage(struct gl_context *ctx,
+ struct gl_shader_program *prog,
+ const unsigned num_data_slots)
+{
+ /* On the outside chance that there were no uniforms, bail out.
+ */
+ if (prog->data->NumUniformStorage == 0)
+ return;
+
+ unsigned int boolean_true = ctx->Const.UniformBooleanTrue;
+
+ union gl_constant_value *data;
+ if (prog->data->UniformStorage == NULL) {
+ prog->data->UniformStorage = rzalloc_array(prog->data,
+ struct gl_uniform_storage,
+ prog->data->NumUniformStorage);
+ data = rzalloc_array(prog->data->UniformStorage,
+ union gl_constant_value, num_data_slots);
+ prog->data->UniformDataDefaults =
+ rzalloc_array(prog->data->UniformStorage,
+ union gl_constant_value, num_data_slots);
+ } else {
+ data = prog->data->UniformDataSlots;
+ }
+
+#ifndef NDEBUG
+ union gl_constant_value *data_end = &data[num_data_slots];
+#endif
+
+ parcel_out_uniform_storage parcel(prog, prog->UniformHash,
+ prog->data->UniformStorage, data,
+ ctx->Const.UseSTD430AsDefaultPacking);
+
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
+ struct gl_linked_shader *shader = prog->_LinkedShaders[i];
- for (unsigned k = 0; k < entries; k++)
- sh->SubroutineUniformRemapTable[sh->NumSubroutineUniformRemapTable + k] = &uniforms[i];
- uniforms[i].remap_location = sh->NumSubroutineUniformRemapTable;
- sh->NumSubroutineUniformRemapTable += entries;
+ if (!shader)
+ continue;
+
+ parcel.start_shader((gl_shader_stage)i);
+
+ foreach_in_list(ir_instruction, node, shader->ir) {
+ ir_variable *const var = node->as_variable();
+
+ if ((var == NULL) || (var->data.mode != ir_var_uniform &&
+ var->data.mode != ir_var_shader_storage))
+ continue;
+
+ parcel.set_and_process(var);
}
+
+ shader->Program->SamplersUsed = parcel.shader_samplers_used;
+ shader->shadow_samplers = parcel.shader_shadow_samplers;
+ shader->Program->sh.ShaderStorageBlocksWriteAccess =
+ parcel.shader_storage_blocks_write_access;
+
+ if (parcel.num_bindless_samplers > 0) {
+ shader->Program->sh.NumBindlessSamplers = parcel.num_bindless_samplers;
+ shader->Program->sh.BindlessSamplers =
+ rzalloc_array(shader->Program, gl_bindless_sampler,
+ parcel.num_bindless_samplers);
+ for (unsigned j = 0; j < parcel.num_bindless_samplers; j++) {
+ shader->Program->sh.BindlessSamplers[j].target =
+ parcel.bindless_targets[j];
+ }
+ }
+
+ if (parcel.num_bindless_images > 0) {
+ shader->Program->sh.NumBindlessImages = parcel.num_bindless_images;
+ shader->Program->sh.BindlessImages =
+ rzalloc_array(shader->Program, gl_bindless_image,
+ parcel.num_bindless_images);
+ for (unsigned j = 0; j < parcel.num_bindless_images; j++) {
+ shader->Program->sh.BindlessImages[j].access =
+ parcel.bindless_access[j];
+ }
+ }
+
+ STATIC_ASSERT(ARRAY_SIZE(shader->Program->sh.SamplerTargets) ==
+ ARRAY_SIZE(parcel.targets));
+ for (unsigned j = 0; j < ARRAY_SIZE(parcel.targets); j++)
+ shader->Program->sh.SamplerTargets[j] = parcel.targets[j];
}
#ifndef NDEBUG
- for (unsigned i = 0; i < num_uniforms; i++) {
- assert(uniforms[i].storage != NULL || uniforms[i].builtin);
+ for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
+ assert(prog->data->UniformStorage[i].storage != NULL ||
+ prog->data->UniformStorage[i].builtin ||
+ prog->data->UniformStorage[i].is_shader_storage ||
+ prog->data->UniformStorage[i].block_index != -1);
}
assert(parcel.values == data_end);
#endif
- prog->NumUniformStorage = num_uniforms;
- prog->NumHiddenUniforms = hidden_uniforms;
- prog->UniformStorage = uniforms;
+ link_setup_uniform_remap_tables(ctx, prog);
- /**
- * Scan the program for image uniforms and store image unit access
- * information into the gl_shader data structure.
+ /* Set shader cache fields */
+ prog->data->NumUniformDataSlots = num_data_slots;
+ prog->data->UniformDataSlots = data;
+
+ link_set_uniform_initializers(prog, boolean_true);
+}
+
+void
+link_assign_uniform_locations(struct gl_shader_program *prog,
+ struct gl_context *ctx)
+{
+ ralloc_free(prog->data->UniformStorage);
+ prog->data->UniformStorage = NULL;
+ prog->data->NumUniformStorage = 0;
+
+ if (prog->UniformHash != NULL) {
+ prog->UniformHash->clear();
+ } else {
+ prog->UniformHash = new string_to_uint_map;
+ }
+
+ /* First pass: Count the uniform resources used by the user-defined
+ * uniforms. While this happens, each active uniform will have an index
+ * assigned to it.
+ *
+ * Note: this is *NOT* the index that is returned to the application by
+ * glGetUniformLocation.
*/
+ struct string_to_uint_map *hiddenUniforms = new string_to_uint_map;
+ count_uniform_size uniform_size(prog->UniformHash, hiddenUniforms,
+ ctx->Const.UseSTD430AsDefaultPacking);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
- continue;
+ continue;
+
+ link_update_uniform_buffer_variables(sh, i);
+
+ /* Reset various per-shader target counts.
+ */
+ uniform_size.start_shader();
foreach_in_list(ir_instruction, node, sh->ir) {
- ir_variable *var = node->as_variable();
+ ir_variable *const 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);
- }
+ if ((var == NULL) || (var->data.mode != ir_var_uniform &&
+ var->data.mode != ir_var_shader_storage))
+ continue;
+
+ uniform_size.process(var);
+ }
+
+ if (uniform_size.num_shader_samplers >
+ ctx->Const.Program[i].MaxTextureImageUnits) {
+ linker_error(prog, "Too many %s shader texture samplers\n",
+ _mesa_shader_stage_to_string(i));
+ continue;
+ }
+
+ if (uniform_size.num_shader_images >
+ ctx->Const.Program[i].MaxImageUniforms) {
+ linker_error(prog, "Too many %s shader image uniforms (%u > %u)\n",
+ _mesa_shader_stage_to_string(i),
+ sh->Program->info.num_images,
+ ctx->Const.Program[i].MaxImageUniforms);
+ continue;
+ }
+
+ sh->Program->info.num_textures = uniform_size.num_shader_samplers;
+ sh->Program->info.num_images = uniform_size.num_shader_images;
+ 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->Program->info.num_ubos; i++) {
+ sh->num_combined_uniform_components +=
+ sh->Program->sh.UniformBlocks[i]->UniformBufferSize / 4;
}
}
- link_set_uniform_initializers(prog, boolean_true);
+ if (prog->data->LinkStatus == LINKING_FAILURE) {
+ delete hiddenUniforms;
+ return;
+ }
+
+ prog->data->NumUniformStorage = uniform_size.num_active_uniforms;
+ prog->data->NumHiddenUniforms = uniform_size.num_hidden_uniforms;
+
+ /* assign hidden uniforms a slot id */
+ hiddenUniforms->iterate(assign_hidden_uniform_slot_id, &uniform_size);
+ delete hiddenUniforms;
- return;
+ link_assign_uniform_storage(ctx, prog, uniform_size.num_values);
}
projects / mesa.git / blobdiff