qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-04-06 01:11:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

[qfcc] Auto-cast compatible structs in assignment

Browse source 
This allows struct block members to be copied out of a block for spir-v.
The code may not be optimal (the full struct is copied rather than only
used members), but it gets my vertex shaders compiling again and thus
passing that part of validation.
This commit is contained in:
Bill Currie 2025-02-03 14:06:27 +09:00
parent 52c5ec3119
commit d952bec679
4 changed files with 70 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -56,6 +56,8 @@ typedef struct {
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);
const expr_t *(*test_expr) (const expr_t *expr);
const expr_t *(*check_types_compatible) (const expr_t *dst,
const expr_t *src);
bool (*setup_intrinsic_symtab) (symtab_t *symtab);

6
tools/qfcc/source/expr_assign.c
View file

@ -207,6 +207,12 @@ check_types_compatible (const expr_t *dst, const expr_t *src)
}
return nullptr;
}
if (current_target.check_types_compatible) {
auto expr = current_target.check_types_compatible (dst, src);
if (expr) {
return expr;
}
}
// traditional qcc is a little sloppy
if (!options.traditional) {
return type_mismatch (dst, src, '=');

21
tools/qfcc/source/expr_construct.c
View file

@ -290,6 +290,24 @@ math_constructor (const type_t *type, const expr_t *params, const expr_t *e)
return construct_by_components (type, params, e);
}
static const expr_t *
struct_constructor (const type_t *type, const expr_t *params, const expr_t *e)
{
scoped_src_loc (e);
int num_param = list_count (&params->list);
const expr_t *param_exprs[num_param + 1] = {};
list_scatter_rev (&params->list, param_exprs);
auto comp = new_compound_init ();
comp->compound.type = type;
for (int i = 0; i < num_param; i++) {
auto param = param_exprs[i];
append_element (comp, new_element (param, nullptr));
}
return comp;
}
const expr_t *
constructor_expr (const expr_t *e, const expr_t *params)
{
@ -303,5 +321,8 @@ constructor_expr (const expr_t *e, const expr_t *params)
if (is_math (type)) {
return math_constructor (type, params, e);
}
if (is_struct (type)) {
return struct_constructor (type, params, e);
}
return error (e, "not implemented");
}

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

@ -2626,6 +2626,46 @@ spirv_shift_op (int op, const expr_t *e1, const expr_t *e2)
return fold_constants (e);
}
static const expr_t *
spirv_check_types_compatible (const expr_t *dst, const expr_t *src)
{
auto dst_type = get_type (dst);
auto src_type = get_type (src);
if (!is_struct (dst_type) || !is_struct (src_type)) {
return nullptr;
}
auto dst_tab = type_symtab (dst_type);
auto src_tab = type_symtab (src_type);
auto dsym = dst_tab->symbols;
auto ssym = src_tab->symbols;
int count = 0;
for (; dsym && ssym; dsym = dsym->next, ssym = ssym->next, count++) {
if (dsym->type != ssym->type || strcmp (dsym->name, ssym->name) != 0) {
break;
}
}
// struct symtabs didn't match, or both empty
if (dsym || ssym || !count) {
return nullptr;
}
expr_t type_expr = {
.loc = dst->loc,
.type = ex_type,
.typ.type = dst_type,
};
const expr_t *param_exprs[count];
int i = 0;
for (ssym = src_tab->symbols; ssym; ssym = ssym->next, i++) {
auto e = new_field_expr (src, new_name_expr (ssym->name));
e->field.type = ssym->type;
param_exprs[i] = e;
}
auto params = new_list_expr (nullptr);
list_gather (&params->list, param_exprs, count);
return constructor_expr (&type_expr, params);
}
static void
spirv_init (void)
{
@ -2648,4 +2688,5 @@ target_t spirv_target = {
// ruamoko and spirv are mostly compatible for bools other than lbool
// but that's handled by spirv_mirror_bool
.test_expr = ruamoko_test_expr,
.check_types_compatible = spirv_check_types_compatible,
};