[Mesa-dev] [PATCH v2 12/28] glsl/ir: Add builtin constant function support for doubles
Ian Romanick
idr at freedesktop.org
Fri Feb 6 00:02:19 PST 2015
On 02/06/2015 06:56 AM, Ilia Mirkin wrote:
> From: Dave Airlie <airlied at gmail.com>
>
> Signed-off-by: Dave Airlie <airlied at redhat.com>
> ---
> src/glsl/ir_constant_expression.cpp | 242 +++++++++++++++++++++++++++++++-----
> 1 file changed, 210 insertions(+), 32 deletions(-)
>
> diff --git a/src/glsl/ir_constant_expression.cpp b/src/glsl/ir_constant_expression.cpp
> index 1e8b3a3..33b8f4f 100644
> --- a/src/glsl/ir_constant_expression.cpp
> +++ b/src/glsl/ir_constant_expression.cpp
> @@ -60,7 +60,7 @@ static double copysign(double x, double y)
> #endif
>
> static float
> -dot(ir_constant *op0, ir_constant *op1)
> +dot_f(ir_constant *op0, ir_constant *op1)
> {
> assert(op0->type->is_float() && op1->type->is_float());
>
> @@ -71,6 +71,18 @@ dot(ir_constant *op0, ir_constant *op1)
> return result;
> }
>
> +static double
> +dot_d(ir_constant *op0, ir_constant *op1)
> +{
> + assert(op0->type->is_double() && op1->type->is_double());
> +
> + double result = 0;
> + for (unsigned c = 0; c < op0->type->components(); c++)
> + result += op0->value.d[c] * op1->value.d[c];
> +
> + return result;
> +}
> +
> /* This method is the only one supported by gcc. Unions in particular
> * are iffy, and read-through-converted-pointer is killed by strict
> * aliasing. OTOH, the compiler sees through the memcpy, so the
> @@ -667,32 +679,75 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> data.b[0] = true;
> }
> break;
> -
> - case ir_unop_trunc:
> + case ir_unop_d2f:
> + assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.f[c] = op[0]->value.d[c];
> + }
> + break;
> + case ir_unop_f2d:
> assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> for (unsigned c = 0; c < op[0]->type->components(); c++) {
> - data.f[c] = truncf(op[0]->value.f[c]);
> + data.d[c] = op[0]->value.f[c];
> + }
> + break;
> + case ir_unop_d2i:
> + assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i[c] = op[0]->value.d[c];
> + }
> + break;
> + case ir_unop_i2d:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.d[c] = op[0]->value.i[c];
> + }
> + break;
> + case ir_unop_d2u:
> + assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u[c] = op[0]->value.d[c];
> + }
> + break;
> + case ir_unop_u2d:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.d[c] = op[0]->value.u[c];
> + }
> + break;
> + case ir_unop_trunc:
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = trunc(op[0]->value.d[c]);
> + else
> + data.f[c] = truncf(op[0]->value.f[c]);
> }
> break;
>
> case ir_unop_round_even:
> - assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> for (unsigned c = 0; c < op[0]->type->components(); c++) {
> - data.f[c] = _mesa_round_to_even(op[0]->value.f[c]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = _mesa_round_to_even(op[0]->value.d[c]);
> + else
> + data.f[c] = _mesa_round_to_even(op[0]->value.f[c]);
> }
> break;
>
> case ir_unop_ceil:
> - assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> for (unsigned c = 0; c < op[0]->type->components(); c++) {
> - data.f[c] = ceilf(op[0]->value.f[c]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = ceil(op[0]->value.d[c]);
> + else
> + data.f[c] = ceilf(op[0]->value.f[c]);
> }
> break;
>
> case ir_unop_floor:
> - assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> for (unsigned c = 0; c < op[0]->type->components(); c++) {
> - data.f[c] = floorf(op[0]->value.f[c]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = floor(op[0]->value.d[c]);
> + else
> + data.f[c] = floorf(op[0]->value.f[c]);
> }
> break;
>
> @@ -708,6 +763,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = op[0]->value.f[c] - floor(op[0]->value.f[c]);
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = op[0]->value.d[c] - floor(op[0]->value.d[c]);
> + break;
> default:
> assert(0);
Maybe follow-up by replacing a bunch of these with unreachable().
> }
> @@ -742,6 +800,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = -op[0]->value.f[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = -op[0]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -762,6 +823,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = fabs(op[0]->value.f[c]);
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = fabs(op[0]->value.d[c]);
> + break;
> default:
> assert(0);
> }
> @@ -780,6 +844,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = float((op[0]->value.f[c] > 0)-(op[0]->value.f[c] < 0));
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = double((op[0]->value.d[c] > 0)-(op[0]->value.d[c] < 0));
> + break;
> default:
> assert(0);
> }
> @@ -787,7 +854,6 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> break;
>
> case ir_unop_rcp:
> - 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:
> @@ -802,6 +868,10 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> if (op[0]->value.f[c] != 0.0)
> data.f[c] = 1.0F / op[0]->value.f[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + if (op[0]->value.d[c] != 0.0)
> + data.d[c] = 1.0 / op[0]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -809,16 +879,20 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> break;
>
> case ir_unop_rsq:
> - assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> for (unsigned c = 0; c < op[0]->type->components(); c++) {
> - data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = 1.0 / sqrt(op[0]->value.d[c]);
> + else
> + data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
> }
> break;
>
> case ir_unop_sqrt:
> - assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> for (unsigned c = 0; c < op[0]->type->components(); c++) {
> - data.f[c] = sqrtf(op[0]->value.f[c]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = sqrt(op[0]->value.d[c]);
> + else
> + data.f[c] = sqrtf(op[0]->value.f[c]);
> }
> break;
>
> @@ -934,7 +1008,10 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> break;
>
> case ir_binop_dot:
> - data.f[0] = dot(op[0], op[1]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[0] = dot_d(op[0], op[1]);
> + else
> + data.f[0] = dot_f(op[0], op[1]);
> break;
>
> case ir_binop_min:
> @@ -953,6 +1030,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = MIN2(op[0]->value.d[c0], op[1]->value.d[c1]);
> + break;
> default:
> assert(0);
> }
> @@ -975,6 +1055,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = MAX2(op[0]->value.d[c0], op[1]->value.d[c1]);
> + break;
> default:
> assert(0);
> }
> @@ -997,6 +1080,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = op[0]->value.d[c0] + op[1]->value.d[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1019,6 +1105,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1043,6 +1132,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = op[0]->value.d[c0] * op[1]->value.d[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1066,7 +1158,10 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> for (unsigned j = 0; j < p; j++) {
> for (unsigned i = 0; i < n; i++) {
> for (unsigned k = 0; k < m; k++) {
> - data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[i+n*j] += op[0]->value.d[i+n*k]*op[1]->value.d[k+m*j];
> + else
> + data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
> }
> }
> }
> @@ -1098,6 +1193,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = op[0]->value.d[c0] / op[1]->value.d[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1133,6 +1231,13 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]
> * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
> break;
> + case GLSL_TYPE_DOUBLE:
> + /* We don't use fmod because it rounds toward zero; GLSL specifies
> + * the use of floor.
> + */
> + data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1]
> + * floor(op[0]->value.d[c0] / op[1]->value.d[c1]);
> + break;
> default:
> assert(0);
> }
> @@ -1169,6 +1274,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.b[c] = op[0]->value.d[c] < op[1]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -1187,6 +1295,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.b[c] = op[0]->value.f[c] > op[1]->value.f[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.b[c] = op[0]->value.d[c] > op[1]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -1205,6 +1316,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.b[c] = op[0]->value.f[c] <= op[1]->value.f[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.b[c] = op[0]->value.d[c] <= op[1]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -1223,6 +1337,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.b[c] = op[0]->value.d[c] >= op[1]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -1244,6 +1361,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_BOOL:
> data.b[c] = op[0]->value.b[c] == op[1]->value.b[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.b[c] = op[0]->value.d[c] == op[1]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -1265,6 +1385,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_BOOL:
> data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.b[c] = op[0]->value.d[c] != op[1]->value.d[c];
> + break;
> default:
> assert(0);
> }
> @@ -1375,6 +1498,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[0] = op[0]->value.f[c];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[0] = op[0]->value.d[c];
> + break;
> case GLSL_TYPE_BOOL:
> data.b[0] = op[0]->value.b[c];
> break;
> @@ -1474,6 +1600,19 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> data.f[c] = CLAMP(op[0]->value.f[c], 0.0f, 1.0f);
> }
> break;
> + case ir_unop_pack_double_2x32: {
> + /* XXX needs to be checked on big-endian */
I think this should just work. The spec says that the 32-bit values are
little-endian:
"The first vector component specifies the 32 least significant
bits; the second component specifies the 32 most significant bits."
On a little-endian system, you have a memcpy, and on big-endian it will
be a 32-bit word swap... which is correct... I think...
> + uint64_t temp;
> + temp = (uint64_t)op[0]->value.u[0] | ((uint64_t)op[0]->value.u[1] << 32);
> + data.d[0] = *(double *)&temp;
> +
> + break;
> + }
> + case ir_unop_unpack_double_2x32:
> + /* XXX needs to be checked on big-endian */
> + data.u[0] = *(uint32_t *)&op[0]->value.d[0];
> + data.u[1] = *((uint32_t *)&op[0]->value.d[0] + 1);
> + break;
>
> case ir_triop_bitfield_extract: {
> int offset = op[1]->value.i[0];
> @@ -1523,40 +1662,66 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
>
> case ir_binop_ldexp:
> for (unsigned c = 0; c < components; c++) {
> - data.f[c] = ldexp(op[0]->value.f[c], op[1]->value.i[c]);
> - /* Flush subnormal values to zero. */
> - if (!isnormal(data.f[c]))
> - data.f[c] = copysign(0.0f, op[0]->value.f[c]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE) {
> + data.d[c] = ldexp(op[0]->value.d[c], op[1]->value.i[c]);
> + /* Flush subnormal values to zero. */
> + if (!isnormal(data.d[c]))
> + data.d[c] = copysign(0.0, op[0]->value.d[c]);
> +
> + } else {
> + data.f[c] = ldexp(op[0]->value.f[c], op[1]->value.i[c]);
> + /* Flush subnormal values to zero. */
> + if (!isnormal(data.f[c]))
> + data.f[c] = copysign(0.0f, op[0]->value.f[c]);
> + }
> }
> break;
>
> case ir_triop_fma:
> - assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> - assert(op[1]->type->base_type == GLSL_TYPE_FLOAT);
> - assert(op[2]->type->base_type == GLSL_TYPE_FLOAT);
> + assert(op[0]->type->base_type == GLSL_TYPE_FLOAT ||
> + op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + assert(op[1]->type->base_type == GLSL_TYPE_FLOAT ||
> + op[1]->type->base_type == GLSL_TYPE_DOUBLE);
> + assert(op[2]->type->base_type == GLSL_TYPE_FLOAT ||
> + op[2]->type->base_type == GLSL_TYPE_DOUBLE);
>
> for (unsigned c = 0; c < components; c++) {
> - data.f[c] = op[0]->value.f[c] * op[1]->value.f[c]
> - + op[2]->value.f[c];
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = op[0]->value.d[c] * op[1]->value.d[c]
> + + op[2]->value.d[c];
> + else
> + data.f[c] = op[0]->value.f[c] * op[1]->value.f[c]
> + + op[2]->value.f[c];
> }
> break;
>
> case ir_triop_lrp: {
> - assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> - assert(op[1]->type->base_type == GLSL_TYPE_FLOAT);
> - assert(op[2]->type->base_type == GLSL_TYPE_FLOAT);
> + assert(op[0]->type->base_type == GLSL_TYPE_FLOAT ||
> + op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + assert(op[1]->type->base_type == GLSL_TYPE_FLOAT ||
> + op[1]->type->base_type == GLSL_TYPE_DOUBLE);
> + assert(op[2]->type->base_type == GLSL_TYPE_FLOAT ||
> + op[2]->type->base_type == GLSL_TYPE_DOUBLE);
>
> unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1;
> for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) {
> - data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) +
> - (op[1]->value.f[c] * op[2]->value.f[c2]);
> + if (op[0]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = op[0]->value.d[c] * (1.0 - op[2]->value.d[c2]) +
> + (op[1]->value.d[c] * op[2]->value.d[c2]);
> + else
> + data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) +
> + (op[1]->value.f[c] * op[2]->value.f[c2]);
> }
> break;
> }
>
> case ir_triop_csel:
> for (unsigned c = 0; c < components; c++) {
> - data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c]
> + if (op[1]->type->base_type == GLSL_TYPE_DOUBLE)
> + data.d[c] = op[0]->value.b[c] ? op[1]->value.d[c]
> + : op[2]->value.d[c];
> + else
> + data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c]
> : op[2]->value.u[c];
> }
> break;
> @@ -1579,6 +1744,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_BOOL:
> data.b[idx] = op[1]->value.b[0];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[idx] = op[1]->value.d[0];
> + break;
> default:
> assert(!"Should not get here.");
> break;
> @@ -1625,6 +1793,9 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_FLOAT:
> data.f[c] = op[c]->value.f[0];
> break;
> + case GLSL_TYPE_DOUBLE:
> + data.d[c] = op[c]->value.d[0];
> + break;
> default:
> assert(0);
> }
> @@ -1666,6 +1837,7 @@ ir_swizzle::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_INT: data.u[i] = v->value.u[swiz_idx[i]]; break;
> case GLSL_TYPE_FLOAT: data.f[i] = v->value.f[swiz_idx[i]]; break;
> case GLSL_TYPE_BOOL: data.b[i] = v->value.b[swiz_idx[i]]; break;
> + case GLSL_TYPE_DOUBLE:data.d[i] = v->value.d[swiz_idx[i]]; break;
> default: assert(!"Should not get here."); break;
> }
> }
> @@ -1740,6 +1912,12 @@ ir_dereference_array::constant_expression_value(struct hash_table *variable_cont
>
> break;
>
> + case GLSL_TYPE_DOUBLE:
> + for (unsigned i = 0; i < column_type->vector_elements; i++)
> + data.d[i] = array->value.d[mat_idx + i];
> +
> + break;
> +
> default:
> assert(!"Should not get here.");
> break;
>
More information about the mesa-dev
mailing list