glsl: Fix constant-folding for reciprocal expressions

Do not constant-fold a reciprocal if any component of the reciprocated
expression is 0. For example, do not constant-fold `1 / vec4(0, 1, 2, 3)`.

Incorrect, previous behavior
----------------------------
Reciprocals were constant-folded even when some component of the
reciprocated expression was 0. The incorrectly applied arithmetic was:
   1 / 0 := 0
For example,
   1 / vec4(0, 1, 2, 3) = vec4(0, 1, 1/2, 1/3)

NOTE: This is a candidate for the 7.9 and 7.10 branches.

diff --git a/src/glsl/ir_constant_expression.cpp b/src/glsl/ir_constant_expression.cpp
index cf958aa7a1716a0f9879edc3bed465f760efad70..321374f7f643fe11d4880ce21c65085248d1d587 100644 (file)
--- a/src/glsl/ir_constant_expression.cpp
+++ b/src/glsl/ir_constant_expression.cpp
@@ -288,20 +288,24 @@ ir_expression::constant_expression_value()
       break;
 
    case ir_unop_rcp:
+      /* FINISHME: Emit warning when division-by-zero is detected. */
       assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
       for (unsigned c = 0; c < op[0]->type->components(); c++) {
         switch (this->type->base_type) {
         case GLSL_TYPE_UINT:
-           if (op[0]->value.u[c] != 0.0)
-              data.u[c] = 1 / op[0]->value.u[c];
+           if (op[0]->value.u[c] == 0.0)
+              return NULL;
+           data.u[c] = 1 / op[0]->value.u[c];
            break;
         case GLSL_TYPE_INT:
-           if (op[0]->value.i[c] != 0.0)
-              data.i[c] = 1 / op[0]->value.i[c];
+           if (op[0]->value.i[c] == 0.0)
+              return NULL;
+           data.i[c] = 1 / op[0]->value.i[c];
            break;
         case GLSL_TYPE_FLOAT:
-           if (op[0]->value.f[c] != 0.0)
-              data.f[c] = 1.0F / op[0]->value.f[c];
+           if (op[0]->value.f[c] == 0.0)
+              return NULL;
+           data.f[c] = 1.0F / op[0]->value.f[c];
            break;
         default:
            assert(0);