#include "glsl_parser_extras.h"
#include "ir.h"
#include "program.h"
-#include "program/hash_table.h"
+#include "program/prog_instruction.h"
+#include "util/set.h"
+#include "util/string_to_uint_map.h"
#include "linker.h"
#include "link_varyings.h"
#include "ir_optimization.h"
};
-class geom_array_resize_visitor : public ir_hierarchical_visitor {
+class array_resize_visitor : public ir_hierarchical_visitor {
public:
unsigned num_vertices;
gl_shader_program *prog;
+ gl_shader_stage stage;
- geom_array_resize_visitor(unsigned num_vertices, gl_shader_program *prog)
+ array_resize_visitor(unsigned num_vertices,
+ gl_shader_program *prog,
+ gl_shader_stage stage)
{
this->num_vertices = num_vertices;
this->prog = prog;
+ this->stage = stage;
}
- virtual ~geom_array_resize_visitor()
+ virtual ~array_resize_visitor()
{
/* empty */
}
virtual ir_visitor_status visit(ir_variable *var)
{
- if (!var->type->is_array() || var->data.mode != ir_var_shader_in)
+ if (!var->type->is_array() || var->data.mode != ir_var_shader_in ||
+ var->data.patch)
return visit_continue;
unsigned size = var->type->length;
- /* Generate a link error if the shader has declared this array with an
- * incorrect size.
- */
- if (size && size != this->num_vertices) {
- linker_error(this->prog, "size of array %s declared as %u, "
- "but number of input vertices is %u\n",
- var->name, size, this->num_vertices);
- return visit_continue;
- }
+ if (stage == MESA_SHADER_GEOMETRY) {
+ /* Generate a link error if the shader has declared this array with
+ * an incorrect size.
+ */
+ if (!var->data.implicit_sized_array &&
+ size && size != this->num_vertices) {
+ linker_error(this->prog, "size of array %s declared as %u, "
+ "but number of input vertices is %u\n",
+ var->name, size, this->num_vertices);
+ return visit_continue;
+ }
- /* Generate a link error if the shader attempts to access an input
- * array using an index too large for its actual size assigned at link
- * time.
- */
- if (var->data.max_array_access >= (int)this->num_vertices) {
- linker_error(this->prog, "geometry shader accesses element %i of "
- "%s, but only %i input vertices\n",
- var->data.max_array_access, var->name, this->num_vertices);
- return visit_continue;
+ /* Generate a link error if the shader attempts to access an input
+ * array using an index too large for its actual size assigned at
+ * link time.
+ */
+ if (var->data.max_array_access >= (int)this->num_vertices) {
+ linker_error(this->prog, "%s shader accesses element %i of "
+ "%s, but only %i input vertices\n",
+ _mesa_shader_stage_to_string(this->stage),
+ var->data.max_array_access, var->name, this->num_vertices);
+ return visit_continue;
+ }
}
var->type = glsl_type::get_array_instance(var->type->fields.array,
}
};
-class tess_eval_array_resize_visitor : public ir_hierarchical_visitor {
-public:
- unsigned num_vertices;
- gl_shader_program *prog;
-
- tess_eval_array_resize_visitor(unsigned num_vertices, gl_shader_program *prog)
- {
- this->num_vertices = num_vertices;
- this->prog = prog;
- }
-
- virtual ~tess_eval_array_resize_visitor()
- {
- /* empty */
- }
-
- virtual ir_visitor_status visit(ir_variable *var)
- {
- if (!var->type->is_array() || var->data.mode != ir_var_shader_in || var->data.patch)
- return visit_continue;
-
- var->type = glsl_type::get_array_instance(var->type->fields.array,
- this->num_vertices);
- var->data.max_array_access = this->num_vertices - 1;
-
- return visit_continue;
- }
-
- /* Dereferences of input variables need to be updated so that their type
- * matches the newly assigned type of the variable they are accessing. */
- virtual ir_visitor_status visit(ir_dereference_variable *ir)
- {
- ir->type = ir->var->type;
- return visit_continue;
- }
-
- /* Dereferences of 2D input arrays need to be updated so that their type
- * matches the newly assigned type of the array they are accessing. */
- virtual ir_visitor_status visit_leave(ir_dereference_array *ir)
- {
- const glsl_type *const vt = ir->array->type;
- if (vt->is_array())
- ir->type = vt->fields.array;
- return visit_continue;
- }
-};
-
-class barrier_use_visitor : public ir_hierarchical_visitor {
-public:
- barrier_use_visitor(gl_shader_program *prog)
- : prog(prog), in_main(false), after_return(false), control_flow(0)
- {
- }
-
- virtual ~barrier_use_visitor()
- {
- /* empty */
- }
-
- virtual ir_visitor_status visit_enter(ir_function *ir)
- {
- if (strcmp(ir->name, "main") == 0)
- in_main = true;
-
- return visit_continue;
- }
-
- virtual ir_visitor_status visit_leave(ir_function *)
- {
- in_main = false;
- after_return = false;
- return visit_continue;
- }
-
- virtual ir_visitor_status visit_leave(ir_return *)
- {
- after_return = true;
- return visit_continue;
- }
-
- virtual ir_visitor_status visit_enter(ir_if *)
- {
- ++control_flow;
- return visit_continue;
- }
-
- virtual ir_visitor_status visit_leave(ir_if *)
- {
- --control_flow;
- return visit_continue;
- }
-
- virtual ir_visitor_status visit_enter(ir_loop *)
- {
- ++control_flow;
- return visit_continue;
- }
-
- virtual ir_visitor_status visit_leave(ir_loop *)
- {
- --control_flow;
- return visit_continue;
- }
-
- /* FINISHME: `switch` is not expressed at the IR level -- it's already
- * been lowered to a mess of `if`s. We'll correctly disallow any use of
- * barrier() in a conditional path within the switch, but not in a path
- * which is always hit.
- */
-
- virtual ir_visitor_status visit_enter(ir_call *ir)
- {
- if (ir->use_builtin && strcmp(ir->callee_name(), "barrier") == 0) {
- /* Use of barrier(); determine if it is legal: */
- if (!in_main) {
- linker_error(prog, "Builtin barrier() may only be used in main");
- return visit_stop;
- }
-
- if (after_return) {
- linker_error(prog, "Builtin barrier() may not be used after return");
- return visit_stop;
- }
-
- if (control_flow != 0) {
- linker_error(prog, "Builtin barrier() may not be used inside control flow");
- return visit_stop;
- }
- }
- return visit_continue;
- }
-
-private:
- gl_shader_program *prog;
- bool in_main, after_return;
- int control_flow;
-};
-
/**
* Visitor that determines the highest stream id to which a (geometry) shader
* emits vertices. It also checks whether End{Stream}Primitive is ever called.
*/
static void
analyze_clip_cull_usage(struct gl_shader_program *prog,
- struct gl_shader *shader,
+ struct gl_linked_shader *shader,
struct gl_context *ctx,
GLuint *clip_distance_array_size,
GLuint *cull_distance_array_size)
*clip_distance_array_size = 0;
*cull_distance_array_size = 0;
- if (!prog->IsES && prog->Version >= 130) {
+ if (prog->Version >= (prog->IsES ? 300 : 130)) {
/* From section 7.1 (Vertex Shader Special Variables) of the
* GLSL 1.30 spec:
*
* gl_ClipVertex and gl_ClipDistance."
*
* This does not apply to GLSL ES shaders, since GLSL ES defines neither
- * gl_ClipVertex nor gl_ClipDistance.
+ * gl_ClipVertex nor gl_ClipDistance. However with
+ * GL_EXT_clip_cull_distance, this functionality is exposed in ES 3.0.
*/
- find_assignment_visitor clip_vertex("gl_ClipVertex");
find_assignment_visitor clip_distance("gl_ClipDistance");
find_assignment_visitor cull_distance("gl_CullDistance");
- clip_vertex.run(shader->ir);
clip_distance.run(shader->ir);
cull_distance.run(shader->ir);
* a program to statically read or write both gl_ClipVertex and either
* gl_ClipDistance or gl_CullDistance.
*
- * This does not apply to GLSL ES shaders, since GLSL ES defines neither
- * gl_ClipVertex, gl_ClipDistance or gl_CullDistance.
+ * This does not apply to GLSL ES shaders, since GLSL ES doesn't define
+ * gl_ClipVertex.
*/
- if (clip_vertex.variable_found() && clip_distance.variable_found()) {
- linker_error(prog, "%s shader writes to both `gl_ClipVertex' "
- "and `gl_ClipDistance'\n",
- _mesa_shader_stage_to_string(shader->Stage));
- return;
- }
- if (clip_vertex.variable_found() && cull_distance.variable_found()) {
- linker_error(prog, "%s shader writes to both `gl_ClipVertex' "
- "and `gl_CullDistance'\n",
- _mesa_shader_stage_to_string(shader->Stage));
- return;
+ if (!prog->IsES) {
+ find_assignment_visitor clip_vertex("gl_ClipVertex");
+
+ clip_vertex.run(shader->ir);
+
+ if (clip_vertex.variable_found() && clip_distance.variable_found()) {
+ linker_error(prog, "%s shader writes to both `gl_ClipVertex' "
+ "and `gl_ClipDistance'\n",
+ _mesa_shader_stage_to_string(shader->Stage));
+ return;
+ }
+ if (clip_vertex.variable_found() && cull_distance.variable_found()) {
+ linker_error(prog, "%s shader writes to both `gl_ClipVertex' "
+ "and `gl_CullDistance'\n",
+ _mesa_shader_stage_to_string(shader->Stage));
+ return;
+ }
}
if (clip_distance.variable_found()) {
*/
void
validate_vertex_shader_executable(struct gl_shader_program *prog,
- struct gl_shader *shader,
+ struct gl_linked_shader *shader,
struct gl_context *ctx)
{
if (shader == NULL)
if (!find.variable_found()) {
if (prog->IsES) {
linker_warning(prog,
- "vertex shader does not write to `gl_Position'."
- "It's value is undefined. \n");
+ "vertex shader does not write to `gl_Position'. "
+ "Its value is undefined. \n");
} else {
linker_error(prog,
"vertex shader does not write to `gl_Position'. \n");
void
validate_tess_eval_shader_executable(struct gl_shader_program *prog,
- struct gl_shader *shader,
+ struct gl_linked_shader *shader,
struct gl_context *ctx)
{
if (shader == NULL)
*/
void
validate_fragment_shader_executable(struct gl_shader_program *prog,
- struct gl_shader *shader)
+ struct gl_linked_shader *shader)
{
if (shader == NULL)
return;
*/
void
validate_geometry_shader_executable(struct gl_shader_program *prog,
- struct gl_shader *shader,
+ struct gl_linked_shader *shader,
struct gl_context *ctx)
{
if (shader == NULL)
return;
- unsigned num_vertices = vertices_per_prim(prog->Geom.InputType);
+ unsigned num_vertices = vertices_per_prim(shader->info.Geom.InputType);
prog->Geom.VerticesIn = num_vertices;
analyze_clip_cull_usage(prog, shader, ctx,
validate_geometry_shader_emissions(struct gl_context *ctx,
struct gl_shader_program *prog)
{
- if (prog->_LinkedShaders[MESA_SHADER_GEOMETRY] != NULL) {
+ struct gl_linked_shader *sh = prog->_LinkedShaders[MESA_SHADER_GEOMETRY];
+
+ if (sh != NULL) {
find_emit_vertex_visitor emit_vertex(ctx->Const.MaxVertexStreams - 1);
- emit_vertex.run(prog->_LinkedShaders[MESA_SHADER_GEOMETRY]->ir);
+ emit_vertex.run(sh->ir);
if (emit_vertex.error()) {
linker_error(prog, "Invalid call %s(%d). Accepted values for the "
"stream parameter are in the range [0, %d].\n",
* EmitStreamVertex() or EmitEndPrimitive() are called with a non-zero
* stream.
*/
- if (prog->Geom.UsesStreams && prog->Geom.OutputType != GL_POINTS) {
+ if (prog->Geom.UsesStreams && sh->info.Geom.OutputType != GL_POINTS) {
linker_error(prog, "EmitStreamVertex(n) and EndStreamPrimitive(n) "
"with n>0 requires point output\n");
}
*/
void
cross_validate_globals(struct gl_shader_program *prog,
- struct gl_shader **shader_list,
- unsigned num_shaders,
- bool uniforms_only)
+ struct exec_list *ir, glsl_symbol_table *variables,
+ bool uniforms_only)
{
- /* Examine all of the uniforms in all of the shaders and cross validate
- * them.
- */
- glsl_symbol_table variables;
- for (unsigned i = 0; i < num_shaders; i++) {
- if (shader_list[i] == NULL)
- continue;
-
- foreach_in_list(ir_instruction, node, shader_list[i]->ir) {
- ir_variable *const var = node->as_variable();
+ foreach_in_list(ir_instruction, node, ir) {
+ ir_variable *const var = node->as_variable();
- if (var == NULL)
- continue;
+ if (var == NULL)
+ continue;
- if (uniforms_only && (var->data.mode != ir_var_uniform && var->data.mode != ir_var_shader_storage))
- continue;
+ if (uniforms_only && (var->data.mode != ir_var_uniform && var->data.mode != ir_var_shader_storage))
+ continue;
- /* don't cross validate subroutine uniforms */
- if (var->type->contains_subroutine())
- continue;
+ /* don't cross validate subroutine uniforms */
+ if (var->type->contains_subroutine())
+ continue;
- /* Don't cross validate temporaries that are at global scope. These
- * will eventually get pulled into the shaders 'main'.
- */
- if (var->data.mode == ir_var_temporary)
- continue;
+ /* Don't cross validate temporaries that are at global scope. These
+ * will eventually get pulled into the shaders 'main'.
+ */
+ if (var->data.mode == ir_var_temporary)
+ continue;
- /* If a global with this name has already been seen, verify that the
- * new instance has the same type. In addition, if the globals have
- * initializers, the values of the initializers must be the same.
- */
- ir_variable *const existing = variables.get_variable(var->name);
- if (existing != NULL) {
- /* Check if types match. Interface blocks have some special
- * rules so we handle those elsewhere.
- */
- if (var->type != existing->type &&
- !var->is_interface_instance()) {
- if (!validate_intrastage_arrays(prog, var, existing)) {
- if (var->type->is_record() && existing->type->is_record()
- && existing->type->record_compare(var->type)) {
- existing->type = var->type;
- } else {
- /* If it is an unsized array in a Shader Storage Block,
- * two different shaders can access to different elements.
- * Because of that, they might be converted to different
- * sized arrays, then check that they are compatible but
- * ignore the array size.
- */
- if (!(var->data.mode == ir_var_shader_storage &&
- var->data.from_ssbo_unsized_array &&
- existing->data.mode == ir_var_shader_storage &&
- existing->data.from_ssbo_unsized_array &&
- var->type->gl_type == existing->type->gl_type)) {
- linker_error(prog, "%s `%s' declared as type "
- "`%s' and type `%s'\n",
- mode_string(var),
- var->name, var->type->name,
- existing->type->name);
- return;
- }
+ /* If a global with this name has already been seen, verify that the
+ * new instance has the same type. In addition, if the globals have
+ * initializers, the values of the initializers must be the same.
+ */
+ ir_variable *const existing = variables->get_variable(var->name);
+ if (existing != NULL) {
+ /* Check if types match. Interface blocks have some special
+ * rules so we handle those elsewhere.
+ */
+ if (var->type != existing->type &&
+ !var->is_interface_instance()) {
+ if (!validate_intrastage_arrays(prog, var, existing)) {
+ if (var->type->is_record() && existing->type->is_record()
+ && existing->type->record_compare(var->type)) {
+ existing->type = var->type;
+ } else {
+ /* If it is an unsized array in a Shader Storage Block,
+ * two different shaders can access to different elements.
+ * Because of that, they might be converted to different
+ * sized arrays, then check that they are compatible but
+ * ignore the array size.
+ */
+ if (!(var->data.mode == ir_var_shader_storage &&
+ var->data.from_ssbo_unsized_array &&
+ existing->data.mode == ir_var_shader_storage &&
+ existing->data.from_ssbo_unsized_array &&
+ var->type->gl_type == existing->type->gl_type)) {
+ linker_error(prog, "%s `%s' declared as type "
+ "`%s' and type `%s'\n",
+ mode_string(var),
+ var->name, var->type->name,
+ existing->type->name);
+ return;
}
- }
- }
-
- if (var->data.explicit_location) {
- if (existing->data.explicit_location
- && (var->data.location != existing->data.location)) {
- linker_error(prog, "explicit locations for %s "
- "`%s' have differing values\n",
- mode_string(var), var->name);
- return;
- }
+ }
+ }
+ }
- if (var->data.location_frac != existing->data.location_frac) {
- linker_error(prog, "explicit components for %s "
- "`%s' have differing values\n",
- mode_string(var), var->name);
- return;
- }
+ if (var->data.explicit_location) {
+ if (existing->data.explicit_location
+ && (var->data.location != existing->data.location)) {
+ linker_error(prog, "explicit locations for %s "
+ "`%s' have differing values\n",
+ mode_string(var), var->name);
+ return;
+ }
- existing->data.location = var->data.location;
- existing->data.explicit_location = true;
- } else {
- /* Check if uniform with implicit location was marked explicit
- * by earlier shader stage. If so, mark it explicit in this stage
- * too to make sure later processing does not treat it as
- * implicit one.
- */
- if (existing->data.explicit_location) {
- var->data.location = existing->data.location;
- var->data.explicit_location = true;
- }
+ if (var->data.location_frac != existing->data.location_frac) {
+ linker_error(prog, "explicit components for %s `%s' have "
+ "differing values\n", mode_string(var), var->name);
+ return;
}
- /* From the GLSL 4.20 specification:
- * "A link error will result if two compilation units in a program
- * specify different integer-constant bindings for the same
- * opaque-uniform name. However, it is not an error to specify a
- * binding on some but not all declarations for the same name"
+ existing->data.location = var->data.location;
+ existing->data.explicit_location = true;
+ } else {
+ /* Check if uniform with implicit location was marked explicit
+ * by earlier shader stage. If so, mark it explicit in this stage
+ * too to make sure later processing does not treat it as
+ * implicit one.
*/
- if (var->data.explicit_binding) {
- if (existing->data.explicit_binding &&
- var->data.binding != existing->data.binding) {
- linker_error(prog, "explicit bindings for %s "
- "`%s' have differing values\n",
- mode_string(var), var->name);
- return;
- }
-
- existing->data.binding = var->data.binding;
- existing->data.explicit_binding = true;
+ if (existing->data.explicit_location) {
+ var->data.location = existing->data.location;
+ var->data.explicit_location = true;
}
+ }
- if (var->type->contains_atomic() &&
- var->data.offset != existing->data.offset) {
- linker_error(prog, "offset specifications for %s "
+ /* From the GLSL 4.20 specification:
+ * "A link error will result if two compilation units in a program
+ * specify different integer-constant bindings for the same
+ * opaque-uniform name. However, it is not an error to specify a
+ * binding on some but not all declarations for the same name"
+ */
+ if (var->data.explicit_binding) {
+ if (existing->data.explicit_binding &&
+ var->data.binding != existing->data.binding) {
+ linker_error(prog, "explicit bindings for %s "
"`%s' have differing values\n",
mode_string(var), var->name);
return;
}
- /* Validate layout qualifiers for gl_FragDepth.
- *
- * From the AMD/ARB_conservative_depth specs:
- *
- * "If gl_FragDepth is redeclared in any fragment shader in a
- * program, it must be redeclared in all fragment shaders in
- * that program that have static assignments to
- * gl_FragDepth. All redeclarations of gl_FragDepth in all
- * fragment shaders in a single program must have the same set
- * of qualifiers."
- */
- if (strcmp(var->name, "gl_FragDepth") == 0) {
- bool layout_declared = var->data.depth_layout != ir_depth_layout_none;
- bool layout_differs =
- var->data.depth_layout != existing->data.depth_layout;
-
- if (layout_declared && layout_differs) {
- linker_error(prog,
- "All redeclarations of gl_FragDepth in all "
- "fragment shaders in a single program must have "
- "the same set of qualifiers.\n");
- }
+ existing->data.binding = var->data.binding;
+ existing->data.explicit_binding = true;
+ }
- if (var->data.used && layout_differs) {
- linker_error(prog,
- "If gl_FragDepth is redeclared with a layout "
- "qualifier in any fragment shader, it must be "
- "redeclared with the same layout qualifier in "
- "all fragment shaders that have assignments to "
- "gl_FragDepth\n");
- }
- }
+ if (var->type->contains_atomic() &&
+ var->data.offset != existing->data.offset) {
+ linker_error(prog, "offset specifications for %s "
+ "`%s' have differing values\n",
+ mode_string(var), var->name);
+ return;
+ }
- /* Page 35 (page 41 of the PDF) of the GLSL 4.20 spec says:
- *
- * "If a shared global has multiple initializers, the
- * initializers must all be constant expressions, and they
- * must all have the same value. Otherwise, a link error will
- * result. (A shared global having only one initializer does
- * not require that initializer to be a constant expression.)"
- *
- * Previous to 4.20 the GLSL spec simply said that initializers
- * must have the same value. In this case of non-constant
- * initializers, this was impossible to determine. As a result,
- * no vendor actually implemented that behavior. The 4.20
- * behavior matches the implemented behavior of at least one other
- * vendor, so we'll implement that for all GLSL versions.
- */
- if (var->constant_initializer != NULL) {
- if (existing->constant_initializer != NULL) {
- if (!var->constant_initializer->has_value(existing->constant_initializer)) {
- linker_error(prog, "initializers for %s "
- "`%s' have differing values\n",
- mode_string(var), var->name);
- return;
- }
- } else {
- /* If the first-seen instance of a particular uniform did
- * not have an initializer but a later instance does,
- * replace the former with the later.
- */
- variables.replace_variable(existing->name, var);
- }
- }
+ /* Validate layout qualifiers for gl_FragDepth.
+ *
+ * From the AMD/ARB_conservative_depth specs:
+ *
+ * "If gl_FragDepth is redeclared in any fragment shader in a
+ * program, it must be redeclared in all fragment shaders in
+ * that program that have static assignments to
+ * gl_FragDepth. All redeclarations of gl_FragDepth in all
+ * fragment shaders in a single program must have the same set
+ * of qualifiers."
+ */
+ if (strcmp(var->name, "gl_FragDepth") == 0) {
+ bool layout_declared = var->data.depth_layout != ir_depth_layout_none;
+ bool layout_differs =
+ var->data.depth_layout != existing->data.depth_layout;
- if (var->data.has_initializer) {
- if (existing->data.has_initializer
- && (var->constant_initializer == NULL
- || existing->constant_initializer == NULL)) {
- linker_error(prog,
- "shared global variable `%s' has multiple "
- "non-constant initializers.\n",
- var->name);
- return;
- }
- }
+ if (layout_declared && layout_differs) {
+ linker_error(prog,
+ "All redeclarations of gl_FragDepth in all "
+ "fragment shaders in a single program must have "
+ "the same set of qualifiers.\n");
+ }
- if (existing->data.invariant != var->data.invariant) {
- linker_error(prog, "declarations for %s `%s' have "
- "mismatching invariant qualifiers\n",
- mode_string(var), var->name);
- return;
- }
- if (existing->data.centroid != var->data.centroid) {
- linker_error(prog, "declarations for %s `%s' have "
- "mismatching centroid qualifiers\n",
- mode_string(var), var->name);
- return;
+ if (var->data.used && layout_differs) {
+ linker_error(prog,
+ "If gl_FragDepth is redeclared with a layout "
+ "qualifier in any fragment shader, it must be "
+ "redeclared with the same layout qualifier in "
+ "all fragment shaders that have assignments to "
+ "gl_FragDepth\n");
}
- if (existing->data.sample != var->data.sample) {
- linker_error(prog, "declarations for %s `%s` have "
- "mismatching sample qualifiers\n",
- mode_string(var), var->name);
- return;
+ }
+
+ /* Page 35 (page 41 of the PDF) of the GLSL 4.20 spec says:
+ *
+ * "If a shared global has multiple initializers, the
+ * initializers must all be constant expressions, and they
+ * must all have the same value. Otherwise, a link error will
+ * result. (A shared global having only one initializer does
+ * not require that initializer to be a constant expression.)"
+ *
+ * Previous to 4.20 the GLSL spec simply said that initializers
+ * must have the same value. In this case of non-constant
+ * initializers, this was impossible to determine. As a result,
+ * no vendor actually implemented that behavior. The 4.20
+ * behavior matches the implemented behavior of at least one other
+ * vendor, so we'll implement that for all GLSL versions.
+ */
+ if (var->constant_initializer != NULL) {
+ if (existing->constant_initializer != NULL) {
+ if (!var->constant_initializer->has_value(existing->constant_initializer)) {
+ linker_error(prog, "initializers for %s "
+ "`%s' have differing values\n",
+ mode_string(var), var->name);
+ return;
+ }
+ } else {
+ /* If the first-seen instance of a particular uniform did
+ * not have an initializer but a later instance does,
+ * replace the former with the later.
+ */
+ variables->replace_variable(existing->name, var);
}
- if (existing->data.image_format != var->data.image_format) {
- linker_error(prog, "declarations for %s `%s` have "
- "mismatching image format qualifiers\n",
- mode_string(var), var->name);
+ }
+
+ if (var->data.has_initializer) {
+ if (existing->data.has_initializer
+ && (var->constant_initializer == NULL
+ || existing->constant_initializer == NULL)) {
+ linker_error(prog,
+ "shared global variable `%s' has multiple "
+ "non-constant initializers.\n",
+ var->name);
return;
}
- } else
- variables.add_variable(var);
- }
+ }
+
+ if (existing->data.invariant != var->data.invariant) {
+ linker_error(prog, "declarations for %s `%s' have "
+ "mismatching invariant qualifiers\n",
+ mode_string(var), var->name);
+ return;
+ }
+ if (existing->data.centroid != var->data.centroid) {
+ linker_error(prog, "declarations for %s `%s' have "
+ "mismatching centroid qualifiers\n",
+ mode_string(var), var->name);
+ return;
+ }
+ if (existing->data.sample != var->data.sample) {
+ linker_error(prog, "declarations for %s `%s` have "
+ "mismatching sample qualifiers\n",
+ mode_string(var), var->name);
+ return;
+ }
+ if (existing->data.image_format != var->data.image_format) {
+ linker_error(prog, "declarations for %s `%s` have "
+ "mismatching image format qualifiers\n",
+ mode_string(var), var->name);
+ return;
+ }
+
+ if (prog->IsES && existing->data.precision != var->data.precision) {
+ linker_error(prog, "declarations for %s `%s` have "
+ "mismatching precision qualifiers\n",
+ mode_string(var), var->name);
+ return;
+ }
+ } else
+ variables->add_variable(var);
}
}
void
cross_validate_uniforms(struct gl_shader_program *prog)
{
- cross_validate_globals(prog, prog->_LinkedShaders,
- MESA_SHADER_STAGES, true);
+ glsl_symbol_table variables;
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (prog->_LinkedShaders[i] == NULL)
+ continue;
+
+ cross_validate_globals(prog, prog->_LinkedShaders[i]->ir, &variables,
+ true);
+ }
}
/**
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
InterfaceBlockStageIndex[i] = new int[max_num_buffer_blocks];
for (unsigned int j = 0; j < max_num_buffer_blocks; j++)
int stage_index = InterfaceBlockStageIndex[i][j];
if (stage_index != -1) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
blks[j].stageref |= (1 << i);
* Populates a shaders symbol table with all global declarations
*/
static void
-populate_symbol_table(gl_shader *sh)
+populate_symbol_table(gl_linked_shader *sh)
{
sh->symbols = new(sh) glsl_symbol_table;
* should be added.
*/
void
-remap_variables(ir_instruction *inst, struct gl_shader *target,
+remap_variables(ir_instruction *inst, struct gl_linked_shader *target,
hash_table *temps)
{
class remap_visitor : public ir_hierarchical_visitor {
public:
- remap_visitor(struct gl_shader *target,
+ remap_visitor(struct gl_linked_shader *target,
hash_table *temps)
{
this->target = target;
virtual ir_visitor_status visit(ir_dereference_variable *ir)
{
if (ir->var->data.mode == ir_var_temporary) {
- ir_variable *var = (ir_variable *) hash_table_find(temps, ir->var);
+ hash_entry *entry = _mesa_hash_table_search(temps, ir->var);
+ ir_variable *var = entry ? (ir_variable *) entry->data : NULL;
assert(var != NULL);
ir->var = var;
}
private:
- struct gl_shader *target;
+ struct gl_linked_shader *target;
glsl_symbol_table *symbols;
exec_list *instructions;
hash_table *temps;
*/
exec_node *
move_non_declarations(exec_list *instructions, exec_node *last,
- bool make_copies, gl_shader *target)
+ bool make_copies, gl_linked_shader *target)
{
hash_table *temps = NULL;
if (make_copies)
- temps = hash_table_ctor(0, hash_table_pointer_hash,
- hash_table_pointer_compare);
+ temps = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
+ _mesa_key_pointer_equal);
foreach_in_list_safe(ir_instruction, inst, instructions) {
if (inst->as_function())
inst = inst->clone(target, NULL);
if (var != NULL)
- hash_table_insert(temps, inst, var);
+ _mesa_hash_table_insert(temps, var, inst);
else
remap_variables(inst, target, temps);
} else {
}
if (make_copies)
- hash_table_dtor(temps);
+ _mesa_hash_table_destroy(temps, NULL);
return last;
}
public:
array_sizing_visitor()
: mem_ctx(ralloc_context(NULL)),
- unnamed_interfaces(hash_table_ctor(0, hash_table_pointer_hash,
- hash_table_pointer_compare))
+ unnamed_interfaces(_mesa_hash_table_create(NULL, _mesa_hash_pointer,
+ _mesa_key_pointer_equal))
{
}
~array_sizing_visitor()
{
- hash_table_dtor(this->unnamed_interfaces);
+ _mesa_hash_table_destroy(this->unnamed_interfaces, NULL);
ralloc_free(this->mem_ctx);
}
virtual ir_visitor_status visit(ir_variable *var)
{
const glsl_type *type_without_array;
+ bool implicit_sized_array = var->data.implicit_sized_array;
fixup_type(&var->type, var->data.max_array_access,
- var->data.from_ssbo_unsized_array);
+ var->data.from_ssbo_unsized_array,
+ &implicit_sized_array);
+ var->data.implicit_sized_array = implicit_sized_array;
type_without_array = var->type->without_array();
if (var->type->is_interface()) {
if (interface_contains_unsized_arrays(var->type)) {
/* Store a pointer to the variable in the unnamed_interfaces
* hashtable.
*/
- ir_variable **interface_vars = (ir_variable **)
- hash_table_find(this->unnamed_interfaces, ifc_type);
+ hash_entry *entry =
+ _mesa_hash_table_search(this->unnamed_interfaces,
+ ifc_type);
+
+ ir_variable **interface_vars = entry ? (ir_variable **) entry->data : NULL;
+
if (interface_vars == NULL) {
interface_vars = rzalloc_array(mem_ctx, ir_variable *,
ifc_type->length);
- hash_table_insert(this->unnamed_interfaces, interface_vars,
- ifc_type);
+ _mesa_hash_table_insert(this->unnamed_interfaces, ifc_type,
+ interface_vars);
}
unsigned index = ifc_type->field_index(var->name);
assert(index < ifc_type->length);
* it with a sized array whose size is determined by max_array_access.
*/
static void fixup_type(const glsl_type **type, unsigned max_array_access,
- bool from_ssbo_unsized_array)
+ bool from_ssbo_unsized_array, bool *implicit_sized)
{
if (!from_ssbo_unsized_array && (*type)->is_unsized_array()) {
*type = glsl_type::get_array_instance((*type)->fields.array,
max_array_access + 1);
+ *implicit_sized = true;
assert(*type != NULL);
}
}
memcpy(fields, type->fields.structure,
num_fields * sizeof(*fields));
for (unsigned i = 0; i < num_fields; i++) {
+ bool implicit_sized_array = fields[i].implicit_sized_array;
/* If SSBO last member is unsized array, we don't replace it by a sized
* array.
*/
if (is_ssbo && i == (num_fields - 1))
fixup_type(&fields[i].type, max_ifc_array_access[i],
- true);
+ true, &implicit_sized_array);
else
fixup_type(&fields[i].type, max_ifc_array_access[i],
- false);
+ false, &implicit_sized_array);
+ fields[i].implicit_sized_array = implicit_sized_array;
}
glsl_interface_packing packing =
(glsl_interface_packing) type->interface_packing;
static void
link_xfb_stride_layout_qualifiers(struct gl_context *ctx,
struct gl_shader_program *prog,
- struct gl_shader *linked_shader,
+ struct gl_linked_shader *linked_shader,
struct gl_shader **shader_list,
unsigned num_shaders)
{
for (unsigned i = 0; i < MAX_FEEDBACK_BUFFERS; i++) {
- linked_shader->TransformFeedback.BufferStride[i] = 0;
+ linked_shader->info.TransformFeedback.BufferStride[i] = 0;
}
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
- if (shader->TransformFeedback.BufferStride[j]) {
- if (linked_shader->TransformFeedback.BufferStride[j] != 0 &&
- shader->TransformFeedback.BufferStride[j] != 0 &&
- linked_shader->TransformFeedback.BufferStride[j] !=
- shader->TransformFeedback.BufferStride[j]) {
+ if (shader->info.TransformFeedback.BufferStride[j]) {
+ if (linked_shader->info.TransformFeedback.BufferStride[j] != 0 &&
+ shader->info.TransformFeedback.BufferStride[j] != 0 &&
+ linked_shader->info.TransformFeedback.BufferStride[j] !=
+ shader->info.TransformFeedback.BufferStride[j]) {
linker_error(prog,
"intrastage shaders defined with conflicting "
"xfb_stride for buffer %d (%d and %d)\n", j,
- linked_shader->TransformFeedback.BufferStride[j],
- shader->TransformFeedback.BufferStride[j]);
+ linked_shader->
+ info.TransformFeedback.BufferStride[j],
+ shader->info.TransformFeedback.BufferStride[j]);
return;
}
- if (shader->TransformFeedback.BufferStride[j])
- linked_shader->TransformFeedback.BufferStride[j] =
- shader->TransformFeedback.BufferStride[j];
+ if (shader->info.TransformFeedback.BufferStride[j])
+ linked_shader->info.TransformFeedback.BufferStride[j] =
+ shader->info.TransformFeedback.BufferStride[j];
}
}
}
for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
- if (linked_shader->TransformFeedback.BufferStride[j]) {
+ if (linked_shader->info.TransformFeedback.BufferStride[j]) {
prog->TransformFeedback.BufferStride[j] =
- linked_shader->TransformFeedback.BufferStride[j];
+ linked_shader->info.TransformFeedback.BufferStride[j];
/* We will validate doubles at a later stage */
if (prog->TransformFeedback.BufferStride[j] % 4) {
*/
static void
link_tcs_out_layout_qualifiers(struct gl_shader_program *prog,
- struct gl_shader *linked_shader,
+ struct gl_linked_shader *linked_shader,
struct gl_shader **shader_list,
unsigned num_shaders)
{
- linked_shader->TessCtrl.VerticesOut = 0;
+ linked_shader->info.TessCtrl.VerticesOut = 0;
if (linked_shader->Stage != MESA_SHADER_TESS_CTRL)
return;
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
- if (shader->TessCtrl.VerticesOut != 0) {
- if (linked_shader->TessCtrl.VerticesOut != 0 &&
- linked_shader->TessCtrl.VerticesOut != shader->TessCtrl.VerticesOut) {
+ if (shader->info.TessCtrl.VerticesOut != 0) {
+ if (linked_shader->info.TessCtrl.VerticesOut != 0 &&
+ linked_shader->info.TessCtrl.VerticesOut !=
+ shader->info.TessCtrl.VerticesOut) {
linker_error(prog, "tessellation control shader defined with "
"conflicting output vertex count (%d and %d)\n",
- linked_shader->TessCtrl.VerticesOut,
- shader->TessCtrl.VerticesOut);
+ linked_shader->info.TessCtrl.VerticesOut,
+ shader->info.TessCtrl.VerticesOut);
return;
}
- linked_shader->TessCtrl.VerticesOut = shader->TessCtrl.VerticesOut;
+ linked_shader->info.TessCtrl.VerticesOut =
+ shader->info.TessCtrl.VerticesOut;
}
}
* since we already know we're in the right type of shader program
* for doing it.
*/
- if (linked_shader->TessCtrl.VerticesOut == 0) {
+ if (linked_shader->info.TessCtrl.VerticesOut == 0) {
linker_error(prog, "tessellation control shader didn't declare "
"vertices out layout qualifier\n");
return;
}
- prog->TessCtrl.VerticesOut = linked_shader->TessCtrl.VerticesOut;
}
*/
static void
link_tes_in_layout_qualifiers(struct gl_shader_program *prog,
- struct gl_shader *linked_shader,
+ struct gl_linked_shader *linked_shader,
struct gl_shader **shader_list,
unsigned num_shaders)
{
- linked_shader->TessEval.PrimitiveMode = PRIM_UNKNOWN;
- linked_shader->TessEval.Spacing = 0;
- linked_shader->TessEval.VertexOrder = 0;
- linked_shader->TessEval.PointMode = -1;
+ linked_shader->info.TessEval.PrimitiveMode = PRIM_UNKNOWN;
+ linked_shader->info.TessEval.Spacing = 0;
+ linked_shader->info.TessEval.VertexOrder = 0;
+ linked_shader->info.TessEval.PointMode = -1;
if (linked_shader->Stage != MESA_SHADER_TESS_EVAL)
return;
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
- if (shader->TessEval.PrimitiveMode != PRIM_UNKNOWN) {
- if (linked_shader->TessEval.PrimitiveMode != PRIM_UNKNOWN &&
- linked_shader->TessEval.PrimitiveMode != shader->TessEval.PrimitiveMode) {
+ if (shader->info.TessEval.PrimitiveMode != PRIM_UNKNOWN) {
+ if (linked_shader->info.TessEval.PrimitiveMode != PRIM_UNKNOWN &&
+ linked_shader->info.TessEval.PrimitiveMode !=
+ shader->info.TessEval.PrimitiveMode) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting input primitive modes.\n");
return;
}
- linked_shader->TessEval.PrimitiveMode = shader->TessEval.PrimitiveMode;
+ linked_shader->info.TessEval.PrimitiveMode = shader->info.TessEval.PrimitiveMode;
}
- if (shader->TessEval.Spacing != 0) {
- if (linked_shader->TessEval.Spacing != 0 &&
- linked_shader->TessEval.Spacing != shader->TessEval.Spacing) {
+ if (shader->info.TessEval.Spacing != 0) {
+ if (linked_shader->info.TessEval.Spacing != 0 &&
+ linked_shader->info.TessEval.Spacing !=
+ shader->info.TessEval.Spacing) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting vertex spacing.\n");
return;
}
- linked_shader->TessEval.Spacing = shader->TessEval.Spacing;
+ linked_shader->info.TessEval.Spacing = shader->info.TessEval.Spacing;
}
- if (shader->TessEval.VertexOrder != 0) {
- if (linked_shader->TessEval.VertexOrder != 0 &&
- linked_shader->TessEval.VertexOrder != shader->TessEval.VertexOrder) {
+ if (shader->info.TessEval.VertexOrder != 0) {
+ if (linked_shader->info.TessEval.VertexOrder != 0 &&
+ linked_shader->info.TessEval.VertexOrder !=
+ shader->info.TessEval.VertexOrder) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting ordering.\n");
return;
}
- linked_shader->TessEval.VertexOrder = shader->TessEval.VertexOrder;
+ linked_shader->info.TessEval.VertexOrder =
+ shader->info.TessEval.VertexOrder;
}
- if (shader->TessEval.PointMode != -1) {
- if (linked_shader->TessEval.PointMode != -1 &&
- linked_shader->TessEval.PointMode != shader->TessEval.PointMode) {
+ if (shader->info.TessEval.PointMode != -1) {
+ if (linked_shader->info.TessEval.PointMode != -1 &&
+ linked_shader->info.TessEval.PointMode !=
+ shader->info.TessEval.PointMode) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting point modes.\n");
return;
}
- linked_shader->TessEval.PointMode = shader->TessEval.PointMode;
+ linked_shader->info.TessEval.PointMode =
+ shader->info.TessEval.PointMode;
}
}
* since we already know we're in the right type of shader program
* for doing it.
*/
- if (linked_shader->TessEval.PrimitiveMode == PRIM_UNKNOWN) {
+ if (linked_shader->info.TessEval.PrimitiveMode == PRIM_UNKNOWN) {
linker_error(prog,
"tessellation evaluation shader didn't declare input "
"primitive modes.\n");
return;
}
- prog->TessEval.PrimitiveMode = linked_shader->TessEval.PrimitiveMode;
- if (linked_shader->TessEval.Spacing == 0)
- linked_shader->TessEval.Spacing = GL_EQUAL;
- prog->TessEval.Spacing = linked_shader->TessEval.Spacing;
+ if (linked_shader->info.TessEval.Spacing == 0)
+ linked_shader->info.TessEval.Spacing = GL_EQUAL;
- if (linked_shader->TessEval.VertexOrder == 0)
- linked_shader->TessEval.VertexOrder = GL_CCW;
- prog->TessEval.VertexOrder = linked_shader->TessEval.VertexOrder;
+ if (linked_shader->info.TessEval.VertexOrder == 0)
+ linked_shader->info.TessEval.VertexOrder = GL_CCW;
- if (linked_shader->TessEval.PointMode == -1)
- linked_shader->TessEval.PointMode = GL_FALSE;
- prog->TessEval.PointMode = linked_shader->TessEval.PointMode;
+ if (linked_shader->info.TessEval.PointMode == -1)
+ linked_shader->info.TessEval.PointMode = GL_FALSE;
}
* and propagates them to the linked FS and linked shader program.
*/
static void
-link_fs_input_layout_qualifiers(struct gl_shader_program *prog,
- struct gl_shader *linked_shader,
+link_fs_inout_layout_qualifiers(struct gl_shader_program *prog,
+ struct gl_linked_shader *linked_shader,
struct gl_shader **shader_list,
unsigned num_shaders)
{
- linked_shader->redeclares_gl_fragcoord = false;
- linked_shader->uses_gl_fragcoord = false;
- linked_shader->origin_upper_left = false;
- linked_shader->pixel_center_integer = false;
+ linked_shader->info.redeclares_gl_fragcoord = false;
+ linked_shader->info.uses_gl_fragcoord = false;
+ linked_shader->info.origin_upper_left = false;
+ linked_shader->info.pixel_center_integer = false;
+ linked_shader->info.BlendSupport = 0;
if (linked_shader->Stage != MESA_SHADER_FRAGMENT ||
(prog->Version < 150 && !prog->ARB_fragment_coord_conventions_enable))
* it must be redeclared in all the fragment shaders in that program
* that have a static use gl_FragCoord."
*/
- if ((linked_shader->redeclares_gl_fragcoord
- && !shader->redeclares_gl_fragcoord
- && shader->uses_gl_fragcoord)
- || (shader->redeclares_gl_fragcoord
- && !linked_shader->redeclares_gl_fragcoord
- && linked_shader->uses_gl_fragcoord)) {
+ if ((linked_shader->info.redeclares_gl_fragcoord
+ && !shader->info.redeclares_gl_fragcoord
+ && shader->info.uses_gl_fragcoord)
+ || (shader->info.redeclares_gl_fragcoord
+ && !linked_shader->info.redeclares_gl_fragcoord
+ && linked_shader->info.uses_gl_fragcoord)) {
linker_error(prog, "fragment shader defined with conflicting "
"layout qualifiers for gl_FragCoord\n");
}
* "All redeclarations of gl_FragCoord in all fragment shaders in a
* single program must have the same set of qualifiers."
*/
- if (linked_shader->redeclares_gl_fragcoord && shader->redeclares_gl_fragcoord
- && (shader->origin_upper_left != linked_shader->origin_upper_left
- || shader->pixel_center_integer != linked_shader->pixel_center_integer)) {
+ if (linked_shader->info.redeclares_gl_fragcoord &&
+ shader->info.redeclares_gl_fragcoord &&
+ (shader->info.origin_upper_left !=
+ linked_shader->info.origin_upper_left ||
+ shader->info.pixel_center_integer !=
+ linked_shader->info.pixel_center_integer)) {
linker_error(prog, "fragment shader defined with conflicting "
"layout qualifiers for gl_FragCoord\n");
}
* are multiple redeclarations, all the fields except uses_gl_fragcoord
* are already known to be the same.
*/
- if (shader->redeclares_gl_fragcoord || shader->uses_gl_fragcoord) {
- linked_shader->redeclares_gl_fragcoord =
- shader->redeclares_gl_fragcoord;
- linked_shader->uses_gl_fragcoord = linked_shader->uses_gl_fragcoord
- || shader->uses_gl_fragcoord;
- linked_shader->origin_upper_left = shader->origin_upper_left;
- linked_shader->pixel_center_integer = shader->pixel_center_integer;
+ if (shader->info.redeclares_gl_fragcoord ||
+ shader->info.uses_gl_fragcoord) {
+ linked_shader->info.redeclares_gl_fragcoord =
+ shader->info.redeclares_gl_fragcoord;
+ linked_shader->info.uses_gl_fragcoord =
+ linked_shader->info.uses_gl_fragcoord ||
+ shader->info.uses_gl_fragcoord;
+ linked_shader->info.origin_upper_left =
+ shader->info.origin_upper_left;
+ linked_shader->info.pixel_center_integer =
+ shader->info.pixel_center_integer;
}
- linked_shader->EarlyFragmentTests |= shader->EarlyFragmentTests;
+ linked_shader->info.EarlyFragmentTests |=
+ shader->info.EarlyFragmentTests;
+ linked_shader->info.BlendSupport |= shader->info.BlendSupport;
}
}
*/
static void
link_gs_inout_layout_qualifiers(struct gl_shader_program *prog,
- struct gl_shader *linked_shader,
+ struct gl_linked_shader *linked_shader,
struct gl_shader **shader_list,
unsigned num_shaders)
{
- linked_shader->Geom.VerticesOut = 0;
- linked_shader->Geom.Invocations = 0;
- linked_shader->Geom.InputType = PRIM_UNKNOWN;
- linked_shader->Geom.OutputType = PRIM_UNKNOWN;
+ linked_shader->info.Geom.VerticesOut = -1;
+ linked_shader->info.Geom.Invocations = 0;
+ linked_shader->info.Geom.InputType = PRIM_UNKNOWN;
+ linked_shader->info.Geom.OutputType = PRIM_UNKNOWN;
/* No in/out qualifiers defined for anything but GLSL 1.50+
* geometry shaders so far.
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
- if (shader->Geom.InputType != PRIM_UNKNOWN) {
- if (linked_shader->Geom.InputType != PRIM_UNKNOWN &&
- linked_shader->Geom.InputType != shader->Geom.InputType) {
+ if (shader->info.Geom.InputType != PRIM_UNKNOWN) {
+ if (linked_shader->info.Geom.InputType != PRIM_UNKNOWN &&
+ linked_shader->info.Geom.InputType !=
+ shader->info.Geom.InputType) {
linker_error(prog, "geometry shader defined with conflicting "
"input types\n");
return;
}
- linked_shader->Geom.InputType = shader->Geom.InputType;
+ linked_shader->info.Geom.InputType = shader->info.Geom.InputType;
}
- if (shader->Geom.OutputType != PRIM_UNKNOWN) {
- if (linked_shader->Geom.OutputType != PRIM_UNKNOWN &&
- linked_shader->Geom.OutputType != shader->Geom.OutputType) {
+ if (shader->info.Geom.OutputType != PRIM_UNKNOWN) {
+ if (linked_shader->info.Geom.OutputType != PRIM_UNKNOWN &&
+ linked_shader->info.Geom.OutputType !=
+ shader->info.Geom.OutputType) {
linker_error(prog, "geometry shader defined with conflicting "
"output types\n");
return;
}
- linked_shader->Geom.OutputType = shader->Geom.OutputType;
+ linked_shader->info.Geom.OutputType = shader->info.Geom.OutputType;
}
- if (shader->Geom.VerticesOut != 0) {
- if (linked_shader->Geom.VerticesOut != 0 &&
- linked_shader->Geom.VerticesOut != shader->Geom.VerticesOut) {
+ if (shader->info.Geom.VerticesOut != -1) {
+ if (linked_shader->info.Geom.VerticesOut != -1 &&
+ linked_shader->info.Geom.VerticesOut !=
+ shader->info.Geom.VerticesOut) {
linker_error(prog, "geometry shader defined with conflicting "
"output vertex count (%d and %d)\n",
- linked_shader->Geom.VerticesOut,
- shader->Geom.VerticesOut);
+ linked_shader->info.Geom.VerticesOut,
+ shader->info.Geom.VerticesOut);
return;
}
- linked_shader->Geom.VerticesOut = shader->Geom.VerticesOut;
+ linked_shader->info.Geom.VerticesOut = shader->info.Geom.VerticesOut;
}
- if (shader->Geom.Invocations != 0) {
- if (linked_shader->Geom.Invocations != 0 &&
- linked_shader->Geom.Invocations != shader->Geom.Invocations) {
+ if (shader->info.Geom.Invocations != 0) {
+ if (linked_shader->info.Geom.Invocations != 0 &&
+ linked_shader->info.Geom.Invocations !=
+ shader->info.Geom.Invocations) {
linker_error(prog, "geometry shader defined with conflicting "
"invocation count (%d and %d)\n",
- linked_shader->Geom.Invocations,
- shader->Geom.Invocations);
+ linked_shader->info.Geom.Invocations,
+ shader->info.Geom.Invocations);
return;
}
- linked_shader->Geom.Invocations = shader->Geom.Invocations;
+ linked_shader->info.Geom.Invocations = shader->info.Geom.Invocations;
}
}
* since we already know we're in the right type of shader program
* for doing it.
*/
- if (linked_shader->Geom.InputType == PRIM_UNKNOWN) {
+ if (linked_shader->info.Geom.InputType == PRIM_UNKNOWN) {
linker_error(prog,
"geometry shader didn't declare primitive input type\n");
return;
}
- prog->Geom.InputType = linked_shader->Geom.InputType;
- if (linked_shader->Geom.OutputType == PRIM_UNKNOWN) {
+ if (linked_shader->info.Geom.OutputType == PRIM_UNKNOWN) {
linker_error(prog,
"geometry shader didn't declare primitive output type\n");
return;
}
- prog->Geom.OutputType = linked_shader->Geom.OutputType;
- if (linked_shader->Geom.VerticesOut == 0) {
+ if (linked_shader->info.Geom.VerticesOut == -1) {
linker_error(prog,
"geometry shader didn't declare max_vertices\n");
return;
}
- prog->Geom.VerticesOut = linked_shader->Geom.VerticesOut;
-
- if (linked_shader->Geom.Invocations == 0)
- linked_shader->Geom.Invocations = 1;
- prog->Geom.Invocations = linked_shader->Geom.Invocations;
+ if (linked_shader->info.Geom.Invocations == 0)
+ linked_shader->info.Geom.Invocations = 1;
}
*/
static void
link_cs_input_layout_qualifiers(struct gl_shader_program *prog,
- struct gl_shader *linked_shader,
+ struct gl_linked_shader *linked_shader,
struct gl_shader **shader_list,
unsigned num_shaders)
{
for (int i = 0; i < 3; i++)
- linked_shader->Comp.LocalSize[i] = 0;
+ linked_shader->info.Comp.LocalSize[i] = 0;
/* This function is called for all shader stages, but it only has an effect
* for compute shaders.
for (unsigned sh = 0; sh < num_shaders; sh++) {
struct gl_shader *shader = shader_list[sh];
- if (shader->Comp.LocalSize[0] != 0) {
- if (linked_shader->Comp.LocalSize[0] != 0) {
+ if (shader->info.Comp.LocalSize[0] != 0) {
+ if (linked_shader->info.Comp.LocalSize[0] != 0) {
for (int i = 0; i < 3; i++) {
- if (linked_shader->Comp.LocalSize[i] !=
- shader->Comp.LocalSize[i]) {
+ if (linked_shader->info.Comp.LocalSize[i] !=
+ shader->info.Comp.LocalSize[i]) {
linker_error(prog, "compute shader defined with conflicting "
"local sizes\n");
return;
}
}
}
- for (int i = 0; i < 3; i++)
- linked_shader->Comp.LocalSize[i] = shader->Comp.LocalSize[i];
+ for (int i = 0; i < 3; i++) {
+ linked_shader->info.Comp.LocalSize[i] =
+ shader->info.Comp.LocalSize[i];
+ }
}
}
* since we already know we're in the right type of shader program
* for doing it.
*/
- if (linked_shader->Comp.LocalSize[0] == 0) {
+ if (linked_shader->info.Comp.LocalSize[0] == 0) {
linker_error(prog, "compute shader didn't declare local size\n");
return;
}
for (int i = 0; i < 3; i++)
- prog->Comp.LocalSize[i] = linked_shader->Comp.LocalSize[i];
+ prog->Comp.LocalSize[i] = linked_shader->info.Comp.LocalSize[i];
}
* If this function is supplied a single shader, it is cloned, and the new
* shader is returned.
*/
-static struct gl_shader *
+static struct gl_linked_shader *
link_intrastage_shaders(void *mem_ctx,
struct gl_context *ctx,
struct gl_shader_program *prog,
/* Check that global variables defined in multiple shaders are consistent.
*/
- cross_validate_globals(prog, shader_list, num_shaders, false);
+ glsl_symbol_table variables;
+ for (unsigned i = 0; i < num_shaders; i++) {
+ if (shader_list[i] == NULL)
+ continue;
+ cross_validate_globals(prog, shader_list[i]->ir, &variables, false);
+ }
+
if (!prog->LinkStatus)
return NULL;
if (!prog->LinkStatus)
return NULL;
- /* Link up uniform blocks defined within this stage. */
- link_uniform_blocks(mem_ctx, ctx, prog, shader_list, num_shaders,
- &ubo_blocks, &num_ubo_blocks, &ssbo_blocks,
- &num_ssbo_blocks);
-
- if (!prog->LinkStatus)
- return NULL;
-
/* Check that there is only a single definition of each function signature
* across all shaders.
*/
continue;
foreach_in_list(ir_function_signature, sig, &f->signatures) {
- if (!sig->is_defined || sig->is_builtin())
+ if (!sig->is_defined)
continue;
ir_function_signature *other_sig =
other->exact_matching_signature(NULL, &sig->parameters);
- if ((other_sig != NULL) && other_sig->is_defined
- && !other_sig->is_builtin()) {
+ if (other_sig != NULL && other_sig->is_defined) {
linker_error(prog, "function `%s' is multiply defined\n",
f->name);
return NULL;
*/
gl_shader *main = NULL;
for (unsigned i = 0; i < num_shaders; i++) {
- if (_mesa_get_main_function_signature(shader_list[i]) != NULL) {
+ if (_mesa_get_main_function_signature(shader_list[i]->symbols)) {
main = shader_list[i];
break;
}
return NULL;
}
- gl_shader *linked = ctx->Driver.NewShader(NULL, 0, main->Type);
+ gl_linked_shader *linked = ctx->Driver.NewShader(shader_list[0]->Stage);
linked->ir = new(linked) exec_list;
clone_ir_list(mem_ctx, linked->ir, main->ir);
- /* Copy ubo blocks to linked shader list */
- linked->UniformBlocks =
- ralloc_array(linked, gl_uniform_block *, num_ubo_blocks);
- ralloc_steal(linked, ubo_blocks);
- for (unsigned i = 0; i < num_ubo_blocks; i++) {
- linked->UniformBlocks[i] = &ubo_blocks[i];
- }
- linked->NumUniformBlocks = num_ubo_blocks;
-
- /* Copy ssbo blocks to linked shader list */
- linked->ShaderStorageBlocks =
- ralloc_array(linked, gl_uniform_block *, num_ssbo_blocks);
- ralloc_steal(linked, ssbo_blocks);
- for (unsigned i = 0; i < num_ssbo_blocks; i++) {
- linked->ShaderStorageBlocks[i] = &ssbo_blocks[i];
- }
- linked->NumShaderStorageBlocks = num_ssbo_blocks;
-
- link_fs_input_layout_qualifiers(prog, linked, shader_list, num_shaders);
+ link_fs_inout_layout_qualifiers(prog, linked, shader_list, num_shaders);
link_tcs_out_layout_qualifiers(prog, linked, shader_list, num_shaders);
link_tes_in_layout_qualifiers(prog, linked, shader_list, num_shaders);
link_gs_inout_layout_qualifiers(prog, linked, shader_list, num_shaders);
* copy of the original shader that contained the main function).
*/
ir_function_signature *const main_sig =
- _mesa_get_main_function_signature(linked);
+ _mesa_get_main_function_signature(linked->symbols);
/* Move any instructions other than variable declarations or function
* declarations into main.
insertion_point, true, linked);
}
- /* Check if any shader needs built-in functions. */
- bool need_builtins = false;
- for (unsigned i = 0; i < num_shaders; i++) {
- if (shader_list[i]->uses_builtin_functions) {
- need_builtins = true;
- break;
- }
+ if (!link_function_calls(prog, linked, shader_list, num_shaders)) {
+ _mesa_delete_linked_shader(ctx, linked);
+ return NULL;
}
- bool ok;
- if (need_builtins) {
- /* Make a temporary array one larger than shader_list, which will hold
- * the built-in function shader as well.
- */
- gl_shader **linking_shaders = (gl_shader **)
- calloc(num_shaders + 1, sizeof(gl_shader *));
-
- ok = linking_shaders != NULL;
-
- if (ok) {
- memcpy(linking_shaders, shader_list, num_shaders * sizeof(gl_shader *));
- _mesa_glsl_initialize_builtin_functions();
- linking_shaders[num_shaders] = _mesa_glsl_get_builtin_function_shader();
+ /* Make a pass over all variable declarations to ensure that arrays with
+ * unspecified sizes have a size specified. The size is inferred from the
+ * max_array_access field.
+ */
+ array_sizing_visitor v;
+ v.run(linked->ir);
+ v.fixup_unnamed_interface_types();
- ok = link_function_calls(prog, linked, linking_shaders, num_shaders + 1);
+ /* Link up uniform blocks defined within this stage. */
+ link_uniform_blocks(mem_ctx, ctx, prog, linked, &ubo_blocks,
+ &num_ubo_blocks, &ssbo_blocks, &num_ssbo_blocks);
- free(linking_shaders);
- } else {
- _mesa_error_no_memory(__func__);
- }
- } else {
- ok = link_function_calls(prog, linked, shader_list, num_shaders);
+ if (!prog->LinkStatus) {
+ _mesa_delete_linked_shader(ctx, linked);
+ return NULL;
}
+ /* Copy ubo blocks to linked shader list */
+ linked->UniformBlocks =
+ ralloc_array(linked, gl_uniform_block *, num_ubo_blocks);
+ ralloc_steal(linked, ubo_blocks);
+ for (unsigned i = 0; i < num_ubo_blocks; i++) {
+ linked->UniformBlocks[i] = &ubo_blocks[i];
+ }
+ linked->NumUniformBlocks = num_ubo_blocks;
- if (!ok) {
- _mesa_delete_shader(ctx, linked);
- return NULL;
+ /* Copy ssbo blocks to linked shader list */
+ linked->ShaderStorageBlocks =
+ ralloc_array(linked, gl_uniform_block *, num_ssbo_blocks);
+ ralloc_steal(linked, ssbo_blocks);
+ for (unsigned i = 0; i < num_ssbo_blocks; i++) {
+ linked->ShaderStorageBlocks[i] = &ssbo_blocks[i];
}
+ linked->NumShaderStorageBlocks = num_ssbo_blocks;
/* At this point linked should contain all of the linked IR, so
* validate it to make sure nothing went wrong.
/* Set the size of geometry shader input arrays */
if (linked->Stage == MESA_SHADER_GEOMETRY) {
- unsigned num_vertices = vertices_per_prim(prog->Geom.InputType);
- geom_array_resize_visitor input_resize_visitor(num_vertices, prog);
+ unsigned num_vertices = vertices_per_prim(linked->info.Geom.InputType);
+ array_resize_visitor input_resize_visitor(num_vertices, prog,
+ MESA_SHADER_GEOMETRY);
foreach_in_list(ir_instruction, ir, linked->ir) {
ir->accept(&input_resize_visitor);
}
if (ctx->Const.VertexID_is_zero_based)
lower_vertex_id(linked);
- /* Validate correct usage of barrier() in the tess control shader */
- if (linked->Stage == MESA_SHADER_TESS_CTRL) {
- barrier_use_visitor visitor(prog);
- foreach_in_list(ir_instruction, ir, linked->ir) {
- ir->accept(&visitor);
- }
- }
-
- /* Make a pass over all variable declarations to ensure that arrays with
- * unspecified sizes have a size specified. The size is inferred from the
- * max_array_access field.
- */
- array_sizing_visitor v;
- v.run(linked->ir);
- v.fixup_unnamed_interface_types();
-
return linked;
}
if (prog->_LinkedShaders[MESA_SHADER_TESS_EVAL] == NULL)
return;
- gl_shader *const tcs = prog->_LinkedShaders[MESA_SHADER_TESS_CTRL];
- gl_shader *const tes = prog->_LinkedShaders[MESA_SHADER_TESS_EVAL];
+ gl_linked_shader *const tcs = prog->_LinkedShaders[MESA_SHADER_TESS_CTRL];
+ gl_linked_shader *const tes = prog->_LinkedShaders[MESA_SHADER_TESS_EVAL];
/* If no control shader is present, then the TES inputs are statically
* sized to MaxPatchVertices; the actual size of the arrays won't be
* known until draw time.
*/
const int num_vertices = tcs
- ? tcs->TessCtrl.VerticesOut
+ ? tcs->info.TessCtrl.VerticesOut
: ctx->Const.MaxPatchVertices;
- tess_eval_array_resize_visitor input_resize_visitor(num_vertices, prog);
+ array_resize_visitor input_resize_visitor(num_vertices, prog,
+ MESA_SHADER_TESS_EVAL);
foreach_in_list(ir_instruction, ir, tes->ir) {
ir->accept(&input_resize_visitor);
}
- if (tcs) {
+ if (tcs || ctx->Const.LowerTESPatchVerticesIn) {
/* Convert the gl_PatchVerticesIn system value into a constant, since
* the value is known at this point.
*/
if (var && var->data.mode == ir_var_system_value &&
var->data.location == SYSTEM_VALUE_VERTICES_IN) {
void *mem_ctx = ralloc_parent(var);
- var->data.mode = ir_var_auto;
var->data.location = 0;
- var->constant_value = new(mem_ctx) ir_constant(num_vertices);
+ var->data.explicit_location = false;
+ if (tcs) {
+ var->data.mode = ir_var_auto;
+ var->constant_value = new(mem_ctx) ir_constant(num_vertices);
+ } else {
+ var->data.mode = ir_var_uniform;
+ var->data.how_declared = ir_var_hidden;
+ var->allocate_state_slots(1);
+ ir_state_slot *slot0 = &var->get_state_slots()[0];
+ slot0->swizzle = SWIZZLE_XXXX;
+ slot0->tokens[0] = STATE_INTERNAL;
+ slot0->tokens[1] = STATE_TES_PATCH_VERTICES_IN;
+ for (int i = 2; i < STATE_LENGTH; i++)
+ slot0->tokens[i] = 0;
+ }
}
}
}
/**
* Assign locations for either VS inputs or FS outputs
*
+ * \param mem_ctx Temporary ralloc context used for linking
* \param prog Shader program whose variables need locations assigned
* \param constants Driver specific constant values for the program.
* \param target_index Selector for the program target to receive location
* error is emitted to the shader link log and false is returned.
*/
bool
-assign_attribute_or_color_locations(gl_shader_program *prog,
+assign_attribute_or_color_locations(void *mem_ctx,
+ gl_shader_program *prog,
struct gl_constants *constants,
unsigned target_index)
{
assert((target_index == MESA_SHADER_VERTEX)
|| (target_index == MESA_SHADER_FRAGMENT));
- gl_shader *const sh = prog->_LinkedShaders[target_index];
+ gl_linked_shader *const sh = prog->_LinkedShaders[target_index];
if (sh == NULL)
return true;
} to_assign[32];
assert(max_index <= 32);
+ /* Temporary array for the set of attributes that have locations assigned.
+ */
+ ir_variable *assigned[16];
+
unsigned num_attr = 0;
+ unsigned assigned_attr = 0;
foreach_in_list(ir_instruction, node, sh->ir) {
ir_variable *const var = node->as_variable();
} else if (target_index == MESA_SHADER_FRAGMENT) {
unsigned binding;
unsigned index;
+ const char *name = var->name;
+ const glsl_type *type = var->type;
+
+ while (type) {
+ /* Check if there's a binding for the variable name */
+ if (prog->FragDataBindings->get(binding, name)) {
+ assert(binding >= FRAG_RESULT_DATA0);
+ var->data.location = binding;
+ var->data.is_unmatched_generic_inout = 0;
+
+ if (prog->FragDataIndexBindings->get(index, name)) {
+ var->data.index = index;
+ }
+ break;
+ }
- if (prog->FragDataBindings->get(binding, var->name)) {
- assert(binding >= FRAG_RESULT_DATA0);
- var->data.location = binding;
- var->data.is_unmatched_generic_inout = 0;
+ /* If not, but it's an array type, look for name[0] */
+ if (type->is_array()) {
+ name = ralloc_asprintf(mem_ctx, "%s[0]", name);
+ type = type->fields.array;
+ continue;
+ }
- if (prog->FragDataIndexBindings->get(index, var->name)) {
- var->data.index = index;
- }
- }
+ break;
+ }
}
+ if (strcmp(var->name, "gl_LastFragData") == 0)
+ continue;
+
/* From GL4.5 core spec, section 15.2 (Shader Execution):
*
* "Output binding assignments will cause LinkProgram to fail:
* attribute overlaps any previously allocated bits.
*/
if ((~(use_mask << attr) & used_locations) != used_locations) {
- if (target_index == MESA_SHADER_FRAGMENT ||
- (prog->IsES && prog->Version >= 300)) {
- linker_error(prog,
- "overlapping location is assigned "
- "to %s `%s' %d %d %d\n", string,
- var->name, used_locations, use_mask, attr);
+ if (target_index == MESA_SHADER_FRAGMENT && !prog->IsES) {
+ /* From section 4.4.2 (Output Layout Qualifiers) of the GLSL
+ * 4.40 spec:
+ *
+ * "Additionally, for fragment shader outputs, if two
+ * variables are placed within the same location, they
+ * must have the same underlying type (floating-point or
+ * integer). No component aliasing of output variables or
+ * members is allowed.
+ */
+ for (unsigned i = 0; i < assigned_attr; i++) {
+ unsigned assigned_slots =
+ assigned[i]->type->count_attribute_slots(false);
+ unsigned assig_attr =
+ assigned[i]->data.location - generic_base;
+ unsigned assigned_use_mask = (1 << assigned_slots) - 1;
+
+ if ((assigned_use_mask << assig_attr) &
+ (use_mask << attr)) {
+
+ const glsl_type *assigned_type =
+ assigned[i]->type->without_array();
+ const glsl_type *type = var->type->without_array();
+ if (assigned_type->base_type != type->base_type) {
+ linker_error(prog, "types do not match for aliased"
+ " %ss %s and %s\n", string,
+ assigned[i]->name, var->name);
+ return false;
+ }
+
+ unsigned assigned_component_mask =
+ ((1 << assigned_type->vector_elements) - 1) <<
+ assigned[i]->data.location_frac;
+ unsigned component_mask =
+ ((1 << type->vector_elements) - 1) <<
+ var->data.location_frac;
+ if (assigned_component_mask & component_mask) {
+ linker_error(prog, "overlapping component is "
+ "assigned to %ss %s and %s "
+ "(component=%d)\n",
+ string, assigned[i]->name, var->name,
+ var->data.location_frac);
+ return false;
+ }
+ }
+ }
+ } else if (target_index == MESA_SHADER_FRAGMENT ||
+ (prog->IsES && prog->Version >= 300)) {
+ linker_error(prog, "overlapping location is assigned "
+ "to %s `%s' %d %d %d\n", string, var->name,
+ used_locations, use_mask, attr);
return false;
} else {
- linker_warning(prog,
- "overlapping location is assigned "
- "to %s `%s' %d %d %d\n", string,
- var->name, used_locations, use_mask, attr);
+ linker_warning(prog, "overlapping location is assigned "
+ "to %s `%s' %d %d %d\n", string, var->name,
+ used_locations, use_mask, attr);
}
}
* issue (3) of the GL_ARB_vertex_attrib_64bit behavior, this
* is optional behavior, but it seems preferable.
*/
- if (var->type->without_array()->is_dual_slot_double())
+ if (var->type->without_array()->is_dual_slot())
double_storage_locations |= (use_mask << attr);
}
+ assigned[assigned_attr] = var;
+ assigned_attr++;
+
continue;
}
to_assign[i].var->data.is_unmatched_generic_inout = 0;
used_locations |= (use_mask << location);
- if (to_assign[i].var->type->without_array()->is_dual_slot_double())
+ if (to_assign[i].var->type->without_array()->is_dual_slot())
double_storage_locations |= (use_mask << location);
}
* unmatch flag if found so we don't optimise them away.
*/
static void
-match_explicit_outputs_to_inputs(gl_shader *producer,
- gl_shader *consumer)
+match_explicit_outputs_to_inputs(gl_linked_shader *producer,
+ gl_linked_shader *consumer)
{
glsl_symbol_table parameters;
ir_variable *explicit_locations[MAX_VARYINGS_INCL_PATCH][4] =
unsigned total_shader_storage_blocks = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
continue;
link_calculate_subroutine_compat(struct gl_shader_program *prog)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
int count;
if (!sh)
continue;
check_subroutine_resources(struct gl_shader_program *prog)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh) {
if (sh->NumSubroutineUniformRemapTable > MAX_SUBROUTINE_UNIFORM_LOCATIONS)
return;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh) {
if (sh->NumImages > ctx->Const.Program[i].MaxImageUniforms)
static bool
reserve_subroutine_explicit_locations(struct gl_shader_program *prog,
- struct gl_shader *sh,
+ struct gl_linked_shader *sh,
ir_variable *var)
{
unsigned slots = var->type->uniform_locations();
unsigned entries_total = 0;
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = prog->_LinkedShaders[i];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[i];
if (!sh)
continue;
}
static bool
-add_program_resource(struct gl_shader_program *prog, GLenum type,
- const void *data, uint8_t stages)
+add_program_resource(struct gl_shader_program *prog,
+ struct set *resource_set,
+ GLenum type, const void *data, uint8_t stages)
{
assert(data);
/* If resource already exists, do not add it again. */
- for (unsigned i = 0; i < prog->NumProgramResourceList; i++)
- if (prog->ProgramResourceList[i].Data == data)
- return true;
+ if (_mesa_set_search(resource_set, data))
+ return true;
prog->ProgramResourceList =
reralloc(prog,
prog->NumProgramResourceList++;
+ _mesa_set_add(resource_set, data);
+
return true;
}
assert(MESA_SHADER_STAGES < 8);
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = shProg->_LinkedShaders[i];
+ struct gl_linked_shader *sh = shProg->_LinkedShaders[i];
if (!sh)
continue;
create_shader_variable(struct gl_shader_program *shProg,
const ir_variable *in,
const char *name, const glsl_type *type,
- bool use_implicit_location, int location)
+ bool use_implicit_location, int location,
+ const glsl_type *outermost_struct_type)
{
gl_shader_variable *out = ralloc(shProg, struct gl_shader_variable);
if (!out)
if (in->data.mode == ir_var_system_value &&
in->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE) {
out->name = ralloc_strdup(shProg, "gl_VertexID");
+ } else if ((in->data.mode == ir_var_shader_out &&
+ in->data.location == VARYING_SLOT_TESS_LEVEL_OUTER) ||
+ (in->data.mode == ir_var_system_value &&
+ in->data.location == SYSTEM_VALUE_TESS_LEVEL_OUTER)) {
+ out->name = ralloc_strdup(shProg, "gl_TessLevelOuter");
+ type = glsl_type::get_array_instance(glsl_type::float_type, 4);
+ } else if ((in->data.mode == ir_var_shader_out &&
+ in->data.location == VARYING_SLOT_TESS_LEVEL_INNER) ||
+ (in->data.mode == ir_var_system_value &&
+ in->data.location == SYSTEM_VALUE_TESS_LEVEL_INNER)) {
+ out->name = ralloc_strdup(shProg, "gl_TessLevelInner");
+ type = glsl_type::get_array_instance(glsl_type::float_type, 2);
} else {
out->name = ralloc_strdup(shProg, name);
}
}
out->type = type;
+ out->outermost_struct_type = outermost_struct_type;
+ out->interface_type = in->get_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->explicit_location = in->data.explicit_location;
+ out->precision = in->data.precision;
return out;
}
static bool
-add_shader_variable(struct gl_shader_program *shProg, unsigned stage_mask,
+add_shader_variable(struct gl_shader_program *shProg, struct set *resource_set,
+ unsigned stage_mask,
GLenum programInterface, ir_variable *var,
const char *name, const glsl_type *type,
- bool use_implicit_location, int location)
+ bool use_implicit_location, int location,
+ const glsl_type *outermost_struct_type = NULL)
{
const bool is_vertex_input =
programInterface == GL_PROGRAM_INPUT &&
* 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 < type->length; i++) {
const struct glsl_struct_field *field = &type->fields.structure[i];
char *field_name = ralloc_asprintf(shProg, "%s.%s", name, field->name);
- if (!add_shader_variable(shProg, stage_mask, programInterface,
+ if (!add_shader_variable(shProg, resource_set,
+ stage_mask, programInterface,
var, field_name, field->type,
- use_implicit_location, field_location))
+ use_implicit_location, field_location,
+ outermost_struct_type))
return false;
field_location +=
*/
gl_shader_variable *sha_v =
create_shader_variable(shProg, var, prefixed_name, type,
- use_implicit_location, location);
+ use_implicit_location, location,
+ outermost_struct_type);
if (!sha_v)
return false;
- return add_program_resource(shProg, programInterface, sha_v, stage_mask);
+ return add_program_resource(shProg, resource_set,
+ programInterface, sha_v, stage_mask);
}
}
}
static bool
add_interface_variables(struct gl_shader_program *shProg,
+ struct set *resource_set,
unsigned stage, GLenum programInterface)
{
exec_list *ir = shProg->_LinkedShaders[stage]->ir;
continue;
};
+ if (var->data.patch)
+ loc_bias = int(VARYING_SLOT_PATCH0);
+
/* Skip packed varyings, packed varyings are handled separately
* by add_packed_varyings.
*/
(stage == MESA_SHADER_VERTEX && var->data.mode == ir_var_shader_in) ||
(stage == MESA_SHADER_FRAGMENT && var->data.mode == ir_var_shader_out);
- if (!add_shader_variable(shProg, 1 << stage, programInterface,
+ if (!add_shader_variable(shProg, resource_set,
+ 1 << stage, programInterface,
var, var->name, var->type, vs_input_or_fs_output,
var->data.location - loc_bias))
return false;
}
static bool
-add_packed_varyings(struct gl_shader_program *shProg, int stage, GLenum type)
+add_packed_varyings(struct gl_shader_program *shProg, struct set *resource_set,
+ int stage, GLenum type)
{
- struct gl_shader *sh = shProg->_LinkedShaders[stage];
+ struct gl_linked_shader *sh = shProg->_LinkedShaders[stage];
GLenum iface;
if (!sh || !sh->packed_varyings)
if (type == iface) {
const int stage_mask =
build_stageref(shProg, var->name, var->data.mode);
- if (!add_shader_variable(shProg, stage_mask,
+ if (!add_shader_variable(shProg, resource_set,
+ stage_mask,
iface, var, var->name, var->type, false,
var->data.location - VARYING_SLOT_VAR0))
return false;
}
static bool
-add_fragdata_arrays(struct gl_shader_program *shProg)
+add_fragdata_arrays(struct gl_shader_program *shProg, struct set *resource_set)
{
- struct gl_shader *sh = shProg->_LinkedShaders[MESA_SHADER_FRAGMENT];
+ struct gl_linked_shader *sh = shProg->_LinkedShaders[MESA_SHADER_FRAGMENT];
if (!sh || !sh->fragdata_arrays)
return true;
if (var) {
assert(var->data.mode == ir_var_shader_out);
- if (!add_shader_variable(shProg,
+ if (!add_shader_variable(shProg, resource_set,
1 << MESA_SHADER_FRAGMENT,
GL_PROGRAM_OUTPUT, var, var->name, var->type,
true, var->data.location - FRAG_RESULT_DATA0))
}
}
- for (unsigned i = 0; i < shProg->NumShaders; i++) {
- if (shProg->Shaders[i] == NULL)
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
+ const gl_linked_shader *sh = shProg->_LinkedShaders[i];
+ if (sh == NULL)
continue;
- const gl_shader *stage = shProg->Shaders[i];
- foreach_in_list(ir_instruction, node, stage->ir) {
+ foreach_in_list(ir_instruction, node, sh->ir) {
ir_variable *var = node->as_variable();
if (!var || !var->get_interface_type() ||
var->data.mode != ir_var_shader_storage)
if (input_stage == MESA_SHADER_STAGES && output_stage == 0)
return;
+ struct set *resource_set = _mesa_set_create(NULL,
+ _mesa_hash_pointer,
+ _mesa_key_pointer_equal);
+
/* Program interface needs to expose varyings in case of SSO. */
if (shProg->SeparateShader) {
- if (!add_packed_varyings(shProg, input_stage, GL_PROGRAM_INPUT))
+ if (!add_packed_varyings(shProg, resource_set,
+ input_stage, GL_PROGRAM_INPUT))
return;
- if (!add_packed_varyings(shProg, output_stage, GL_PROGRAM_OUTPUT))
+ if (!add_packed_varyings(shProg, resource_set,
+ output_stage, GL_PROGRAM_OUTPUT))
return;
}
- if (!add_fragdata_arrays(shProg))
+ if (!add_fragdata_arrays(shProg, resource_set))
return;
/* Add inputs and outputs to the resource list. */
- if (!add_interface_variables(shProg, input_stage, GL_PROGRAM_INPUT))
+ if (!add_interface_variables(shProg, resource_set,
+ input_stage, GL_PROGRAM_INPUT))
return;
- if (!add_interface_variables(shProg, output_stage, GL_PROGRAM_OUTPUT))
+ if (!add_interface_variables(shProg, resource_set,
+ output_stage, GL_PROGRAM_OUTPUT))
return;
/* Add transform feedback varyings. */
if (shProg->LinkedTransformFeedback.NumVarying > 0) {
for (int i = 0; i < shProg->LinkedTransformFeedback.NumVarying; i++) {
- if (!add_program_resource(shProg, GL_TRANSFORM_FEEDBACK_VARYING,
+ if (!add_program_resource(shProg, resource_set,
+ GL_TRANSFORM_FEEDBACK_VARYING,
&shProg->LinkedTransformFeedback.Varyings[i],
0))
return;
for (unsigned i = 0; i < ctx->Const.MaxTransformFeedbackBuffers; i++) {
if ((shProg->LinkedTransformFeedback.ActiveBuffers >> i) & 1) {
shProg->LinkedTransformFeedback.Buffers[i].Binding = i;
- if (!add_program_resource(shProg, GL_TRANSFORM_FEEDBACK_BUFFER,
+ if (!add_program_resource(shProg, resource_set,
+ GL_TRANSFORM_FEEDBACK_BUFFER,
&shProg->LinkedTransformFeedback.Buffers[i],
0))
return;
calculate_array_size_and_stride(shProg, &shProg->UniformStorage[i]);
}
- if (!add_program_resource(shProg, type,
+ if (!add_program_resource(shProg, resource_set, type,
&shProg->UniformStorage[i], stageref))
return;
}
/* Add program uniform blocks. */
for (unsigned i = 0; i < shProg->NumUniformBlocks; i++) {
- if (!add_program_resource(shProg, GL_UNIFORM_BLOCK,
+ if (!add_program_resource(shProg, resource_set, GL_UNIFORM_BLOCK,
&shProg->UniformBlocks[i], 0))
return;
}
/* Add program shader storage blocks. */
for (unsigned i = 0; i < shProg->NumShaderStorageBlocks; i++) {
- if (!add_program_resource(shProg, GL_SHADER_STORAGE_BLOCK,
+ if (!add_program_resource(shProg, resource_set, GL_SHADER_STORAGE_BLOCK,
&shProg->ShaderStorageBlocks[i], 0))
return;
}
/* Add atomic counter buffers. */
for (unsigned i = 0; i < shProg->NumAtomicBuffers; i++) {
- if (!add_program_resource(shProg, GL_ATOMIC_COUNTER_BUFFER,
+ if (!add_program_resource(shProg, resource_set, GL_ATOMIC_COUNTER_BUFFER,
&shProg->AtomicBuffers[i], 0))
return;
}
type = _mesa_shader_stage_to_subroutine_uniform((gl_shader_stage)j);
/* add shader subroutines */
- if (!add_program_resource(shProg, type, &shProg->UniformStorage[i], 0))
+ if (!add_program_resource(shProg, resource_set,
+ type, &shProg->UniformStorage[i], 0))
return;
}
}
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- struct gl_shader *sh = shProg->_LinkedShaders[i];
+ struct gl_linked_shader *sh = shProg->_LinkedShaders[i];
GLuint type;
if (!sh)
type = _mesa_shader_stage_to_subroutine((gl_shader_stage)i);
for (unsigned j = 0; j < sh->NumSubroutineFunctions; j++) {
- if (!add_program_resource(shProg, type, &sh->SubroutineFunctions[j], 0))
+ if (!add_program_resource(shProg, resource_set,
+ type, &sh->SubroutineFunctions[j], 0))
return;
}
}
+
+ _mesa_set_destroy(resource_set, NULL);
}
/**
link_assign_subroutine_types(struct gl_shader_program *prog)
{
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- gl_shader *sh = prog->_LinkedShaders[i];
+ gl_linked_shader *sh = prog->_LinkedShaders[i];
if (sh == NULL)
continue;
return;
for (unsigned stage = 0; stage < MESA_SHADER_STAGES; stage++) {
- gl_shader *sh = prog->_LinkedShaders[stage];
+ gl_linked_shader *sh = prog->_LinkedShaders[stage];
if (!sh)
continue;
}
}
+static bool
+link_varyings_and_uniforms(unsigned first, unsigned last,
+ unsigned num_explicit_uniform_locs,
+ struct gl_context *ctx,
+ struct gl_shader_program *prog, void *mem_ctx)
+{
+ bool has_xfb_qualifiers = false;
+ unsigned num_tfeedback_decls = 0;
+ char **varying_names = NULL;
+ tfeedback_decl *tfeedback_decls = NULL;
+
+ /* Mark all generic shader inputs and outputs as unpaired. */
+ for (unsigned i = MESA_SHADER_VERTEX; i <= MESA_SHADER_FRAGMENT; i++) {
+ if (prog->_LinkedShaders[i] != NULL) {
+ link_invalidate_variable_locations(prog->_LinkedShaders[i]->ir);
+ }
+ }
+
+ unsigned prev = first;
+ for (unsigned i = prev + 1; i <= MESA_SHADER_FRAGMENT; i++) {
+ if (prog->_LinkedShaders[i] == NULL)
+ continue;
+
+ match_explicit_outputs_to_inputs(prog->_LinkedShaders[prev],
+ prog->_LinkedShaders[i]);
+ prev = i;
+ }
+
+ if (!assign_attribute_or_color_locations(mem_ctx, prog, &ctx->Const,
+ MESA_SHADER_VERTEX)) {
+ return false;
+ }
+
+ if (!assign_attribute_or_color_locations(mem_ctx, prog, &ctx->Const,
+ MESA_SHADER_FRAGMENT)) {
+ return false;
+ }
+
+ /* From the ARB_enhanced_layouts spec:
+ *
+ * "If the shader used to record output variables for transform feedback
+ * varyings uses the "xfb_buffer", "xfb_offset", or "xfb_stride" layout
+ * qualifiers, the values specified by TransformFeedbackVaryings are
+ * ignored, and the set of variables captured for transform feedback is
+ * instead derived from the specified layout qualifiers."
+ */
+ for (int i = MESA_SHADER_FRAGMENT - 1; i >= 0; i--) {
+ /* Find last stage before fragment shader */
+ if (prog->_LinkedShaders[i]) {
+ has_xfb_qualifiers =
+ process_xfb_layout_qualifiers(mem_ctx, prog->_LinkedShaders[i],
+ &num_tfeedback_decls,
+ &varying_names);
+ break;
+ }
+ }
+
+ if (!has_xfb_qualifiers) {
+ num_tfeedback_decls = prog->TransformFeedback.NumVarying;
+ varying_names = prog->TransformFeedback.VaryingNames;
+ }
+
+ if (num_tfeedback_decls != 0) {
+ /* From GL_EXT_transform_feedback:
+ * A program will fail to link if:
+ *
+ * * the <count> specified by TransformFeedbackVaryingsEXT is
+ * non-zero, but the program object has no vertex or geometry
+ * shader;
+ */
+ if (first >= MESA_SHADER_FRAGMENT) {
+ linker_error(prog, "Transform feedback varyings specified, but "
+ "no vertex, tessellation, or geometry shader is "
+ "present.\n");
+ return false;
+ }
+
+ tfeedback_decls = ralloc_array(mem_ctx, tfeedback_decl,
+ num_tfeedback_decls);
+ if (!parse_tfeedback_decls(ctx, prog, mem_ctx, num_tfeedback_decls,
+ varying_names, tfeedback_decls))
+ return false;
+ }
+
+ /* If there is no fragment shader we need to set transform feedback.
+ *
+ * For SSO we also need to assign output locations. We assign them here
+ * because we need to do it for both single stage programs and multi stage
+ * programs.
+ */
+ if (last < MESA_SHADER_FRAGMENT &&
+ (num_tfeedback_decls != 0 || prog->SeparateShader)) {
+ const uint64_t reserved_out_slots =
+ reserved_varying_slot(prog->_LinkedShaders[last], ir_var_shader_out);
+ if (!assign_varying_locations(ctx, mem_ctx, prog,
+ prog->_LinkedShaders[last], NULL,
+ num_tfeedback_decls, tfeedback_decls,
+ reserved_out_slots))
+ return false;
+ }
+
+ if (last <= MESA_SHADER_FRAGMENT) {
+ /* Remove unused varyings from the first/last stage unless SSO */
+ remove_unused_shader_inputs_and_outputs(prog->SeparateShader,
+ prog->_LinkedShaders[first],
+ ir_var_shader_in);
+ remove_unused_shader_inputs_and_outputs(prog->SeparateShader,
+ prog->_LinkedShaders[last],
+ ir_var_shader_out);
+
+ /* If the program is made up of only a single stage */
+ if (first == last) {
+ gl_linked_shader *const sh = prog->_LinkedShaders[last];
+
+ do_dead_builtin_varyings(ctx, NULL, sh, 0, NULL);
+ do_dead_builtin_varyings(ctx, sh, NULL, num_tfeedback_decls,
+ tfeedback_decls);
+
+ if (prog->SeparateShader) {
+ const uint64_t reserved_slots =
+ reserved_varying_slot(sh, ir_var_shader_in);
+
+ /* Assign input locations for SSO, output locations are already
+ * assigned.
+ */
+ if (!assign_varying_locations(ctx, mem_ctx, prog,
+ NULL /* producer */,
+ sh /* consumer */,
+ 0 /* num_tfeedback_decls */,
+ NULL /* tfeedback_decls */,
+ reserved_slots))
+ return false;
+ }
+ } else {
+ /* Linking the stages in the opposite order (from fragment to vertex)
+ * ensures that inter-shader outputs written to in an earlier stage
+ * are eliminated if they are (transitively) not used in a later
+ * stage.
+ */
+ int next = last;
+ for (int i = next - 1; i >= 0; i--) {
+ if (prog->_LinkedShaders[i] == NULL && i != 0)
+ continue;
+
+ gl_linked_shader *const sh_i = prog->_LinkedShaders[i];
+ gl_linked_shader *const sh_next = prog->_LinkedShaders[next];
+
+ const uint64_t reserved_out_slots =
+ reserved_varying_slot(sh_i, ir_var_shader_out);
+ const uint64_t reserved_in_slots =
+ reserved_varying_slot(sh_next, ir_var_shader_in);
+
+ do_dead_builtin_varyings(ctx, sh_i, sh_next,
+ next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
+ tfeedback_decls);
+
+ if (!assign_varying_locations(ctx, mem_ctx, prog, sh_i, sh_next,
+ next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
+ tfeedback_decls,
+ reserved_out_slots | reserved_in_slots))
+ return false;
+
+ /* This must be done after all dead varyings are eliminated. */
+ if (sh_i != NULL) {
+ unsigned slots_used = _mesa_bitcount_64(reserved_out_slots);
+ if (!check_against_output_limit(ctx, prog, sh_i, slots_used)) {
+ return false;
+ }
+ }
+
+ unsigned slots_used = _mesa_bitcount_64(reserved_in_slots);
+ if (!check_against_input_limit(ctx, prog, sh_next, slots_used))
+ return false;
+
+ next = i;
+ }
+ }
+ }
+
+ if (!store_tfeedback_info(ctx, prog, num_tfeedback_decls, tfeedback_decls,
+ has_xfb_qualifiers))
+ return false;
+
+ update_array_sizes(prog);
+ link_assign_uniform_locations(prog, ctx, num_explicit_uniform_locs);
+ link_assign_atomic_counter_resources(ctx, prog);
+
+ link_calculate_subroutine_compat(prog);
+ check_resources(ctx, prog);
+ check_subroutine_resources(prog);
+ check_image_resources(ctx, prog);
+ link_check_atomic_counter_resources(ctx, prog);
+
+ if (!prog->LinkStatus)
+ return false;
+
+ for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (prog->_LinkedShaders[i] == NULL)
+ continue;
+
+ const struct gl_shader_compiler_options *options =
+ &ctx->Const.ShaderCompilerOptions[i];
+
+ if (options->LowerBufferInterfaceBlocks)
+ lower_ubo_reference(prog->_LinkedShaders[i],
+ options->ClampBlockIndicesToArrayBounds);
+
+ if (options->LowerShaderSharedVariables)
+ lower_shared_reference(prog->_LinkedShaders[i],
+ &prog->Comp.SharedSize);
+
+ lower_vector_derefs(prog->_LinkedShaders[i]);
+ do_vec_index_to_swizzle(prog->_LinkedShaders[i]->ir);
+ }
+
+ return true;
+}
+
void
link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
{
return;
}
- unsigned num_tfeedback_decls = 0;
unsigned int num_explicit_uniform_locs = 0;
- bool has_xfb_qualifiers = false;
- char **varying_names = NULL;
- tfeedback_decl *tfeedback_decls = NULL;
void *mem_ctx = ralloc_context(NULL); // temporary linker context
goto done;
}
- if (prog->Shaders[i]->ARB_fragment_coord_conventions_enable) {
+ if (prog->Shaders[i]->info.ARB_fragment_coord_conventions_enable) {
prog->ARB_fragment_coord_conventions_enable = true;
}
}
for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) {
- if (prog->_LinkedShaders[i] != NULL)
- _mesa_delete_shader(ctx, prog->_LinkedShaders[i]);
+ if (prog->_LinkedShaders[i] != NULL) {
+ _mesa_delete_linked_shader(ctx, prog->_LinkedShaders[i]);
+ }
prog->_LinkedShaders[i] = NULL;
}
*/
for (int stage = 0; stage < MESA_SHADER_STAGES; stage++) {
if (num_shaders[stage] > 0) {
- gl_shader *const sh =
+ gl_linked_shader *const sh =
link_intrastage_shaders(mem_ctx, ctx, prog, shader_list[stage],
num_shaders[stage]);
if (!prog->LinkStatus) {
if (sh)
- _mesa_delete_shader(ctx, sh);
+ _mesa_delete_linked_shader(ctx, sh);
goto done;
}
}
if (!prog->LinkStatus) {
if (sh)
- _mesa_delete_shader(ctx, sh);
+ _mesa_delete_linked_shader(ctx, sh);
goto done;
}
- _mesa_reference_shader(ctx, &prog->_LinkedShaders[stage], sh);
+ prog->_LinkedShaders[stage] = sh;
}
}
}
/* Cross-validate uniform blocks between shader stages */
- validate_interstage_uniform_blocks(prog, prog->_LinkedShaders,
- MESA_SHADER_STAGES);
+ validate_interstage_uniform_blocks(prog, prog->_LinkedShaders);
if (!prog->LinkStatus)
goto done;
* This rule also applies to GLSL ES 3.00.
*/
if (max_version >= (prog->IsES ? 300 : 130)) {
- struct gl_shader *sh = prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
+ struct gl_linked_shader *sh = prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
if (sh) {
lower_discard_flow(sh->ir);
}
ctx->Const.NativeIntegers))
;
- lower_const_arrays_to_uniforms(prog->_LinkedShaders[i]->ir);
+ lower_const_arrays_to_uniforms(prog->_LinkedShaders[i]->ir, i);
+ propagate_invariance(prog->_LinkedShaders[i]->ir);
}
/* Validation for special cases where we allow sampler array indexing
/* Check and validate stream emissions in geometry shaders */
validate_geometry_shader_emissions(ctx, prog);
- /* Mark all generic shader inputs and outputs as unpaired. */
- for (unsigned i = MESA_SHADER_VERTEX; i <= MESA_SHADER_FRAGMENT; i++) {
- if (prog->_LinkedShaders[i] != NULL) {
- link_invalidate_variable_locations(prog->_LinkedShaders[i]->ir);
- }
- }
-
- prev = first;
- for (unsigned i = prev + 1; i <= MESA_SHADER_FRAGMENT; i++) {
- if (prog->_LinkedShaders[i] == NULL)
- continue;
-
- match_explicit_outputs_to_inputs(prog->_LinkedShaders[prev],
- prog->_LinkedShaders[i]);
- prev = i;
- }
-
- if (!assign_attribute_or_color_locations(prog, &ctx->Const,
- MESA_SHADER_VERTEX)) {
- goto done;
- }
-
- if (!assign_attribute_or_color_locations(prog, &ctx->Const,
- MESA_SHADER_FRAGMENT)) {
- goto done;
- }
-
- /* From the ARB_enhanced_layouts spec:
- *
- * "If the shader used to record output variables for transform feedback
- * varyings uses the "xfb_buffer", "xfb_offset", or "xfb_stride" layout
- * qualifiers, the values specified by TransformFeedbackVaryings are
- * ignored, and the set of variables captured for transform feedback is
- * instead derived from the specified layout qualifiers."
- */
- for (int i = MESA_SHADER_FRAGMENT - 1; i >= 0; i--) {
- /* Find last stage before fragment shader */
- if (prog->_LinkedShaders[i]) {
- has_xfb_qualifiers =
- process_xfb_layout_qualifiers(mem_ctx, prog->_LinkedShaders[i],
- &num_tfeedback_decls,
- &varying_names);
- break;
- }
- }
-
- if (!has_xfb_qualifiers) {
- num_tfeedback_decls = prog->TransformFeedback.NumVarying;
- varying_names = prog->TransformFeedback.VaryingNames;
- }
-
- if (num_tfeedback_decls != 0) {
- /* From GL_EXT_transform_feedback:
- * A program will fail to link if:
- *
- * * the <count> specified by TransformFeedbackVaryingsEXT is
- * non-zero, but the program object has no vertex or geometry
- * shader;
- */
- if (first >= MESA_SHADER_FRAGMENT) {
- linker_error(prog, "Transform feedback varyings specified, but "
- "no vertex, tessellation, or geometry shader is "
- "present.\n");
- goto done;
- }
-
- tfeedback_decls = ralloc_array(mem_ctx, tfeedback_decl,
- num_tfeedback_decls);
- if (!parse_tfeedback_decls(ctx, prog, mem_ctx, num_tfeedback_decls,
- varying_names, tfeedback_decls))
- goto done;
- }
-
- /* If there is no fragment shader we need to set transform feedback.
- *
- * For SSO we also need to assign output locations. We assign them here
- * because we need to do it for both single stage programs and multi stage
- * programs.
- */
- if (last < MESA_SHADER_FRAGMENT &&
- (num_tfeedback_decls != 0 || prog->SeparateShader)) {
- if (!assign_varying_locations(ctx, mem_ctx, prog,
- prog->_LinkedShaders[last], NULL,
- num_tfeedback_decls, tfeedback_decls))
- goto done;
- }
-
- if (last <= MESA_SHADER_FRAGMENT) {
- /* Remove unused varyings from the first/last stage unless SSO */
- remove_unused_shader_inputs_and_outputs(prog->SeparateShader,
- prog->_LinkedShaders[first],
- ir_var_shader_in);
- remove_unused_shader_inputs_and_outputs(prog->SeparateShader,
- prog->_LinkedShaders[last],
- ir_var_shader_out);
-
- /* If the program is made up of only a single stage */
- if (first == last) {
-
- gl_shader *const sh = prog->_LinkedShaders[last];
- if (prog->SeparateShader) {
- /* Assign input locations for SSO, output locations are already
- * assigned.
- */
- if (!assign_varying_locations(ctx, mem_ctx, prog,
- NULL /* producer */,
- sh /* consumer */,
- 0 /* num_tfeedback_decls */,
- NULL /* tfeedback_decls */))
- goto done;
- }
-
- do_dead_builtin_varyings(ctx, NULL, sh, 0, NULL);
- do_dead_builtin_varyings(ctx, sh, NULL, num_tfeedback_decls,
- tfeedback_decls);
- } else {
- /* Linking the stages in the opposite order (from fragment to vertex)
- * ensures that inter-shader outputs written to in an earlier stage
- * are eliminated if they are (transitively) not used in a later
- * stage.
- */
- int next = last;
- for (int i = next - 1; i >= 0; i--) {
- if (prog->_LinkedShaders[i] == NULL && i != 0)
- continue;
-
- gl_shader *const sh_i = prog->_LinkedShaders[i];
- gl_shader *const sh_next = prog->_LinkedShaders[next];
-
- if (!assign_varying_locations(ctx, mem_ctx, prog, sh_i, sh_next,
- next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
- tfeedback_decls))
- goto done;
-
- do_dead_builtin_varyings(ctx, sh_i, sh_next,
- next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
- tfeedback_decls);
-
- /* This must be done after all dead varyings are eliminated. */
- if (sh_i != NULL) {
- if (!check_against_output_limit(ctx, prog, sh_i)) {
- goto done;
- }
- }
- if (!check_against_input_limit(ctx, prog, sh_next))
- goto done;
-
- next = i;
- }
- }
- }
-
- if (!store_tfeedback_info(ctx, prog, num_tfeedback_decls, tfeedback_decls,
- has_xfb_qualifiers))
- goto done;
-
- update_array_sizes(prog);
- link_assign_uniform_locations(prog, ctx->Const.UniformBooleanTrue,
- num_explicit_uniform_locs,
- ctx->Const.MaxUserAssignableUniformLocations);
- link_assign_atomic_counter_resources(ctx, prog);
store_fragdepth_layout(prog);
- link_calculate_subroutine_compat(prog);
- check_resources(ctx, prog);
- check_subroutine_resources(prog);
- check_image_resources(ctx, prog);
- link_check_atomic_counter_resources(ctx, prog);
-
- if (!prog->LinkStatus)
+ if(!link_varyings_and_uniforms(first, last, num_explicit_uniform_locs, ctx,
+ prog, mem_ctx))
goto done;
/* OpenGL ES < 3.1 requires that a vertex shader and a fragment shader both
}
}
- for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
- if (prog->_LinkedShaders[i] == NULL)
- continue;
-
- const struct gl_shader_compiler_options *options =
- &ctx->Const.ShaderCompilerOptions[i];
-
- if (options->LowerBufferInterfaceBlocks)
- lower_ubo_reference(prog->_LinkedShaders[i]);
-
- if (options->LowerShaderSharedVariables)
- lower_shared_reference(prog->_LinkedShaders[i],
- &prog->Comp.SharedSize);
-
- lower_vector_derefs(prog->_LinkedShaders[i]);
- do_vec_index_to_swizzle(prog->_LinkedShaders[i]->ir);
- }
-
done:
for (unsigned i = 0; i < MESA_SHADER_STAGES; i++) {
free(shader_list[i]);
projects / mesa.git / blobdiff