fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 20:28:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

glsl,gallium,mesa: replace MESA_SHADER_STAGES with MESA_SHADER_MESH_STAGES

Browse source 
Prepare for mesh shader support, change all shared code to
use MESA_SHADER_MESH_STAGES.

Use command:
  find src/gallium/auxiliary/ -type f -not -path '*/.git/*' -exec sed -i 's/\bMESA_SHADER_STAGES\b/MESA_SHADER_MESH_STAGES/g' {} +
  find src/compiler -type f -not -path '*/.git/*' -exec sed -i 's/\bMESA_SHADER_STAGES\b/MESA_SHADER_MESH_STAGES/g' {} +
  find src/mesa -type f -not -path '*/.git/*' -exec sed -i 's/\bMESA_SHADER_STAGES\b/MESA_SHADER_MESH_STAGES/g' {} +

Reviewed-by: Marek Olšák <marek.olsak@amd.com>
Reviewed-by: Yonggang Luo <luoyonggang@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/36596>
This commit is contained in:
Qiang Yu 2025-08-06 16:01:54 +08:00 • committed by Marge Bot
parent fba8bddc4f
commit 5f1983f346
37 changed files with 159 additions and 159 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
src/compiler/glsl/gl_nir_link_atomics.c
View file

@ -42,7 +42,7 @@ struct active_atomic_buffer {
struct active_atomic_counter_uniform *uniforms;
unsigned num_uniforms;
unsigned uniform_buffer_size;
unsigned stage_counter_references[MESA_SHADER_STAGES];
unsigned stage_counter_references[MESA_SHADER_MESH_STAGES];
unsigned size;
};
@ -142,7 +142,7 @@ find_active_atomic_counters(const struct gl_constants *consts,
consts->MaxAtomicBufferBindings);
*num_buffers = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; ++i) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; ++i) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
continue;
@ -195,7 +195,7 @@ gl_nir_link_assign_atomic_counter_resources(const struct gl_constants *consts,
struct gl_shader_program *prog)
{
unsigned num_buffers;
unsigned num_atomic_buffers[MESA_SHADER_STAGES] = {0};
unsigned num_atomic_buffers[MESA_SHADER_MESH_STAGES] = {0};
struct active_atomic_buffer *abs =
find_active_atomic_counters(consts, prog, &num_buffers);
@ -246,7 +246,7 @@ gl_nir_link_assign_atomic_counter_resources(const struct gl_constants *consts,
}
/* Assign stage-specific fields. */
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; ++stage) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; ++stage) {
if (ab->stage_counter_references[stage]) {
mab->StageReferences[stage] = GL_TRUE;
num_atomic_buffers[stage]++;
@ -261,7 +261,7 @@ gl_nir_link_assign_atomic_counter_resources(const struct gl_constants *consts,
/* Store a list pointers to atomic buffers per stage and store the index
* to the intra-stage buffer list in uniform storage.
*/
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; ++stage) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; ++stage) {
if (prog->_LinkedShaders[stage] == NULL ||
num_atomic_buffers[stage] <= 0)
continue;
@ -308,8 +308,8 @@ gl_nir_link_check_atomic_counter_resources(const struct gl_constants *consts,
unsigned num_buffers;
struct active_atomic_buffer *abs =
find_active_atomic_counters(consts, prog, &num_buffers);
unsigned atomic_counters[MESA_SHADER_STAGES] = {0};
unsigned atomic_buffers[MESA_SHADER_STAGES] = {0};
unsigned atomic_counters[MESA_SHADER_MESH_STAGES] = {0};
unsigned atomic_buffers[MESA_SHADER_MESH_STAGES] = {0};
unsigned total_atomic_counters = 0;
unsigned total_atomic_buffers = 0;
@ -341,7 +341,7 @@ gl_nir_link_check_atomic_counter_resources(const struct gl_constants *consts,
}
}
for (unsigned j = 0; j < MESA_SHADER_STAGES; ++j) {
for (unsigned j = 0; j < MESA_SHADER_MESH_STAGES; ++j) {
const unsigned n = abs[i].stage_counter_references[j];
if (n) {
@ -354,7 +354,7 @@ gl_nir_link_check_atomic_counter_resources(const struct gl_constants *consts,
}
/* Check that they are within the supported limits. */
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (atomic_counters[i] > consts->Program[i].MaxAtomicCounters)
linker_error(prog, "Too many %s shader atomic counters",
_mesa_shader_stage_to_string(i));

2
src/compiler/glsl/gl_nir_link_interface_blocks.c
View file

@ -757,7 +757,7 @@ gl_nir_validate_interstage_uniform_blocks(struct gl_shader_program *prog,
struct hash_table *ht = _mesa_hash_table_create(mem_ctx, _mesa_hash_string,
_mesa_key_string_equal);
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (stages[i] == NULL)
continue;

12
src/compiler/glsl/gl_nir_link_uniform_blocks.c
View file

@ -262,13 +262,13 @@ static bool
nir_interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog,
enum block_type block_type)
{
int *interfaceBlockStageIndex[MESA_SHADER_STAGES];
int *interfaceBlockStageIndex[MESA_SHADER_MESH_STAGES];
struct gl_uniform_block *blks = NULL;
unsigned *num_blks = block_type == BLOCK_SSBO ? &prog->data->NumShaderStorageBlocks :
&prog->data->NumUniformBlocks;
unsigned max_num_buffer_blocks = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i]) {
if (block_type == BLOCK_SSBO) {
max_num_buffer_blocks +=
@ -280,7 +280,7 @@ nir_interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog,
}
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
interfaceBlockStageIndex[i] = malloc(max_num_buffer_blocks * sizeof(int));
@ -328,7 +328,7 @@ nir_interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog,
/* Update per stage block pointers to point to the program list.
*/
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
for (unsigned j = 0; j < *num_blks; j++) {
int stage_index = interfaceBlockStageIndex[i][j];
@ -345,7 +345,7 @@ nir_interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog,
}
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
free(interfaceBlockStageIndex[i]);
}
@ -1250,7 +1250,7 @@ gl_nir_link_uniform_blocks(const struct gl_constants *consts,
{
void *mem_ctx = ralloc_context(NULL);
bool ret = false;
for (int stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (int stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *const linked = prog->_LinkedShaders[stage];
struct gl_uniform_block *ubo_blocks = NULL;
unsigned num_ubo_blocks = 0;

6
src/compiler/glsl/gl_nir_link_uniform_initializers.c
View file

@ -60,7 +60,7 @@ set_opaque_binding(struct set_opaque_binding_closure *data,
for (unsigned int i = 0; i < elements; i++)
storage->storage[i].i = data->binding++;
for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
for (int sh = 0; sh < MESA_SHADER_MESH_STAGES; sh++) {
struct gl_linked_shader *shader = data->shader_prog->_LinkedShaders[sh];
if (!shader)
@ -243,7 +243,7 @@ set_uniform_initializer(struct set_uniform_initializer_closure *data,
data->boolean_true);
if (glsl_type_is_sampler(storage->type)) {
for (int sh = 0; sh < MESA_SHADER_STAGES; sh++) {
for (int sh = 0; sh < MESA_SHADER_MESH_STAGES; sh++) {
struct gl_linked_shader *shader =
data->shader_prog->_LinkedShaders[sh];
@ -261,7 +261,7 @@ void
gl_nir_set_uniform_initializers(const struct gl_constants *consts,
struct gl_shader_program *prog)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (!sh)
continue;

12
src/compiler/glsl/gl_nir_link_uniforms.c
View file

@ -222,7 +222,7 @@ update_array_sizes(struct gl_shader_program *prog, nir_variable *var,
struct uniform_array_info *ainfo = NULL;
int words = BITSET_WORDS(glsl_array_size(var->type));
int max_array_size = 0;
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[stage];
if (!sh)
continue;
@ -740,7 +740,7 @@ struct nir_link_uniforms_state {
int top_level_array_stride;
struct type_tree_entry *current_type;
struct hash_table *referenced_uniforms[MESA_SHADER_STAGES];
struct hash_table *referenced_uniforms[MESA_SHADER_MESH_STAGES];
struct hash_table *uniform_hash;
};
@ -1650,7 +1650,7 @@ gl_nir_link_uniforms(const struct gl_constants *consts,
if (!prog->data->spirv) {
/* Gather information on uniform use */
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[stage];
if (!sh)
continue;
@ -1665,7 +1665,7 @@ gl_nir_link_uniforms(const struct gl_constants *consts,
if(!consts->DisableUniformArrayResize) {
/* Resize uniform arrays based on the maximum array index */
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[stage];
if (!sh)
continue;
@ -1681,7 +1681,7 @@ gl_nir_link_uniforms(const struct gl_constants *consts,
if (!prog->data->spirv) {
struct set *storage_counted =
_mesa_set_create(NULL, _mesa_hash_string, _mesa_key_string_equal);
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[stage];
if (!sh)
continue;
@ -1717,7 +1717,7 @@ gl_nir_link_uniforms(const struct gl_constants *consts,
state.uniform_hash = _mesa_hash_table_create(NULL, _mesa_hash_string,
_mesa_key_string_equal);
for (unsigned shader_type = 0; shader_type < MESA_SHADER_STAGES; shader_type++) {
for (unsigned shader_type = 0; shader_type < MESA_SHADER_MESH_STAGES; shader_type++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[shader_type];
if (!sh)
continue;

10
src/compiler/glsl/gl_nir_link_varyings.c
View file

@ -3980,10 +3980,10 @@ link_varyings(const struct pipe_screen *screen,
return false;
}
struct gl_linked_shader *linked_shader[MESA_SHADER_STAGES];
struct gl_linked_shader *linked_shader[MESA_SHADER_MESH_STAGES];
unsigned num_shaders = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i])
linked_shader[num_shaders++] = prog->_LinkedShaders[i];
}
@ -4338,7 +4338,7 @@ gl_nir_link_varyings(const struct pipe_screen *screen,
MESA_TRACE_FUNC();
first = MESA_SHADER_STAGES;
first = MESA_SHADER_MESH_STAGES;
last = 0;
/* We need to initialise the program resource list because the varying
@ -4347,10 +4347,10 @@ gl_nir_link_varyings(const struct pipe_screen *screen,
init_program_resource_list(prog);
/* Determine first and last stage. */
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (!prog->_LinkedShaders[i])
continue;
if (first == MESA_SHADER_STAGES)
if (first == MESA_SHADER_MESH_STAGES)
first = i;
last = i;
}

64
src/compiler/glsl/gl_nir_linker.c
View file

@ -557,22 +557,22 @@ disable_varying_optimizations_for_sso(struct gl_shader_program *prog)
unsigned first, last;
assert(prog->SeparateShader);
first = MESA_SHADER_STAGES;
first = MESA_SHADER_MESH_STAGES;
last = 0;
/* Determine first and last stage. Excluding the compute stage */
for (unsigned i = 0; i < MESA_SHADER_COMPUTE; i++) {
if (!prog->_LinkedShaders[i])
continue;
if (first == MESA_SHADER_STAGES)
if (first == MESA_SHADER_MESH_STAGES)
first = i;
last = i;
}
if (first == MESA_SHADER_STAGES)
if (first == MESA_SHADER_MESH_STAGES)
return;
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
if (!prog->_LinkedShaders[stage])
continue;
@ -984,22 +984,22 @@ nir_build_program_resource_list(const struct gl_constants *consts,
if (rebuild_resourse_list)
init_program_resource_list(prog);
int input_stage = MESA_SHADER_STAGES, output_stage = 0;
int input_stage = MESA_SHADER_MESH_STAGES, output_stage = 0;
/* Determine first input and final output stage. These are used to
* detect which variables should be enumerated in the resource list
* for GL_PROGRAM_INPUT and GL_PROGRAM_OUTPUT.
*/
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (!prog->_LinkedShaders[i])
continue;
if (input_stage == MESA_SHADER_STAGES)
if (input_stage == MESA_SHADER_MESH_STAGES)
input_stage = i;
output_stage = i;
}
/* Empty shader, no resources. */
if (input_stage == MESA_SHADER_STAGES && output_stage == 0)
if (input_stage == MESA_SHADER_MESH_STAGES && output_stage == 0)
return;
struct set *resource_set = _mesa_pointer_set_create(NULL);
@ -1055,7 +1055,7 @@ nir_build_program_resource_list(const struct gl_constants *consts,
struct gl_uniform_storage *uniform = &prog->data->UniformStorage[i];
if (uniform->hidden) {
for (int j = MESA_SHADER_VERTEX; j < MESA_SHADER_STAGES; j++) {
for (int j = MESA_SHADER_VERTEX; j < MESA_SHADER_MESH_STAGES; j++) {
if (!uniform->opaque[j].active ||
glsl_get_base_type(uniform->type) != GLSL_TYPE_SUBROUTINE)
continue;
@ -1445,12 +1445,12 @@ void
gl_nir_lower_optimize_varyings(const struct gl_constants *consts,
struct gl_shader_program *prog, bool spirv)
{
nir_shader *shaders[MESA_SHADER_STAGES];
nir_shader *shaders[MESA_SHADER_MESH_STAGES];
unsigned num_shaders = 0;
unsigned max_ubos = UINT_MAX;
unsigned max_uniform_comps = UINT_MAX;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *shader = prog->_LinkedShaders[i];
if (!shader)
@ -1486,12 +1486,12 @@ gl_nir_link_spirv(const struct pipe_screen *screen,
struct gl_shader_program *prog,
const struct gl_nir_linker_options *options)
{
struct gl_linked_shader *linked_shader[MESA_SHADER_STAGES];
struct gl_linked_shader *linked_shader[MESA_SHADER_MESH_STAGES];
unsigned num_shaders = 0;
MESA_TRACE_FUNC();
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i]) {
linked_shader[num_shaders++] = prog->_LinkedShaders[i];
@ -1506,7 +1506,7 @@ gl_nir_link_spirv(const struct pipe_screen *screen,
gl_nir_lower_optimize_varyings(consts, prog, true);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *shader = prog->_LinkedShaders[i];
if (shader) {
const nir_remove_dead_variables_options opts = {
@ -1908,7 +1908,7 @@ cross_validate_uniforms(const struct gl_constants *consts,
void *mem_ctx = ralloc_context(NULL);
struct hash_table *variables =
_mesa_hash_table_create(mem_ctx, _mesa_hash_string, _mesa_key_string_equal);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
@ -3075,7 +3075,7 @@ check_image_resources(const struct gl_constants *consts,
if (!exts->ARB_shader_image_load_store)
return;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (!sh)
continue;
@ -3126,7 +3126,7 @@ validate_sampler_array_indexing(const struct pipe_screen *screen,
const struct gl_constants *consts,
struct gl_shader_program *prog)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
@ -3527,10 +3527,10 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
/* Separate the shaders into groups based on their type.
*/
struct gl_shader **shader_list[MESA_SHADER_STAGES];
unsigned num_shaders[MESA_SHADER_STAGES];
struct gl_shader **shader_list[MESA_SHADER_MESH_STAGES];
unsigned num_shaders[MESA_SHADER_MESH_STAGES];
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
shader_list[i] = (struct gl_shader **)
calloc(prog->NumShaders, sizeof(struct gl_shader *));
num_shaders[i] = 0;
@ -3640,7 +3640,7 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
/* Link all shaders for a particular stage and validate the result.
*/
for (int stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (int stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
if (num_shaders[stage] > 0) {
struct gl_linked_shader *const sh =
link_intrastage_shaders(mem_ctx, ctx, prog, shader_list[stage],
@ -3659,7 +3659,7 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
/* Link all shaders for a particular stage and validate the result.
*/
for (int stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (int stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[stage];
if (sh) {
nir_shader *shader = sh->Program->nir;
@ -3712,7 +3712,7 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
if (!prog->data->LinkStatus)
goto done;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
@ -3730,12 +3730,12 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
/* Validate the inputs of each stage with the output of the preceding
* stage.
*/
unsigned prev = MESA_SHADER_STAGES;
unsigned prev = MESA_SHADER_MESH_STAGES;
for (unsigned i = 0; i <= MESA_SHADER_FRAGMENT; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;
if (prev == MESA_SHADER_STAGES) {
if (prev == MESA_SHADER_MESH_STAGES) {
prev = i;
continue;
}
@ -3771,14 +3771,14 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
break;
}
unsigned first = MESA_SHADER_STAGES;
unsigned first = MESA_SHADER_MESH_STAGES;
unsigned last = 0;
/* Determine first and last stage. */
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (!prog->_LinkedShaders[i])
continue;
if (first == MESA_SHADER_STAGES)
if (first == MESA_SHADER_MESH_STAGES)
first = i;
last = i;
}
@ -3824,10 +3824,10 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
if (prog->SeparateShader)
disable_varying_optimizations_for_sso(prog);
struct gl_linked_shader *linked_shader[MESA_SHADER_STAGES];
struct gl_linked_shader *linked_shader[MESA_SHADER_MESH_STAGES];
unsigned num_linked_shaders = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i]) {
linked_shader[num_linked_shaders++] = prog->_LinkedShaders[i];
@ -3880,7 +3880,7 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
if (num_linked_shaders == 1)
gl_nir_opts(linked_shader[0]->Program->nir);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *shader = prog->_LinkedShaders[i];
if (shader) {
if (consts->GLSLLowerConstArrays) {
@ -3965,7 +3965,7 @@ gl_nir_link_glsl(struct gl_context *ctx, struct gl_shader_program *prog)
}
done:
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
free(shader_list[i]);
}

2
src/compiler/glsl/gl_nir_lower_named_interface_blocks.c
View file

@ -362,7 +362,7 @@ lower_named_interface_blocks(struct gl_linked_shader *sh)
void
gl_nir_lower_named_interface_blocks(struct gl_shader_program *prog)
{
for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i] != NULL) {
NIR_PASS(_, prog->_LinkedShaders[i]->Program->nir, nir_split_var_copies);
lower_named_interface_blocks(prog->_LinkedShaders[i]);

4
src/compiler/glsl/gl_nir_lower_packed_varyings.c
View file

@ -1028,9 +1028,9 @@ gl_nir_lower_packed_varyings(const struct gl_constants *consts,
locations_used);
/* Determine if the shader interface is exposed to api query */
struct gl_linked_shader *linked_shaders[MESA_SHADER_STAGES];
struct gl_linked_shader *linked_shaders[MESA_SHADER_MESH_STAGES];
unsigned num_shaders = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i])
linked_shaders[num_shaders++] = prog->_LinkedShaders[i];
}

2
src/compiler/glsl/glsl_parser_extras.cpp
View file

@ -67,7 +67,7 @@ _mesa_glsl_parse_state::_mesa_glsl_parse_state(struct gl_context *_ctx,
api(_ctx->API), cs_input_local_size_specified(false), cs_input_local_size(),
switch_state(), warnings_enabled(true)
{
assert(stage < MESA_SHADER_STAGES);
assert(stage < MESA_SHADER_MESH_STAGES);
this->stage = stage;
this->scanner = NULL;

2
src/compiler/glsl/linker_util.cpp
View file

@ -299,7 +299,7 @@ link_util_check_uniform_resources(const struct gl_constants *consts,
unsigned total_uniform_blocks = 0;
unsigned total_shader_storage_blocks = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)

22
src/compiler/glsl/serialize.cpp
View file

@ -42,7 +42,7 @@
static void
write_subroutines(struct blob *metadata, struct gl_shader_program *prog)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (!sh)
continue;
@ -72,7 +72,7 @@ read_subroutines(struct blob_reader *metadata, struct gl_shader_program *prog)
{
struct gl_subroutine_function *subs;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (!sh)
continue;
@ -133,7 +133,7 @@ write_buffer_blocks(struct blob *metadata, struct gl_shader_program *prog)
write_buffer_block(metadata, &prog->data->ShaderStorageBlocks[i]);
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (!sh)
continue;
@ -210,7 +210,7 @@ read_buffer_blocks(struct blob_reader *metadata,
read_buffer_block(metadata, &prog->data->ShaderStorageBlocks[i], prog);
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (!sh)
continue;
@ -243,7 +243,7 @@ write_atomic_buffers(struct blob *metadata, struct gl_shader_program *prog)
{
blob_write_uint32(metadata, prog->data->NumAtomicBuffers);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i]) {
struct gl_program *glprog = prog->_LinkedShaders[i]->Program;
blob_write_uint32(metadata, glprog->info.num_abos);
@ -273,8 +273,8 @@ read_atomic_buffers(struct blob_reader *metadata,
rzalloc_array(prog, gl_active_atomic_buffer,
prog->data->NumAtomicBuffers);
struct gl_active_atomic_buffer **stage_buff_list[MESA_SHADER_STAGES];
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
struct gl_active_atomic_buffer **stage_buff_list[MESA_SHADER_MESH_STAGES];
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i]) {
struct gl_program *glprog = prog->_LinkedShaders[i]->Program;
@ -302,7 +302,7 @@ read_atomic_buffers(struct blob_reader *metadata,
prog->data->AtomicBuffers[i].Uniforms[j] = blob_read_uint32(metadata);
}
for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) {
for (unsigned j = 0; j < MESA_SHADER_MESH_STAGES; j++) {
if (prog->data->AtomicBuffers[i].StageReferences[j]) {
*stage_buff_list[j] = &prog->data->AtomicBuffers[i];
stage_buff_list[j]++;
@ -622,7 +622,7 @@ write_uniform_remap_tables(struct blob *metadata,
prog->data->UniformStorage,
prog->UniformRemapTable);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh) {
write_uniform_remap_table(metadata,
@ -677,7 +677,7 @@ read_uniform_remap_tables(struct blob_reader *metadata,
read_uniform_remap_table(metadata, prog, &prog->NumUniformRemapTable,
prog->data->UniformStorage);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh) {
struct gl_program *glprog = sh->Program;
@ -1279,7 +1279,7 @@ serialize_glsl_program(struct blob *blob, struct gl_context *ctx,
blob_write_uint32(blob, prog->IsES);
blob_write_uint32(blob, prog->data->linked_stages);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh) {
write_shader_metadata(blob, sh);

2
src/compiler/glsl/shader_cache.cpp
View file

@ -102,7 +102,7 @@ shader_cache_write_program_metadata(struct gl_context *ctx,
blob_init(&metadata);
if (ctx->Driver.ShaderCacheSerializeDriverBlob) {
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh)
ctx->Driver.ShaderCacheSerializeDriverBlob(ctx, sh->Program);

4
src/compiler/glsl/standalone.cpp
View file

@ -265,7 +265,7 @@ initialize_context(struct gl_context *ctx, gl_api api)
/* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
ctx->Const.MaxUserAssignableUniformLocations =
4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
4 * MESA_SHADER_MESH_STAGES * MAX_UNIFORMS;
}
/* Returned string will have 'ctx' as its ralloc owner. */
@ -446,7 +446,7 @@ standalone_compile_shader(const struct standalone_options *_options,
return whole_program;
fail:
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (whole_program->_LinkedShaders[i])
_mesa_delete_linked_shader(ctx, whole_program->_LinkedShaders[i]);
}

4
src/compiler/glsl/standalone_scaffolding.cpp
View file

@ -151,7 +151,7 @@ void
_mesa_clear_shader_program_data(struct gl_context *ctx,
struct gl_shader_program *shProg)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (shProg->_LinkedShaders[i] != NULL) {
_mesa_delete_linked_shader(ctx, shProg->_LinkedShaders[i]);
shProg->_LinkedShaders[i] = NULL;
@ -315,7 +315,7 @@ standalone_destroy_shader_program(struct gl_shader_program *whole_program)
ralloc_free(whole_program->Shaders[i]->nir);
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (whole_program->_LinkedShaders[i]) {
if (whole_program->_LinkedShaders[i]->Program->Parameters)
_mesa_free_parameter_list(whole_program->_LinkedShaders[i]->Program->Parameters);

4
src/compiler/glsl/tests/test_gl_lower_mediump.cpp
View file

@ -172,7 +172,7 @@ namespace
initialize_context_to_defaults(ctx, API_OPENGLES2);
ctx->Version = 31;
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
((struct pipe_shader_caps*)&ctx->screen->shader_caps[i])->fp16 = true;
((struct pipe_shader_caps*)&ctx->screen->shader_caps[i])->int16 = true;
ctx->screen->nir_options[i] = &compiler_options;
@ -180,7 +180,7 @@ namespace
/* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
ctx->Const.MaxUserAssignableUniformLocations =
4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
4 * MESA_SHADER_MESH_STAGES * MAX_UNIFORMS;
ctx->Const.Program[MESA_SHADER_VERTEX].MaxCombinedUniformComponents = 128 * 4;
ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxCombinedUniformComponents = 16 * 4;

8
src/gallium/auxiliary/driver_ddebug/dd_draw.c
View file

@ -405,7 +405,7 @@ dd_dump_draw_vbo(struct dd_draw_state *dstate, struct pipe_draw_info *info,
}
fprintf(f, "\n");
for (sh = 0; sh < MESA_SHADER_STAGES; sh++) {
for (sh = 0; sh < MESA_SHADER_MESH_STAGES; sh++) {
if (sh == MESA_SHADER_COMPUTE)
continue;
@ -827,7 +827,7 @@ dd_init_copy_of_draw_state(struct dd_draw_state_copy *state)
state->base.render_cond.query = &state->render_cond;
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
state->base.shaders[i] = &state->shaders[i];
for (j = 0; j < PIPE_MAX_SAMPLERS; j++)
state->base.sampler_states[i][j] = &state->sampler_states[i][j];
@ -850,7 +850,7 @@ dd_unreference_copy_of_draw_state(struct dd_draw_state_copy *state)
for (i = 0; i < ARRAY_SIZE(dst->so_targets); i++)
pipe_so_target_reference(&dst->so_targets[i], NULL);
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (dst->shaders[i])
tgsi_free_tokens(dst->shaders[i]->state.shader.tokens);
@ -890,7 +890,7 @@ dd_copy_draw_state(struct dd_draw_state *dst, struct dd_draw_state *src)
pipe_so_target_reference(&dst->so_targets[i], src->so_targets[i]);
memcpy(dst->so_offsets, src->so_offsets, sizeof(src->so_offsets));
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (!src->shaders[i]) {
dst->shaders[i] = NULL;
continue;

16
src/gallium/auxiliary/driver_ddebug/dd_pipe.h
View file

@ -246,12 +246,12 @@ struct dd_draw_state
struct pipe_stream_output_target *so_targets[PIPE_MAX_SO_BUFFERS];
unsigned so_offsets[PIPE_MAX_SO_BUFFERS];
struct dd_state *shaders[MESA_SHADER_STAGES];
struct pipe_constant_buffer constant_buffers[MESA_SHADER_STAGES][PIPE_MAX_CONSTANT_BUFFERS];
struct pipe_sampler_view *sampler_views[MESA_SHADER_STAGES][PIPE_MAX_SAMPLERS];
struct dd_state *sampler_states[MESA_SHADER_STAGES][PIPE_MAX_SAMPLERS];
struct pipe_image_view shader_images[MESA_SHADER_STAGES][PIPE_MAX_SHADER_IMAGES];
struct pipe_shader_buffer shader_buffers[MESA_SHADER_STAGES][PIPE_MAX_SHADER_BUFFERS];
struct dd_state *shaders[MESA_SHADER_MESH_STAGES];
struct pipe_constant_buffer constant_buffers[MESA_SHADER_MESH_STAGES][PIPE_MAX_CONSTANT_BUFFERS];
struct pipe_sampler_view *sampler_views[MESA_SHADER_MESH_STAGES][PIPE_MAX_SAMPLERS];
struct dd_state *sampler_states[MESA_SHADER_MESH_STAGES][PIPE_MAX_SAMPLERS];
struct pipe_image_view shader_images[MESA_SHADER_MESH_STAGES][PIPE_MAX_SHADER_IMAGES];
struct pipe_shader_buffer shader_buffers[MESA_SHADER_MESH_STAGES][PIPE_MAX_SHADER_BUFFERS];
struct dd_state *velems;
struct dd_state *rs;
@ -280,8 +280,8 @@ struct dd_draw_state_copy
* these variables, which serve as storage.
*/
struct dd_query render_cond;
struct dd_state shaders[MESA_SHADER_STAGES];
struct dd_state sampler_states[MESA_SHADER_STAGES][PIPE_MAX_SAMPLERS];
struct dd_state shaders[MESA_SHADER_MESH_STAGES];
struct dd_state sampler_states[MESA_SHADER_MESH_STAGES][PIPE_MAX_SAMPLERS];
struct dd_state velems;
struct dd_state rs;
struct dd_state dsa;

2
src/gallium/auxiliary/driver_trace/tr_context.c
View file

@ -755,7 +755,7 @@ trace_context_link_shader(struct pipe_context *_pipe, void **shaders)
trace_dump_call_begin("pipe_context", "link_shader");
trace_dump_arg(ptr, pipe);
trace_dump_arg_array(ptr, shaders, MESA_SHADER_STAGES);
trace_dump_arg_array(ptr, shaders, MESA_SHADER_MESH_STAGES);
pipe->link_shader(pipe, shaders);
trace_dump_call_end();
}

18
src/gallium/auxiliary/util/u_threaded_context.h
View file

@ -636,9 +636,9 @@ struct threaded_context {
bool flushing;
bool seen_streamout_buffers;
bool seen_shader_buffers[MESA_SHADER_STAGES];
bool seen_image_buffers[MESA_SHADER_STAGES];
bool seen_sampler_buffers[MESA_SHADER_STAGES];
bool seen_shader_buffers[MESA_SHADER_MESH_STAGES];
bool seen_image_buffers[MESA_SHADER_MESH_STAGES];
bool seen_sampler_buffers[MESA_SHADER_MESH_STAGES];
int8_t last_completed;
int8_t batch_generation;
@ -669,12 +669,12 @@ struct threaded_context {
*/
uint32_t vertex_buffers[PIPE_MAX_ATTRIBS];
uint32_t streamout_buffers[PIPE_MAX_SO_BUFFERS];
uint32_t const_buffers[MESA_SHADER_STAGES][PIPE_MAX_CONSTANT_BUFFERS];
uint32_t shader_buffers[MESA_SHADER_STAGES][PIPE_MAX_SHADER_BUFFERS];
uint32_t image_buffers[MESA_SHADER_STAGES][PIPE_MAX_SHADER_IMAGES];
uint32_t shader_buffers_writeable_mask[MESA_SHADER_STAGES];
uint64_t image_buffers_writeable_mask[MESA_SHADER_STAGES];
uint32_t sampler_buffers[MESA_SHADER_STAGES][PIPE_MAX_SHADER_SAMPLER_VIEWS];
uint32_t const_buffers[MESA_SHADER_MESH_STAGES][PIPE_MAX_CONSTANT_BUFFERS];
uint32_t shader_buffers[MESA_SHADER_MESH_STAGES][PIPE_MAX_SHADER_BUFFERS];
uint32_t image_buffers[MESA_SHADER_MESH_STAGES][PIPE_MAX_SHADER_IMAGES];
uint32_t shader_buffers_writeable_mask[MESA_SHADER_MESH_STAGES];
uint64_t image_buffers_writeable_mask[MESA_SHADER_MESH_STAGES];
uint32_t sampler_buffers[MESA_SHADER_MESH_STAGES][PIPE_MAX_SHADER_SAMPLER_VIEWS];
struct tc_batch batch_slots[TC_MAX_BATCHES];
struct tc_buffer_list buffer_lists[TC_MAX_BUFFER_LISTS];

2
src/mesa/main/consts_exts.h
View file

@ -438,7 +438,7 @@ struct gl_constants
} ViewportBounds; /**< GL_ARB_viewport_array */
GLuint MaxWindowRectangles; /**< GL_EXT_window_rectangles */
struct gl_program_constants Program[MESA_SHADER_STAGES];
struct gl_program_constants Program[MESA_SHADER_MESH_STAGES];
GLuint MaxProgramMatrices;
GLuint MaxProgramMatrixStackDepth;

4
src/mesa/main/context.c
View file

@ -429,9 +429,9 @@ _mesa_init_constants(struct gl_constants *consts, gl_api api)
/* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
consts->MaxUserAssignableUniformLocations =
4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
4 * MESA_SHADER_MESH_STAGES * MAX_UNIFORMS;
for (i = 0; i < MESA_SHADER_STAGES; i++)
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++)
init_program_limits(consts, i, &consts->Program[i]);
consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;

4
src/mesa/main/draw_validate.c
View file

@ -470,7 +470,7 @@ _mesa_update_valid_to_render_state(struct gl_context *ctx)
if (shader->Flags & GLSL_LOG) {
struct gl_program **prog = shader->CurrentProgram;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog[i] == NULL || prog[i]->_Used)
continue;
@ -486,7 +486,7 @@ _mesa_update_valid_to_render_state(struct gl_context *ctx)
_mesa_append_uniforms_to_file(prog[i]);
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog[i] != NULL)
prog[i]->_Used = GL_TRUE;
}

8
src/mesa/main/mtypes.h
View file

@ -2282,9 +2282,9 @@ struct gl_pipeline_object
*
* There is a separate program set for each shader stage.
*/
struct gl_program *CurrentProgram[MESA_SHADER_STAGES];
struct gl_program *CurrentProgram[MESA_SHADER_MESH_STAGES];
struct gl_shader_program *ReferencedPrograms[MESA_SHADER_STAGES];
struct gl_shader_program *ReferencedPrograms[MESA_SHADER_MESH_STAGES];
/**
* Program used by glUniform calls.
@ -2903,7 +2903,7 @@ struct gl_driver_flags
uint64_t NewFragClamp;
/** Shader constants (uniforms, program parameters, state constants) */
uint64_t NewShaderConstants[MESA_SHADER_STAGES];
uint64_t NewShaderConstants[MESA_SHADER_MESH_STAGES];
/** For GL_CLAMP emulation */
uint64_t NewSamplersWithClamp;
@ -3506,7 +3506,7 @@ struct gl_context
*/
struct gl_image_unit ImageUnits[MAX_IMAGE_UNITS];
struct gl_subroutine_index_binding SubroutineIndex[MESA_SHADER_STAGES];
struct gl_subroutine_index_binding SubroutineIndex[MESA_SHADER_MESH_STAGES];
/*@}*/
struct gl_meta_state *Meta; /**< for "meta" operations */

12
src/mesa/main/pipelineobj.c
View file

@ -60,7 +60,7 @@ _mesa_delete_pipeline_object(struct gl_context *ctx,
{
unsigned i;
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
_mesa_reference_program(ctx, &obj->CurrentProgram[i], NULL);
_mesa_reference_shader_program(ctx, &obj->ReferencedPrograms[i], NULL);
}
@ -530,7 +530,7 @@ _mesa_bind_pipeline(struct gl_context *ctx,
ctx->Pipeline.Default);
}
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_program *prog = ctx->_Shader->CurrentProgram[i];
if (prog) {
_mesa_program_init_subroutine_defaults(ctx, prog);
@ -820,7 +820,7 @@ program_stages_interleaved_illegally(const struct gl_pipeline_object *pipe)
/* Look for programs bound to stages: A -> B -> A, with any intervening
* sequence of unrelated programs or empty stages.
*/
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_program *cur = pipe->CurrentProgram[i];
/* Empty stages anywhere in the pipe are OK. Also we can be confident
@ -878,7 +878,7 @@ _mesa_validate_program_pipeline(struct gl_context* ctx,
* bound to the vertex stage also has a fragment shader, the fragment
* shader must also be bound to the fragment stage.
*/
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (!program_stages_all_active(pipe, pipe->CurrentProgram[i])) {
return GL_FALSE;
}
@ -939,7 +939,7 @@ _mesa_validate_program_pipeline(struct gl_context* ctx,
* applied to the pipeline object via UseProgramStages with the
* PROGRAM_SEPARABLE parameter set to FALSE.
*/
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (pipe->CurrentProgram[i] &&
!pipe->CurrentProgram[i]->info.separate_shader) {
pipe->InfoLog = ralloc_asprintf(pipe,
@ -962,7 +962,7 @@ _mesa_validate_program_pipeline(struct gl_context* ctx,
* there is a current program pipeline object, and that object is
* empty (no executable code is installed for any stage).
*/
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (pipe->CurrentProgram[i]) {
program_empty = false;
break;

6
src/mesa/main/program_binary.c
View file

@ -173,7 +173,7 @@ static void
write_program_payload(struct gl_context *ctx, struct blob *blob,
struct gl_shader_program *sh_prog)
{
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *shader = sh_prog->_LinkedShaders[stage];
if (shader)
ctx->Driver.ProgramBinarySerializeDriverBlob(ctx, sh_prog,
@ -184,7 +184,7 @@ write_program_payload(struct gl_context *ctx, struct blob *blob,
serialize_glsl_program(blob, ctx, sh_prog);
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
struct gl_linked_shader *shader = sh_prog->_LinkedShaders[stage];
if (shader) {
struct gl_program *prog = sh_prog->_LinkedShaders[stage]->Program;
@ -291,7 +291,7 @@ _mesa_program_binary(struct gl_context *ctx, struct gl_shader_program *sh_prog,
unsigned programs_in_use = 0;
if (ctx->_Shader)
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
if (ctx->_Shader->CurrentProgram[stage] &&
ctx->_Shader->CurrentProgram[stage]->Id == sh_prog->Name) {
programs_in_use |= 1 << stage;

2
src/mesa/main/shader_query.cpp
View file

@ -1249,7 +1249,7 @@ stage_from_enum(GLenum ref)
return MESA_SHADER_COMPUTE;
default:
assert(!"shader stage not supported");
return MESA_SHADER_STAGES;
return MESA_SHADER_MESH_STAGES;
}
}

6
src/mesa/main/shader_types.h
View file

@ -464,7 +464,7 @@ struct gl_shader_program
* \c MESA_SHADER_* defines. Entries for non-existent stages will be
* \c NULL.
*/
struct gl_linked_shader *_LinkedShaders[MESA_SHADER_STAGES];
struct gl_linked_shader *_LinkedShaders[MESA_SHADER_MESH_STAGES];
unsigned GLSL_Version; /**< GLSL version used for linking */
};
@ -687,7 +687,7 @@ struct gl_active_atomic_buffer
GLuint MinimumSize;
/** Shader stages making use of it. */
GLboolean StageReferences[MESA_SHADER_STAGES];
GLboolean StageReferences[MESA_SHADER_MESH_STAGES];
};
struct gl_resource_name
@ -793,7 +793,7 @@ struct gl_uniform_storage {
*/
unsigned array_elements;
struct gl_opaque_uniform_index opaque[MESA_SHADER_STAGES];
struct gl_opaque_uniform_index opaque[MESA_SHADER_MESH_STAGES];
/**
* Mask of shader stages (1 << MESA_SHADER_xxx) where this uniform is used.

10
src/mesa/main/shaderapi.c
View file

@ -221,7 +221,7 @@ _mesa_init_shader_state(struct gl_context *ctx)
void
_mesa_free_shader_state(struct gl_context *ctx)
{
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
_mesa_reference_program(ctx, &ctx->Shader.CurrentProgram[i], NULL);
_mesa_reference_shader_program(ctx,
&ctx->Shader.ReferencedPrograms[i],
@ -722,7 +722,7 @@ get_shader_program_completion_status(struct gl_context *ctx,
if (!screen->is_parallel_shader_compilation_finished)
return true;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *linked = shprog->_LinkedShaders[i];
void *sh = NULL;
@ -1255,7 +1255,7 @@ update_programs_in_pipeline(void *data, void *userData)
(struct update_programs_in_pipeline_params *) userData;
struct gl_pipeline_object *obj = (struct gl_pipeline_object *) data;
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
if (obj->CurrentProgram[stage] &&
obj->CurrentProgram[stage]->Id == params->shProg->Name) {
struct gl_program *prog = params->shProg->_LinkedShaders[stage]->Program;
@ -1348,7 +1348,7 @@ link_program(struct gl_context *ctx, struct gl_shader_program *shProg,
unsigned programs_in_use = 0;
if (ctx->_Shader)
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
for (unsigned stage = 0; stage < MESA_SHADER_MESH_STAGES; stage++) {
if (ctx->_Shader->CurrentProgram[stage] &&
ctx->_Shader->CurrentProgram[stage]->Id == shProg->Name) {
programs_in_use |= 1 << stage;
@ -1497,7 +1497,7 @@ void
_mesa_use_shader_program(struct gl_context *ctx,
struct gl_shader_program *shProg)
{
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_program *new_prog = NULL;
if (shProg && shProg->_LinkedShaders[i])
new_prog = shProg->_LinkedShaders[i]->Program;

2
src/mesa/main/shaderobj.c
View file

@ -323,7 +323,7 @@ void
_mesa_clear_shader_program_data(struct gl_context *ctx,
struct gl_shader_program *shProg)
{
for (mesa_shader_stage sh = 0; sh < MESA_SHADER_STAGES; sh++) {
for (mesa_shader_stage sh = 0; sh < MESA_SHADER_MESH_STAGES; sh++) {
if (shProg->_LinkedShaders[sh] != NULL) {
_mesa_delete_linked_shader(ctx, shProg->_LinkedShaders[sh]);
shProg->_LinkedShaders[sh] = NULL;

4
src/mesa/main/texstate.c
View file

@ -732,7 +732,7 @@ update_program_texture_state(struct gl_context *ctx, struct gl_program **prog,
{
int i;
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
GLbitfield mask;
GLuint s;
@ -891,7 +891,7 @@ fix_missing_textures_for_atifs(struct gl_context *ctx,
GLbitfield
_mesa_update_texture_state(struct gl_context *ctx)
{
struct gl_program *prog[MESA_SHADER_STAGES];
struct gl_program *prog[MESA_SHADER_MESH_STAGES];
int i;
int old_max_unit = ctx->Texture._MaxEnabledTexImageUnit;
BITSET_DECLARE(enabled_texture_units, MAX_COMBINED_TEXTURE_IMAGE_UNITS);

12
src/mesa/main/uniform_query.cpp
View file

@ -787,7 +787,7 @@ log_uniform(const void *values, enum glsl_base_type basicType,
static void
log_program_parameters(const struct gl_shader_program *shProg)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (shProg->_LinkedShaders[i] == NULL)
continue;
@ -1273,7 +1273,7 @@ _mesa_flush_vertices_for_uniforms(struct gl_context *ctx,
while (mask) {
unsigned index = u_bit_scan(&mask);
assert(index < MESA_SHADER_STAGES);
assert(index < MESA_SHADER_MESH_STAGES);
new_driver_state |= ctx->DriverFlags.NewShaderConstants[index];
}
@ -1532,7 +1532,7 @@ _mesa_uniform(GLint location, GLsizei count, const GLvoid *values,
shProg->SamplersValidated = GL_TRUE;
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *const sh = shProg->_LinkedShaders[i];
/* If the shader stage doesn't use the sampler uniform, skip this. */
@ -1589,7 +1589,7 @@ _mesa_uniform(GLint location, GLsizei count, const GLvoid *values,
* uniforms to image units present in the shader data structure.
*/
if (glsl_type_is_image(uni->type)) {
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = shProg->_LinkedShaders[i];
/* If the shader stage doesn't use the image uniform, skip this. */
@ -2114,7 +2114,7 @@ _mesa_uniform_handle(GLint location, GLsizei count, const GLvoid *values,
/* Mark this bindless sampler as not bound to a texture unit because
* it refers to a texture handle.
*/
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *const sh = shProg->_LinkedShaders[i];
/* If the shader stage doesn't use the sampler uniform, skip this. */
@ -2137,7 +2137,7 @@ _mesa_uniform_handle(GLint location, GLsizei count, const GLvoid *values,
/* Mark this bindless image as not bound to an image unit because it
* refers to a texture handle.
*/
for (int i = 0; i < MESA_SHADER_STAGES; i++) {
for (int i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
struct gl_linked_shader *sh = shProg->_LinkedShaders[i];
/* If the shader stage doesn't use the sampler uniform, skip this. */

16
src/mesa/state_tracker/st_context.h
View file

@ -199,7 +199,7 @@ struct st_context
* This means it has only 1 variant, not counting glBitmap and
* glDrawPixels.
*/
bool shader_has_one_variant[MESA_SHADER_STAGES];
bool shader_has_one_variant[MESA_SHADER_MESH_STAGES];
bool needs_texcoord_semantic;
bool apply_texture_swizzle_to_border_color;
@ -227,8 +227,8 @@ struct st_context
struct pipe_sampler_state frag_samplers[PIPE_MAX_SAMPLERS];
GLuint num_vert_samplers;
GLuint num_frag_samplers;
GLuint num_sampler_views[MESA_SHADER_STAGES];
unsigned num_images[MESA_SHADER_STAGES];
GLuint num_sampler_views[MESA_SHADER_MESH_STAGES];
unsigned num_images[MESA_SHADER_MESH_STAGES];
struct pipe_clip_state clip;
unsigned constbuf0_enabled_shader_mask;
unsigned fb_width;
@ -274,7 +274,7 @@ struct st_context
struct gl_program *fp; /**< Currently bound fragment program */
struct gl_program *cp; /**< Currently bound compute program */
};
struct gl_program *current_program[MESA_SHADER_STAGES];
struct gl_program *current_program[MESA_SHADER_MESH_STAGES];
};
struct st_common_variant *vp_variant;
@ -365,8 +365,8 @@ struct st_context
bool uses_user_vertex_buffers;
unsigned last_used_atomic_bindings[MESA_SHADER_STAGES];
unsigned last_num_ssbos[MESA_SHADER_STAGES];
unsigned last_used_atomic_bindings[MESA_SHADER_MESH_STAGES];
unsigned last_num_ssbos[MESA_SHADER_MESH_STAGES];
int32_t draw_stamp;
int32_t read_stamp;
@ -377,8 +377,8 @@ struct st_context
/* Array of bound texture/image handles which are resident in the context.
*/
struct st_bound_handles bound_texture_handles[MESA_SHADER_STAGES];
struct st_bound_handles bound_image_handles[MESA_SHADER_STAGES];
struct st_bound_handles bound_texture_handles[MESA_SHADER_MESH_STAGES];
struct st_bound_handles bound_image_handles[MESA_SHADER_MESH_STAGES];
/* Winsys buffers */
struct list_head winsys_buffers;

2
src/mesa/state_tracker/st_extensions.c
View file

@ -199,7 +199,7 @@ void st_init_limits(struct pipe_screen *screen,
c->PointSizeFixed = screen->caps.point_size_fixed != PIPE_POINT_SIZE_LOWER_ALWAYS;
for (sh = 0; sh < MESA_SHADER_STAGES; ++sh) {
for (sh = 0; sh < MESA_SHADER_MESH_STAGES; ++sh) {
struct gl_program_constants *pc = &c->Program[sh];
if (!screen->shader_caps[sh].max_instructions)

8
src/mesa/state_tracker/st_glsl_to_nir.cpp
View file

@ -400,7 +400,7 @@ st_link_glsl_to_nir(struct gl_context *ctx,
struct gl_shader_program *shader_program)
{
struct st_context *st = st_context(ctx);
struct gl_linked_shader *linked_shader[MESA_SHADER_STAGES];
struct gl_linked_shader *linked_shader[MESA_SHADER_MESH_STAGES];
unsigned num_shaders = 0;
/* Return early if we are loading the shader from on-disk cache */
@ -417,7 +417,7 @@ st_link_glsl_to_nir(struct gl_context *ctx,
return GL_FALSE;
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (shader_program->_LinkedShaders[i])
linked_shader[num_shaders++] = shader_program->_LinkedShaders[i];
}
@ -604,10 +604,10 @@ st_link_glsl_to_nir(struct gl_context *ctx,
struct pipe_context *pctx = st_context(ctx)->pipe;
if (pctx->link_shader) {
void *driver_handles[MESA_SHADER_STAGES];
void *driver_handles[MESA_SHADER_MESH_STAGES];
memset(driver_handles, 0, sizeof(driver_handles));
for (uint32_t i = 0; i < MESA_SHADER_STAGES; ++i) {
for (uint32_t i = 0; i < MESA_SHADER_MESH_STAGES; ++i) {
struct gl_linked_shader *shader = shader_program->_LinkedShaders[i];
if (shader) {
struct gl_program *p = shader->Program;

2
src/mesa/state_tracker/st_shader_cache.c
View file

@ -213,7 +213,7 @@ st_load_nir_from_disk_cache(struct gl_context *ctx,
if (prog->data->LinkStatus != LINKING_SKIPPED)
return false;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
for (unsigned i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
if (prog->_LinkedShaders[i] == NULL)
continue;

4
src/mesa/state_tracker/st_texture.c
View file

@ -485,7 +485,7 @@ st_destroy_bound_texture_handles(struct st_context *st)
{
unsigned i;
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
st_destroy_bound_texture_handles_per_stage(st, i);
}
}
@ -525,7 +525,7 @@ st_destroy_bound_image_handles(struct st_context *st)
{
unsigned i;
for (i = 0; i < MESA_SHADER_STAGES; i++) {
for (i = 0; i < MESA_SHADER_MESH_STAGES; i++) {
st_destroy_bound_image_handles_per_stage(st, i);
}
}