[Mesa-dev] [PATCH 10/23] glsl: add 64-bit integer support for constant expressions
Ian Romanick
idr at freedesktop.org
Thu Jun 9 19:09:20 UTC 2016
On 06/08/2016 05:48 PM, Dave Airlie wrote:
> From: Dave Airlie <airlied at redhat.com>
>
> This just adds the new operations and add 64-bit integer
> support to all the existing cases where it is needed.
>
> Signed-off-by: Dave Airlie <airlied at redhat.com>
There's a bunch of mixed tabs-and-spaces below.
> ---
> src/compiler/glsl/ir_constant_expression.cpp | 324 +++++++++++++++++++++++++++
> 1 file changed, 324 insertions(+)
>
> diff --git a/src/compiler/glsl/ir_constant_expression.cpp b/src/compiler/glsl/ir_constant_expression.cpp
> index fbbf779..e6f5668 100644
> --- a/src/compiler/glsl/ir_constant_expression.cpp
> +++ b/src/compiler/glsl/ir_constant_expression.cpp
> @@ -88,6 +88,42 @@ bitcast_f2u(float f)
> return u;
> }
>
> +static double
> +bitcast_u642d(uint64_t u)
> +{
> + assert(sizeof(double) == sizeof(uint64_t));
> + double d;
> + memcpy(&d, &u, sizeof(d));
> + return d;
> +}
> +
> +static double
> +bitcast_i642d(int64_t i)
> +{
> + assert(sizeof(double) == sizeof(int64_t));
> + double d;
> + memcpy(&d, &i, sizeof(d));
> + return d;
> +}
> +
> +static double
> +bitcast_d2u64(double d)
> +{
> + assert(sizeof(double) == sizeof(uint64_t));
> + uint64_t u;
> + memcpy(&u, &d, sizeof(d));
> + return u;
> +}
> +
> +static double
> +bitcast_d2i64(double d)
> +{
> + assert(sizeof(double) == sizeof(int64_t));
> + int64_t i;
> + memcpy(&i, &d, sizeof(d));
> + return i;
> +}
> +
> /**
> * Evaluate one component of a floating-point 4x8 unpacking function.
> */
> @@ -690,6 +726,162 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> data.b[c] = op[0]->value.d[c] != 0.0;
> }
> break;
> + case ir_unop_bitcast_u642d:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.d[c] = bitcast_u642d(op[0]->value.u64[c]);
> + }
> + break;
Aiiee! We're drowning in an ocean of copy-and-paste code. I think we
could cut the down with
#define DO_CAST(ir_op, base_type, dest_field, cast, src_field) \
case ir_op: \
assert(op[0]->type->base_type == base_type); \
for (unsigned c = 0; c < op[0]->type->components(); c++) \
data. dest_field [c] = cast (op[0]->value. src_field [c]); \
break;
> + case ir_unop_bitcast_i642d:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.d[c] = bitcast_i642d(op[0]->value.i64[c]);
> + }
> + break;
> + case ir_unop_bitcast_d2u64:
> + assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u64[c] = bitcast_d2u64(op[0]->value.d[c]);
> + }
> + break;
> + case ir_unop_bitcast_d2i64:
> + assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = bitcast_d2i64(op[0]->value.d[c]);
> + }
> + break;
> + case ir_unop_i642i:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i[c] = op[0]->value.i64[c];
> + }
> + break;
> + case ir_unop_u642i:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i[c] = op[0]->value.u64[c];
> + }
> + break;
> + case ir_unop_i642u:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u[c] = op[0]->value.i64[c];
> + }
> + break;
> + case ir_unop_u642u:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u[c] = op[0]->value.u64[c];
> + }
> + break;
> + case ir_unop_i642b:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.b[c] = op[0]->value.i64[c] != 0;
> + }
> + break;
> + case ir_unop_u642b:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.b[c] = op[0]->value.u64[c] != 0;
> + }
> + break;
> + case ir_unop_i642f:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.f[c] = op[0]->value.i64[c];
> + }
> + break;
> + case ir_unop_u642f:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.f[c] = op[0]->value.u64[c];
> + }
> + break;
> + case ir_unop_i642d:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.d[c] = op[0]->value.i64[c];
> + }
> + break;
> + case ir_unop_u642d:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.d[c] = op[0]->value.u64[c];
> + }
> + break;
> + case ir_unop_i2i64:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = op[0]->value.i[c];
> + }
> + break;
> + case ir_unop_u2i64:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = op[0]->value.u[c];
> + }
> + break;
> + case ir_unop_b2i64:
> + assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = op[0]->value.b[c];
> + }
> + break;
> + case ir_unop_f2i64:
> + assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = op[0]->value.f[c];
> + }
> + break;
> + case ir_unop_d2i64:
> + assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = op[0]->value.d[c];
> + }
> + break;
> + case ir_unop_i2u64:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = op[0]->value.i[c];
> + }
> + break;
> + case ir_unop_u2u64:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u64[c] = op[0]->value.u[c];
> + }
> + break;
> + case ir_unop_b2u64:
> + assert(op[0]->type->base_type == GLSL_TYPE_BOOL);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u64[c] = op[0]->value.b[c];
> + }
> + break;
> + case ir_unop_f2u64:
> + assert(op[0]->type->base_type == GLSL_TYPE_FLOAT);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u64[c] = op[0]->value.f[c];
> + }
> + break;
> + case ir_unop_d2u64:
> + assert(op[0]->type->base_type == GLSL_TYPE_DOUBLE);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u64[c] = op[0]->value.d[c];
> + }
> + break;
> + case ir_unop_i642u64:
> + assert(op[0]->type->base_type == GLSL_TYPE_INT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.u64[c] = op[0]->value.i64[c];
> + }
> + break;
> + case ir_unop_u642i64:
> + assert(op[0]->type->base_type == GLSL_TYPE_UINT64);
> + for (unsigned c = 0; c < op[0]->type->components(); c++) {
> + data.i64[c] = op[0]->value.u64[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)
> @@ -776,6 +968,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = -op[0]->value.d[c];
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = -((int64_t)op[0]->value.u64[c]);
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = -op[0]->value.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -799,6 +997,14 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = fabs(op[0]->value.d[c]);
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.u64[c];
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = op[0]->value.i64[c];
> + if (data.i64[c] < 0)
> + data.i64[c] = -data.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -820,6 +1026,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = double((op[0]->value.d[c] > 0)-(op[0]->value.d[c] < 0));
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.i64[c] > 0;
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = (op[0]->value.i64[c] > 0) - (op[0]->value.i64[c] < 0);
> + break;
> default:
> assert(0);
> }
> @@ -1006,6 +1218,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = MIN2(op[0]->value.d[c0], op[1]->value.d[c1]);
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = MIN2(op[0]->value.u64[c0], op[1]->value.u64[c1]);
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = MIN2(op[0]->value.i64[c0], op[1]->value.i64[c1]);
> + break;
> default:
> assert(0);
> }
> @@ -1031,6 +1249,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = MAX2(op[0]->value.d[c0], op[1]->value.d[c1]);
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = MAX2(op[0]->value.u64[c0], op[1]->value.u64[c1]);
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = MAX2(op[0]->value.i64[c0], op[1]->value.i64[c1]);
> + break;
> default:
> assert(0);
> }
> @@ -1056,6 +1280,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = op[0]->value.d[c0] + op[1]->value.d[c1];
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.u64[c0] + op[1]->value.u64[c1];
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = op[0]->value.i64[c0] + op[1]->value.i64[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1081,6 +1311,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1];
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.u64[c0] - op[1]->value.u64[c1];
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = op[0]->value.i64[c0] - op[1]->value.i64[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1108,6 +1344,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = op[0]->value.d[c0] * op[1]->value.d[c1];
> break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.u64[c0] * op[1]->value.u64[c1];
> + break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = op[0]->value.i64[c0] * op[1]->value.i64[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1169,6 +1411,20 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.d[c] = op[0]->value.d[c0] / op[1]->value.d[c1];
> break;
> + case GLSL_TYPE_UINT64:
> + if (op[1]->value.u64[c1] == 0) {
> + data.u64[c] = 0;
> + } else {
> + data.u64[c] = op[0]->value.u64[c0] / op[1]->value.u64[c1];
> + }
> + break;
> + case GLSL_TYPE_INT64:
> + if (op[1]->value.i64[c1] == 0) {
> + data.i64[c] = 0;
> + } else {
> + data.i64[c] = op[0]->value.i64[c0] / op[1]->value.i64[c1];
> + }
> + break;
> default:
> assert(0);
> }
> @@ -1211,6 +1467,20 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> 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;
> + case GLSL_TYPE_UINT64:
> + if (op[1]->value.u64[c1] == 0) {
> + data.u64[c] = 0;
> + } else {
> + data.u64[c] = op[0]->value.u64[c0] % op[1]->value.u64[c1];
> + }
> + break;
> + case GLSL_TYPE_INT64:
> + if (op[1]->value.i64[c1] == 0) {
> + data.i64[c] = 0;
> + } else {
> + data.i64[c] = op[0]->value.i64[c0] % op[1]->value.i64[c1];
> + }
> + break;
> default:
> assert(0);
> }
> @@ -1250,6 +1520,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.b[c] = op[0]->value.d[c] < op[1]->value.d[c];
> break;
> + case GLSL_TYPE_UINT64:
> + data.b[c] = op[0]->value.u64[c] < op[1]->value.u64[c];
> + break;
> + case GLSL_TYPE_INT64:
> + data.b[c] = op[0]->value.i64[c] < op[1]->value.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -1271,6 +1547,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.b[c] = op[0]->value.d[c] > op[1]->value.d[c];
> break;
> + case GLSL_TYPE_UINT64:
> + data.b[c] = op[0]->value.u64[c] > op[1]->value.u64[c];
> + break;
> + case GLSL_TYPE_INT64:
> + data.b[c] = op[0]->value.i64[c] > op[1]->value.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -1292,6 +1574,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.b[c] = op[0]->value.d[c] <= op[1]->value.d[c];
> break;
> + case GLSL_TYPE_UINT64:
> + data.b[c] = op[0]->value.u64[c] <= op[1]->value.u64[c];
> + break;
> + case GLSL_TYPE_INT64:
> + data.b[c] = op[0]->value.i64[c] <= op[1]->value.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -1313,6 +1601,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.b[c] = op[0]->value.d[c] >= op[1]->value.d[c];
> break;
> + case GLSL_TYPE_UINT64:
> + data.b[c] = op[0]->value.u64[c] >= op[1]->value.u64[c];
> + break;
> + case GLSL_TYPE_INT64:
> + data.b[c] = op[0]->value.i64[c] >= op[1]->value.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -1337,6 +1631,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.b[c] = op[0]->value.d[c] == op[1]->value.d[c];
> break;
> + case GLSL_TYPE_UINT64:
> + data.b[c] = op[0]->value.u64[c] == op[1]->value.u64[c];
> + break;
> + case GLSL_TYPE_INT64:
> + data.b[c] = op[0]->value.i64[c] == op[1]->value.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -1361,6 +1661,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_DOUBLE:
> data.b[c] = op[0]->value.d[c] != op[1]->value.d[c];
> break;
> + case GLSL_TYPE_UINT64:
> + data.b[c] = op[0]->value.u64[c] != op[1]->value.u64[c];
> + break;
> + case GLSL_TYPE_INT64:
> + data.b[c] = op[0]->value.i64[c] != op[1]->value.i64[c];
> + break;
> default:
> assert(0);
> }
> @@ -1433,6 +1739,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_UINT:
> data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1];
> break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = op[0]->value.i64[c0] & op[1]->value.i64[c1];
> + break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.u64[c0] & op[1]->value.u64[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1451,6 +1763,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_UINT:
> data.u[c] = op[0]->value.u[c0] | op[1]->value.u[c1];
> break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = op[0]->value.i64[c0] | op[1]->value.i64[c1];
> + break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.u64[c0] | op[1]->value.u64[c1];
> + break;
> default:
> assert(0);
> }
> @@ -1495,6 +1813,12 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
> case GLSL_TYPE_UINT:
> data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1];
> break;
> + case GLSL_TYPE_INT64:
> + data.i64[c] = op[0]->value.i64[c0] ^ op[1]->value.i64[c1];
> + break;
> + case GLSL_TYPE_UINT64:
> + data.u64[c] = op[0]->value.u64[c0] ^ op[1]->value.u64[c1];
> + break;
> default:
> assert(0);
> }
>
More information about the mesa-dev
mailing list