704 lines
26 KiB
C
704 lines
26 KiB
C
/*
|
|
* Copyright © 2018 Intel Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "nir.h"
|
|
#include "GL/gl.h"
|
|
#include "gl_nir.h"
|
|
#include "gl_nir_linker.h"
|
|
#include "linker_util.h"
|
|
#include "main/mtypes.h"
|
|
#include "main/shaderobj.h"
|
|
#include "ir_uniform.h" /* for gl_uniform_storage */
|
|
|
|
/**
|
|
* This file included general link methods, using NIR, instead of IR as
|
|
* the counter-part glsl/linker.cpp
|
|
*/
|
|
|
|
static bool
|
|
can_remove_uniform(nir_variable *var, UNUSED void *data)
|
|
{
|
|
/* Section 2.11.6 (Uniform Variables) of the OpenGL ES 3.0.3 spec
|
|
* says:
|
|
*
|
|
* "All members of a named uniform block declared with a shared or
|
|
* std140 layout qualifier are considered active, even if they are not
|
|
* referenced in any shader in the program. The uniform block itself is
|
|
* also considered active, even if no member of the block is
|
|
* referenced."
|
|
*
|
|
* Although the spec doesn't state it std430 layouts are expect to behave
|
|
* the same way. If the variable is in a uniform block with one of those
|
|
* layouts, do not eliminate it.
|
|
*/
|
|
if (nir_variable_is_in_block(var) &&
|
|
(glsl_get_ifc_packing(var->interface_type) !=
|
|
GLSL_INTERFACE_PACKING_PACKED))
|
|
return false;
|
|
|
|
if (glsl_get_base_type(glsl_without_array(var->type)) ==
|
|
GLSL_TYPE_SUBROUTINE)
|
|
return false;
|
|
|
|
/* Uniform initializers could get used by another stage */
|
|
if (var->constant_initializer)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Built-in / reserved GL variables names start with "gl_"
|
|
*/
|
|
static inline bool
|
|
is_gl_identifier(const char *s)
|
|
{
|
|
return s && s[0] == 'g' && s[1] == 'l' && s[2] == '_';
|
|
}
|
|
|
|
static bool
|
|
inout_has_same_location(const nir_variable *var, unsigned stage)
|
|
{
|
|
if (!var->data.patch &&
|
|
((var->data.mode == nir_var_shader_out &&
|
|
stage == MESA_SHADER_TESS_CTRL) ||
|
|
(var->data.mode == nir_var_shader_in &&
|
|
(stage == MESA_SHADER_TESS_CTRL || stage == MESA_SHADER_TESS_EVAL ||
|
|
stage == MESA_SHADER_GEOMETRY))))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Create gl_shader_variable from nir_variable.
|
|
*/
|
|
static struct gl_shader_variable *
|
|
create_shader_variable(struct gl_shader_program *shProg,
|
|
const nir_variable *in,
|
|
const char *name, const struct glsl_type *type,
|
|
const struct glsl_type *interface_type,
|
|
bool use_implicit_location, int location,
|
|
const struct glsl_type *outermost_struct_type)
|
|
{
|
|
/* Allocate zero-initialized memory to ensure that bitfield padding
|
|
* is zero.
|
|
*/
|
|
struct gl_shader_variable *out = rzalloc(shProg,
|
|
struct gl_shader_variable);
|
|
if (!out)
|
|
return NULL;
|
|
|
|
/* Since gl_VertexID may be lowered to gl_VertexIDMESA, but applications
|
|
* expect to see gl_VertexID in the program resource list. Pretend.
|
|
*/
|
|
if (in->data.mode == nir_var_system_value &&
|
|
in->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE) {
|
|
out->name.string = ralloc_strdup(shProg, "gl_VertexID");
|
|
} else if ((in->data.mode == nir_var_shader_out &&
|
|
in->data.location == VARYING_SLOT_TESS_LEVEL_OUTER) ||
|
|
(in->data.mode == nir_var_system_value &&
|
|
in->data.location == SYSTEM_VALUE_TESS_LEVEL_OUTER)) {
|
|
out->name.string = ralloc_strdup(shProg, "gl_TessLevelOuter");
|
|
type = glsl_array_type(glsl_float_type(), 4, 0);
|
|
} else if ((in->data.mode == nir_var_shader_out &&
|
|
in->data.location == VARYING_SLOT_TESS_LEVEL_INNER) ||
|
|
(in->data.mode == nir_var_system_value &&
|
|
in->data.location == SYSTEM_VALUE_TESS_LEVEL_INNER)) {
|
|
out->name.string = ralloc_strdup(shProg, "gl_TessLevelInner");
|
|
type = glsl_array_type(glsl_float_type(), 2, 0);
|
|
} else {
|
|
out->name.string = ralloc_strdup(shProg, name);
|
|
}
|
|
|
|
resource_name_updated(&out->name);
|
|
|
|
if (!out->name.string)
|
|
return NULL;
|
|
|
|
/* The ARB_program_interface_query spec says:
|
|
*
|
|
* "Not all active variables are assigned valid locations; the
|
|
* following variables will have an effective location of -1:
|
|
*
|
|
* * uniforms declared as atomic counters;
|
|
*
|
|
* * members of a uniform block;
|
|
*
|
|
* * built-in inputs, outputs, and uniforms (starting with "gl_"); and
|
|
*
|
|
* * inputs or outputs not declared with a "location" layout
|
|
* qualifier, except for vertex shader inputs and fragment shader
|
|
* outputs."
|
|
*/
|
|
if (glsl_get_base_type(in->type) == GLSL_TYPE_ATOMIC_UINT ||
|
|
is_gl_identifier(in->name) ||
|
|
!(in->data.explicit_location || use_implicit_location)) {
|
|
out->location = -1;
|
|
} else {
|
|
out->location = location;
|
|
}
|
|
|
|
out->type = type;
|
|
out->outermost_struct_type = outermost_struct_type;
|
|
out->interface_type = interface_type;
|
|
out->component = in->data.location_frac;
|
|
out->index = in->data.index;
|
|
out->patch = in->data.patch;
|
|
out->mode = in->data.mode;
|
|
out->interpolation = in->data.interpolation;
|
|
out->precision = in->data.precision;
|
|
out->explicit_location = in->data.explicit_location;
|
|
|
|
return out;
|
|
}
|
|
|
|
static bool
|
|
add_shader_variable(const struct gl_constants *consts,
|
|
struct gl_shader_program *shProg,
|
|
struct set *resource_set,
|
|
unsigned stage_mask,
|
|
GLenum programInterface, nir_variable *var,
|
|
const char *name, const struct glsl_type *type,
|
|
bool use_implicit_location, int location,
|
|
bool inouts_share_location,
|
|
const struct glsl_type *outermost_struct_type)
|
|
{
|
|
const struct glsl_type *interface_type = var->interface_type;
|
|
|
|
if (outermost_struct_type == NULL) {
|
|
if (var->data.from_named_ifc_block) {
|
|
const char *interface_name = glsl_get_type_name(interface_type);
|
|
|
|
if (glsl_type_is_array(interface_type)) {
|
|
/* Issue #16 of the ARB_program_interface_query spec says:
|
|
*
|
|
* "* If a variable is a member of an interface block without an
|
|
* instance name, it is enumerated using just the variable name.
|
|
*
|
|
* * If a variable is a member of an interface block with an
|
|
* instance name, it is enumerated as "BlockName.Member", where
|
|
* "BlockName" is the name of the interface block (not the
|
|
* instance name) and "Member" is the name of the variable."
|
|
*
|
|
* In particular, it indicates that it should be "BlockName",
|
|
* not "BlockName[array length]". The conformance suite and
|
|
* dEQP both require this behavior.
|
|
*
|
|
* Here, we unwrap the extra array level added by named interface
|
|
* block array lowering so we have the correct variable type. We
|
|
* also unwrap the interface type when constructing the name.
|
|
*
|
|
* We leave interface_type the same so that ES 3.x SSO pipeline
|
|
* validation can enforce the rules requiring array length to
|
|
* match on interface blocks.
|
|
*/
|
|
type = glsl_get_array_element(type);
|
|
|
|
interface_name =
|
|
glsl_get_type_name(glsl_get_array_element(interface_type));
|
|
}
|
|
|
|
name = ralloc_asprintf(shProg, "%s.%s", interface_name, name);
|
|
}
|
|
}
|
|
|
|
switch (glsl_get_base_type(type)) {
|
|
case GLSL_TYPE_STRUCT: {
|
|
/* The ARB_program_interface_query spec says:
|
|
*
|
|
* "For an active variable declared as a structure, a separate entry
|
|
* will be generated for each active structure member. The name of
|
|
* each entry is formed by concatenating the name of the structure,
|
|
* the "." character, and the name of the structure member. If a
|
|
* structure member to enumerate is itself a structure or array,
|
|
* these enumeration rules are applied recursively."
|
|
*/
|
|
if (outermost_struct_type == NULL)
|
|
outermost_struct_type = type;
|
|
|
|
unsigned field_location = location;
|
|
for (unsigned i = 0; i < glsl_get_length(type); i++) {
|
|
const struct glsl_type *field_type = glsl_get_struct_field(type, i);
|
|
const struct glsl_struct_field *field =
|
|
glsl_get_struct_field_data(type, i);
|
|
|
|
char *field_name = ralloc_asprintf(shProg, "%s.%s", name, field->name);
|
|
if (!add_shader_variable(consts, shProg, resource_set,
|
|
stage_mask, programInterface,
|
|
var, field_name, field_type,
|
|
use_implicit_location, field_location,
|
|
false, outermost_struct_type))
|
|
return false;
|
|
|
|
field_location += glsl_count_attribute_slots(field_type, false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
case GLSL_TYPE_ARRAY: {
|
|
/* The ARB_program_interface_query spec says:
|
|
*
|
|
* "For an active variable declared as an array of basic types, a
|
|
* single entry will be generated, with its name string formed by
|
|
* concatenating the name of the array and the string "[0]"."
|
|
*
|
|
* "For an active variable declared as an array of an aggregate data
|
|
* type (structures or arrays), a separate entry will be generated
|
|
* for each active array element, unless noted immediately below.
|
|
* The name of each entry is formed by concatenating the name of
|
|
* the array, the "[" character, an integer identifying the element
|
|
* number, and the "]" character. These enumeration rules are
|
|
* applied recursively, treating each enumerated array element as a
|
|
* separate active variable."
|
|
*/
|
|
const struct glsl_type *array_type = glsl_get_array_element(type);
|
|
if (glsl_get_base_type(array_type) == GLSL_TYPE_STRUCT ||
|
|
glsl_get_base_type(array_type) == GLSL_TYPE_ARRAY) {
|
|
unsigned elem_location = location;
|
|
unsigned stride = inouts_share_location ? 0 :
|
|
glsl_count_attribute_slots(array_type, false);
|
|
for (unsigned i = 0; i < glsl_get_length(type); i++) {
|
|
char *elem = ralloc_asprintf(shProg, "%s[%d]", name, i);
|
|
if (!add_shader_variable(consts, shProg, resource_set,
|
|
stage_mask, programInterface,
|
|
var, elem, array_type,
|
|
use_implicit_location, elem_location,
|
|
false, outermost_struct_type))
|
|
return false;
|
|
elem_location += stride;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
FALLTHROUGH;
|
|
|
|
default: {
|
|
/* The ARB_program_interface_query spec says:
|
|
*
|
|
* "For an active variable declared as a single instance of a basic
|
|
* type, a single entry will be generated, using the variable name
|
|
* from the shader source."
|
|
*/
|
|
struct gl_shader_variable *sha_v =
|
|
create_shader_variable(shProg, var, name, type, interface_type,
|
|
use_implicit_location, location,
|
|
outermost_struct_type);
|
|
if (!sha_v)
|
|
return false;
|
|
|
|
return link_util_add_program_resource(shProg, resource_set,
|
|
programInterface, sha_v, stage_mask);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool
|
|
add_vars_with_modes(const struct gl_constants *consts,
|
|
struct gl_shader_program *prog, struct set *resource_set,
|
|
nir_shader *nir, nir_variable_mode modes,
|
|
unsigned stage, GLenum programInterface)
|
|
{
|
|
nir_foreach_variable_with_modes(var, nir, modes) {
|
|
if (var->data.how_declared == nir_var_hidden)
|
|
continue;
|
|
|
|
int loc_bias = 0;
|
|
switch(var->data.mode) {
|
|
case nir_var_system_value:
|
|
case nir_var_shader_in:
|
|
if (programInterface != GL_PROGRAM_INPUT)
|
|
continue;
|
|
loc_bias = (stage == MESA_SHADER_VERTEX) ? VERT_ATTRIB_GENERIC0
|
|
: VARYING_SLOT_VAR0;
|
|
break;
|
|
case nir_var_shader_out:
|
|
if (programInterface != GL_PROGRAM_OUTPUT)
|
|
continue;
|
|
loc_bias = (stage == MESA_SHADER_FRAGMENT) ? FRAG_RESULT_DATA0
|
|
: VARYING_SLOT_VAR0;
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
if (var->data.patch)
|
|
loc_bias = VARYING_SLOT_PATCH0;
|
|
|
|
if (prog->data->spirv) {
|
|
struct gl_shader_variable *sh_var =
|
|
rzalloc(prog, struct gl_shader_variable);
|
|
|
|
/* In the ARB_gl_spirv spec, names are considered optional debug info, so
|
|
* the linker needs to work without them. Returning them is optional.
|
|
* For simplicity, we ignore names.
|
|
*/
|
|
sh_var->name.string = NULL;
|
|
resource_name_updated(&sh_var->name);
|
|
sh_var->type = var->type;
|
|
sh_var->location = var->data.location - loc_bias;
|
|
sh_var->index = var->data.index;
|
|
|
|
if (!link_util_add_program_resource(prog, resource_set,
|
|
programInterface,
|
|
sh_var, 1 << stage)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
/* Skip packed varyings, packed varyings are handled separately
|
|
* by add_packed_varyings in the GLSL IR
|
|
* build_program_resource_list() call.
|
|
* TODO: handle packed varyings here instead. We likely want a NIR
|
|
* based packing pass first.
|
|
*/
|
|
if (strncmp(var->name, "packed:", 7) == 0)
|
|
continue;
|
|
|
|
const bool vs_input_or_fs_output =
|
|
(stage == MESA_SHADER_VERTEX &&
|
|
var->data.mode == nir_var_shader_in) ||
|
|
(stage == MESA_SHADER_FRAGMENT &&
|
|
var->data.mode == nir_var_shader_out);
|
|
|
|
if (!add_shader_variable(consts, prog, resource_set,
|
|
1 << stage, programInterface,
|
|
var, var->name, var->type,
|
|
vs_input_or_fs_output,
|
|
var->data.location - loc_bias,
|
|
inout_has_same_location(var, stage),
|
|
NULL))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
add_interface_variables(const struct gl_constants *consts,
|
|
struct gl_shader_program *prog,
|
|
struct set *resource_set,
|
|
unsigned stage, GLenum programInterface)
|
|
{
|
|
struct gl_linked_shader *sh = prog->_LinkedShaders[stage];
|
|
if (!sh)
|
|
return true;
|
|
|
|
nir_shader *nir = sh->Program->nir;
|
|
assert(nir);
|
|
|
|
switch (programInterface) {
|
|
case GL_PROGRAM_INPUT: {
|
|
return add_vars_with_modes(consts, prog, resource_set,
|
|
nir, nir_var_shader_in | nir_var_system_value,
|
|
stage, programInterface);
|
|
}
|
|
case GL_PROGRAM_OUTPUT:
|
|
return add_vars_with_modes(consts, prog, resource_set,
|
|
nir, nir_var_shader_out,
|
|
stage, programInterface);
|
|
default:
|
|
assert("!Should not get here");
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* TODO: as we keep adding features, this method is becoming more and more
|
|
* similar to its GLSL counterpart at linker.cpp. Eventually it would be good
|
|
* to check if they could be refactored, and reduce code duplication somehow
|
|
*/
|
|
void
|
|
nir_build_program_resource_list(const struct gl_constants *consts,
|
|
struct gl_shader_program *prog,
|
|
bool rebuild_resourse_list)
|
|
{
|
|
/* Rebuild resource list. */
|
|
if (prog->data->ProgramResourceList && rebuild_resourse_list) {
|
|
ralloc_free(prog->data->ProgramResourceList);
|
|
prog->data->ProgramResourceList = NULL;
|
|
prog->data->NumProgramResourceList = 0;
|
|
}
|
|
|
|
int input_stage = MESA_SHADER_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++) {
|
|
if (!prog->_LinkedShaders[i])
|
|
continue;
|
|
if (input_stage == MESA_SHADER_STAGES)
|
|
input_stage = i;
|
|
output_stage = i;
|
|
}
|
|
|
|
/* Empty shader, no resources. */
|
|
if (input_stage == MESA_SHADER_STAGES && output_stage == 0)
|
|
return;
|
|
|
|
struct set *resource_set = _mesa_pointer_set_create(NULL);
|
|
|
|
/* Add inputs and outputs to the resource list. */
|
|
if (!add_interface_variables(consts, prog, resource_set, input_stage,
|
|
GL_PROGRAM_INPUT)) {
|
|
return;
|
|
}
|
|
|
|
if (!add_interface_variables(consts, prog, resource_set, output_stage,
|
|
GL_PROGRAM_OUTPUT)) {
|
|
return;
|
|
}
|
|
|
|
/* Add transform feedback varyings and buffers. */
|
|
if (prog->last_vert_prog) {
|
|
struct gl_transform_feedback_info *linked_xfb =
|
|
prog->last_vert_prog->sh.LinkedTransformFeedback;
|
|
|
|
/* Add varyings. */
|
|
if (linked_xfb->NumVarying > 0) {
|
|
for (int i = 0; i < linked_xfb->NumVarying; i++) {
|
|
if (!link_util_add_program_resource(prog, resource_set,
|
|
GL_TRANSFORM_FEEDBACK_VARYING,
|
|
&linked_xfb->Varyings[i], 0))
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Add buffers. */
|
|
for (unsigned i = 0; i < consts->MaxTransformFeedbackBuffers; i++) {
|
|
if ((linked_xfb->ActiveBuffers >> i) & 1) {
|
|
linked_xfb->Buffers[i].Binding = i;
|
|
if (!link_util_add_program_resource(prog, resource_set,
|
|
GL_TRANSFORM_FEEDBACK_BUFFER,
|
|
&linked_xfb->Buffers[i], 0))
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Add uniforms
|
|
*
|
|
* Here, it is expected that nir_link_uniforms() has already been
|
|
* called, so that UniformStorage table is already available.
|
|
*/
|
|
int top_level_array_base_offset = -1;
|
|
int top_level_array_size_in_bytes = -1;
|
|
int second_element_offset = -1;
|
|
int block_index = -1;
|
|
for (unsigned i = 0; i < prog->data->NumUniformStorage; i++) {
|
|
struct gl_uniform_storage *uniform = &prog->data->UniformStorage[i];
|
|
|
|
if (uniform->hidden) {
|
|
for (int j = MESA_SHADER_VERTEX; j < MESA_SHADER_STAGES; j++) {
|
|
if (!uniform->opaque[j].active ||
|
|
glsl_get_base_type(uniform->type) != GLSL_TYPE_SUBROUTINE)
|
|
continue;
|
|
|
|
GLenum type =
|
|
_mesa_shader_stage_to_subroutine_uniform((gl_shader_stage)j);
|
|
/* add shader subroutines */
|
|
if (!link_util_add_program_resource(prog, resource_set,
|
|
type, uniform, 0))
|
|
return;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (!link_util_should_add_buffer_variable(prog, uniform,
|
|
top_level_array_base_offset,
|
|
top_level_array_size_in_bytes,
|
|
second_element_offset, block_index))
|
|
continue;
|
|
|
|
|
|
if (prog->data->UniformStorage[i].offset >= second_element_offset) {
|
|
top_level_array_base_offset =
|
|
prog->data->UniformStorage[i].offset;
|
|
|
|
top_level_array_size_in_bytes =
|
|
prog->data->UniformStorage[i].top_level_array_size *
|
|
prog->data->UniformStorage[i].top_level_array_stride;
|
|
|
|
/* Set or reset the second element offset. For non arrays this
|
|
* will be set to -1.
|
|
*/
|
|
second_element_offset = top_level_array_size_in_bytes ?
|
|
top_level_array_base_offset +
|
|
prog->data->UniformStorage[i].top_level_array_stride : -1;
|
|
}
|
|
block_index = uniform->block_index;
|
|
|
|
|
|
GLenum interface = uniform->is_shader_storage ? GL_BUFFER_VARIABLE : GL_UNIFORM;
|
|
if (!link_util_add_program_resource(prog, resource_set, interface, uniform,
|
|
uniform->active_shader_mask)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
for (unsigned i = 0; i < prog->data->NumUniformBlocks; i++) {
|
|
if (!link_util_add_program_resource(prog, resource_set, GL_UNIFORM_BLOCK,
|
|
&prog->data->UniformBlocks[i],
|
|
prog->data->UniformBlocks[i].stageref))
|
|
return;
|
|
}
|
|
|
|
for (unsigned i = 0; i < prog->data->NumShaderStorageBlocks; i++) {
|
|
if (!link_util_add_program_resource(prog, resource_set, GL_SHADER_STORAGE_BLOCK,
|
|
&prog->data->ShaderStorageBlocks[i],
|
|
prog->data->ShaderStorageBlocks[i].stageref))
|
|
return;
|
|
}
|
|
|
|
/* Add atomic counter buffers. */
|
|
for (unsigned i = 0; i < prog->data->NumAtomicBuffers; i++) {
|
|
if (!link_util_add_program_resource(prog, resource_set, GL_ATOMIC_COUNTER_BUFFER,
|
|
&prog->data->AtomicBuffers[i], 0))
|
|
return;
|
|
}
|
|
|
|
unsigned mask = prog->data->linked_stages;
|
|
while (mask) {
|
|
const int i = u_bit_scan(&mask);
|
|
struct gl_program *p = prog->_LinkedShaders[i]->Program;
|
|
|
|
GLuint type = _mesa_shader_stage_to_subroutine((gl_shader_stage)i);
|
|
for (unsigned j = 0; j < p->sh.NumSubroutineFunctions; j++) {
|
|
if (!link_util_add_program_resource(prog, resource_set,
|
|
type,
|
|
&p->sh.SubroutineFunctions[j],
|
|
0))
|
|
return;
|
|
}
|
|
}
|
|
|
|
_mesa_set_destroy(resource_set, NULL);
|
|
}
|
|
|
|
bool
|
|
gl_nir_link_spirv(const struct gl_constants *consts,
|
|
struct gl_shader_program *prog,
|
|
const struct gl_nir_linker_options *options)
|
|
{
|
|
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
|
|
struct gl_linked_shader *shader = prog->_LinkedShaders[i];
|
|
if (shader) {
|
|
const nir_remove_dead_variables_options opts = {
|
|
.can_remove_var = can_remove_uniform,
|
|
};
|
|
nir_remove_dead_variables(shader->Program->nir,
|
|
nir_var_uniform | nir_var_image,
|
|
&opts);
|
|
}
|
|
}
|
|
|
|
if (!gl_nir_link_uniform_blocks(prog))
|
|
return false;
|
|
|
|
if (!gl_nir_link_uniforms(consts, prog, options->fill_parameters))
|
|
return false;
|
|
|
|
gl_nir_link_assign_atomic_counter_resources(consts, prog);
|
|
gl_nir_link_assign_xfb_resources(consts, prog);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Validate shader image resources.
|
|
*/
|
|
static void
|
|
check_image_resources(const struct gl_constants *consts,
|
|
const struct gl_extensions *exts,
|
|
struct gl_shader_program *prog)
|
|
{
|
|
unsigned total_image_units = 0;
|
|
unsigned fragment_outputs = 0;
|
|
unsigned total_shader_storage_blocks = 0;
|
|
|
|
if (!exts->ARB_shader_image_load_store)
|
|
return;
|
|
|
|
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
|
|
struct gl_linked_shader *sh = prog->_LinkedShaders[i];
|
|
if (!sh)
|
|
continue;
|
|
|
|
total_image_units += sh->Program->info.num_images;
|
|
total_shader_storage_blocks += sh->Program->info.num_ssbos;
|
|
}
|
|
|
|
if (total_image_units > consts->MaxCombinedImageUniforms)
|
|
linker_error(prog, "Too many combined image uniforms\n");
|
|
|
|
struct gl_linked_shader *frag_sh =
|
|
prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
|
|
if (frag_sh) {
|
|
uint64_t frag_outputs_written = frag_sh->Program->info.outputs_written;
|
|
fragment_outputs = util_bitcount64(frag_outputs_written);
|
|
}
|
|
|
|
if (total_image_units + fragment_outputs + total_shader_storage_blocks >
|
|
consts->MaxCombinedShaderOutputResources)
|
|
linker_error(prog, "Too many combined image uniforms, shader storage "
|
|
" buffers and fragment outputs\n");
|
|
}
|
|
|
|
bool
|
|
gl_nir_link_glsl(const struct gl_constants *consts,
|
|
const struct gl_extensions *exts,
|
|
struct gl_shader_program *prog)
|
|
{
|
|
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
|
|
struct gl_linked_shader *shader = prog->_LinkedShaders[i];
|
|
if (shader) {
|
|
const nir_remove_dead_variables_options opts = {
|
|
.can_remove_var = can_remove_uniform,
|
|
};
|
|
nir_remove_dead_variables(shader->Program->nir,
|
|
nir_var_uniform | nir_var_image,
|
|
&opts);
|
|
}
|
|
}
|
|
|
|
if (!gl_nir_link_uniforms(consts, prog, true))
|
|
return false;
|
|
|
|
link_util_calculate_subroutine_compat(prog);
|
|
link_util_check_uniform_resources(consts, prog);
|
|
link_util_check_subroutine_resources(prog);
|
|
check_image_resources(consts, exts, prog);
|
|
gl_nir_link_assign_atomic_counter_resources(consts, prog);
|
|
gl_nir_link_check_atomic_counter_resources(consts, prog);
|
|
|
|
if (prog->data->LinkStatus == LINKING_FAILURE)
|
|
return false;
|
|
|
|
return true;
|
|
}
|