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

linker: Make linker_error set LinkStatus to false

Browse source 
Remove the other places that set LinkStatus to false since they all
immediately follow a call to linker_error.  The function linker_error
was previously known as linker_error_printf.  The name was changed
because it may seem surprising that a printf function will set an
error flag.

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
Reviewed-by: Eric Anholt <eric@anholt.net>
(cherry picked from commit 586e741ac1)
This commit is contained in:
Ian Romanick 2011-07-28 14:04:09 -07:00
parent eca2a91a9b
commit b8a46f910d
4 changed files with 90 additions and 100 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/glsl/ir_function_detect_recursion.cpp
View file

@ -311,9 +311,7 @@ emit_errors_linked(const void *key, void *data, void *closure)
f->sig->function_name(),
&f->sig->parameters);
linker_error_printf(prog,
"function `%s' has static recursion.\n",
proto);
linker_error(prog, "function `%s' has static recursion.\n", proto);
ralloc_free(proto);
prog->LinkStatus = false;
}

4
src/glsl/link_functions.cpp
View file

@ -91,8 +91,8 @@ public:
if (sig == NULL) {
/* FINISHME: Log the full signature of unresolved function.
*/
linker_error_printf(this->prog, "unresolved reference to function "
"`%s'\n", name);
linker_error(this->prog, "unresolved reference to function `%s'\n",
name);
this->success = false;
return visit_stop;
}

180
src/glsl/linker.cpp
View file

@ -164,7 +164,7 @@ private:
void
linker_error_printf(gl_shader_program *prog, const char *fmt, ...)
linker_error(gl_shader_program *prog, const char *fmt, ...)
{
va_list ap;
@ -172,6 +172,8 @@ linker_error_printf(gl_shader_program *prog, const char *fmt, ...)
va_start(ap, fmt);
ralloc_vasprintf_append(&prog->InfoLog, fmt, ap);
va_end(ap);
prog->LinkStatus = false;
}
@ -243,8 +245,7 @@ validate_vertex_shader_executable(struct gl_shader_program *prog,
find_assignment_visitor find("gl_Position");
find.run(shader->ir);
if (!find.variable_found()) {
linker_error_printf(prog,
"vertex shader does not write to `gl_Position'\n");
linker_error(prog, "vertex shader does not write to `gl_Position'\n");
return false;
}
@ -271,8 +272,8 @@ validate_fragment_shader_executable(struct gl_shader_program *prog,
frag_data.run(shader->ir);
if (frag_color.variable_found() && frag_data.variable_found()) {
linker_error_printf(prog, "fragment shader writes to both "
"`gl_FragColor' and `gl_FragData'\n");
linker_error(prog, "fragment shader writes to both "
"`gl_FragColor' and `gl_FragData'\n");
return false;
}
@ -357,11 +358,11 @@ cross_validate_globals(struct gl_shader_program *prog,
existing->type = var->type;
}
} else {
linker_error_printf(prog, "%s `%s' declared as type "
"`%s' and type `%s'\n",
mode_string(var),
var->name, var->type->name,
existing->type->name);
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 false;
}
}
@ -369,9 +370,9 @@ cross_validate_globals(struct gl_shader_program *prog,
if (var->explicit_location) {
if (existing->explicit_location
&& (var->location != existing->location)) {
linker_error_printf(prog, "explicit locations for %s "
"`%s' have differing values\n",
mode_string(var), var->name);
linker_error(prog, "explicit locations for %s "
"`%s' have differing values\n",
mode_string(var), var->name);
return false;
}
@ -392,12 +393,12 @@ cross_validate_globals(struct gl_shader_program *prog,
bool layout_declared = var->depth_layout != ir_depth_layout_none;
bool layout_differs = var->depth_layout != existing->depth_layout;
if (layout_declared && layout_differs) {
linker_error_printf(prog,
linker_error(prog,
"All redeclarations of gl_FragDepth in all fragment shaders "
"in a single program must have the same set of qualifiers.");
}
if (var->used && layout_differs) {
linker_error_printf(prog,
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"
@ -410,9 +411,9 @@ cross_validate_globals(struct gl_shader_program *prog,
if (var->constant_value != NULL) {
if (existing->constant_value != NULL) {
if (!var->constant_value->has_value(existing->constant_value)) {
linker_error_printf(prog, "initializers for %s "
"`%s' have differing values\n",
mode_string(var), var->name);
linker_error(prog, "initializers for %s "
"`%s' have differing values\n",
mode_string(var), var->name);
return false;
}
} else
@ -433,15 +434,15 @@ cross_validate_globals(struct gl_shader_program *prog,
}
if (existing->invariant != var->invariant) {
linker_error_printf(prog, "declarations for %s `%s' have "
"mismatching invariant qualifiers\n",
mode_string(var), var->name);
linker_error(prog, "declarations for %s `%s' have "
"mismatching invariant qualifiers\n",
mode_string(var), var->name);
return false;
}
if (existing->centroid != var->centroid) {
linker_error_printf(prog, "declarations for %s `%s' have "
"mismatching centroid qualifiers\n",
mode_string(var), var->name);
linker_error(prog, "declarations for %s `%s' have "
"mismatching centroid qualifiers\n",
mode_string(var), var->name);
return false;
}
} else
@ -529,13 +530,12 @@ cross_validate_outputs_to_inputs(struct gl_shader_program *prog,
*/
if (!output->type->is_array()
|| (strncmp("gl_", output->name, 3) != 0)) {
linker_error_printf(prog,
"%s shader output `%s' declared as "
"type `%s', but %s shader input declared "
"as type `%s'\n",
producer_stage, output->name,
output->type->name,
consumer_stage, input->type->name);
linker_error(prog,
"%s shader output `%s' declared as type `%s', "
"but %s shader input declared as type `%s'\n",
producer_stage, output->name,
output->type->name,
consumer_stage, input->type->name);
return false;
}
}
@ -543,40 +543,40 @@ cross_validate_outputs_to_inputs(struct gl_shader_program *prog,
/* Check that all of the qualifiers match between stages.
*/
if (input->centroid != output->centroid) {
linker_error_printf(prog,
"%s shader output `%s' %s centroid qualifier, "
"but %s shader input %s centroid qualifier\n",
producer_stage,
output->name,
(output->centroid) ? "has" : "lacks",
consumer_stage,
(input->centroid) ? "has" : "lacks");
linker_error(prog,
"%s shader output `%s' %s centroid qualifier, "
"but %s shader input %s centroid qualifier\n",
producer_stage,
output->name,
(output->centroid) ? "has" : "lacks",
consumer_stage,
(input->centroid) ? "has" : "lacks");
return false;
}
if (input->invariant != output->invariant) {
linker_error_printf(prog,
"%s shader output `%s' %s invariant qualifier, "
"but %s shader input %s invariant qualifier\n",
producer_stage,
output->name,
(output->invariant) ? "has" : "lacks",
consumer_stage,
(input->invariant) ? "has" : "lacks");
linker_error(prog,
"%s shader output `%s' %s invariant qualifier, "
"but %s shader input %s invariant qualifier\n",
producer_stage,
output->name,
(output->invariant) ? "has" : "lacks",
consumer_stage,
(input->invariant) ? "has" : "lacks");
return false;
}
if (input->interpolation != output->interpolation) {
linker_error_printf(prog,
"%s shader output `%s' specifies %s "
"interpolation qualifier, "
"but %s shader input specifies %s "
"interpolation qualifier\n",
producer_stage,
output->name,
output->interpolation_string(),
consumer_stage,
input->interpolation_string());
linker_error(prog,
"%s shader output `%s' specifies %s "
"interpolation qualifier, "
"but %s shader input specifies %s "
"interpolation qualifier\n",
producer_stage,
output->name,
output->interpolation_string(),
consumer_stage,
input->interpolation_string());
return false;
}
}
@ -823,9 +823,8 @@ link_intrastage_shaders(void *mem_ctx,
if ((other_sig != NULL) && other_sig->is_defined
&& !other_sig->is_builtin) {
linker_error_printf(prog,
"function `%s' is multiply defined",
f->name);
linker_error(prog, "function `%s' is multiply defined",
f->name);
return NULL;
}
}
@ -849,9 +848,9 @@ link_intrastage_shaders(void *mem_ctx,
}
if (main == NULL) {
linker_error_printf(prog, "%s shader lacks `main'\n",
(shader_list[0]->Type == GL_VERTEX_SHADER)
? "vertex" : "fragment");
linker_error(prog, "%s shader lacks `main'\n",
(shader_list[0]->Type == GL_VERTEX_SHADER)
? "vertex" : "fragment");
return NULL;
}
@ -1309,10 +1308,10 @@ assign_attribute_or_color_locations(gl_shader_program *prog,
* attribute overlaps any previously allocated bits.
*/
if ((~(use_mask << attr) & used_locations) != used_locations) {
linker_error_printf(prog,
"insufficient contiguous attribute locations "
"available for vertex shader input `%s'",
var->name);
linker_error(prog,
"insufficient contiguous attribute locations "
"available for vertex shader input `%s'",
var->name);
return false;
}
@ -1353,11 +1352,10 @@ assign_attribute_or_color_locations(gl_shader_program *prog,
if ((var->location >= (int)(max_index + generic_base))
|| (var->location < 0)) {
linker_error_printf(prog,
"invalid explicit location %d specified for "
"`%s'\n",
(var->location < 0) ? var->location : attr,
var->name);
linker_error(prog,
"invalid explicit location %d specified for `%s'\n",
(var->location < 0) ? var->location : attr,
var->name);
return false;
} else if (var->location >= generic_base) {
used_locations |= (use_mask << attr);
@ -1406,10 +1404,10 @@ assign_attribute_or_color_locations(gl_shader_program *prog,
const char *const string = (target_index == MESA_SHADER_VERTEX)
? "vertex shader input" : "fragment shader output";
linker_error_printf(prog,
"insufficient contiguous attribute locations "
"available for %s `%s'",
string, to_assign[i].var->name);
linker_error(prog,
"insufficient contiguous attribute locations "
"available for %s `%s'",
string, to_assign[i].var->name);
return false;
}
@ -1525,9 +1523,8 @@ assign_varying_locations(struct gl_context *ctx,
* "glsl1-varying read but not written" in piglit.
*/
linker_error_printf(prog, "fragment shader varying %s not written "
"by vertex shader\n.", var->name);
prog->LinkStatus = false;
linker_error(prog, "fragment shader varying %s not written "
"by vertex shader\n.", var->name);
}
/* An 'in' variable is only really a shader input if its
@ -1544,17 +1541,17 @@ assign_varying_locations(struct gl_context *ctx,
if (ctx->API == API_OPENGLES2 || prog->Version == 100) {
if (varying_vectors > ctx->Const.MaxVarying) {
linker_error_printf(prog, "shader uses too many varying vectors "
"(%u > %u)\n",
varying_vectors, ctx->Const.MaxVarying);
linker_error(prog, "shader uses too many varying vectors "
"(%u > %u)\n",
varying_vectors, ctx->Const.MaxVarying);
return false;
}
} else {
const unsigned float_components = varying_vectors * 4;
if (float_components > ctx->Const.MaxVarying * 4) {
linker_error_printf(prog, "shader uses too many varying components "
"(%u > %u)\n",
float_components, ctx->Const.MaxVarying * 4);
linker_error(prog, "shader uses too many varying components "
"(%u > %u)\n",
float_components, ctx->Const.MaxVarying * 4);
return false;
}
}
@ -1618,8 +1615,8 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
assert(max_version <= 130);
if ((max_version >= 130 || min_version == 100)
&& min_version != max_version) {
linker_error_printf(prog, "all shaders must use same shading "
"language version\n");
linker_error(prog, "all shaders must use same shading "
"language version\n");
goto done;
}
@ -1720,12 +1717,10 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
* FINISHME: at least 16, so hardcode 16 for now.
*/
if (!assign_attribute_or_color_locations(prog, MESA_SHADER_VERTEX, 16)) {
prog->LinkStatus = false;
goto done;
}
if (!assign_attribute_or_color_locations(prog, MESA_SHADER_FRAGMENT, ctx->Const.MaxDrawBuffers)) {
prog->LinkStatus = false;
goto done;
}
@ -1742,7 +1737,6 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
if (!assign_varying_locations(ctx, prog,
prog->_LinkedShaders[prev],
prog->_LinkedShaders[i])) {
prog->LinkStatus = false;
goto done;
}
@ -1774,11 +1768,9 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
*/
if (ctx->API == API_OPENGLES2 || prog->Version == 100) {
if (prog->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) {
linker_error_printf(prog, "program lacks a vertex shader\n");
prog->LinkStatus = false;
linker_error(prog, "program lacks a vertex shader\n");
} else if (prog->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL) {
linker_error_printf(prog, "program lacks a fragment shader\n");
prog->LinkStatus = false;
linker_error(prog, "program lacks a fragment shader\n");
}
}

2
src/glsl/linker.h
View file

@ -26,7 +26,7 @@
#define GLSL_LINKER_H
extern void
linker_error_printf(gl_shader_program *prog, const char *fmt, ...);
linker_error(gl_shader_program *prog, const char *fmt, ...);
extern bool
link_function_calls(gl_shader_program *prog, gl_shader *main,