qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-02-25 05:01:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

[qfcc] Split up shift ops by target

Browse source 
v6 can't do shifts at all, and rua/spir-v can do only integral shifts.
This commit is contained in:
Bill Currie 2025-01-18 20:44:55 +09:00
parent 77158130ca
commit 7dc1ab0ea8
5 changed files with 109 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
tools/qfcc/include/target.h
View file

@ -51,6 +51,7 @@ typedef struct {
const expr_t *(*proc_address) (const expr_t *expr, rua_ctx_t *ctx);
// for both vector and quaternion types
const expr_t *(*vector_compare)(int op, const expr_t *e1, const expr_t *e2);
const expr_t *(*shift_op)(int op, const expr_t *e1, const expr_t *e2);
bool (*setup_intrinsic_symtab) (symtab_t *symtab);

9
tools/qfcc/source/expr_binary.c
View file

@ -160,6 +160,12 @@ entity_compare (int op, const expr_t *e1, const expr_t *e2)
return e;
}
static const expr_t *
target_shift_op (int op, const expr_t *e1, const expr_t *e2)
{
return current_target.shift_op (op, e1, e2);
}
static const type_t *
promote_type (const type_t *dst, const type_t *src)
{
@ -504,7 +510,8 @@ static expr_type_t compare_ops[] = {
};
static expr_type_t shift_ops[] = {
{ .match_a = is_math, .match_b = is_math, },
{ .match_a = is_math, .match_b = is_math,
.process = target_shift_op },
{}
};

37
tools/qfcc/source/target_rua.c
View file

@ -370,6 +370,42 @@ ruamoko_vector_compare (int op, const expr_t *e1, const expr_t *e2)
return e;
}
static const expr_t *
ruamoko_shift_op (int op, const expr_t *e1, const expr_t *e2)
{
auto t1 = get_type (e1);
auto t2 = get_type (e2);
if (is_matrix (t1) || is_matrix (t2)) {
return error (e1, "invalid operands for %s", get_op_string (op));
}
if (is_real (t1)) {
warning (e1, "shift of floating point value");
}
if (is_real (t2)) {
warning (e2, "shift by floating point value");
}
if (is_double (t1)) {
t1 = vector_type (&type_long, type_width (t1));
t2 = vector_type (&type_long, type_width (t1));
}
if (is_float (t1)) {
t1 = vector_type (&type_int, type_width (t1));
t2 = vector_type (&type_int, type_width (t1));
}
if (is_uint (t1) || is_int (t1)) {
t2 = vector_type (&type_int, type_width (t1));
}
if (is_ulong (t1) || is_long (t1)) {
t2 = vector_type (&type_long, type_width (t1));
}
e1 = cast_expr (t1, e1);
e2 = cast_expr (t2, e2);
auto e = new_binary_expr (op, e1, e2);
e->expr.type = t1;
return fold_constants (e);
}
target_t ruamoko_target = {
.value_too_large = ruamoko_value_too_large,
.build_scope = ruamoko_build_scope,
@ -381,4 +417,5 @@ target_t ruamoko_target = {
.proc_caselabel = ruamoko_proc_caselabel,
.proc_address = ruamoko_proc_address,
.vector_compare = ruamoko_vector_compare,
.shift_op = ruamoko_shift_op,
};

26
tools/qfcc/source/target_spirv.c
View file

@ -2216,6 +2216,31 @@ spirv_vector_compare (int op, const expr_t *e1, const expr_t *e2)
return e;
}
static const expr_t *
spirv_shift_op (int op, const expr_t *e1, const expr_t *e2)
{
auto t1 = get_type (e1);
auto t2 = get_type (e2);
if (is_matrix (t1) || is_matrix (t2)) {
return error (e1, "invalid operands for %s", get_op_string (op));
}
if (!is_integral (t1) || !is_integral (t2)) {
return error (e1, "invalid operands for %s", get_op_string (op));
}
if (is_uint (t1)) {
t2 = vector_type (&type_int, type_width (t1));
}
if (is_ulong (t1)) {
t2 = vector_type (&type_long, type_width (t1));
}
e1 = cast_expr (t1, e1);
e2 = cast_expr (t2, e2);
auto e = new_binary_expr (op, e1, e2);
e->expr.type = t1;
return fold_constants (e);
}
target_t spirv_target = {
.value_too_large = spirv_value_too_large,
.build_scope = spirv_build_scope,
@ -2225,4 +2250,5 @@ target_t spirv_target = {
.assign_vector = spirv_assign_vector,
.setup_intrinsic_symtab = spirv_setup_intrinsic_symtab,
.vector_compare = spirv_vector_compare,
.shift_op = spirv_shift_op,
};

37
tools/qfcc/source/target_v6.c
View file

@ -219,6 +219,41 @@ v6p_vector_compare (int op, const expr_t *e1, const expr_t *e2)
return do_vector_compare (op, e1, e2, &type_int);
}
static const expr_t *
v6_shift_op (int op, const expr_t *e1, const expr_t *e2)
{
return error (e1, "shift ops not supported");
}
static const expr_t *
v6p_shift_op (int op, const expr_t *e1, const expr_t *e2)
{
auto t1 = get_type (e1);
auto t2 = get_type (e2);
if (!is_scalar (t1) || !is_scalar (t2)) {
return error (e1, "invalid operands for %s", get_op_string (op));
}
if (is_double (t1) && !e1->implicit) {
warning (e1, "shift of double");
}
if (is_double (t2) && !e2->implicit) {
warning (e2, "shift by double");
}
const type_t *type;
if (is_real (t1)) {
e1 = cast_expr (&type_float, e1);
e2 = cast_expr (&type_float, e2);
type = &type_float;
} else {
e2 = cast_expr (&type_int, e2);
type = t1;
}
auto e = new_binary_expr (op, e1, e2);
e->expr.type = type;
return fold_constants (e);
}
target_t v6_target = {
.value_too_large = v6_value_too_large,
.build_scope = v6p_build_scope,
@ -231,6 +266,7 @@ target_t v6_target = {
.proc_caselabel = ruamoko_proc_caselabel,
.proc_address = ruamoko_proc_address,
.vector_compare = v6_vector_compare,
.shift_op = v6_shift_op,
};
target_t v6p_target = {
@ -245,4 +281,5 @@ target_t v6p_target = {
.proc_caselabel = ruamoko_proc_caselabel,
.proc_address = ruamoko_proc_address,
.vector_compare = v6p_vector_compare,
.shift_op = v6p_shift_op,
};