Mesa (master): glsl: Let ir_builder expressions take un-dereferenced variables.
Eric Anholt
anholt at kemper.freedesktop.org
Sat Apr 14 00:04:42 UTC 2012
Module: Mesa
Branch: master
Commit: d6e6566206029ace72ba037a3ef7950876eeb88b
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=d6e6566206029ace72ba037a3ef7950876eeb88b
Author: Eric Anholt <eric at anholt.net>
Date: Mon Mar 19 14:04:23 2012 -0700
glsl: Let ir_builder expressions take un-dereferenced variables.
Having to explicitly dereference is irritating and bloats the code,
when the compiler can detect and do the right thing.
v2: Use a little shim class to produce the automatic dereference
generation at compile time as opposed to runtime, while also
allowing compile-time type checking.
Reviewed-by: Kenneth Graunke <kenneth at whitecape.org>
---
src/glsl/ir_builder.cpp | 19 ++++++++---------
src/glsl/ir_builder.h | 37 ++++++++++++++++++++++++++++-----
src/mesa/main/ff_fragment_shader.cpp | 19 +++++------------
3 files changed, 46 insertions(+), 29 deletions(-)
diff --git a/src/glsl/ir_builder.cpp b/src/glsl/ir_builder.cpp
index a9d8714..a867eb4 100644
--- a/src/glsl/ir_builder.cpp
+++ b/src/glsl/ir_builder.cpp
@@ -28,38 +28,37 @@ using namespace ir_builder;
namespace ir_builder {
ir_expression *
-expr(ir_expression_operation op,
- ir_rvalue *a, ir_rvalue *b)
+expr(ir_expression_operation op, operand a, operand b)
{
- void *mem_ctx = ralloc_parent(a);
+ void *mem_ctx = ralloc_parent(a.val);
- return new(mem_ctx) ir_expression(op, a, b);
+ return new(mem_ctx) ir_expression(op, a.val, b.val);
}
-ir_expression *add(ir_rvalue *a, ir_rvalue *b)
+ir_expression *add(operand a, operand b)
{
return expr(ir_binop_add, a, b);
}
-ir_expression *sub(ir_rvalue *a, ir_rvalue *b)
+ir_expression *sub(operand a, operand b)
{
return expr(ir_binop_sub, a, b);
}
-ir_expression *mul(ir_rvalue *a, ir_rvalue *b)
+ir_expression *mul(operand a, operand b)
{
return expr(ir_binop_mul, a, b);
}
-ir_expression *dot(ir_rvalue *a, ir_rvalue *b)
+ir_expression *dot(operand a, operand b)
{
return expr(ir_binop_dot, a, b);
}
ir_expression *
-saturate(ir_rvalue *a)
+saturate(operand a)
{
- void *mem_ctx = ralloc_parent(a);
+ void *mem_ctx = ralloc_parent(a.val);
return expr(ir_binop_max,
expr(ir_binop_min, a, new(mem_ctx) ir_constant(1.0f)),
diff --git a/src/glsl/ir_builder.h b/src/glsl/ir_builder.h
index 5d6f476..78b119d 100644
--- a/src/glsl/ir_builder.h
+++ b/src/glsl/ir_builder.h
@@ -25,11 +25,36 @@
namespace ir_builder {
-ir_expression *expr(ir_expression_operation op, ir_rvalue *a, ir_rvalue *b);
-ir_expression *add(ir_rvalue *a, ir_rvalue *b);
-ir_expression *sub(ir_rvalue *a, ir_rvalue *b);
-ir_expression *mul(ir_rvalue *a, ir_rvalue *b);
-ir_expression *dot(ir_rvalue *a, ir_rvalue *b);
-ir_expression *saturate(ir_rvalue *a);
+/**
+ * This little class exists to let the helper expression generators
+ * take either an ir_rvalue * or an ir_variable * to be automatically
+ * dereferenced, while still providing compile-time type checking.
+ *
+ * You don't have to explicitly call the constructor -- C++ will see
+ * that you passed an ir_variable, and silently call the
+ * operand(ir_variable *var) constructor behind your back.
+ */
+class operand {
+public:
+ operand(ir_rvalue *val)
+ : val(val)
+ {
+ }
+
+ operand(ir_variable *var)
+ {
+ void *mem_ctx = ralloc_parent(var);
+ val = new(mem_ctx) ir_dereference_variable(var);
+ }
+
+ ir_rvalue *val;
+};
+
+ir_expression *expr(ir_expression_operation op, operand a, operand b);
+ir_expression *add(operand a, operand b);
+ir_expression *sub(operand a, operand b);
+ir_expression *mul(operand a, operand b);
+ir_expression *dot(operand a, operand b);
+ir_expression *saturate(operand a);
} /* namespace ir_builder */
diff --git a/src/mesa/main/ff_fragment_shader.cpp b/src/mesa/main/ff_fragment_shader.cpp
index cfee334..2d56d3b 100644
--- a/src/mesa/main/ff_fragment_shader.cpp
+++ b/src/mesa/main/ff_fragment_shader.cpp
@@ -1112,13 +1112,10 @@ load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )
GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;
ir_rvalue *bump;
ir_rvalue *texcoord;
- ir_variable *rot_mat_0_var, *rot_mat_1_var;
- ir_dereference_variable *rot_mat_0, *rot_mat_1;
+ ir_variable *rot_mat_0, *rot_mat_1;
- rot_mat_0_var = p->shader->symbols->get_variable("gl_BumpRotMatrix0MESA");
- rot_mat_1_var = p->shader->symbols->get_variable("gl_BumpRotMatrix1MESA");
- rot_mat_0 = new(p->mem_ctx) ir_dereference_variable(rot_mat_0_var);
- rot_mat_1 = new(p->mem_ctx) ir_dereference_variable(rot_mat_1_var);
+ rot_mat_0 = p->shader->symbols->get_variable("gl_BumpRotMatrix0MESA");
+ rot_mat_1 = p->shader->symbols->get_variable("gl_BumpRotMatrix1MESA");
ir_variable *tc_array = p->shader->symbols->get_variable("gl_TexCoord");
assert(tc_array);
@@ -1262,9 +1259,7 @@ emit_fog_instructions(struct texenv_fragment_program *p,
ir_assignment *assign = new(p->mem_ctx) ir_assignment(temp, f);
p->instructions->push_tail(assign);
- f = new(p->mem_ctx) ir_dereference_variable(temp_var);
- temp = new(p->mem_ctx) ir_dereference_variable(temp_var);
- f = mul(f, temp);
+ f = mul(temp_var, temp_var);
f = new(p->mem_ctx) ir_expression(ir_unop_neg, f);
f = new(p->mem_ctx) ir_expression(ir_unop_exp2, f);
break;
@@ -1276,15 +1271,13 @@ emit_fog_instructions(struct texenv_fragment_program *p,
assign = new(p->mem_ctx) ir_assignment(temp, f);
p->instructions->push_tail(assign);
- f = new(p->mem_ctx) ir_dereference_variable(f_var);
- f = sub(new(p->mem_ctx) ir_constant(1.0f), f);
+ f = sub(new(p->mem_ctx) ir_constant(1.0f), f_var);
temp = new(p->mem_ctx) ir_dereference_variable(params);
temp = new(p->mem_ctx) ir_dereference_record(temp, "color");
temp = new(p->mem_ctx) ir_swizzle(temp, 0, 1, 2, 3, 3);
temp = mul(temp, f);
- f = new(p->mem_ctx) ir_dereference_variable(f_var);
- f = add(temp, mul(fragcolor, f));
+ f = add(temp, mul(fragcolor, f_var));
ir_dereference *deref = new(p->mem_ctx) ir_dereference_variable(fog_result);
assign = new(p->mem_ctx) ir_assignment(deref, f, NULL, WRITEMASK_XYZ);
More information about the mesa-commit
mailing list