mirror of
https://gitlab.winehq.org/wine/vkd3d.git
synced 2024-11-21 16:46:41 -08:00
bc7c89bc1f
Signed-off-by: Giovanni Mascellani <gmascellani@codeweavers.com> Signed-off-by: Zebediah Figura <zfigura@codeweavers.com> Signed-off-by: Francisco Casas <fcasas@codeweavers.com> Signed-off-by: Matteo Bruni <mbruni@codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com> Signed-off-by: Alexandre Julliard <julliard@winehq.org>
287 lines
8.2 KiB
C
287 lines
8.2 KiB
C
/*
|
|
* HLSL constant value operations for constant folding
|
|
*
|
|
* Copyright 2022 Francisco Casas for CodeWeavers
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "hlsl.h"
|
|
|
|
static bool fold_cast(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst, struct hlsl_ir_constant *src)
|
|
{
|
|
unsigned int k;
|
|
uint32_t u;
|
|
int32_t i;
|
|
double d;
|
|
float f;
|
|
bool b;
|
|
|
|
if (dst->node.data_type->dimx != src->node.data_type->dimx
|
|
|| dst->node.data_type->dimy != src->node.data_type->dimy)
|
|
{
|
|
FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, src->node.data_type),
|
|
debug_hlsl_type(ctx, dst->node.data_type));
|
|
return false;
|
|
}
|
|
|
|
for (k = 0; k < 4; ++k)
|
|
{
|
|
switch (src->node.data_type->base_type)
|
|
{
|
|
case HLSL_TYPE_FLOAT:
|
|
case HLSL_TYPE_HALF:
|
|
u = src->value[k].f;
|
|
i = src->value[k].f;
|
|
f = src->value[k].f;
|
|
d = src->value[k].f;
|
|
b = src->value[k].f;
|
|
break;
|
|
|
|
case HLSL_TYPE_DOUBLE:
|
|
u = src->value[k].d;
|
|
i = src->value[k].d;
|
|
f = src->value[k].d;
|
|
d = src->value[k].d;
|
|
b = src->value[k].d;
|
|
break;
|
|
|
|
case HLSL_TYPE_INT:
|
|
u = src->value[k].i;
|
|
i = src->value[k].i;
|
|
f = src->value[k].i;
|
|
d = src->value[k].i;
|
|
b = src->value[k].i;
|
|
break;
|
|
|
|
case HLSL_TYPE_UINT:
|
|
u = src->value[k].u;
|
|
i = src->value[k].u;
|
|
f = src->value[k].u;
|
|
d = src->value[k].u;
|
|
b = src->value[k].u;
|
|
break;
|
|
|
|
case HLSL_TYPE_BOOL:
|
|
u = src->value[k].b;
|
|
i = src->value[k].b;
|
|
f = src->value[k].b;
|
|
d = src->value[k].b;
|
|
b = src->value[k].b;
|
|
break;
|
|
|
|
default:
|
|
FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, src->node.data_type),
|
|
debug_hlsl_type(ctx, dst->node.data_type));
|
|
return false;
|
|
}
|
|
|
|
switch (dst->node.data_type->base_type)
|
|
{
|
|
case HLSL_TYPE_FLOAT:
|
|
case HLSL_TYPE_HALF:
|
|
dst->value[k].f = f;
|
|
break;
|
|
|
|
case HLSL_TYPE_DOUBLE:
|
|
dst->value[k].d = d;
|
|
break;
|
|
|
|
case HLSL_TYPE_INT:
|
|
dst->value[k].i = i;
|
|
break;
|
|
|
|
case HLSL_TYPE_UINT:
|
|
dst->value[k].u = u;
|
|
break;
|
|
|
|
case HLSL_TYPE_BOOL:
|
|
dst->value[k].b = b;
|
|
break;
|
|
|
|
default:
|
|
FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, src->node.data_type),
|
|
debug_hlsl_type(ctx, dst->node.data_type));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool fold_neg(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst, struct hlsl_ir_constant *src)
|
|
{
|
|
enum hlsl_base_type type = dst->node.data_type->base_type;
|
|
unsigned int k;
|
|
|
|
assert(type == src->node.data_type->base_type);
|
|
|
|
for (k = 0; k < 4; ++k)
|
|
{
|
|
switch (type)
|
|
{
|
|
case HLSL_TYPE_FLOAT:
|
|
case HLSL_TYPE_HALF:
|
|
dst->value[k].f = -src->value[k].f;
|
|
break;
|
|
|
|
case HLSL_TYPE_DOUBLE:
|
|
dst->value[k].d = -src->value[k].d;
|
|
break;
|
|
|
|
case HLSL_TYPE_INT:
|
|
case HLSL_TYPE_UINT:
|
|
dst->value[k].u = -src->value[k].u;
|
|
break;
|
|
|
|
default:
|
|
FIXME("Fold negation for type %s.\n", debug_hlsl_type(ctx, dst->node.data_type));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool fold_add(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst, struct hlsl_ir_constant *src1,
|
|
struct hlsl_ir_constant *src2)
|
|
{
|
|
enum hlsl_base_type type = dst->node.data_type->base_type;
|
|
unsigned int k;
|
|
|
|
assert(type == src1->node.data_type->base_type);
|
|
assert(type == src2->node.data_type->base_type);
|
|
|
|
for (k = 0; k < 4; ++k)
|
|
{
|
|
switch (type)
|
|
{
|
|
case HLSL_TYPE_FLOAT:
|
|
case HLSL_TYPE_HALF:
|
|
dst->value[k].f = src1->value[k].f + src2->value[k].f;
|
|
break;
|
|
|
|
case HLSL_TYPE_DOUBLE:
|
|
dst->value[k].d = src1->value[k].d + src2->value[k].d;
|
|
break;
|
|
|
|
/* Handling HLSL_TYPE_INT through the unsigned field to avoid
|
|
* undefined behavior with signed integers in C. */
|
|
case HLSL_TYPE_INT:
|
|
case HLSL_TYPE_UINT:
|
|
dst->value[k].u = src1->value[k].u + src2->value[k].u;
|
|
break;
|
|
|
|
default:
|
|
FIXME("Fold addition for type %s.\n", debug_hlsl_type(ctx, dst->node.data_type));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool fold_mul(struct hlsl_ctx *ctx, struct hlsl_ir_constant *dst,
|
|
struct hlsl_ir_constant *src1, struct hlsl_ir_constant *src2)
|
|
{
|
|
enum hlsl_base_type type = dst->node.data_type->base_type;
|
|
unsigned int k;
|
|
|
|
assert(type == src1->node.data_type->base_type);
|
|
assert(type == src2->node.data_type->base_type);
|
|
|
|
for (k = 0; k < 4; ++k)
|
|
{
|
|
switch (type)
|
|
{
|
|
case HLSL_TYPE_FLOAT:
|
|
case HLSL_TYPE_HALF:
|
|
dst->value[k].f = src1->value[k].f * src2->value[k].f;
|
|
break;
|
|
|
|
case HLSL_TYPE_DOUBLE:
|
|
dst->value[k].d = src1->value[k].d * src2->value[k].d;
|
|
break;
|
|
|
|
case HLSL_TYPE_INT:
|
|
case HLSL_TYPE_UINT:
|
|
dst->value[k].u = src1->value[k].u * src2->value[k].u;
|
|
break;
|
|
|
|
default:
|
|
FIXME("Fold multiplication for type %s.\n", debug_hlsl_type(ctx, dst->node.data_type));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool hlsl_fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context)
|
|
{
|
|
struct hlsl_ir_constant *arg1, *arg2 = NULL, *res;
|
|
struct hlsl_ir_expr *expr;
|
|
unsigned int i;
|
|
bool success;
|
|
|
|
if (instr->type != HLSL_IR_EXPR)
|
|
return false;
|
|
expr = hlsl_ir_expr(instr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(expr->operands); ++i)
|
|
{
|
|
if (expr->operands[i].node && expr->operands[i].node->type != HLSL_IR_CONSTANT)
|
|
return false;
|
|
}
|
|
arg1 = hlsl_ir_constant(expr->operands[0].node);
|
|
if (expr->operands[1].node)
|
|
arg2 = hlsl_ir_constant(expr->operands[1].node);
|
|
|
|
if (!(res = hlsl_alloc(ctx, sizeof(*res))))
|
|
return false;
|
|
init_node(&res->node, HLSL_IR_CONSTANT, instr->data_type, instr->loc);
|
|
|
|
switch (expr->op)
|
|
{
|
|
case HLSL_OP1_CAST:
|
|
success = fold_cast(ctx, res, arg1);
|
|
break;
|
|
|
|
case HLSL_OP1_NEG:
|
|
success = fold_neg(ctx, res, arg1);
|
|
break;
|
|
|
|
case HLSL_OP2_ADD:
|
|
success = fold_add(ctx, res, arg1, arg2);
|
|
break;
|
|
|
|
case HLSL_OP2_MUL:
|
|
success = fold_mul(ctx, res, arg1, arg2);
|
|
break;
|
|
|
|
default:
|
|
FIXME("Fold \"%s\" expression.\n", debug_hlsl_expr_op(expr->op));
|
|
success = false;
|
|
break;
|
|
}
|
|
|
|
if (success)
|
|
{
|
|
list_add_before(&expr->node.entry, &res->node.entry);
|
|
hlsl_replace_node(&expr->node, &res->node);
|
|
}
|
|
else
|
|
{
|
|
vkd3d_free(res);
|
|
}
|
|
return success;
|
|
}
|