X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fcompiler%2Fglsl%2Flinker.cpp;h=d963f540a5243dceaab5fb09f005fe77a98f308f;hb=1591e668e162daf4057a0d44df4e70f19b94fc76;hp=1ea5c1f08074c62a8ecf7fa3ab71f0a7a7eeae0e;hpb=09f01215933f8f7f8d3d4cda9ff94605164df9a9;p=mesa.git diff --git a/src/compiler/glsl/linker.cpp b/src/compiler/glsl/linker.cpp index 1ea5c1f0807..d963f540a52 100644 --- a/src/compiler/glsl/linker.cpp +++ b/src/compiler/glsl/linker.cpp @@ -72,6 +72,7 @@ #include "ir.h" #include "program.h" #include "program/hash_table.h" +#include "program/prog_instruction.h" #include "linker.h" #include "link_varyings.h" #include "ir_optimization.h" @@ -205,7 +206,8 @@ public: /* Generate a link error if the shader has declared this array with an * incorrect size. */ - if (size && size != this->num_vertices) { + 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); @@ -216,7 +218,7 @@ public: * array using an index too large for its actual size assigned at link * time. */ - if (var->data.max_array_access >= this->num_vertices) { + 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); @@ -641,21 +643,27 @@ link_invalidate_variable_locations(exec_list *ir) /** - * Set clip_distance_array_size based on the given shader. + * Set clip_distance_array_size based and cull_distance_array_size on the given + * shader. * * Also check for errors based on incorrect usage of gl_ClipVertex and - * gl_ClipDistance. + * gl_ClipDistance and gl_CullDistance. + * Additionally test whether the arrays gl_ClipDistance and gl_CullDistance + * exceed the maximum size defined by gl_MaxCombinedClipAndCullDistances. * * Return false if an error was reported. */ static void -analyze_clip_usage(struct gl_shader_program *prog, - struct gl_shader *shader, - GLuint *clip_distance_array_size) +analyze_clip_cull_usage(struct gl_shader_program *prog, + 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: * @@ -663,27 +671,71 @@ analyze_clip_usage(struct gl_shader_program *prog, * 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); - 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; + cull_distance.run(shader->ir); + + /* From the ARB_cull_distance spec: + * + * It is a compile-time or link-time error for the set of shaders forming + * 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 doesn't define + * gl_ClipVertex. + */ + 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()) { ir_variable *clip_distance_var = - shader->symbols->get_variable("gl_ClipDistance"); - + shader->symbols->get_variable("gl_ClipDistance"); assert(clip_distance_var); *clip_distance_array_size = clip_distance_var->type->length; } + if (cull_distance.variable_found()) { + ir_variable *cull_distance_var = + shader->symbols->get_variable("gl_CullDistance"); + assert(cull_distance_var); + *cull_distance_array_size = cull_distance_var->type->length; + } + /* From the ARB_cull_distance spec: + * + * It is a compile-time or link-time error for the set of shaders forming + * a program to have the sum of the sizes of the gl_ClipDistance and + * gl_CullDistance arrays to be larger than + * gl_MaxCombinedClipAndCullDistances. + */ + if ((*clip_distance_array_size + *cull_distance_array_size) > + ctx->Const.MaxClipPlanes) { + linker_error(prog, "%s shader: the combined size of " + "'gl_ClipDistance' and 'gl_CullDistance' size cannot " + "be larger than " + "gl_MaxCombinedClipAndCullDistances (%u)", + _mesa_shader_stage_to_string(shader->Stage), + ctx->Const.MaxClipPlanes); + } } } @@ -691,13 +743,15 @@ analyze_clip_usage(struct gl_shader_program *prog, /** * Verify that a vertex shader executable meets all semantic requirements. * - * Also sets prog->Vert.ClipDistanceArraySize as a side effect. + * Also sets prog->Vert.ClipDistanceArraySize and + * prog->Vert.CullDistanceArraySize as a side effect. * * \param shader Vertex shader executable to be verified */ 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) return; @@ -744,17 +798,22 @@ validate_vertex_shader_executable(struct gl_shader_program *prog, } } - analyze_clip_usage(prog, shader, &prog->Vert.ClipDistanceArraySize); + analyze_clip_cull_usage(prog, shader, ctx, + &prog->Vert.ClipDistanceArraySize, + &prog->Vert.CullDistanceArraySize); } 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) return; - analyze_clip_usage(prog, shader, &prog->TessEval.ClipDistanceArraySize); + analyze_clip_cull_usage(prog, shader, ctx, + &prog->TessEval.ClipDistanceArraySize, + &prog->TessEval.CullDistanceArraySize); } @@ -765,7 +824,7 @@ validate_tess_eval_shader_executable(struct gl_shader_program *prog, */ void validate_fragment_shader_executable(struct gl_shader_program *prog, - struct gl_shader *shader) + struct gl_linked_shader *shader) { if (shader == NULL) return; @@ -785,22 +844,25 @@ validate_fragment_shader_executable(struct gl_shader_program *prog, /** * Verify that a geometry shader executable meets all semantic requirements * - * Also sets prog->Geom.VerticesIn, and prog->Geom.ClipDistanceArraySize as - * a side effect. + * Also sets prog->Geom.VerticesIn, and prog->Geom.ClipDistanceArraySize and + * prog->Geom.CullDistanceArraySize as a side effect. * * \param shader Geometry shader executable to be verified */ 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_usage(prog, shader, &prog->Geom.ClipDistanceArraySize); + analyze_clip_cull_usage(prog, shader, ctx, + &prog->Geom.ClipDistanceArraySize, + &prog->Geom.CullDistanceArraySize); } /** @@ -811,9 +873,11 @@ static void 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", @@ -848,7 +912,7 @@ validate_geometry_shader_emissions(struct gl_context *ctx, * 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"); } @@ -869,7 +933,7 @@ validate_intrastage_arrays(struct gl_shader_program *prog, if ((var->type->fields.array == existing->type->fields.array) && ((var->type->length == 0)|| (existing->type->length == 0))) { if (var->type->length != 0) { - if (var->type->length <= existing->data.max_array_access) { + if ((int)var->type->length <= existing->data.max_array_access) { linker_error(prog, "%s `%s' declared as type " "`%s' but outermost dimension has an index" " of `%i'\n", @@ -880,7 +944,7 @@ validate_intrastage_arrays(struct gl_shader_program *prog, existing->type = var->type; return true; } else if (existing->type->length != 0) { - if(existing->type->length <= var->data.max_array_access && + if((int)existing->type->length <= var->data.max_array_access && !existing->data.from_ssbo_unsized_array) { linker_error(prog, "%s `%s' declared as type " "`%s' but outermost dimension has an index" @@ -910,246 +974,225 @@ validate_intrastage_arrays(struct gl_shader_program *prog, */ 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.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"); - } - - 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"); - } - } + existing->data.binding = var->data.binding; + existing->data.explicit_binding = true; + } - /* 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, copy the - * initializer to the version stored in the symbol table. - */ - /* FINISHME: This is wrong. The constant_value field should - * FINISHME: not be modified! Imagine a case where a shader - * FINISHME: without an initializer is linked in two different - * FINISHME: programs with shaders that have differing - * FINISHME: initializers. Linking with the first will - * FINISHME: modify the shader, and linking with the second - * FINISHME: will fail. - */ - existing->constant_initializer = - var->constant_initializer->clone(ralloc_parent(existing), - NULL); - } - } + 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; + } - 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; - } + /* 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; - /* Some instance had an initializer, so keep track of that. In - * this location, all sorts of initializers (constant or - * otherwise) will propagate the existence to the variable - * stored in the symbol table. - */ - existing->data.has_initializer = true; - } + 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; + } + } else + variables->add_variable(var); } } @@ -1160,8 +1203,14 @@ cross_validate_globals(struct gl_shader_program *prog, 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); + } } /** @@ -1191,7 +1240,7 @@ interstage_cross_validate_uniform_blocks(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]; InterfaceBlockStageIndex[i] = new int[max_num_buffer_blocks]; for (unsigned int j = 0; j < max_num_buffer_blocks; j++) @@ -1236,7 +1285,7 @@ interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog, 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); @@ -1265,7 +1314,7 @@ interstage_cross_validate_uniform_blocks(struct gl_shader_program *prog, * 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; @@ -1303,12 +1352,12 @@ populate_symbol_table(gl_shader *sh) * 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; @@ -1343,7 +1392,7 @@ remap_variables(ir_instruction *inst, struct gl_shader *target, } private: - struct gl_shader *target; + struct gl_linked_shader *target; glsl_symbol_table *symbols; exec_list *instructions; hash_table *temps; @@ -1378,7 +1427,7 @@ remap_variables(ir_instruction *inst, struct gl_shader *target, */ 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; @@ -1444,8 +1493,11 @@ public: 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)) { @@ -1503,11 +1555,12 @@ private: * 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); } } @@ -1548,7 +1601,7 @@ private: */ static const glsl_type * resize_interface_members(const glsl_type *type, - const unsigned *max_ifc_array_access, + const int *max_ifc_array_access, bool is_ssbo) { unsigned num_fields = type->length; @@ -1556,15 +1609,17 @@ private: 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; @@ -1627,42 +1682,43 @@ private: 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) { @@ -1691,11 +1747,11 @@ link_xfb_stride_layout_qualifiers(struct gl_context *ctx, */ 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; @@ -1713,16 +1769,18 @@ link_tcs_out_layout_qualifiers(struct gl_shader_program *prog, 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; } } @@ -1730,12 +1788,11 @@ link_tcs_out_layout_qualifiers(struct gl_shader_program *prog, * 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; } @@ -1747,14 +1804,14 @@ link_tcs_out_layout_qualifiers(struct gl_shader_program *prog, */ 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; @@ -1776,44 +1833,50 @@ link_tes_in_layout_qualifiers(struct gl_shader_program *prog, 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; } } @@ -1822,25 +1885,21 @@ link_tes_in_layout_qualifiers(struct gl_shader_program *prog, * 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; } @@ -1851,14 +1910,14 @@ link_tes_in_layout_qualifiers(struct gl_shader_program *prog, */ static void link_fs_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) { - 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; if (linked_shader->Stage != MESA_SHADER_FRAGMENT || (prog->Version < 150 && !prog->ARB_fragment_coord_conventions_enable)) @@ -1872,12 +1931,12 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog, * 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"); } @@ -1887,9 +1946,12 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog, * "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"); } @@ -1899,16 +1961,21 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog, * 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; } } @@ -1919,14 +1986,14 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog, */ 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. @@ -1947,48 +2014,52 @@ link_gs_inout_layout_qualifiers(struct gl_shader_program *prog, 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; } } @@ -1996,31 +2067,26 @@ link_gs_inout_layout_qualifiers(struct gl_shader_program *prog, * 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; } @@ -2031,12 +2097,12 @@ link_gs_inout_layout_qualifiers(struct gl_shader_program *prog, */ 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. @@ -2057,19 +2123,21 @@ link_cs_input_layout_qualifiers(struct gl_shader_program *prog, 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]; + } } } @@ -2077,12 +2145,12 @@ link_cs_input_layout_qualifiers(struct gl_shader_program *prog, * 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]; } @@ -2093,7 +2161,7 @@ link_cs_input_layout_qualifiers(struct gl_shader_program *prog, * 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, @@ -2107,7 +2175,13 @@ link_intrastage_shaders(void *mem_ctx, /* 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; @@ -2118,14 +2192,6 @@ link_intrastage_shaders(void *mem_ctx, 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. */ @@ -2173,7 +2239,7 @@ link_intrastage_shaders(void *mem_ctx, */ 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; } @@ -2185,28 +2251,10 @@ link_intrastage_shaders(void *mem_ctx, 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_tcs_out_layout_qualifiers(prog, linked, shader_list, num_shaders); link_tes_in_layout_qualifiers(prog, linked, shader_list, num_shaders); @@ -2221,7 +2269,7 @@ link_intrastage_shaders(void *mem_ctx, * 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. @@ -2241,7 +2289,7 @@ link_intrastage_shaders(void *mem_ctx, /* 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) { + if (shader_list[i]->info.uses_builtin_functions) { need_builtins = true; break; } @@ -2274,10 +2322,45 @@ link_intrastage_shaders(void *mem_ctx, if (!ok) { - _mesa_delete_shader(ctx, linked); + _mesa_delete_linked_shader(ctx, linked); + return NULL; + } + + /* 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(); + + /* 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); + + 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; + + /* 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. */ @@ -2285,7 +2368,7 @@ link_intrastage_shaders(void *mem_ctx, /* Set the size of geometry shader input arrays */ if (linked->Stage == MESA_SHADER_GEOMETRY) { - unsigned num_vertices = vertices_per_prim(prog->Geom.InputType); + unsigned num_vertices = vertices_per_prim(linked->info.Geom.InputType); geom_array_resize_visitor input_resize_visitor(num_vertices, prog); foreach_in_list(ir_instruction, ir, linked->ir) { ir->accept(&input_resize_visitor); @@ -2303,14 +2386,6 @@ link_intrastage_shaders(void *mem_ctx, } } - /* 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; } @@ -2354,10 +2429,10 @@ update_array_sizes(struct gl_shader_program *prog) * Subroutine uniforms are not removed. */ if (var->is_in_buffer_block() || var->type->contains_atomic() || - var->type->contains_subroutine()) + var->type->contains_subroutine() || var->constant_initializer) continue; - unsigned int size = var->data.max_array_access; + int size = var->data.max_array_access; for (unsigned j = 0; j < MESA_SHADER_STAGES; j++) { if (prog->_LinkedShaders[j] == NULL) continue; @@ -2374,7 +2449,7 @@ update_array_sizes(struct gl_shader_program *prog) } } - if (size + 1 != var->type->length) { + if (size + 1 != (int)var->type->length) { /* If this is a built-in uniform (i.e., it's backed by some * fixed-function state), adjust the number of state slots to * match the new array size. The number of slots per array entry @@ -2410,15 +2485,15 @@ resize_tes_inputs(struct gl_context *ctx, 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); @@ -2426,7 +2501,7 @@ resize_tes_inputs(struct gl_context *ctx, 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. */ @@ -2435,9 +2510,22 @@ resize_tes_inputs(struct gl_context *ctx, 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; + } } } } @@ -2510,7 +2598,7 @@ assign_attribute_or_color_locations(gl_shader_program *prog, 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; @@ -2556,7 +2644,12 @@ assign_attribute_or_color_locations(gl_shader_program *prog, } 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(); @@ -2618,7 +2711,7 @@ assign_attribute_or_color_locations(gl_shader_program *prog, return false; } - const unsigned slots = var->type->count_attribute_slots(target_index == MESA_SHADER_VERTEX ? true : false); + const unsigned slots = var->type->count_attribute_slots(target_index == MESA_SHADER_VERTEX); /* If the variable is not a built-in and has a location statically * assigned in the shader (presumably via a layout qualifier), make sure @@ -2718,18 +2811,62 @@ assign_attribute_or_color_locations(gl_shader_program *prog, * 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); } } @@ -2755,10 +2892,13 @@ assign_attribute_or_color_locations(gl_shader_program *prog, * 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; } @@ -2828,6 +2968,26 @@ assign_attribute_or_color_locations(gl_shader_program *prog, to_assign[i].var->data.location = generic_base + location; 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_storage_locations |= (use_mask << location); + } + + /* Now that we have all the locations, from the GL 4.5 core spec, section + * 11.1.1 (Vertex Attributes), dvec3, dvec4, dmat2x3, dmat2x4, dmat3, + * dmat3x4, dmat4x3, and dmat4 count as consuming twice as many attributes + * as equivalent single-precision types. + */ + if (target_index == MESA_SHADER_VERTEX) { + unsigned total_attribs_size = + _mesa_bitcount(used_locations & ((1 << max_index) - 1)) + + _mesa_bitcount(double_storage_locations); + if (total_attribs_size > max_index) { + linker_error(prog, + "attempt to use %d vertex attribute slots only %d available ", + total_attribs_size, max_index); + return false; + } } return true; @@ -2838,12 +2998,12 @@ assign_attribute_or_color_locations(gl_shader_program *prog, * unmatch flag if found so we don't optimise them away. */ static void -match_explicit_outputs_to_inputs(struct gl_shader_program *prog, - 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_VARYING] = { NULL }; + ir_variable *explicit_locations[MAX_VARYINGS_INCL_PATCH][4] = + { {NULL, NULL} }; /* Find all shader outputs in the "producer" stage. */ @@ -2856,8 +3016,8 @@ match_explicit_outputs_to_inputs(struct gl_shader_program *prog, if (var->data.explicit_location && var->data.location >= VARYING_SLOT_VAR0) { const unsigned idx = var->data.location - VARYING_SLOT_VAR0; - if (explicit_locations[idx] == NULL) - explicit_locations[idx] = var; + if (explicit_locations[idx][var->data.location_frac] == NULL) + explicit_locations[idx][var->data.location_frac] = var; } } @@ -2871,7 +3031,8 @@ match_explicit_outputs_to_inputs(struct gl_shader_program *prog, ir_variable *output = NULL; if (input->data.explicit_location && input->data.location >= VARYING_SLOT_VAR0) { - output = explicit_locations[input->data.location - VARYING_SLOT_VAR0]; + output = explicit_locations[input->data.location - VARYING_SLOT_VAR0] + [input->data.location_frac]; if (output != NULL){ input->data.is_unmatched_generic_inout = 0; @@ -2942,7 +3103,7 @@ check_resources(struct gl_context *ctx, struct gl_shader_program *prog) 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; @@ -3036,18 +3197,26 @@ static void 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; for (unsigned j = 0; j < sh->NumSubroutineUniformRemapTable; j++) { + if (sh->SubroutineUniformRemapTable[j] == INACTIVE_UNIFORM_EXPLICIT_LOCATION) + continue; + struct gl_uniform_storage *uni = sh->SubroutineUniformRemapTable[j]; if (!uni) continue; + sh->NumSubroutineUniforms++; count = 0; + if (sh->NumSubroutineFunctions == 0) { + linker_error(prog, "subroutine uniform %s defined but no valid functions found\n", uni->type->name); + continue; + } for (unsigned f = 0; f < sh->NumSubroutineFunctions; f++) { struct gl_subroutine_function *fn = &sh->SubroutineFunctions[f]; for (int k = 0; k < fn->num_compat_types; k++) { @@ -3066,7 +3235,7 @@ static void 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) @@ -3089,7 +3258,7 @@ check_image_resources(struct gl_context *ctx, struct gl_shader_program *prog) 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) @@ -3193,7 +3362,7 @@ reserve_explicit_locations(struct gl_shader_program *prog, 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(); @@ -3268,7 +3437,7 @@ check_explicit_uniform_locations(struct gl_context *ctx, 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; @@ -3368,12 +3537,12 @@ should_add_buffer_variable(struct gl_shader_program *shProg, if (found_interface) name = name + block_name_len + 1; - /* From: ARB_program_interface_query extension: + /* The ARB_program_interface_query spec says: * - * "For an active shader storage block member declared as an array, an - * entry will be generated only for the first array element, regardless - * of its type. For arrays of aggregate types, the enumeration rules are - * applied recursively for the single enumerated array element. + * "For an active shader storage block member declared as an array, an + * entry will be generated only for the first array element, regardless + * of its type. For arrays of aggregate types, the enumeration rules + * are applied recursively for the single enumerated array element." */ const char *struct_first_dot = strchr(name, '.'); const char *first_square_bracket = strchr(name, '['); @@ -3473,7 +3642,7 @@ build_stageref(struct gl_shader_program *shProg, const char *name, 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; @@ -3518,8 +3687,10 @@ build_stageref(struct gl_shader_program *shProg, const char *name, */ static gl_shader_variable * create_shader_variable(struct gl_shader_program *shProg, - const ir_variable *in, bool use_implicit_location, - int location) + const ir_variable *in, + const char *name, const glsl_type *type, + bool use_implicit_location, int location, + const glsl_type *outermost_struct_type) { gl_shader_variable *out = ralloc(shProg, struct gl_shader_variable); if (!out) @@ -3532,25 +3703,26 @@ create_shader_variable(struct gl_shader_program *shProg, in->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE) { out->name = ralloc_strdup(shProg, "gl_VertexID"); } else { - out->name = ralloc_strdup(shProg, in->name); + out->name = ralloc_strdup(shProg, name); } if (!out->name) return NULL; - /* From the ARB_program_interface_query specification: + /* 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: + * "Not all active variables are assigned valid locations; the + * following variables will have an effective location of -1: * - * * uniforms declared as atomic counters; + * * uniforms declared as atomic counters; * - * * members of a uniform block; + * * members of a uniform block; * - * * built-in inputs, outputs, and uniforms (starting with "gl_"); and + * * 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." + * * inputs or outputs not declared with a "location" layout + * qualifier, except for vertex shader inputs and fragment shader + * outputs." */ if (in->type->base_type == GLSL_TYPE_ATOMIC_UINT || is_gl_identifier(in->name) || @@ -3560,10 +3732,16 @@ create_shader_variable(struct gl_shader_program *shProg, out->location = location; } - out->type = in->type; + 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; } @@ -3571,14 +3749,77 @@ create_shader_variable(struct gl_shader_program *shProg, static bool add_shader_variable(struct gl_shader_program *shProg, unsigned stage_mask, GLenum programInterface, ir_variable *var, - bool use_implicit_location, int location) + const char *name, const glsl_type *type, + bool use_implicit_location, int location, + const glsl_type *outermost_struct_type = NULL) { - gl_shader_variable *sha_v = - create_shader_variable(shProg, var, use_implicit_location, location); - if (!sha_v) - return false; + const bool is_vertex_input = + programInterface == GL_PROGRAM_INPUT && + stage_mask == MESA_SHADER_VERTEX; + + switch (type->base_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 < 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, + var, field_name, field->type, + use_implicit_location, field_location, + outermost_struct_type)) + return false; + + field_location += + field->type->count_attribute_slots(is_vertex_input); + } + return true; + } - return add_program_resource(shProg, programInterface, sha_v, stage_mask); + default: { + /* 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." + */ + const char *prefixed_name = (var->data.from_named_ifc_block && + !is_gl_identifier(var->name)) + ? ralloc_asprintf(shProg, "%s.%s", var->get_interface_type()->name, + name) + : name; + + /* 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." + */ + gl_shader_variable *sha_v = + create_shader_variable(shProg, var, prefixed_name, type, + use_implicit_location, location, + outermost_struct_type); + if (!sha_v) + return false; + + return add_program_resource(shProg, programInterface, sha_v, stage_mask); + } + } } static bool @@ -3630,7 +3871,7 @@ add_interface_variables(struct gl_shader_program *shProg, (stage == MESA_SHADER_FRAGMENT && var->data.mode == ir_var_shader_out); if (!add_shader_variable(shProg, 1 << stage, programInterface, - var, vs_input_or_fs_output, + var, var->name, var->type, vs_input_or_fs_output, var->data.location - loc_bias)) return false; } @@ -3640,7 +3881,7 @@ add_interface_variables(struct gl_shader_program *shProg, static bool add_packed_varyings(struct gl_shader_program *shProg, 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) @@ -3664,7 +3905,7 @@ add_packed_varyings(struct gl_shader_program *shProg, int stage, GLenum type) const int stage_mask = build_stageref(shProg, var->name, var->data.mode); if (!add_shader_variable(shProg, stage_mask, - iface, var, false, + iface, var, var->name, var->type, false, var->data.location - VARYING_SLOT_VAR0)) return false; } @@ -3676,7 +3917,7 @@ add_packed_varyings(struct gl_shader_program *shProg, int stage, GLenum type) static bool add_fragdata_arrays(struct gl_shader_program *shProg) { - 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; @@ -3688,8 +3929,8 @@ add_fragdata_arrays(struct gl_shader_program *shProg) if (!add_shader_variable(shProg, 1 << MESA_SHADER_FRAGMENT, - GL_PROGRAM_OUTPUT, var, true, - var->data.location - FRAG_RESULT_DATA0)) + GL_PROGRAM_OUTPUT, var, var->name, var->type, + true, var->data.location - FRAG_RESULT_DATA0)) return false; } } @@ -3702,14 +3943,16 @@ get_top_level_name(const char *name) const char *first_dot = strchr(name, '.'); const char *first_square_bracket = strchr(name, '['); int name_size = 0; - /* From ARB_program_interface_query spec: + + /* The ARB_program_interface_query spec says: * - * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer identifying the - * number of active array elements of the top-level shader storage block - * member containing to the active variable is written to . If the - * top-level block member is not declared as an array, the value one is - * written to . If the top-level block member is an array with no - * declared size, the value zero is written to . + * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer identifying + * the number of active array elements of the top-level shader storage + * block member containing to the active variable is written to + * . If the top-level block member is not declared as an + * array, the value one is written to . If the top-level block + * member is an array with no declared size, the value zero is written + * to ." */ /* The buffer variable is on top level.*/ @@ -3779,15 +4022,15 @@ static int get_array_size(struct gl_uniform_storage *uni, const glsl_struct_field *field, char *interface_name, char *var_name) { - /* From GL_ARB_program_interface_query spec: + /* The ARB_program_interface_query spec says: * - * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer - * identifying the number of active array elements of the top-level - * shader storage block member containing to the active variable is - * written to . If the top-level block member is not - * declared as an array, the value one is written to . If - * the top-level block member is an array with no declared size, - * the value zero is written to . + * "For the property TOP_LEVEL_ARRAY_SIZE, a single integer identifying + * the number of active array elements of the top-level shader storage + * block member containing to the active variable is written to + * . If the top-level block member is not declared as an + * array, the value one is written to . If the top-level block + * member is an array with no declared size, the value zero is written + * to ." */ if (is_top_level_shader_storage_block_member(uni->name, interface_name, @@ -3806,17 +4049,16 @@ get_array_stride(struct gl_uniform_storage *uni, const glsl_type *interface, const glsl_struct_field *field, char *interface_name, char *var_name) { - /* From GL_ARB_program_interface_query: + /* The ARB_program_interface_query spec says: * - * "For the property TOP_LEVEL_ARRAY_STRIDE, a single integer - * identifying the stride between array elements of the top-level - * shader storage block member containing the active variable is - * written to . For top-level block members declared as - * arrays, the value written is the difference, in basic machine - * units, between the offsets of the active variable for - * consecutive elements in the top-level array. For top-level - * block members not declared as an array, zero is written to - * ." + * "For the property TOP_LEVEL_ARRAY_STRIDE, a single integer + * identifying the stride between array elements of the top-level + * shader storage block member containing the active variable is + * written to . For top-level block members declared as + * arrays, the value written is the difference, in basic machine units, + * between the offsets of the active variable for consecutive elements + * in the top-level array. For top-level block members not declared as + * an array, zero is written to ." */ if (field->type->is_array()) { const enum glsl_matrix_layout matrix_layout = @@ -4050,7 +4292,7 @@ build_program_resource_list(struct gl_context *ctx, } 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) @@ -4102,11 +4344,12 @@ static void 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; + sh->MaxSubroutineFunctionIndex = 0; foreach_in_list(ir_instruction, node, sh->ir) { ir_function *fn = node->as_function(); if (!fn) @@ -4118,6 +4361,12 @@ link_assign_subroutine_types(struct gl_shader_program *prog) if (!fn->num_subroutine_types) continue; + /* these should have been calculated earlier. */ + assert(fn->subroutine_index != -1); + if (sh->NumSubroutineFunctions + 1 > MAX_SUBROUTINES) { + linker_error(prog, "Too many subroutine functions declared.\n"); + return; + } sh->SubroutineFunctions = reralloc(sh, sh->SubroutineFunctions, struct gl_subroutine_function, sh->NumSubroutineFunctions + 1); @@ -4145,24 +4394,13 @@ link_assign_subroutine_types(struct gl_shader_program *prog) sh->SubroutineFunctions[sh->NumSubroutineFunctions].index = fn->subroutine_index; + if (fn->subroutine_index > (int)sh->MaxSubroutineFunctionIndex) + sh->MaxSubroutineFunctionIndex = fn->subroutine_index; + for (int j = 0; j < fn->num_subroutine_types; j++) sh->SubroutineFunctions[sh->NumSubroutineFunctions].types[j] = fn->subroutine_types[j]; sh->NumSubroutineFunctions++; } - - /* Assign index for subroutines without an explicit index*/ - int index = 0; - for (unsigned j = 0; j < sh->NumSubroutineFunctions; j++) { - while (sh->SubroutineFunctions[j].index == -1) { - for (unsigned k = 0; k < sh->NumSubroutineFunctions; k++) { - if (sh->SubroutineFunctions[k].index == index) - break; - else if (k == sh->NumSubroutineFunctions - 1) - sh->SubroutineFunctions[j].index = index; - } - index++; - } - } } } @@ -4212,7 +4450,7 @@ disable_varying_optimizations_for_sso(struct gl_shader_program *prog) 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; @@ -4296,7 +4534,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) 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; } @@ -4371,8 +4609,9 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) } 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; } @@ -4381,28 +4620,28 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) */ 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; } switch (stage) { case MESA_SHADER_VERTEX: - validate_vertex_shader_executable(prog, sh); + validate_vertex_shader_executable(prog, sh, ctx); break; case MESA_SHADER_TESS_CTRL: /* nothing to be done */ break; case MESA_SHADER_TESS_EVAL: - validate_tess_eval_shader_executable(prog, sh); + validate_tess_eval_shader_executable(prog, sh, ctx); break; case MESA_SHADER_GEOMETRY: - validate_geometry_shader_executable(prog, sh); + validate_geometry_shader_executable(prog, sh, ctx); break; case MESA_SHADER_FRAGMENT: validate_fragment_shader_executable(prog, sh); @@ -4410,22 +4649,27 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) } 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; } } - if (num_shaders[MESA_SHADER_GEOMETRY] > 0) + if (num_shaders[MESA_SHADER_GEOMETRY] > 0) { prog->LastClipDistanceArraySize = prog->Geom.ClipDistanceArraySize; - else if (num_shaders[MESA_SHADER_TESS_EVAL] > 0) + prog->LastCullDistanceArraySize = prog->Geom.CullDistanceArraySize; + } else if (num_shaders[MESA_SHADER_TESS_EVAL] > 0) { prog->LastClipDistanceArraySize = prog->TessEval.ClipDistanceArraySize; - else if (num_shaders[MESA_SHADER_VERTEX] > 0) + prog->LastCullDistanceArraySize = prog->TessEval.CullDistanceArraySize; + } else if (num_shaders[MESA_SHADER_VERTEX] > 0) { prog->LastClipDistanceArraySize = prog->Vert.ClipDistanceArraySize; - else + prog->LastCullDistanceArraySize = prog->Vert.CullDistanceArraySize; + } else { prog->LastClipDistanceArraySize = 0; /* Not used */ + prog->LastCullDistanceArraySize = 0; /* Not used */ + } /* Here begins the inter-stage linking phase. Some initial validation is * performed, then locations are assigned for uniforms, attributes, and @@ -4480,8 +4724,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) } /* 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; @@ -4497,7 +4740,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) * 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); } @@ -4526,8 +4769,8 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) if (!prog->LinkStatus) goto done; - if (ctx->Const.ShaderCompilerOptions[i].LowerClipDistance) { - lower_clip_distance(prog->_LinkedShaders[i]); + if (ctx->Const.ShaderCompilerOptions[i].LowerCombinedClipCullDistance) { + lower_clip_cull_distance(prog, prog->_LinkedShaders[i]); } if (ctx->Const.LowerTessLevel) { @@ -4540,6 +4783,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) ; lower_const_arrays_to_uniforms(prog->_LinkedShaders[i]->ir); + propagate_invariance(prog->_LinkedShaders[i]->ir); } /* Validation for special cases where we allow sampler array indexing @@ -4567,7 +4811,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) if (prog->_LinkedShaders[i] == NULL) continue; - match_explicit_outputs_to_inputs(prog, prog->_LinkedShaders[prev], + match_explicit_outputs_to_inputs(prog->_LinkedShaders[prev], prog->_LinkedShaders[i]); prev = i; } @@ -4630,15 +4874,18 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) /* If there is no fragment shader we need to set transform feedback. * - * For SSO we need 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. + * 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)) + num_tfeedback_decls, tfeedback_decls, + reserved_out_slots)) goto done; } @@ -4654,8 +4901,11 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) /* If the program is made up of only a single stage */ if (first == last) { - gl_shader *const sh = prog->_LinkedShaders[last]; + gl_linked_shader *const sh = prog->_LinkedShaders[last]; 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. */ @@ -4663,7 +4913,8 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) NULL /* producer */, sh /* consumer */, 0 /* num_tfeedback_decls */, - NULL /* tfeedback_decls */)) + NULL /* tfeedback_decls */, + reserved_slots)) goto done; } @@ -4678,15 +4929,21 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) */ int next = last; for (int i = next - 1; i >= 0; i--) { - if (prog->_LinkedShaders[i] == NULL) + if (prog->_LinkedShaders[i] == NULL && i != 0) continue; - gl_shader *const sh_i = prog->_LinkedShaders[i]; - gl_shader *const sh_next = prog->_LinkedShaders[next]; + 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); if (!assign_varying_locations(ctx, mem_ctx, prog, sh_i, sh_next, next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0, - tfeedback_decls)) + tfeedback_decls, + reserved_out_slots | reserved_in_slots)) goto done; do_dead_builtin_varyings(ctx, sh_i, sh_next, @@ -4694,9 +4951,15 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) tfeedback_decls); /* This must be done after all dead varyings are eliminated. */ - if (!check_against_output_limit(ctx, prog, sh_i)) - goto done; - if (!check_against_input_limit(ctx, prog, sh_next)) + if (sh_i != NULL) { + unsigned slots_used = _mesa_bitcount_64(reserved_out_slots); + if (!check_against_output_limit(ctx, prog, sh_i, slots_used)) { + goto done; + } + } + + unsigned slots_used = _mesa_bitcount_64(reserved_in_slots); + if (!check_against_input_limit(ctx, prog, sh_next, slots_used)) goto done; next = i; @@ -4763,14 +5026,19 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) if (prog->_LinkedShaders[i] == NULL) continue; - if (ctx->Const.ShaderCompilerOptions[i].LowerBufferInterfaceBlocks) - lower_ubo_reference(prog->_LinkedShaders[i]); + const struct gl_shader_compiler_options *options = + &ctx->Const.ShaderCompilerOptions[i]; + + if (options->LowerBufferInterfaceBlocks) + lower_ubo_reference(prog->_LinkedShaders[i], + options->ClampBlockIndicesToArrayBounds); - if (ctx->Const.ShaderCompilerOptions[i].LowerShaderSharedVariables) + 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: