* the built-in varyings have pre-assigned locations. Also, the elimination
* of unused gl_TexCoord elements requires its own lowering pass anyway.
*
- * It's implemented by replacing all occurences of dead varyings with
+ * It's implemented by replacing all occurrences of dead varyings with
* temporary variables, which creates dead code. It is recommended to run
* a dead-code elimination pass after this.
*
* If any texture coordinate slots can be eliminated, the gl_TexCoord array is
* broken down into separate vec4 variables with locations equal to
* VARYING_SLOT_TEX0 + i.
+ *
+ * The same is done for the gl_FragData fragment shader output.
*/
-#include "main/imports.h" /* for snprintf */
+#include "main/core.h" /* for snprintf and ARRAY_SIZE */
#include "ir.h"
#include "ir_rvalue_visitor.h"
#include "ir_optimization.h"
#include "glsl_types.h"
#include "link_varyings.h"
+namespace {
/**
* This obtains detailed information about built-in varyings from shader code.
class varying_info_visitor : public ir_hierarchical_visitor {
public:
/* "mode" can be either ir_var_shader_in or ir_var_shader_out */
- varying_info_visitor(ir_variable_mode mode)
+ varying_info_visitor(ir_variable_mode mode, bool find_frag_outputs = false)
: lower_texcoord_array(true),
texcoord_array(NULL),
texcoord_usage(0),
+ find_frag_outputs(find_frag_outputs),
+ lower_fragdata_array(true),
+ fragdata_array(NULL),
+ fragdata_usage(0),
color_usage(0),
tfeedback_color_usage(0),
fog(NULL),
{
ir_variable *var = ir->variable_referenced();
- if (var && var->mode == this->mode &&
- var->location == VARYING_SLOT_TEX0) {
+ if (!var || var->data.mode != this->mode)
+ return visit_continue;
+
+ if (this->find_frag_outputs && var->data.location == FRAG_RESULT_DATA0) {
+ this->fragdata_array = var;
+
+ ir_constant *index = ir->array_index->as_constant();
+ if (index == NULL) {
+ /* This is variable indexing. */
+ this->fragdata_usage |= (1 << var->type->array_size()) - 1;
+ this->lower_fragdata_array = false;
+ }
+ else {
+ this->fragdata_usage |= 1 << index->get_uint_component(0);
+ /* Don't lower fragdata array if the output variable
+ * is not a float variable (or float vector) because it will
+ * generate wrong register assignments because of different
+ * data types.
+ */
+ if (var->type->gl_type != GL_FLOAT &&
+ var->type->gl_type != GL_FLOAT_VEC2 &&
+ var->type->gl_type != GL_FLOAT_VEC3 &&
+ var->type->gl_type != GL_FLOAT_VEC4)
+ this->lower_fragdata_array = false;
+ }
+
+ /* Don't visit the leaves of ir_dereference_array. */
+ return visit_continue_with_parent;
+ }
+
+ if (!this->find_frag_outputs && var->data.location == VARYING_SLOT_TEX0) {
this->texcoord_array = var;
ir_constant *index = ir->array_index->as_constant();
{
ir_variable *var = ir->variable_referenced();
- if (var->mode == this->mode && var->type->is_array() &&
- var->location == VARYING_SLOT_TEX0) {
+ if (var->data.mode != this->mode || !var->type->is_array())
+ return visit_continue;
+
+ if (this->find_frag_outputs && var->data.location == FRAG_RESULT_DATA0) {
+ /* This is a whole array dereference. */
+ this->fragdata_usage |= (1 << var->type->array_size()) - 1;
+ this->lower_fragdata_array = false;
+ return visit_continue;
+ }
+
+ if (!this->find_frag_outputs && var->data.location == VARYING_SLOT_TEX0) {
/* This is a whole array dereference like "gl_TexCoord = x;",
* there's probably no point in lowering that.
*/
virtual ir_visitor_status visit(ir_variable *var)
{
- if (var->mode != this->mode)
+ if (var->data.mode != this->mode)
+ return visit_continue;
+
+ /* Nothing to do here for fragment outputs. */
+ if (this->find_frag_outputs)
return visit_continue;
/* Handle colors and fog. */
- switch (var->location) {
+ switch (var->data.location) {
case VARYING_SLOT_COL0:
this->color[0] = var;
this->color_usage |= 1;
if (!this->texcoord_array) {
this->lower_texcoord_array = false;
}
+ if (!this->fragdata_array) {
+ this->lower_fragdata_array = false;
+ }
}
bool lower_texcoord_array;
ir_variable *texcoord_array;
unsigned texcoord_usage; /* bitmask */
+ bool find_frag_outputs; /* false if it's looking for varyings */
+ bool lower_fragdata_array;
+ ir_variable *fragdata_array;
+ unsigned fragdata_usage; /* bitmask */
+
ir_variable *color[2];
ir_variable *backcolor[2];
unsigned color_usage; /* bitmask */
*/
class replace_varyings_visitor : public ir_rvalue_visitor {
public:
- replace_varyings_visitor(exec_list *ir,
+ replace_varyings_visitor(struct gl_shader *sha,
const varying_info_visitor *info,
unsigned external_texcoord_usage,
unsigned external_color_usage,
bool external_has_fog)
- : info(info), new_fog(NULL)
+ : shader(sha), info(info), new_fog(NULL)
{
- void *const ctx = ir;
+ void *const ctx = shader->ir;
+ memset(this->new_fragdata, 0, sizeof(this->new_fragdata));
memset(this->new_texcoord, 0, sizeof(this->new_texcoord));
memset(this->new_color, 0, sizeof(this->new_color));
memset(this->new_backcolor, 0, sizeof(this->new_backcolor));
*
* We're going to break down the gl_TexCoord array into separate
* variables. First, add declarations of the new variables all
- * occurences of gl_TexCoord will be replaced with.
+ * occurrences of gl_TexCoord will be replaced with.
*/
if (info->lower_texcoord_array) {
- for (int i = MAX_TEXTURE_COORD_UNITS-1; i >= 0; i--) {
- if (info->texcoord_usage & (1 << i)) {
- char name[32];
-
- if (!(external_texcoord_usage & (1 << i))) {
- /* This varying is unused in the next stage. Declare
- * a temporary instead of an output. */
- snprintf(name, 32, "gl_%s_TexCoord%i_dummy", mode_str, i);
- this->new_texcoord[i] =
- new (ctx) ir_variable(glsl_type::vec4_type, name,
- ir_var_temporary);
- }
- else {
- snprintf(name, 32, "gl_%s_TexCoord%i", mode_str, i);
- this->new_texcoord[i] =
- new(ctx) ir_variable(glsl_type::vec4_type, name,
- info->mode);
- this->new_texcoord[i]->location = VARYING_SLOT_TEX0 + i;
- this->new_texcoord[i]->explicit_location = true;
- this->new_texcoord[i]->explicit_index = 0;
- }
-
- ir->head->insert_before(new_texcoord[i]);
- }
- }
+ prepare_array(shader->ir, this->new_texcoord,
+ ARRAY_SIZE(this->new_texcoord),
+ VARYING_SLOT_TEX0, "TexCoord", mode_str,
+ info->texcoord_usage, external_texcoord_usage);
+ }
+
+ /* Handle gl_FragData in the same way like gl_TexCoord. */
+ if (info->lower_fragdata_array) {
+ prepare_array(shader->ir, this->new_fragdata,
+ ARRAY_SIZE(this->new_fragdata),
+ FRAG_RESULT_DATA0, "FragData", mode_str,
+ info->fragdata_usage, (1 << MAX_DRAW_BUFFERS) - 1);
}
/* Create dummy variables which will replace set-but-unused color and
}
/* Now do the replacing. */
- visit_list_elements(this, ir);
+ visit_list_elements(this, shader->ir);
+ }
+
+ void prepare_array(exec_list *ir,
+ ir_variable **new_var,
+ int max_elements, unsigned start_location,
+ const char *var_name, const char *mode_str,
+ unsigned usage, unsigned external_usage)
+ {
+ void *const ctx = ir;
+
+ for (int i = max_elements-1; i >= 0; i--) {
+ if (usage & (1 << i)) {
+ char name[32];
+
+ if (!(external_usage & (1 << i))) {
+ /* This varying is unused in the next stage. Declare
+ * a temporary instead of an output. */
+ snprintf(name, 32, "gl_%s_%s%i_dummy", mode_str, var_name, i);
+ new_var[i] =
+ new (ctx) ir_variable(glsl_type::vec4_type, name,
+ ir_var_temporary);
+ }
+ else {
+ snprintf(name, 32, "gl_%s_%s%i", mode_str, var_name, i);
+ new_var[i] =
+ new(ctx) ir_variable(glsl_type::vec4_type, name,
+ this->info->mode);
+ new_var[i]->data.location = start_location + i;
+ new_var[i]->data.explicit_location = true;
+ new_var[i]->data.explicit_index = 0;
+ }
+
+ ir->head->insert_before(new_var[i]);
+ }
+ }
}
virtual ir_visitor_status visit(ir_variable *var)
var->remove();
}
+ /* Remove the gl_FragData array. */
+ if (this->info->lower_fragdata_array &&
+ var == this->info->fragdata_array) {
+
+ /* Clone variable for program resource list before it is removed. */
+ if (!shader->fragdata_arrays)
+ shader->fragdata_arrays = new (shader) exec_list;
+
+ shader->fragdata_arrays->push_tail(var->clone(shader, NULL));
+
+ var->remove();
+ }
+
/* Replace set-but-unused color and fog outputs with dummy variables. */
for (int i = 0; i < 2; i++) {
if (var == this->info->color[i] && this->new_color[i]) {
* variable dereference representing gl_TexCoord[i].
*/
if (this->info->lower_texcoord_array) {
- /* gl_TexCoord[i] occurence */
+ /* gl_TexCoord[i] occurrence */
ir_dereference_array *const da = (*rvalue)->as_dereference_array();
if (da && da->variable_referenced() ==
}
}
+ /* Same for gl_FragData. */
+ if (this->info->lower_fragdata_array) {
+ /* gl_FragData[i] occurrence */
+ ir_dereference_array *const da = (*rvalue)->as_dereference_array();
+
+ if (da && da->variable_referenced() == this->info->fragdata_array) {
+ unsigned i = da->array_index->as_constant()->get_uint_component(0);
+
+ *rvalue = new(ctx) ir_dereference_variable(this->new_fragdata[i]);
+ return;
+ }
+ }
+
/* Replace set-but-unused color and fog outputs with dummy variables. */
ir_dereference_variable *const dv = (*rvalue)->as_dereference_variable();
if (!dv)
}
private:
+ struct gl_shader *shader;
const varying_info_visitor *info;
- struct ir_variable *new_texcoord[MAX_TEXTURE_COORD_UNITS];
- struct ir_variable *new_color[2];
- struct ir_variable *new_backcolor[2];
- struct ir_variable *new_fog;
+ ir_variable *new_fragdata[MAX_DRAW_BUFFERS];
+ ir_variable *new_texcoord[MAX_TEXTURE_COORD_UNITS];
+ ir_variable *new_color[2];
+ ir_variable *new_backcolor[2];
+ ir_variable *new_fog;
};
+} /* anonymous namespace */
static void
-lower_texcoord_array(exec_list *ir, const varying_info_visitor *info)
+lower_texcoord_array(struct gl_shader *shader, const varying_info_visitor *info)
{
- replace_varyings_visitor(ir, info,
+ replace_varyings_visitor(shader, info,
(1 << MAX_TEXTURE_COORD_UNITS) - 1,
1 | 2, true);
}
+static void
+lower_fragdata_array(struct gl_shader *shader)
+{
+ varying_info_visitor info(ir_var_shader_out, true);
+ info.get(shader->ir, 0, NULL);
+
+ replace_varyings_visitor(shader, &info, 0, 0, 0);
+}
+
void
do_dead_builtin_varyings(struct gl_context *ctx,
unsigned num_tfeedback_decls,
tfeedback_decl *tfeedback_decls)
{
- /* This optimization has no effect with the core context and GLES2, because
- * the built-in varyings we're eliminating here are not available there.
- *
- * EXT_separate_shader_objects doesn't allow this optimization,
- * because a program object can be bound partially (e.g. only one
- * stage of a program object can be bound).
+ /* Lower the gl_FragData array to separate variables. */
+ if (consumer && consumer->Stage == MESA_SHADER_FRAGMENT) {
+ lower_fragdata_array(consumer);
+ }
+
+ /* Lowering of built-in varyings has no effect with the core context and
+ * GLES2, because they are not available there.
*/
if (ctx->API == API_OPENGL_CORE ||
- ctx->API == API_OPENGLES2 ||
- ctx->Extensions.EXT_separate_shader_objects) {
+ ctx->API == API_OPENGLES2) {
return;
}
if (!consumer) {
/* At least eliminate unused gl_TexCoord elements. */
if (producer_info.lower_texcoord_array) {
- lower_texcoord_array(producer->ir, &producer_info);
+ lower_texcoord_array(producer, &producer_info);
}
return;
}
if (!producer) {
/* At least eliminate unused gl_TexCoord elements. */
if (consumer_info.lower_texcoord_array) {
- lower_texcoord_array(consumer->ir, &consumer_info);
+ lower_texcoord_array(consumer, &consumer_info);
}
return;
}
if (producer_info.lower_texcoord_array ||
producer_info.color_usage ||
producer_info.has_fog) {
- replace_varyings_visitor(producer->ir,
+ replace_varyings_visitor(producer,
&producer_info,
consumer_info.texcoord_usage,
consumer_info.color_usage,
* This doesn't prevent elimination of the gl_TexCoord elements which
* are not read by the fragment shader. We want to eliminate those anyway.
*/
- if (consumer->Type == GL_FRAGMENT_SHADER) {
+ if (consumer->Stage == MESA_SHADER_FRAGMENT) {
producer_info.texcoord_usage = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
}
if (consumer_info.lower_texcoord_array ||
consumer_info.color_usage ||
consumer_info.has_fog) {
- replace_varyings_visitor(consumer->ir,
+ replace_varyings_visitor(consumer,
&consumer_info,
producer_info.texcoord_usage,
producer_info.color_usage,
projects / mesa.git / blobdiff