mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2025-12-22 15:40:11 +01:00
46f9f74c57
This adds support for adding names of varying to the resource list which is required for us to use this function with the glsl linker. Support for names is optional for spirv which is why it had not been added yet. This is mostly a copy of the GLSL IR code adapted to nir. Reviewed-by: Alejandro Piñeiro <apinheiro@igalia.com>
553 lines
21 KiB
C
553 lines
21 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_nir.h"
|
|
#include "gl_nir_linker.h"
|
|
#include "linker_util.h"
|
|
#include "main/mtypes.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
|
|
*
|
|
* Also note that this is tailored for ARB_gl_spirv needs and particularities
|
|
*/
|
|
|
|
/**
|
|
* 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 = 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 = 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 = ralloc_strdup(shProg, "gl_TessLevelInner");
|
|
type = glsl_array_type(glsl_float_type(), 2, 0);
|
|
} else {
|
|
out->name = ralloc_strdup(shProg, name);
|
|
}
|
|
|
|
if (!out->name)
|
|
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_context *ctx,
|
|
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(ctx, 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(ctx, 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_from_list(const struct gl_context *ctx,
|
|
struct gl_shader_program *prog, struct set *resource_set,
|
|
const struct exec_list *var_list, unsigned stage,
|
|
GLenum programInterface)
|
|
{
|
|
nir_foreach_variable(var, var_list) {
|
|
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 = NULL;
|
|
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(ctx, 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_context *ctx,
|
|
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: {
|
|
bool result = add_vars_from_list(ctx, prog, resource_set,
|
|
&nir->inputs, stage, programInterface);
|
|
result &= add_vars_from_list(ctx, prog, resource_set, &nir->system_values,
|
|
stage, programInterface);
|
|
return result;
|
|
}
|
|
case GL_PROGRAM_OUTPUT:
|
|
return add_vars_from_list(ctx, prog, resource_set, &nir->outputs, 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(struct gl_context *ctx,
|
|
struct gl_shader_program *prog)
|
|
{
|
|
/* Rebuild resource list. */
|
|
if (prog->data->ProgramResourceList) {
|
|
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(ctx, prog, resource_set, input_stage,
|
|
GL_PROGRAM_INPUT)) {
|
|
return;
|
|
}
|
|
|
|
if (!add_interface_variables(ctx, 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 < ctx->Const.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];
|
|
|
|
/* Do not add uniforms internally used by Mesa. */
|
|
if (uniform->hidden)
|
|
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;
|
|
}
|
|
|
|
_mesa_set_destroy(resource_set, NULL);
|
|
}
|
|
|
|
bool
|
|
gl_nir_link(struct gl_context *ctx, struct gl_shader_program *prog,
|
|
const struct gl_nir_linker_options *options)
|
|
{
|
|
if (!gl_nir_link_uniform_blocks(ctx, prog))
|
|
return false;
|
|
|
|
if (!gl_nir_link_uniforms(ctx, prog, options->fill_parameters))
|
|
return false;
|
|
|
|
gl_nir_link_assign_atomic_counter_resources(ctx, prog);
|
|
gl_nir_link_assign_xfb_resources(ctx, prog);
|
|
|
|
return true;
|
|
}
|